util.hpp

/******************************************************************************
 *
 * Project:  PROJ
 * Purpose:  ISO19111:2018 implementation
 * Author:   Even Rouault <even dot rouault at spatialys dot com>
 *
 ******************************************************************************
 * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#ifndef UTIL_HH_INCLUDED
#define UTIL_HH_INCLUDED

#if !(__cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900))
#error Must have C++11 or newer.
#endif

#include <exception>
#include <map>
#include <memory>
#include <string>
#include <vector>

#ifndef NS_PROJ

namespace osgeo {
namespace proj {}
} // namespace osgeo
#endif


#ifndef PROJ_DLL
#ifdef PROJ_MSVC_DLL_EXPORT
#define PROJ_DLL __declspec(dllexport)
#elif defined(PROJ_MSVC_DLL_IMPORT)
#define PROJ_DLL __declspec(dllimport)
#else
#define PROJ_DLL
#endif
#endif

#include "nn.hpp"

/* To allow customizing the base namespace of PROJ */
#ifndef NS_PROJ
#define NS_PROJ osgeo::proj
#define NS_PROJ_START                                                          \
    namespace osgeo {                                                          \
    namespace proj {
#define NS_PROJ_END                                                            \
    }                                                                          \
    }
#endif

// Private-implementation (Pimpl) pattern
#define PROJ_OPAQUE_PRIVATE_DATA                                               \
  private:                                                                     \
    struct Private;                                                            \
    std::unique_ptr<Private> d;                                                \
                                                                               \
  protected:                                                                   \
    Private *getPrivate() noexcept { return d.get(); }                         \
    const Private *getPrivate() const noexcept { return d.get(); }             \
                                                                               \
  private:

// To include in the protected/private section of a class definition,
// to be able to call make_shared on a protected/private constructor
#define INLINED_MAKE_SHARED                                                    \
    template <typename T, typename... Args>                                    \
    static std::shared_ptr<T> make_shared(Args &&... args) {                   \
        return std::shared_ptr<T>(new T(std::forward<Args>(args)...));         \
    }                                                                          \
    template <typename T, typename... Args>                                    \
    static util::nn_shared_ptr<T> nn_make_shared(Args &&... args) {            \
        return util::nn_shared_ptr<T>(                                         \
            util::i_promise_i_checked_for_null,                                \
            std::shared_ptr<T>(new T(std::forward<Args>(args)...)));           \
    }

// To include in the protected/private section of a class definition,
// to be able to call make_unique on a protected/private constructor
#define INLINED_MAKE_UNIQUE                                                    \
    template <typename T, typename... Args>                                    \
    static std::unique_ptr<T> make_unique(Args &&... args) {                   \
        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));         \
    }

#ifdef DOXYGEN_ENABLED
#define PROJ_FRIEND(mytype)
#define PROJ_FRIEND_OPTIONAL(mytype)
#else
#define PROJ_FRIEND(mytype) friend class mytype
#define PROJ_FRIEND_OPTIONAL(mytype) friend class util::optional<mytype>
#endif

#ifndef PROJ_PRIVATE
#define PROJ_PRIVATE public
#endif

#if defined(__GNUC__)
#define PROJ_NO_INLINE __attribute__((noinline))
#define PROJ_NO_RETURN __attribute__((noreturn))
// Applies to a function that has no side effect, and its return will not
// change if the arguments are the same. But is return may change
// if the object state changes. So this is for getters of mutable objects.
#define PROJ_PURE_DECL const noexcept __attribute__((pure))
// Applies to a function that has no side effect, and its return will not
// change if the arguments are the same, and their pointed value must not
// be modified. So this is for getters of immutable objets. This is stronger
// than PROJ_PURE_DECL.
#define PROJ_CONST_DECL const noexcept __attribute__((const))
#else
#define PROJ_NO_RETURN
#define PROJ_NO_INLINE
#define PROJ_PURE_DECL const noexcept
#define PROJ_CONST_DECL const noexcept
#endif
#define PROJ_PURE_DEFN const noexcept
#define PROJ_CONST_DEFN const noexcept


NS_PROJ_START

