SDException.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 "DLL_EXPORT.h"

#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>

namespace seismicdrive
{

    #ifdef _MSC_VER
        #pragma warning(push)
        #pragma warning(disable : 4275)
    #endif

    struct DLL_PUBLIC SDException : public std::runtime_error
    {
      protected:
        SDException(const std::string what);
    };

    #ifdef _MSC_VER
        #pragma warning(pop)
        #pragma warning(push)
        #pragma warning(disable : 4251 4996)
    #endif

    struct DLL_PUBLIC DEPRECATED("Catch error::format::Json instead") SDExceptionValueError : public SDException
    {
      protected:
        SDExceptionValueError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::authprovider::Error instead") SDExceptionAuthProviderError : public SDException
    {
      protected:
        SDExceptionAuthProviderError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::seismicstore::ActionFailed instead") SDExceptionSDAccessorError : public SDException
    {
      protected:
        SDExceptionSDAccessorError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::storage::AccessError instead") SDExceptionGCSAccessorError : public SDException
    {
      protected:
        SDExceptionGCSAccessorError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::dataset::Error instead") SDExceptionDatasetError : public SDException
    {
      protected:
        SDExceptionDatasetError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::dataset::context::Expired instead") SDExceptionContextExpired : public SDException
    {
      protected:
        SDExceptionContextExpired(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::dataset::context::UnknownFormat instead") SDExceptionContextVersionTooNew : public SDException
    {
      protected:
        SDExceptionContextVersionTooNew(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::dataset::context::PathMismatch instead") SDExceptionContextPathNoMatch : public SDException
    {
      protected:
        SDExceptionContextPathNoMatch(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::storage::Error instead") SDExceptionStorageError : public SDException
    {
      protected:
        SDExceptionStorageError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::storage::Error instead") SDExceptionAzureStorageError : public SDExceptionStorageError
    {
        SDExceptionAzureStorageError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::internal::Error instead") SDExceptionInternalError : public SDException
    {
      protected:
        SDExceptionInternalError(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Not thrown by the SDAPI") SDExceptionOutdatedMethod : public SDException
    {
      private:
        SDExceptionOutdatedMethod(std::string what);
    };

    struct DLL_PUBLIC DEPRECATED("Catch error::seismicstore::NotJson instead") SDExpectedJsonException : public SDException
    {
      protected:
        SDExpectedJsonException(std::string what);
    };


    struct DLL_PUBLIC DEPRECATED("Catch error::dataset::context::NotReadOnly instead") SDExpectedReadOnlyDatasetException : public SDException
    {
      protected:
        SDExpectedReadOnlyDatasetException(std::string what);
    };

    class DLL_PUBLIC DEPRECATED("Catch error::dataset::Locked instead") SDExceptionDatasetLocked : public SDException
    {
      public:
        enum Reason
        {
            UNKNOWN = 0,
            WRITE_LOCKED = 1,
            READ_LOCKED = 2,
            CANNOT_LOCK = 3,
            CANNOT_UNLOCK = 4
        };

        Reason const &reason() const { return mReason; }

        std::uint32_t get_estimated_lock_lease_seconds() const { return mTimeToLiveSeconds; }

      protected:
        SDExceptionDatasetLocked(std::string const &what);

        SDExceptionDatasetLocked(std::string const &what,
                                 Reason reason,
                                 std::uint32_t ttl = (std::numeric_limits<std::uint32_t>::max)()); //For more info on wrapping max with parenthesis please refer to https://stackoverflow.com/questions/11544073/how-do-i-deal-with-the-max-macro-in-windows-h-colliding-with-max-in-std

        Reason mReason;

        std::uint32_t mTimeToLiveSeconds;
    };

    namespace error
    {
        namespace authprovider
        {
            class DLL_PUBLIC Error : public SDExceptionAuthProviderError
            {
              public:
                class Impl;

                Error(const Impl &impl);

                ~Error();

              protected:
                Error(Impl *impl);

                std::shared_ptr<Impl> impl;
            };
        }

        namespace dataset
        {
            class DLL_PUBLIC Error : public SDExceptionDatasetError
            {
              public:
                std::string getPath();

                class Impl;

                Error(const Impl &impl);

                ~Error();

              protected:
                Error(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            class DLL_PUBLIC OpenFailed : public Error
            {
              public:
                std::string getPath();

                class Impl;

                OpenFailed(const Impl &impl);

                ~OpenFailed();

              protected:
                OpenFailed(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC DeleteFailed : public Error
            {
              public:
                std::string getPath();

                class Impl;

                DeleteFailed(const Impl &impl);

                ~DeleteFailed();

              protected:
                DeleteFailed(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC FlushFailed : public Error
            {
              public:
                std::string getPath();

                class Impl;

                FlushFailed(const Impl &impl);

                ~FlushFailed();

              protected:
                FlushFailed(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC NotOpen : public Error
            {
              public:
                std::string getPath();

                class Impl;

                NotOpen(const Impl &impl);

                ~NotOpen();

              protected:
                NotOpen(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC AlreadyOpen : public Error
            {
              public:
                std::string getPath();

                class Impl;

                AlreadyOpen(const Impl &impl);

                ~AlreadyOpen();

              protected:
                AlreadyOpen(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC UpdateFailed : public Error
            {
              public:
                std::string getPath();

                std::string getField();

                class Impl;

                UpdateFailed(const Impl &impl);

                ~UpdateFailed();

              protected:
                UpdateFailed(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC InvalidPrefix : public Error
            {
              public:
                std::string getPath();

                class Impl;

                InvalidPrefix(const Impl &impl);

                ~InvalidPrefix();

              protected:
                InvalidPrefix(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC InvalidPath : public Error
            {
              public:
                std::string getPath();

                class Impl;

                InvalidPath(const Impl &impl);

                ~InvalidPath();

              protected:
                InvalidPath(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC InvalidNodeId : public Error
            {
              public:
                uint64_t getNodeId();

                class Impl;

                InvalidNodeId(const Impl &impl);

                ~InvalidNodeId();

              protected:
                InvalidNodeId(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC Locked : public SDExceptionDatasetLocked
            {
              public:
                std::string getPath();

                bool isReadLocked() const;

                bool isWriteLocked() const;

                bool lockFailed() const;

                bool unlockFailed() const;

                std::uint32_t getEstimatedLockLeaseSeconds() const;

                Reason const &reason() const = delete;

                std::uint32_t get_estimated_lock_lease_seconds() const = delete;

                class Impl;

                Locked(const Impl &impl);

                ~Locked();

              protected:
                Locked(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            namespace context
            {
                class DLL_PUBLIC NotReadOnly : public SDExpectedReadOnlyDatasetException
                {
                  public:
                    std::string getPath();

                    class Impl;

                    NotReadOnly(const Impl &impl);

                    ~NotReadOnly();

                  protected:
                    NotReadOnly(Impl *impl);

                    std::shared_ptr<Impl> impl;
                };

                class DLL_PUBLIC Expired : public SDExceptionContextExpired
                {
                  public:
                    std::string getPath();

                    class Impl;

                    Expired(const Impl &impl);

                    ~Expired();

                  protected:
                    Expired(Impl *impl);

                    std::shared_ptr<Impl> impl;
                };

                class DLL_PUBLIC UnknownFormat : public SDExceptionContextVersionTooNew
                {
                  public:
                    std::string getPath();

                    class Impl;

                    UnknownFormat(const Impl &impl);

                    ~UnknownFormat();

                  protected:
                    UnknownFormat(Impl *impl);

                    std::shared_ptr<Impl> impl;
                };

                class DLL_PUBLIC PathMismatch : public SDExceptionContextPathNoMatch
                {
                  public:
                    std::string getPath();

                    std::string getContextPath();

                    class Impl;

                    PathMismatch(const Impl &impl);

                    ~PathMismatch();

                  protected:
                    PathMismatch(Impl *impl);

                    std::shared_ptr<Impl> impl;
                };
            }
        }

        namespace format
        {
            class DLL_PUBLIC Error : public SDExceptionValueError
            {
              public:
                class Impl;

                Error(const Impl &impl);

                ~Error();

              protected:
                Error(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            class DLL_PUBLIC Json : public Error
            {
              public:
                class Impl;

                Json(const Impl &impl);

                ~Json();

              protected:
                Json(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC ToJson : public Json
            {
              public:
                class Impl;

                ToJson(const Impl &impl);

                ~ToJson();

              protected:
                ToJson(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC FromJson : public Json
            {
              public:
                class Impl;

                FromJson(const Impl &impl);

                ~FromJson();

                std::string getMissingVariable();

              protected:
                FromJson(Impl *impl);

                Impl &impl;
            };
        }

        namespace internal
        {
            class DLL_PUBLIC Error : public SDExceptionInternalError
            {
              public:
                class Impl;

                Error(const Impl &impl);

                ~Error();

              protected:
                Error(Impl *impl);

                std::shared_ptr<Impl> impl;
            };
        }

        // Not to be documented
        class DLL_PUBLIC Exception : public SDException
        {
          protected:
            class Impl;

            Exception(const Impl &impl);

            ~Exception();

            Exception(Impl *impl);

            std::shared_ptr<Impl> impl;
        };

        namespace manager
        {
            class DLL_PUBLIC Error : public Exception
            {
              protected:
                class Impl;

                Error(const Impl &impl);

                ~Error();

                Error(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC AuthProviderNotSet : public Error
            {
              public:
                class Impl;

                AuthProviderNotSet(const Impl &impl);

                ~AuthProviderNotSet();

              protected:
                AuthProviderNotSet(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC AuthProviderTypeChange : public Error
            {
              public:
                class Impl;

                AuthProviderTypeChange(const Impl &impl);

                ~AuthProviderTypeChange();

              protected:
                AuthProviderTypeChange(Impl *impl);

                Impl &impl;
            };

            namespace context
            {
                class DLL_PUBLIC UnknownFormat : public Error
                {
                  public:
                    class Impl;

                    UnknownFormat(const Impl &impl);

                    ~UnknownFormat();

                  protected:
                    UnknownFormat(Impl *impl);

                    Impl &impl;
                };
            }

            class DLL_PUBLIC ServiceUrlNotSet : public Error
            {
              public:
                class Impl;

                ServiceUrlNotSet(const Impl &impl);

                ~ServiceUrlNotSet();

              protected:
                ServiceUrlNotSet(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC ApiKeyNotSet : public Error
            {
              public:
                class Impl;

                ApiKeyNotSet(const Impl &impl);

                ~ApiKeyNotSet();

              protected:
                ApiKeyNotSet(Impl *impl);

                Impl &impl;
            };
        }

        namespace seismicstore
        {
            class DLL_PUBLIC ActionFailed : public SDExceptionSDAccessorError
            {
              public:
                class Impl;

                ActionFailed(const Impl &impl);

                ~ActionFailed();

              protected:
                ActionFailed(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            class DLL_PUBLIC NotJson : public SDExpectedJsonException
            {
              public:
                class Impl;

                NotJson(const Impl &impl);

                ~NotJson();

              protected:
                NotJson(Impl *impl);

                std::shared_ptr<Impl> impl;
            };
        }

        namespace storage
        {
            class DLL_PUBLIC Error : public SDExceptionStorageError
            {
              public:
                class Impl;

                Error(const Impl &impl);

                ~Error();

              protected:
                Error(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            class DLL_PUBLIC NotImplemented : public Error
            {
              public:
                std::string whatsNotImplemented();

                class Impl;

                NotImplemented(const Impl &impl);

                ~NotImplemented();

              protected:
                NotImplemented(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC InvalidSasUri : public Error
            {
              public:
                class Impl;

                InvalidSasUri(const Impl &impl);

                ~InvalidSasUri();

              protected:
                InvalidSasUri(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC AccessError : public SDExceptionGCSAccessorError
            {
              public:
                class Impl;

                AccessError(const Impl &impl);

                ~AccessError();

              protected:
                AccessError(Impl *impl);

                std::shared_ptr<Impl> impl;
            };

            class DLL_PUBLIC ProviderError : public Error
            {
              public:
                class Impl;

                ProviderError(const Impl &impl);

                ~ProviderError();

              protected:
                ProviderError(Impl *impl);

                Impl &impl;
            };

            class DLL_PUBLIC NotBuilt : public ProviderError
            {
              public:
                std::string whatsNotBuilt();

                class Impl;

                NotBuilt(const Impl &impl);

                ~NotBuilt();

              protected:
                NotBuilt(Impl *impl);

                Impl &impl;
            };
        }
    }
}

#ifdef _MSC_VER
    #pragma warning(pop)
#endif