MimmoSharedPointer.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo 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.
 *
 *  mimmo 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 mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
#ifndef __MIMMOSHAREDPOINTER_HPP__
#define __MIMMOSHAREDPOINTER_HPP__
 
#include <mimmo_binary_stream.hpp>
 
//forward declaration.
namespace mimmo{
    template<class O>
    class MimmoSharedPointer;
}
 
// Providing binary stream for class MimmoSharedPointer
template< class T>
mimmo::IBinaryStream& operator>>(mimmo::IBinaryStream &buffer, mimmo::MimmoSharedPointer<T>& element);
 
template< class T >
mimmo::OBinaryStream& operator<<(mimmo::OBinaryStream &buffer, const mimmo::MimmoSharedPointer<T>& element);
namespace mimmo{
 
template<class O>
class MimmoSharedPointer
{
 
template< class T>
friend mimmo::IBinaryStream& (::operator>>) (mimmo::IBinaryStream &buffer, mimmo::MimmoSharedPointer<T>& element);
 
template< class T >
friend mimmo::OBinaryStream& (::operator<<) (mimmo::OBinaryStream &buffer, const mimmo::MimmoSharedPointer<T>& element);
 
public:
 
    MimmoSharedPointer();
    MimmoSharedPointer(O* object);
    ~MimmoSharedPointer();
    MimmoSharedPointer(const MimmoSharedPointer<O> & other);
    MimmoSharedPointer(MimmoSharedPointer<O> && other);
    MimmoSharedPointer & operator=(const MimmoSharedPointer<O> & other);
    MimmoSharedPointer & operator=(MimmoSharedPointer<O> && other);
 
    //methods
    void  swap(MimmoSharedPointer<O>& other) noexcept;
    O* get() const;
    std::size_t getCounter() const;
 
    void reset(O* object = nullptr);
 
    //derefencing operators
    O& operator*() const;
    O* operator->() const;
 
    //boolean operators
    bool operator!() const;
    operator bool() const;
 
    //inline compare operators
    inline bool operator==(const mimmo::MimmoSharedPointer<O>& rhs) const
    {
        return (get() == rhs.get());
    };
 
    inline bool operator!=(const mimmo::MimmoSharedPointer<O>& rhs) const
    {
        return !(*this == rhs);
    }
 
    inline bool operator==(const O* _rhs) const
    {
        // Check only pointer to object
        return (m_object == _rhs);
    };
 
    inline bool operator!=(const O* _rhs) const
    {
        return !(*this == _rhs);
    }
 
    inline bool operator==(const void* _rhs) const
    {
        // Check only pointer to object
        return (m_object == _rhs);
    };
 
    inline bool operator!=(const void* _rhs) const
    {
        return !(*this == _rhs);
    }
 
    inline bool operator==(const std::nullptr_t _rhs) const
    {
        // Check only pointer to object
        return (m_object == _rhs);
    };
 
    inline bool operator!=(const std::nullptr_t _rhs) const
    {
        return !(*this == _rhs);
    }
 
    inline bool operator==(const long int lrhs) const
    {
        // Check only pointer to object
        if (lrhs == 0){
            return (!m_object);
        }
        else{
            return bool(m_object);
        }
    };
 
    inline bool operator!=(const long int lrhs) const
    {
        return !(*this == lrhs);
    }
 
 
protected:
 
    void _init(O* object = nullptr, std::size_t* counter = nullptr);
    void _reset(O* object = nullptr, std::size_t* counter = nullptr);
    void _decrement();
 
    O*              m_object;   
    std::size_t*    m_counter;  
};
 
} // end namespace mimmo
 
 
namespace std{
 
template<class O>
struct hash<mimmo::MimmoSharedPointer<O> >
{
    size_t
    operator()(const mimmo::MimmoSharedPointer<O> & obj) const;
 
    size_t
    operator()(mimmo::MimmoSharedPointer<O> & obj);
};
 
} // end namespace std
 
#include "MimmoSharedPointer.tpp"
 
#endif /* __MIMMOSHAREDPOINTER_HPP__ */