piercedStorage.hpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_PIERCED_STORAGE_HPP__
#define __BITPIT_PIERCED_STORAGE_HPP__
 
#include <vector>
 
#include "piercedStorageRange.hpp"
#include "piercedStorageIterator.hpp"
#include "piercedKernel.hpp"
#include "piercedSync.hpp"
 
#define __PS_REFERENCE__       typename PiercedStorage<value_t, id_t>::reference
#define __PS_CONST_REFERENCE__ typename PiercedStorage<value_t, id_t>::const_reference
#define __PS_POINTER__         typename PiercedStorage<value_t, id_t>::pointer
#define __PS_CONST_POINTER__   typename PiercedStorage<value_t, id_t>::const_pointer
 
namespace bitpit {
 
class BasePiercedStorage {
 
public:
    virtual ~BasePiercedStorage() = default;
 
protected:
    BasePiercedStorage() = default;
 
};
 
template<typename id_t = long>
class PiercedStorageSyncSlave : public PiercedSyncSlave, public BasePiercedStorage {
 
public:
    // Template typedef
 
    template<typename PK_id_t>
    using Kernel = PiercedKernel<PK_id_t>;
 
    // Typedefs
 
    typedef typename Kernel<id_t>::id_type id_type;
 
    typedef Kernel<id_t> kernel_t;
 
    // Enums
    enum KernelType {
        KERNEL_NONE    = -1,
        KERNEL_STATIC  =  0,
        KERNEL_DYNAMIC =  1
    };
 
    // Virtual destructor
    virtual ~PiercedStorageSyncSlave();
 
