memory.h

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <memory>
#include <typeindex>
 
namespace dg
{
 
//there is probably a better class in boost...
template<class Cloneable>
struct ClonePtr
{
    ClonePtr() : m_ptr() {}
    ClonePtr( std::nullptr_t):m_ptr(nullptr){}
    ClonePtr( Cloneable* ptr): m_ptr(ptr){}
 
    ClonePtr( const Cloneable& src) : m_ptr( src.clone() ) { }
 
    ClonePtr( const ClonePtr& src) : m_ptr( src.m_ptr.get() == nullptr ? nullptr : src.m_ptr->clone() ) { }
    ClonePtr& operator=( const ClonePtr& src)
    {
        //copy and swap
        ClonePtr tmp(src);
        swap( *this, tmp );
        return *this;
    }
    ClonePtr( ClonePtr&& src) noexcept : m_ptr( nullptr)
    {
        swap( *this, src); //steal resource
    }
    ClonePtr& operator=( ClonePtr&& src) noexcept
    {
        swap( *this, src );
        return *this;
    }
    friend void swap( ClonePtr& first, ClonePtr& second)
    {
        std::swap(first.m_ptr,second.m_ptr);
    }
 
    void reset( Cloneable* ptr){
        m_ptr.reset( ptr);
    }
    Cloneable* release() noexcept { m_ptr.release();}
    void reset( const Cloneable& src){
        ClonePtr tmp(src);
        swap(*this, tmp);
    }
 
    Cloneable * get() {return m_ptr.get();}
    const Cloneable* get() const {return m_ptr.get();}
 
    Cloneable& operator*() { return *m_ptr;}
    const Cloneable& operator*() const { return *m_ptr;}
    Cloneable* operator->() { return m_ptr.operator->();}
    const Cloneable* operator->()const { return m_ptr.operator->();}
    explicit operator bool() const{ return (bool)m_ptr;}
 
 
    private:
    std::unique_ptr<Cloneable> m_ptr;
};
 
namespace detail
{
 
//should not be public (because of the const behaviour, which is a dirty trick...)
template<template<typename> typename Vector>
struct AnyVector
{
    AnyVector( ) : m_type( typeid( void)){}
 
    // If not allocated or wrong type; change size and type
    // May need to be called using any_vec.template set<value_type>(size)
    template<class value_type>
    void set(unsigned size)
    {
        auto type_idx = std::type_index( typeid( value_type));
        if( type_idx != m_type)
        {
            m_vec.emplace<Vector<value_type>>(size);
            m_type = type_idx;
        }
        else
        {
            auto ptr = std::any_cast<Vector<value_type>>(
                &m_vec);
            ptr->resize( size);
        }
    }
    // If you think you need this fct. think again, std::vector e.g. will not release
    // memory on resize unless the size is bigger
    //template<class value_type>
    //void set_at_least( unsigned size);
    template<class value_type>
    void swap ( Vector<value_type>& src)
    {
        auto type_idx = std::type_index( typeid( value_type));
        if( type_idx != m_type)
        {
            m_vec.emplace< Vector<value_type>>(std::move(src));
            m_type = type_idx;
        }
        else
        {
            auto& vec = std::any_cast<Vector<value_type>&>( m_vec);
            src.swap(vec);
        }
    }
    // Get read access to underlying buffer
    // May need to be called using any_vec.template get<value_type>()
    template<class value_type>
    const Vector<value_type>& get( ) const
    {
        // throws if not previously set
        return std::any_cast<const Vector<value_type>&>(
            m_vec);
    }
    template<class value_type>
    Vector<value_type>& get( )
    {
        // throws if not previously set
        return std::any_cast<Vector<value_type>&>(
            m_vec);
    }
    private:
    //std::unordered_map< std::type_index, Buffer<std::any>>  m_vec;
    std::any m_vec;
    std::type_index m_type;
};
 
}//namespace detail
 
}//namespace dg