pointer_hash_map_set.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics 
//
//  License:         BSD License 
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                    
//
 
 
 
#if !defined(KRATOS_POINTER_HASH_MAP_SET_H_INCLUDED )
#define  KRATOS_POINTER_HASH_MAP_SET_H_INCLUDED
 
 
 
// System includes
 
 
// External includes
#include <utility>
#include <type_traits>
#include <unordered_map>
 
// Project includes
#include "includes/define.h"
#include "includes/serializer.h"
#include "containers/set_identity_function.h"
 
namespace Kratos
{
 
 
 
 
 
 
template<class TDataType,
         class THashType = std::hash<TDataType>,
         class TGetKeyType = SetIdentityFunction<TDataType>,
         class TPointerType = Kratos::shared_ptr<TDataType> >
class PointerHashMapSet final
{
 
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(PointerHashMapSet);
 
    typedef decltype(std::declval<TGetKeyType>()(std::declval<TDataType>())) key_type;
 
    typedef TDataType data_type;
    typedef TDataType value_type;
    typedef TPointerType pointer_type;
    typedef TDataType& reference;
    typedef const TDataType& const_reference;
    // typedef std::unordered_map<key_type, TPointerType, THashType> ContainerType;
    typedef std::unordered_map<typename std::remove_reference<key_type>::type, TPointerType, THashType> ContainerType;
 
    typedef typename ContainerType::size_type size_type;
    typedef typename ContainerType::iterator ptr_iterator;
    typedef typename ContainerType::const_iterator ptr_const_iterator;
    typedef typename ContainerType::difference_type difference_type;
 
 
private:
    class iterator_adaptor
    {
        ptr_iterator map_iterator;
    public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type   = std::ptrdiff_t;
        using value_type        = data_type;
        using pointer           = data_type*;
        using reference         = data_type&;
        
        iterator_adaptor(ptr_iterator it) :map_iterator(it) {}
        iterator_adaptor(const iterator_adaptor& it) : map_iterator(it.map_iterator) {}
        iterator_adaptor& operator++() { map_iterator++; return *this; }
        iterator_adaptor operator++(int) { iterator_adaptor tmp(*this); operator++(); return tmp; }
        bool operator==(const iterator_adaptor& rhs) const { return map_iterator == rhs.map_iterator; }
        bool operator!=(const iterator_adaptor& rhs) const { return map_iterator != rhs.map_iterator; }
        data_type& operator*() const { return *(map_iterator->second); }
        pointer_type operator->() const { return map_iterator->second; }
        ptr_iterator& base() { return map_iterator; }
        ptr_iterator const& base() const { return map_iterator; }
    };
 
    class const_iterator_adaptor
    {
        ptr_const_iterator map_iterator;
    public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type   = std::ptrdiff_t;
        using value_type        = data_type;
        using pointer           = data_type*;
        using reference         = data_type&;
 
        const_iterator_adaptor(ptr_const_iterator it) :map_iterator(it) {}
        const_iterator_adaptor(const const_iterator_adaptor& it) : map_iterator(it.map_iterator) {}
        const_iterator_adaptor& operator++() { map_iterator++; return *this; }
        const_iterator_adaptor operator++(int) { const_iterator_adaptor tmp(*this); operator++(); return tmp; }
        bool operator==(const const_iterator_adaptor& rhs) const { return map_iterator == rhs.map_iterator; }
        bool operator!=(const const_iterator_adaptor& rhs) const { return map_iterator != rhs.map_iterator; }
        data_type const& operator*() const { return *(map_iterator->second); }
        pointer_type operator->() const { return map_iterator->second; }
        ptr_const_iterator& base() { return map_iterator; }
        ptr_const_iterator const& base() const { return map_iterator; }
    };
 
 
public:
 
 
    typedef iterator_adaptor iterator;
    typedef const_iterator_adaptor const_iterator;
 
 
    PointerHashMapSet() : mData() {}
 
    template <class TInputIteratorType>
 
    PointerHashMapSet(TInputIteratorType First, TInputIteratorType Last, size_type NewMaxBufferSize = 1)
    {
        for(; First != Last; ++First)
            insert(begin(), *First);
    }
 
    PointerHashMapSet(const PointerHashMapSet& rOther)
        :  mData(rOther.mData) {}
 
    PointerHashMapSet(const ContainerType& rContainer) :  mData(rContainer)
    {
    }
 
    ~PointerHashMapSet() {}
 
 
 
    PointerHashMapSet& operator=(const PointerHashMapSet& rOther)
    {
        mData = rOther.mData;
 
        return *this;
    }
 
    TDataType& operator[](const key_type& Key)
    {
        KRATOS_DEBUG_ERROR_IF(mData.find(Key) == mData.end()) << "The key: " << Key << " is not available in the map" << std::endl;
        return *(mData.find(Key)->second);
    }
 
    pointer_type& operator()(const key_type& Key)
    {
        KRATOS_DEBUG_ERROR_IF(mData.find(Key) == mData.end()) << "The key: " << Key << " is not available in the map" << std::endl;
        return mData.find(Key)->second;
    }
 
    bool operator==( const PointerHashMapSet& r ) const // nothrow
    {
       return (mData == r.mData);
    }
 
    bool operator!=(const PointerHashMapSet& r) const // nothrow
    {
        return (mData != r.mData);
    }
 
 
 
