mde_common.hpp

Go to the documentation of this file.

 
#ifndef MDE_CONFIG_HPP
#define MDE_CONFIG_HPP
 
#include <cstddef>
#include <iostream>
#include <memory>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <functional>
#include <string>
 
#ifdef MDE_ENABLE_PARALLEL
#include <atomic>
#include <mutex>
#include <shared_mutex>
#endif
 
#ifdef MDE_ENABLE_TBB
#include <tbb/tbb.h>
#include <tbb/concurrent_map.h>
#include <tbb/concurrent_vector.h>
#endif
 
#ifdef MDE_ENABLE_SERIALIZATION
#include "mde_serialization.hpp"
#endif
 
#define MDE_VERSION_MAJOR "0"
#define MDE_VERSION_MINOR "6"
#define MDE_VERSION_PATCH "0"
#define MDE_VERSION_STRING (MDE_VERSION_MAJOR "." MDE_VERSION_MINOR "." MDE_VERSION_PATCH)
 
#define MDE_SORTED_VECTOR_BINARY_SEARCH_THRESHOLD 12
#define MDE_DEFAULT_BLOCK_SHIFT 5
#define MDE_DEFAULT_BLOCK_SIZE (1 << MDE_DEFAULT_BLOCK_SHIFT)
#define MDE_DEFAULT_BLOCK_MASK (MDE_DEFAULT_BLOCK_SIZE - 1)
#define MDE_DISABLE_INTERNAL_INTEGRITY_CHECK true
 
namespace mde {
 
#define ____MDE__STR(x) #x
#define __MDE_STR(x) ____MDE__STR(x)
 
#ifdef MDE_ENABLE_DEBUG
#define MDE_DEBUG(x) { x };
#else
#define MDE_DEBUG(x)
#endif
 
using Size = std::size_t;
 
using String = std::string;
 
#ifdef MDE_ENABLE_PARALLEL
 
using RWMutex = std::shared_mutex;
 
using ReadLock = std::shared_lock<RWMutex>;
 
using WriteLock = std::lock_guard<RWMutex>;
 
#endif
 
using IndexValue = Size;
 
template<typename T>
using UniquePointer = std::unique_ptr<T>;
 
template<typename T>
using Vector = std::vector<T>;
 
template<typename K, typename V>
using HashMap = std::unordered_map<K, V>;
 
template<typename K, typename V>
using OrderedMap = std::map<K, V>;
 
template<typename T>
using HashSet = std::unordered_set<T>;
 
template<typename T>
using OrderedSet = std::set<T>;
 
template<typename T>
using DefaultLess = std::less<T>;
 
template<typename T>
using DefaultHash = std::hash<T>;
 
template<typename T>
using DefaultEqual = std::equal_to<T>;
 
template<typename T>
struct DefaultPrinter {
    String operator()(T x) {
        std::stringstream s;
        s << x;
        return s.str();
    }
};
 
struct AbsentValueAccessError : public std::invalid_argument {
    AbsentValueAccessError(const std::string &message):
        std::invalid_argument(message.c_str()) {}
};
 
template<typename T>
class OptionalRef {
    const T *value = nullptr;
    OptionalRef(): value(nullptr) {}
 
public:
    OptionalRef(const T &value): value(&value) {}
 
    static OptionalRef absent() {
        return OptionalRef();
    }
 
    bool is_present() const {
        return value != nullptr;
    }
 
    const T &get() {
        if (value) {
            return *value;
        } else {
            throw AbsentValueAccessError("Tried to access an absent value. "
                                         "A check is likely missing.");
        }
    }
};
 
template<typename T>
class Optional {
    const T value{};
    const bool present;
 
    Optional(): present(false) {}
 
public:
    Optional(const T &value): value(value), present(true) {}
 
    static Optional absent() {
        return Optional();
    }
 
    bool is_present() {
        return present;
    }
 
    const T &get() {
        if (present) {
            return value;
        } else {
            throw AbsentValueAccessError("Tried to access an absent value. "
                                         "A check is likely missing.");
        }
    }
};
 
enum SubsetRelation {
    UNKNOWN  = 0,
    SUBSET   = 1,
    SUPERSET = 2
};
 
 
// The index of the empty set. The first set that will ever be inserted
// in the property set value storage is the empty set.
static const constexpr Size EMPTY_SET_VALUE = 0;
 
template<typename T, typename Hash = DefaultHash<T>>
inline Size compose_hash(const Size prev, T next) {
    return prev ^ (Hash()(next) + 0x9e3779b9 + (prev << 6) + (prev >> 2));
}
 
};
#endif