namespace util {

// Import a few classes from nn.hpp to expose them under our ::util namespace
// for conveniency.
using ::dropbox::oxygen::i_promise_i_checked_for_null;
using ::dropbox::oxygen::nn;
using ::dropbox::oxygen::nn_dynamic_pointer_cast;
using ::dropbox::oxygen::nn_make_shared;

// For return statements, to convert from derived type to base type
using ::dropbox::oxygen::nn_static_pointer_cast;

template <typename T> using nn_shared_ptr = nn<std::shared_ptr<T>>;

#define NN_NO_CHECK(p)                                                         \
    ::dropbox::oxygen::nn<typename std::remove_const<                          \
        typename std::remove_reference<decltype(p)>::type>::type>(             \
        dropbox::oxygen::i_promise_i_checked_for_null, (p))


// To avoid formatting differences between clang-format 3.8 and 7
#define PROJ_NOEXCEPT noexcept

template <class T> class optional {
  public:
    inline optional() : hasVal_(false) {}
    inline explicit optional(const T &val) : hasVal_(true), val_(val) {}
    inline explicit optional(T &&val)
        : hasVal_(true), val_(std::forward<T>(val)) {}

    inline optional(const optional &other) = default;
    inline optional(optional &&other) PROJ_NOEXCEPT
        : hasVal_(other.hasVal_),
          // cppcheck-suppress functionStatic
          val_(std::forward<T>(other.val_)) {
        other.hasVal_ = false;
    }

    inline optional &operator=(const T &val) {
        hasVal_ = true;
        val_ = val;
        return *this;
    }
    inline optional &operator=(T &&val) noexcept {
        hasVal_ = true;
        val_ = std::forward<T>(val);
        return *this;
    }
    inline optional &operator=(const optional &other) = default;
    inline optional &operator=(optional &&other) noexcept {
        hasVal_ = other.hasVal_;
        val_ = std::forward<T>(other.val_);
        other.hasVal_ = false;
        return *this;
    }

    inline T *operator->() { return &val_; }
    inline T &operator*() { return val_; }


    inline const T *operator->() const { return &val_; }

    inline const T &operator*() const { return val_; }

    inline explicit operator bool() const noexcept { return hasVal_; }

    inline bool has_value() const noexcept { return hasVal_; }

  private:
    bool hasVal_;
    T val_{};
};

// ---------------------------------------------------------------------------

class BaseObject;
using BaseObjectPtr = std::shared_ptr<BaseObject>;
#if 1

struct BaseObjectNNPtr : public util::nn<BaseObjectPtr> {
    // This trick enables to avoid inlining of the destructor.
    // This is mostly an alias of the base class.
    template <class T>
    // cppcheck-suppress noExplicitConstructor
    BaseObjectNNPtr(const util::nn<std::shared_ptr<T>> &x)
        : util::nn<BaseObjectPtr>(x) {}
    template <class T>
    BaseObjectNNPtr(util::nn<std::shared_ptr<T>> &&x) noexcept
        : util::nn<BaseObjectPtr>(NN_NO_CHECK(std::move(x.as_nullable()))) {}
    explicit BaseObjectNNPtr(::dropbox::oxygen::i_promise_i_checked_for_null_t,
                             BaseObjectPtr &&arg) noexcept
        : util::nn<BaseObjectPtr>(i_promise_i_checked_for_null,
                                  std::move(arg)) {}
    BaseObjectNNPtr(const BaseObjectNNPtr &) = default;
    BaseObjectNNPtr &operator=(const BaseObjectNNPtr &) = default;

    PROJ_DLL ~BaseObjectNNPtr();
};
#else
using BaseObjectNNPtr = util::nn<BaseObjectPtr>;
#endif

class BaseObject {
  public:
    virtual PROJ_DLL ~BaseObject();

    PROJ_PRIVATE :
        PROJ_DLL BaseObjectNNPtr
        shared_from_this() const;

  protected:
    PROJ_DLL BaseObject();
    PROJ_DLL void assignSelf(const BaseObjectNNPtr &self);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class IComparable {
  public:
    PROJ_DLL virtual ~IComparable();

    enum class PROJ_DLL Criterion {
        STRICT,
        EQUIVALENT
    };

    PROJ_DLL virtual bool
    isEquivalentTo(const IComparable *other,
                   Criterion criterion = Criterion::STRICT) const = 0;
};

// ---------------------------------------------------------------------------

class BoxedValue final : public BaseObject {
  public:

    enum class Type {
        STRING,
        INTEGER,
        BOOLEAN
    };

