cortex.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_cortex_h
#define INCL_evo_cortex_h

#include "ptr.h"
#if defined(EVO_CORTEX_DEFAULT_HASHMAP)
    #include "maphash.h"
    #define EVO_CORTEX_IMPL_DEFAULT =MapHash<String,SharedPtr<PureBase> >
#elif !defined(EVO_CORTEX_NO_DEFAULT)
    #include "maplist.h"
    #define EVO_CORTEX_IMPL_DEFAULT =MapList<String,SharedPtr<PureBase> >
#else
    #define EVO_CORTEX_IMPL_DEFAULT
#endif

#define EVO_CORTEX_MAPLIST(KEY, BASE) evo::Cortex< evo::MapList<KEY, evo::SharedPtr<BASE> > >

#define EVO_CORTEX_MAPHASH(KEY, BASE) evo::Cortex< evo::MapHash<KEY, evo::SharedPtr<BASE> > >

namespace evo {

#if !defined(EVO_CORTEX_DYNAMIC_CAST)

    #define EVO_CORTEX_DYNAMIC_CAST 1
#endif

#if EVO_CORTEX_DYNAMIC_CAST
    #define EVO_CORTEX_IMPL_CAST dynamic_cast
#else
    #define EVO_CORTEX_IMPL_CAST static_cast
#endif


template<class T EVO_CORTEX_IMPL_DEFAULT>
class Cortex : public T {
public:
    typedef Cortex<T> This;                     
    typedef T MapType;                          
    typedef typename T::Value::Item ValueBase;  

#if defined(EVO_OLDCC)
    typedef typename T::Key Key;
    typedef typename T::Value Value;
#else
    using typename T::Key;
    using typename T::Value;
#endif

    Cortex() {
        #if defined(EVO_CPP11)
            static_assert(IsSmartPtr<Value>::value, "Cortex Map Value must be a SharedPtr to a type derived from evo::PureBase");
        #else
            STATIC_ASSERT( IsSmartPtr<Value>::value, ERROR__Cortex_Map_Value_must_be_a_SharedPtr_to_type_derived_from_PureBase );
        #endif
    }

    template<class ItemT>
    This& create(const Key& key) {
        bool created = false;
        Value& item = MapType::get(key, &created);
        if (created)
            item = new ItemT;
        return *this;
    }

    template<class ItemT>
    ItemT& get_create(const Key& key) {
        bool created = false;
        Value& item = MapType::get(key, &created);
        if (created)
            item = new ItemT;
        return *(EVO_CORTEX_IMPL_CAST <ItemT*>(item.ptr()));
    }

    template<class ItemT>
    ItemT* getptr(const Key& key) {
        Value* item = MapType::findM(key);
        if (item == NULL)
            return NULL;
        return EVO_CORTEX_IMPL_CAST <ItemT*>(item->ptr());
    }

    template<class ItemT>
    const ItemT* getptr_const(const Key& key) const {
        const Value* item = MapType::find(key);
        if (item == NULL)
            return NULL;
        return EVO_CORTEX_IMPL_CAST <const ItemT*>(item->ptr());
    }

private:
    Cortex(const Cortex&) EVO_ONCPP11(= delete);
    Cortex& operator=(const Cortex&) EVO_ONCPP11(= delete);
};


struct CortexModuleBase {
    virtual ~CortexModuleBase() {
    }

    template<class T>
    T& as() {
        return * EVO_CORTEX_IMPL_CAST <T*>(this);
    }
};


typedef SharedPtr<CortexModuleBase> CortexModulePtr;


template<class T>
struct CortexModuleAsBase {
    template<class U>
    static T& get(U& ptr) {
        if (!ptr)
            ptr = new T;
        return *EVO_CORTEX_IMPL_CAST <T*>(ptr.ptr());
    }

    template<class U>
    static T* getptr(U& ptr) {
        if (ptr)
            return EVO_CORTEX_IMPL_CAST <T*>(ptr.ptr());
        return NULL;
    }
};


#undef EVO_CORTEX_IMPL_CAST


}
#endif