    // Methods for synchronizing the storage
    void setStaticKernel(const PiercedKernel<id_t> *kernel);
    void setDynamicKernel(const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
    void unsetKernel(bool release = true);
    const PiercedKernel<id_t> * getKernel() const;
    KernelType getKernelType() const;
    PiercedSyncMaster::SyncMode getSyncMode() const;
 
    // Methods that modify the container as a whole
    void swap(PiercedStorageSyncSlave<id_t> &other) noexcept;
 
protected:
    const PiercedKernel<id_t> *m_kernel;
    KernelType m_kernelType;
 
    // Constructors and initialization
    PiercedStorageSyncSlave();
    PiercedStorageSyncSlave(const PiercedKernel<id_t> *kernel);
    PiercedStorageSyncSlave(const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
    PiercedStorageSyncSlave(const PiercedStorageSyncSlave<id_t> &other);
    PiercedStorageSyncSlave(const PiercedStorageSyncSlave<id_t> &other, const PiercedKernel<id_t> *kernel);
    PiercedStorageSyncSlave(const PiercedStorageSyncSlave<id_t> &other, const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
    PiercedStorageSyncSlave(PiercedStorageSyncSlave<id_t> &&other);
    PiercedStorageSyncSlave(PiercedStorageSyncSlave<id_t> &&other, const PiercedKernel<id_t> *kernel);
    PiercedStorageSyncSlave(PiercedStorageSyncSlave<id_t> &&other, const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
 
    // Methods for synchronizing the storage
    virtual void _postSetStaticKernel();
    virtual void _postSetDynamicKernel();
    virtual void _postUnsetKernel(bool release = true);
    void detachKernel();
 
};
 
template<typename value_t, typename id_t = long>
class PiercedStorage : public PiercedStorageSyncSlave<id_t> {
 
// Friendships
template<typename PI_value_t, typename PI_id_t, typename PI_value_no_cv_t>
friend class PiercedStorageIterator;
 
private:
    template <typename T>
    class check_restore
    {
 
    private:
        template<typename class_t>
        static std::true_type test_restore(decltype(std::declval<class_t>().restore(std::declval<std::istream &>())) *);
 
        template<typename class_t>
        static std::false_type test_restore(...);
 
        template<typename class_t>
        static constexpr bool has_restore()
        {
            return std::is_same<decltype(test_restore<class_t>(nullptr)), std::true_type>();
        }
 
    public:
        static const bool value = has_restore<T>();
 
    };
 
    template <typename T>
    class check_dump
    {
 
    private:
        template<typename class_t>
        static std::true_type test_dump(decltype(std::declval<class_t>().dump(std::declval<std::ostream &>())) *);
 
        template<typename class_t>
        static std::false_type test_dump(...);
 
        template<typename class_t>
        static constexpr bool has_dump()
        {
            return std::is_same<decltype(test_dump<class_t>(nullptr)), std::true_type>();
        }
 
    public:
        static const bool value = has_dump<T>();
 
    };
 
    template <typename T, typename Ret, typename... Args>
    class check_initialize
    {
 
    private:
        template<typename C>
        static constexpr auto test_initialize(C *)
            -> typename std::is_same<decltype(std::declval<C>().initialize(std::declval<Args>()...)), Ret>::type;
 
        template<typename class_t>
        static constexpr auto test_initialize(...)
            -> std::false_type;
 
    public:
        static const bool value = std::is_same<decltype(test_initialize<T>(nullptr)), std::true_type>();
 
    };
 
public:
    // Template typedef
 
    template<typename PK_id_t>
    using Kernel = typename PiercedStorageSyncSlave<id_t>::template Kernel<PK_id_t>;
 
    // Typedefs
 
    typedef value_t value_type;
 
    typedef typename Kernel<id_t>::id_type id_type;
 
    typedef Kernel<id_t> kernel_t;
 
    typedef typename PiercedStorageSyncSlave<id_t>::KernelType KernelType;
 
    typedef std::vector<value_t> container_t;
 
    typedef typename container_t::reference reference;
 
    typedef typename container_t::const_reference const_reference;
 
    typedef typename container_t::pointer pointer;
 
    typedef typename container_t::const_pointer const_pointer;
 
    typedef PiercedStorageIterator<value_t, id_t> iterator;
 
    typedef PiercedStorageIterator<const value_t, id_t> const_iterator;
 
    typedef typename std::vector<value_t>::iterator raw_iterator;
 
    typedef typename std::vector<value_t>::const_iterator raw_const_iterator;
 
    typedef PiercedStorageRange<value_t, id_t> range;
 
    typedef PiercedStorageRange<const value_t, id_t> const_range;
 
    static constexpr bool has_restore()
    {
        return check_restore<value_t>::value;
    };
 
    static constexpr bool has_dump()
    {
        return check_dump<value_t>::value;
    };
 
    template<typename... Args>
    static constexpr bool has_initialize()
    {
        return check_initialize<value_t, void, Args...>::value;
    }
 
    template <typename... Args>
    using EnableIfHasInitialize = typename std::enable_if<PiercedStorage<value_t, id_t>::template has_initialize<Args...>()>::type;
 
    // Constructors and initialization
    PiercedStorage();
    PiercedStorage(std::size_t nFields);
    PiercedStorage(std::size_t nFields, const PiercedKernel<id_t> *kernel);
    PiercedStorage(std::size_t nFields, const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
    PiercedStorage(const PiercedStorage<value_t, id_t> &other);
    PiercedStorage(const PiercedStorage<value_t, id_t> &other, const PiercedKernel<id_t> *kernel);
    PiercedStorage(const PiercedStorage<value_t, id_t> &other, const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
    PiercedStorage(PiercedStorage<value_t, id_t> &&other);
    PiercedStorage(PiercedStorage<value_t, id_t> &&other, const PiercedKernel<id_t> *kernel);
    PiercedStorage(PiercedStorage<value_t, id_t> &&other, const PiercedKernel<id_t> *kernel, PiercedSyncMaster::SyncMode syncMode);
 
    PiercedStorage & operator=(const PiercedStorage &other);
    PiercedStorage & operator=(PiercedStorage &&other);
 
    // Methods for accessing container properties
    std::size_t getFieldCount() const;
 
    // Methods that modify the container as a whole
    void swap(PiercedStorage &other) noexcept;
    void fill(const value_t &value);
 
    // Methos to access data stored in the container
    __PS_POINTER__ data();
    __PS_CONST_POINTER__ data() const;
 
    __PS_POINTER__ data(id_t id, std::size_t offset = 0);
    __PS_CONST_POINTER__ data(id_t id, std::size_t offset = 0) const;
 
    __PS_POINTER__ rawData(std::size_t pos, std::size_t offset = 0);
    __PS_CONST_POINTER__ rawData(std::size_t pos, std::size_t offset = 0) const;
 
    // Methods for editing the items using their id
    __PS_REFERENCE__ back(std::size_t k = 0);
    __PS_CONST_REFERENCE__ back(std::size_t k = 0) const;
 
    __PS_REFERENCE__ front(std::size_t k = 0);
    __PS_CONST_REFERENCE__ front(std::size_t k = 0) const;
 
    __PS_REFERENCE__ at(id_t id, std::size_t k = 0);
    __PS_CONST_REFERENCE__ at(id_t id, std::size_t k = 0) const;
 
    __PS_REFERENCE__ operator[](id_t id);
    __PS_CONST_REFERENCE__ operator[](id_t id) const;
 
    void copy(id_t id, value_t *values) const;
    void copy(id_t id, std::size_t nFields, std::size_t offset, value_t *values) const;
 
    void set(id_t id, const value_t &value);
    void set(id_t id, std::size_t k, const value_t &value);
    void set(id_t id, const value_t *values);
    void set(id_t id, std::size_t nFields, std::size_t offset, const value_t *values);
 
    // Methods for editing the items using their position
    __PS_REFERENCE__  rawAt(std::size_t pos, std::size_t offset = 0);
    __PS_CONST_REFERENCE__ rawAt(std::size_t pos, std::size_t offset = 0) const;
 
    void rawCopy(std::size_t pos, value_t *values) const;
    void rawCopy(std::size_t pos, std::size_t nFields, std::size_t offset, value_t *values) const;
 
    void rawSet(std::size_t pos, const value_t &value);
    void rawSet(std::size_t pos, std::size_t k, const value_t &value);
    void rawSet(std::size_t pos, const value_t *values);
    void rawSet(std::size_t pos, std::size_t nFields, std::size_t offset, const value_t *values);
 
    // Iterators
    iterator find(const id_t &id) noexcept;
    const_iterator find(const id_t &id) const noexcept;
 
    iterator rawFind(std::size_t pos) noexcept;
    const_iterator rawFind(std::size_t pos) const noexcept;
 
    iterator begin() noexcept;
    iterator end() noexcept;
    const_iterator begin() const noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
 
    raw_iterator rawBegin() noexcept;
    raw_iterator rawEnd() noexcept;
    raw_const_iterator rawBegin() const noexcept;
    raw_const_iterator rawEnd() const noexcept;
    raw_const_iterator rawCbegin() const noexcept;
    raw_const_iterator rawCend() const noexcept;
 
    // Dump and restore
    template<typename T = value_t, typename std::enable_if<std::is_pod<T>::value || PiercedStorage<T, id_t>::has_restore()>::type * = nullptr>
    void restore(std::istream &stream);
 
    template<typename T = value_t, typename std::enable_if<std::is_pod<T>::value || PiercedStorage<T, id_t>::has_dump()>::type * = nullptr>
    void dump(std::ostream &stream) const;
 
protected:
    // Methods for synchronizing the storage
    void _postSetStaticKernel() override;
    void _postSetDynamicKernel() override;
    void _postUnsetKernel(bool release = true) override;
 
    // Methos for getting information on the storage
    std::size_t rawSize() const;
 
    // Methods for synchronizing the storage
    void commitSyncAction(const PiercedSyncAction &action) override;
 
    // Methos for updating the storage
    void rawReserve(std::size_t n);
    void rawShrinkToFit();
 
    void rawClear(bool release);
    void rawErase(std::size_t pos, std::size_t n);
 
    template<typename T = value_t, typename std::enable_if<!std::is_same<T, bool>::value>::type * = nullptr>
    void rawSwap(std::size_t pos_first, std::size_t pos_second);
    template<typename T = value_t, typename std::enable_if<std::is_same<T, bool>::value>::type * = nullptr>
    void rawSwap(std::size_t pos_first, std::size_t pos_second);
    void rawReorder(const std::vector<std::size_t> &permutations);
 
    void rawResize(std::size_t n, const value_t &value = value_t());
 
    template<typename... Args, typename PiercedStorage<value_t>::template EnableIfHasInitialize<Args...> * = nullptr>
    void rawInitialize(std::size_t pos, Args&&... args);
    template<typename... Args, typename PiercedStorage<value_t>::template EnableIfHasInitialize<Args...> * = nullptr>
    void rawInitialize(std::size_t pos, std::size_t k, Args&&... args);
 
    void rawInsert(std::size_t pos, std::size_t n, const value_t &value);
    void rawPushBack(const value_t &value);
    template<typename T = value_t, typename std::enable_if<!std::is_same<T, bool>::value>::type * = nullptr, typename... Args>
    void rawEmplace(std::size_t pos, Args&&... args);
    template<typename T = value_t, typename std::enable_if<std::is_same<T, bool>::value>::type * = nullptr>
    void rawEmplace(std::size_t pos, bool value = false);
    template<typename T = value_t, typename std::enable_if<!std::is_same<T, bool>::value>::type * = nullptr, typename... Args>
    void rawEmplaceBack(Args&&... args);
    template<typename T = value_t, typename std::enable_if<std::is_same<T, bool>::value>::type * = nullptr>
    void rawEmplaceBack(bool value = false);
    template<typename... Args>
    void rawEmreplace(std::size_t pos, Args&&... args);
 
private:
    std::size_t m_nFields;
    container_t m_fields;
 
    void restoreField(std::istream &stream, std::vector<bool>::reference value);
 
    template<typename T = value_t, typename std::enable_if<!PiercedStorage<T, id_t>::has_restore()>::type * = nullptr>
    void restoreField(std::istream &stream, value_t &value);
 
    template<typename T = value_t, typename std::enable_if<PiercedStorage<T, id_t>::has_restore()>::type * = nullptr>
    void restoreField(std::istream &stream, value_t &object);
 
    void dumpField(std::ostream &stream, std::vector<bool>::const_reference value) const;
 
    template<typename T = value_t, typename std::enable_if<!PiercedStorage<T, id_t>::has_dump()>::type * = nullptr>
    void dumpField(std::ostream &stream, const value_t &value) const;
 
    template<typename T = value_t, typename std::enable_if<PiercedStorage<T, id_t>::has_dump()>::type * = nullptr>
    void dumpField(std::ostream &stream, const value_t &object) const;
 
};
 
}
 
// Templates
#include "piercedStorage.tpp"
 
#endif