    // cppcheck-suppress noExplicitConstructor
    PROJ_DLL BoxedValue(const char *stringValueIn); // needed to avoid the bool
                                                    // constructor to be taken !
    // cppcheck-suppress noExplicitConstructor
    PROJ_DLL BoxedValue(const std::string &stringValueIn);
    // cppcheck-suppress noExplicitConstructor
    PROJ_DLL BoxedValue(int integerValueIn);
    // cppcheck-suppress noExplicitConstructor
    PROJ_DLL BoxedValue(bool booleanValueIn);

    PROJ_PRIVATE :
        PROJ_DLL
        BoxedValue(const BoxedValue &other);

    PROJ_DLL ~BoxedValue() override;

    PROJ_DLL const Type &type() const;
    PROJ_DLL const std::string &stringValue() const;
    PROJ_DLL int integerValue() const;
    PROJ_DLL bool booleanValue() const;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    BoxedValue &operator=(const BoxedValue &) = delete;

    BoxedValue();
};

using BoxedValuePtr = std::shared_ptr<BoxedValue>;
using BoxedValueNNPtr = util::nn<BoxedValuePtr>;

// ---------------------------------------------------------------------------

class ArrayOfBaseObject;
using ArrayOfBaseObjectPtr = std::shared_ptr<ArrayOfBaseObject>;
using ArrayOfBaseObjectNNPtr = util::nn<ArrayOfBaseObjectPtr>;

class ArrayOfBaseObject final : public BaseObject {
  public:
    PROJ_DLL ~ArrayOfBaseObject() override;

    PROJ_DLL void add(const BaseObjectNNPtr &obj);

    PROJ_DLL static ArrayOfBaseObjectNNPtr create();

    PROJ_PRIVATE :
        std::vector<BaseObjectNNPtr>::const_iterator
        begin() const;
    std::vector<BaseObjectNNPtr>::const_iterator end() const;
    bool empty() const;

  protected:
    ArrayOfBaseObject();
    INLINED_MAKE_SHARED