    iterator                   begin()
    {
        return iterator( mData.begin() );
    }
    const_iterator             begin() const
    {
        return const_iterator( mData.begin() );
    }
    iterator                   end()
    {
        return iterator( mData.end() );
    }
    const_iterator             end() const
    {
        return const_iterator( mData.end() );
    }
    ptr_iterator               ptr_begin()
    {
        return mData.begin();
    }
    ptr_const_iterator         ptr_begin() const
    {
        return mData.begin();
    }
    ptr_iterator               ptr_end()
    {
        return mData.end();
    }
    ptr_const_iterator         ptr_end() const
    {
        return mData.end();
    }
 
    reference        front()       /* nothrow */
    {
        //assert( !empty() );
        return *(mData.front().second);
    }
    const_reference  front() const /* nothrow */
    {
        //assert( !empty() );
        return *(mData.front().second);
    }
    reference        back()        /* nothrow */
    {
        //assert( !empty() );
        return *(mData.back().second);
    }
    const_reference  back() const  /* nothrow */
    {
        //assert( !empty() );
        return *(mData.back().second);
    }
 
    size_type size() const
    {
        return mData.size();
    }
 
    //size_type max_size() const
    //{
    //    return mData.max_size();
    //}
 
    //key_compare key_comp() const
    //{
    //    return TCompareType();
    //}
 
    void swap(PointerHashMapSet& rOther)
    {
        mData.swap(rOther.mData);
    }
 
    template<class TOtherDataType>
    iterator insert(const TOtherDataType& rData)
    {
        TDataType* p_new_data = new TDataType(rData);
        return mData.insert(ContainerType::value_type(TGetKeyOf(rData), p_new_data));
    }
 
    iterator insert(TPointerType pData)
    {
        key_type key=KeyOf(*pData);
        typename ContainerType::value_type item(key, pData);
        std::pair<typename ContainerType::iterator, bool> result = mData.insert(item);
        // TODO: I should enable this after adding the KRATOS_ERROR to define.h. Pooyan.
        //if(result.second != true)
        //  KRATOS_ERROR << "Error in adding the new item" << std::endl
        return result.first;
    }
 
    template <class InputIterator>
    void insert(InputIterator First, InputIterator Last)
    {
        for(; First != Last; ++First)
            insert(begin(),*First);
    }
 
 
    iterator erase(iterator pos)
    {
        return mData.erase(pos.base());
    }
 
    size_type erase(key_type const& Key)
    {
        return mData.erase(Key);
    }
 
    iterator erase( iterator first, iterator last )
    {
        return mData.erase( first.base(), last.base() );
    }
 
    void clear()
    {
        mData.clear();
    }
 
    iterator find(const key_type& Key)
    {
         return mData.find(Key);
    }
 
    const_iterator find(const key_type& Key) const
    {
        return mData.find(Key);
    }
 
    size_type count(const key_type& Key)
    {
        return find(Key) == mData.end() ? 0 : 1;
    }
 
    void reserve(int reservedsize)
    {
        mData.reserve(reservedsize);
    }
    int capacity()
    {
        return mData.capacity();
    }
 
 
 
    ContainerType& GetContainer()
    {
        return mData;
    }
 
    const ContainerType& GetContainer() const
    {
        return mData;
    }
 
 
 
 
    bool empty() const
    {
        return mData.empty();
    }
 
 
 
    std::string Info() const
    {
        std::stringstream buffer;
        buffer << "Pointer hash map set (size = " << size() << ") : ";
 
        return buffer.str();
    }
 
 
    void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const
    {
        std::copy(begin(), end(), std::ostream_iterator<TDataType>(rOStream, "\n "));
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
    ContainerType mData;
 
 
 
 
    key_type KeyOf(iterator i)
    {
        return TGetKeyType()(*i);
    }
 
    key_type KeyOf(ptr_iterator i)
    {
        return TGetKeyType()(**i);
    }
 
    key_type KeyOf(const TDataType & i)
    {
        return TGetKeyType()(i);
    }
 
 
 
    friend class Serializer;
 
 
    virtual void save(Serializer& rSerializer) const
    {
        size_type size = mData.size();
 
        rSerializer.save("size", size);
 
        for (ptr_const_iterator i = ptr_begin(); i != ptr_end(); i++)
            rSerializer.save("E", i->second);
    }
 
    virtual void load(Serializer& rSerializer)
    {
        size_type size;
 
        rSerializer.load("size", size);
 
        for (size_type i = 0; i < size; i++)
        {
                pointer_type p = nullptr;// new TDataType;
            rSerializer.load("E", p);
            insert(p);
        }
    }
 
 
 
 
 
 
 
 
 
}; // Class PointerHashMapSet
 
 
 
 
 
 
//template<class TDataType,
//         class TGetKeyType,
//         class TCompareType,
//         class TEqualType,
//         class TPointerType,
//         class ContainerType>
//inline std::istream& operator >> (std::istream& rIStream,
//                                  PointerHashMapSet<TDataType, TGetKeyType, TCompareType, TEqualType, TPointerType, ContainerType>& rThis);
 
template<class TDataType,
         class TGetKeyType,
         class TCompareType,
         class TEqualType,
         class TPointerType,
         class ContainerType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const PointerHashMapSet<TDataType, TGetKeyType, TCompareType, TPointerType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_POINTER_HASH_MAP_SET_H_INCLUDED  defined