MimmoSharedPointer.tpp

/*---------------------------------------------------------------------------*\
 *
 *  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/>.
 *
\*---------------------------------------------------------------------------*/
 
 
template< class T>
mimmo::IBinaryStream& operator>>(mimmo::IBinaryStream &buffer, mimmo::MimmoSharedPointer<T>& element){
    T* object;
    std::size_t* counter;
    buffer >> object;
    buffer >> counter;
    element._reset(object, counter);
    return buffer;
};
 
template< class T >
mimmo::OBinaryStream& operator<<(mimmo::OBinaryStream &buffer, const mimmo::MimmoSharedPointer<T>& element)
{
    buffer << element.m_object;
    buffer << element.m_counter;
    return buffer;
};
 
 
namespace mimmo{
 
template<class O>
MimmoSharedPointer<O>::MimmoSharedPointer()
{
    _init(nullptr, nullptr);
}
 
template<class O>
MimmoSharedPointer<O>::MimmoSharedPointer(O* object)
{
    _init(object, nullptr);
}
 
template<class O>
MimmoSharedPointer<O>::~MimmoSharedPointer(){
    _decrement();
}
 
template<class O>
MimmoSharedPointer<O>::MimmoSharedPointer(const MimmoSharedPointer<O> & other)
{
    m_object = other.m_object;
    m_counter = other.m_counter;
    if (m_counter){
        (*m_counter)++;
    }
}
 
template<class O>
MimmoSharedPointer<O>::MimmoSharedPointer(MimmoSharedPointer<O> && other)
{
    //attach the new contents to the class
    m_object = other.m_object;
    m_counter = other.m_counter;
 
    //empty the target source contents. They are owned by this class now
    other.m_object = nullptr;
    other.m_counter = nullptr;
}
 
template<class O>
MimmoSharedPointer<O> & MimmoSharedPointer<O>::operator=(const MimmoSharedPointer<O> & other)
{
    //check to avoid useless operations in case of auto-copy assignment.
    if(&other == this)
        return *this;
 
    //decrement the old contents in the class(if any).
    _decrement();
 
    //assign new contents from source
    m_object = other.m_object;
    m_counter = other.m_counter;
 
    //incrementing my counter.
    if (m_counter){
        (*m_counter)++;
    }
    return *this;
}
 
template<class O>
MimmoSharedPointer<O> & MimmoSharedPointer<O>::operator=(MimmoSharedPointer<O> && other)
{
    //check to avoid auto-move assignment.
    if(&other == this)
        return *this;
 
    //decrement the old contents in the class(if any).
    _decrement();
 
    //attach the new contents to the class
    m_object = other.m_object;
    m_counter = other.m_counter;
 
    //empty the target source contents. They are owned by this class now
    other.m_object = nullptr;
    other.m_counter = nullptr;
 
    return *this;
}
 
 template<class O>
 void MimmoSharedPointer<O>::swap(MimmoSharedPointer<O>& other) noexcept
{
    std::swap(m_object, other.m_object);
    std::swap(m_counter, other.m_counter);
}
 
 
template<class O>
O* MimmoSharedPointer<O>::get() const
{
    return m_object;
}
 
template<class O>
std::size_t MimmoSharedPointer<O>::getCounter() const
{
    if(m_counter)   return *(m_counter);
    else            return 0;
}
 
 
template<class O>
void MimmoSharedPointer<O>::reset(O* object)
{
    _reset(object, nullptr);
}
 
template<class O>
O& MimmoSharedPointer<O>::operator*() const
{
    return *(m_object);
}
 
template<class O>
O* MimmoSharedPointer<O>::operator->() const
{
    return m_object;
};
 
template<class O>
bool MimmoSharedPointer<O>::operator!() const
{
    return !m_object;
}
 
template<class O>
MimmoSharedPointer<O>::operator bool() const
{
    return bool(m_object);
}
 
template<class O>
void MimmoSharedPointer<O>::_init(O* object, std::size_t* counter )
{
    m_object = object;
    m_counter = counter;
    if (m_object){
        if(!m_counter)
            m_counter = new std::size_t(0);
        (*m_counter)++;
    }
    else{
        m_counter = nullptr;
    }
};
 
template<class O>
void MimmoSharedPointer<O>::_reset(O* object, std::size_t* counter )
{
    _decrement(),
    _init(object, counter);
};
 
template<class O>
void MimmoSharedPointer<O>::_decrement(){
    if (m_counter){
        ( *m_counter )-- ;
        if ( (*m_counter) == 0 ){
            delete m_object;
            delete m_counter;
        }
    }
    m_object = nullptr;
    m_counter = nullptr;
}
 
} //end namespace mimmo
 
namespace std{
 
template<class O>
size_t hash<mimmo::MimmoSharedPointer<O>>::operator()(const mimmo::MimmoSharedPointer<O> & obj) const
{
    return hash<const O*>()(obj.get());
}
 
template<class O>
size_t hash<mimmo::MimmoSharedPointer<O>>::operator()(mimmo::MimmoSharedPointer<O> & obj)
{
    return hash<O*>()(obj.get());
}
 
} // end namespace std