SharedTable.hpp

Go to the documentation of this file.

#ifndef _IDENTT_UTILS_SHAREDTABLE_HPP_
#define _IDENTT_UTILS_SHAREDTABLE_HPP_

#include <memory>
#include <vector>
#include <chrono>
#include <random>

#include <utils/SharedCounter.hpp>
#include <utils/SharedPairMap.hpp>
#include <utils/SharedMap.hpp>

#include <store/StoreLevel.hpp>
#include <store/StoreCache.hpp>
#include <crypto/CryptoBase.hpp>

#define IDENTT_CURRTIME_MS std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()

namespace identt {
namespace utils {
class SharedTable : public std::enable_shared_from_this<SharedTable> {
public:
    using pointer=std::shared_ptr<SharedTable>;
    using dbpointer=identt::store::StoreLevel::dbpointer;
    using LockT = boost::shared_mutex;
    using WriteLockT = boost::unique_lock< LockT >;
    using ReadLockT = boost::shared_lock< LockT >;
    using SharedString = SharedObject<std::string>;
    using SharedDBPointer = SharedObject<dbpointer>;
    using SharedBool = SharedObject<bool>;
    using SharedInt = SharedObject<size_t>;

    using SharedRemote = SharedPairMap<std::string,uint64_t,uint64_t>;
    using RemoteMapT = SharedPairMap<std::string,uint64_t,uint64_t>::PairMapT;

    using SharedTrans = SharedMap<uint64_t,std::string>;
    using KeyRingT = std::unordered_map<std::string,std::shared_ptr<identt::crypto::CryptoBase> >;

    using SharedCache = identt::store::StoreCache::pointer;

    KeyRingT keyring;

    // map of shared followers
    SharedRemote remotes;

    // map of shared transactions
    SharedTrans transactions;

    // shared cache
    SharedCache dbcache;

    // string shared
    SharedString master;
    SharedString shared_secret;
    SharedString hostname;
    SharedString baseurl;
    SharedString thisurl;
    SharedString lastslave;
    // counter shared
    SharedCounter maincounter;
    SharedCounter logcounter;
    // database pointers
    SharedDBPointer maindb;
    SharedDBPointer logdb;
    // booleans
    SharedBool is_master;
    SharedBool is_ready;
    SharedBool lookup_requires_key;
    SharedBool invite_requires_key;
    SharedBool dont_send_sms;
    SharedBool lookup_uses_local;

    SharedTable(const SharedTable&) = delete;
    SharedTable& operator=(const SharedTable&) = delete;

    static pointer create()
    {
        pointer p(new SharedTable());
        return p;
    }

    pointer share()
    {
        return shared_from_this();
    }

    virtual ~SharedTable () {}

private:

    LockT class_mutex;
    LockT number_mutex;

    SharedTable()
        : dbcache ( identt::store::StoreCache::create() )
    {}

};
} // namespace utils
} // namespace identt
#endif /* _IDENTT_UTILS_SHAREDTABLE_HPP_ */