SDExceptionImpl.h

Go to the documentation of this file.

// ============================================================================
// Copyright 2017-2022, Schlumberger
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ============================================================================

#pragma once

#include "SDException.h"
#include "shared/config.h"
#include "shared/mex.h"

#include <string>

namespace seismicdrive
{
    namespace error
    {
        namespace impl
        {
            class Root
            {
              public:
                std::string what;

              protected:
                Root(const std::string &what)
                    : what(what)
                {
                }
            };
        }

        namespace authprovider
        {
            class Error::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };
        }

        namespace dataset
        {
            class Error::Impl : public impl::Root
            {
              public:
                const std::string path;

                Impl(const std::string &what, const std::string &path)
                    : Root(what),
                      path(path)
                {
                }
            };

            class OpenFailed::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Open failed\n"
                                  "Dataset: " + path, path)
                {
                }
            };

            class DeleteFailed::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Delete failed\n"
                                  "Dataset: " + path, path)
                {
                }
            };

            class FlushFailed::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Flush failed\n"
                                  "Dataset: " + path, path)
                {
                }
            };

            class NotOpen::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Dataset is not open: " + path, path)
                {
                }
            };

            class AlreadyOpen::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Dataset is already open: " + path, path)
                {
                }
            };

            class UpdateFailed::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path, const std::string &field)
                    : Error::Impl("Field update failed"
                                  "\nDataset: " + path +
                                  "\nField: " + field, path),
                      field(field)
                {
                }

                const std::string field;
            };

            class InvalidPrefix::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path, const std::string &prefix = sdconfig::PATHPREFIX)
                    : Error::Impl("Invalid Seismic Store path: " + path +
                                  "\nIt should start with " + prefix, path)
                {
                }
            };

            class InvalidPath::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &path)
                    : Error::Impl("Invalid dataset path: " + path +
                                  "\nExpected format: sd://<tenant_name>/<subproject_name>/<path>/<dataset_name>", path)
                {
                }
            };

            class InvalidNodeId::Impl : public Error::Impl
            {
              public:
                Impl(uint64_t nodeId)
                    : Error::Impl("Invalid node ID: " + std::to_string(nodeId), ""),
                      nodeId(nodeId)
                {
                }

                const uint64_t nodeId;
            };

            class Locked::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &what, const std::string &path)
                    : Error::Impl({what, path})
                {
                }
            };

            namespace context
            {
                class NotReadOnly::Impl : public Error::Impl
                {
                  public:
                    Impl(const std::string &path)
                        : Error::Impl("Dataset must be read-only: " + path, path)
                    {
                    }
                };

                class Expired::Impl : public Error::Impl
                {
                  public:
                    Impl(const std::string &path)
                        : Error::Impl("Context expired\n"
                                      "Dataset: " + path, path)
                    {
                    }
                };

                class UnknownFormat::Impl : public Error::Impl
                {
                  public:
                    Impl(const std::string &path)
                        : Error::Impl("Unknown context format\n"
                                      "Dataset: " + path, path)
                    {
                    }
                };

                class PathMismatch::Impl : public Error::Impl
                {
                  public:
                    Impl(const std::string &path, const std::string &contextPath)
                        : Error::Impl("Dataset path does not match context"
                                      "\nDataset: " + path +
                                      "\nContext: " + contextPath, path),
                          contextPath(contextPath)
                    {
                    }

                    const std::string contextPath;
                };
            }
        }

        namespace format
        {
            class Error::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };

            class Json::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &what)
                    : Error::Impl(what)
                {
                }
            };

            class ToJson::Impl : public Json::Impl
            {
              public:
                Impl(const std::string &what)
                    : Json::Impl(what)
                {
                }
            };

            class FromJson::Impl : public Json::Impl
            {
              public:
                Impl(const std::string &what, const std::string &variable)
                    : Json::Impl(what),
                      variable(variable)
                {
                }

                const std::string variable;
            };
        }

        namespace internal
        {
            class Error::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };
        }

        class Exception::Impl : public impl::Root
        {
          public:
            Impl(const std::string &what)
                : Root(what)
            {
            }
        };

        namespace manager
        {
            class Error::Impl : public Exception::Impl
            {
              public:
                Impl(const std::string &what)
                    : Exception::Impl(what)
                {
                }
            };

            class AuthProviderNotSet::Impl : public Error::Impl
            {
              public:
                Impl(int)
                    : Error::Impl(sdmex::sdmanager::AuthProviderNotSet())
                {
                }
            };

            class AuthProviderTypeChange::Impl : public Error::Impl
            {
              public:
                Impl(int)
                    : Error::Impl(sdmex::sdmanager::AuthProviderTypeChange())
                {
                }
            };

            namespace context
            {
                class UnknownFormat::Impl : public Error::Impl
                {
                  public:
                    Impl(int)
                        : Error::Impl(sdmex::sdmanager::SerializeFailed())
                    {
                    }
                };
            }

            class ServiceUrlNotSet::Impl : public Error::Impl
            {
              public:
                Impl(int)
                    : Error::Impl(sdmex::sdmanager::ServiceUrlNotSet())
                {
                }
            };

            class ApiKeyNotSet::Impl : public Error::Impl
            {
              public:
                Impl(int)
                    : Error::Impl(sdmex::sdmanager::ApiKeyNotSet())
                {
                }
            };
        }

        namespace seismicstore
        {
            class ActionFailed::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };

            class NotJson::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };
        }

        namespace storage
        {
            class Error::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };

            class NotImplemented::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &s)
                    : Error::Impl("Not implemented: " + s),
                      notImplemented(s)
                {
                }

                const std::string notImplemented;
            };

            class InvalidSasUri::Impl : public Error::Impl
            {
              public:
                Impl(int)
                    : Error::Impl("Invalid sas uri")
                {
                }
            };

            class AccessError::Impl : public impl::Root
            {
              public:
                Impl(const std::string &what)
                    : Root(what)
                {
                }
            };

            class ProviderError::Impl : public Error::Impl
            {
              public:
                Impl(const std::string &what)
                    : Error::Impl(what)
                {
                }
            };

            class NotBuilt::Impl : public ProviderError::Impl
            {
              public:
                Impl(const std::string &what)
                    : ProviderError::Impl(what + " support was not included when this sdapi was built"),
                      notBuilt(what + " support")
                {
                }

                const std::string notBuilt;
            };
        }
    }
}