  private:
    ArrayOfBaseObject(const ArrayOfBaseObject &other) = delete;
    ArrayOfBaseObject &operator=(const ArrayOfBaseObject &other) = delete;
    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class PropertyMap {
  public:
    PROJ_DLL PropertyMap();
    PROJ_DLL PropertyMap(const PropertyMap &other);
    PROJ_DLL ~PropertyMap();

    PROJ_DLL PropertyMap &set(const std::string &key,
                              const BaseObjectNNPtr &val);

    template <class T>
    inline PropertyMap &set(const std::string &key,
                            const nn_shared_ptr<T> &val) {
        return set(
            key, BaseObjectNNPtr(i_promise_i_checked_for_null,
                                 BaseObjectPtr(val.as_nullable(), val.get())));
    }

    // needed to avoid the bool constructor to be taken !
    PROJ_DLL PropertyMap &set(const std::string &key, const char *val);

    PROJ_DLL PropertyMap &set(const std::string &key, const std::string &val);

    PROJ_DLL PropertyMap &set(const std::string &key, int val);

    PROJ_DLL PropertyMap &set(const std::string &key, bool val);

    PROJ_DLL PropertyMap &set(const std::string &key,
                              const std::vector<std::string> &array);

    PROJ_PRIVATE :
        std::map<std::string, BaseObjectNNPtr>::iterator
        find(const std::string &key) const;
    std::map<std::string, BaseObjectNNPtr>::iterator end() const;

    // throw(InvalidValueTypeException)
    bool getStringValue(const std::string &key, std::string &outVal) const;

    static PropertyMap createAndSetName(const char *name);
    static PropertyMap createAndSetName(const std::string &name);

  private:
    PropertyMap &operator=(const PropertyMap &) = delete;

    PropertyMap &set(const std::string &key, const BoxedValue &val);

    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class LocalName;
using LocalNamePtr = std::shared_ptr<LocalName>;
using LocalNameNNPtr = util::nn<LocalNamePtr>;

class NameSpace;
using NameSpacePtr = std::shared_ptr<NameSpace>;
using NameSpaceNNPtr = util::nn<NameSpacePtr>;

class GenericName;
using GenericNamePtr = std::shared_ptr<GenericName>;
using GenericNameNNPtr = util::nn<GenericNamePtr>;

// ---------------------------------------------------------------------------

class GenericName : public BaseObject {
  public:
    PROJ_DLL virtual ~GenericName() override;

    PROJ_DLL virtual const NameSpacePtr scope() const = 0;

    PROJ_DLL virtual std::string toString() const = 0;

    PROJ_DLL virtual GenericNameNNPtr toFullyQualifiedName() const = 0;

  protected:
    GenericName();
    GenericName(const GenericName &other);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    GenericName &operator=(const GenericName &other) = delete;
};

// ---------------------------------------------------------------------------

class NameSpace {
  public:
    PROJ_DLL ~NameSpace();

    PROJ_DLL bool isGlobal() const;
    PROJ_DLL const GenericNamePtr &name() const;

  protected:
    PROJ_FRIEND(NameFactory);
    PROJ_FRIEND(LocalName);
    explicit NameSpace(const GenericNamePtr &name);
    NameSpace(const NameSpace &other);
    NameSpaceNNPtr getGlobalFromThis() const;
    const std::string &separator() const;
    static const NameSpaceNNPtr GLOBAL;
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    NameSpace &operator=(const NameSpace &other) = delete;

    static NameSpaceNNPtr createGLOBAL();
};

// ---------------------------------------------------------------------------

class LocalName : public GenericName {
  public:
    PROJ_DLL ~LocalName() override;

    PROJ_DLL const NameSpacePtr scope() const override;
    PROJ_DLL std::string toString() const override;
    PROJ_DLL GenericNameNNPtr toFullyQualifiedName() const override;

  protected:
    PROJ_FRIEND(NameFactory);
    PROJ_FRIEND(NameSpace);
    explicit LocalName(const std::string &nameIn);
    LocalName(const LocalName &other);
    LocalName(const NameSpacePtr &ns, const std::string &name);
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    LocalName &operator=(const LocalName &other) = delete;
};

// ---------------------------------------------------------------------------

class NameFactory {
  public:
    PROJ_DLL static NameSpaceNNPtr
    createNameSpace(const GenericNameNNPtr &name,
                    const PropertyMap &properties);
    PROJ_DLL static LocalNameNNPtr createLocalName(const NameSpacePtr &scope,
                                                   const std::string &name);
    PROJ_DLL static GenericNameNNPtr
    createGenericName(const NameSpacePtr &scope,
                      const std::vector<std::string> &parsedNames);
};

// ---------------------------------------------------------------------------

class CodeList {
  public:
    PROJ_DLL ~CodeList();

    // cppcheck-suppress functionStatic
    inline const std::string &toString() PROJ_CONST_DECL { return name_; }

    inline operator std::string() PROJ_CONST_DECL { return toString(); }

    inline bool operator==(const CodeList &other) PROJ_CONST_DECL {
        return name_ == other.name_;
    }
    inline bool operator!=(const CodeList &other) PROJ_CONST_DECL {
        return name_ != other.name_;
    }
  protected:
    explicit CodeList(const std::string &nameIn) : name_(nameIn) {}
    CodeList(const CodeList &other) = default;
    CodeList &operator=(const CodeList &other);

  private:
    std::string name_{};
};

// ---------------------------------------------------------------------------

class Exception : public std::exception {
    std::string msg_;

  public:
    PROJ_DLL explicit Exception(const char *message);
    PROJ_DLL explicit Exception(const std::string &message);
    PROJ_DLL Exception(const Exception &other);
    PROJ_DLL ~Exception() override;
    PROJ_DLL virtual const char *what() const noexcept override;
};

// ---------------------------------------------------------------------------

class InvalidValueTypeException : public Exception {
  public:
    PROJ_DLL explicit InvalidValueTypeException(const char *message);
    PROJ_DLL explicit InvalidValueTypeException(const std::string &message);
    PROJ_DLL InvalidValueTypeException(const InvalidValueTypeException &other);
    PROJ_DLL ~InvalidValueTypeException() override;
};

// ---------------------------------------------------------------------------

class UnsupportedOperationException : public Exception {
  public:
    PROJ_DLL explicit UnsupportedOperationException(const char *message);
    PROJ_DLL explicit UnsupportedOperationException(const std::string &message);
    PROJ_DLL
    UnsupportedOperationException(const UnsupportedOperationException &other);
    PROJ_DLL ~UnsupportedOperationException() override;
};

} // namespace util

NS_PROJ_END

#endif // UTIL_HH_INCLUDED