TypeContainer.h

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#ifndef SKYFIRE_TYPECONTAINER_H
#define SKYFIRE_TYPECONTAINER_H
 
/*
 * Here, you'll find a series of containers that allow you to hold multiple
 * types of object at the same time.
 */
 
#include "Define.h"
#include "Dynamic/TypeList.h"
#include "GridRefManager.h"
#include <map>
#include <vector>
 
 /*
  * @class ContainerMapList is a mulit-type container for map elements
  * By itself its meaningless but collaborate along with TypeContainers,
  * it become the most powerfully container in the whole system.
  */
template<class OBJECT> struct ContainerMapList
{
    //std::map<OBJECT_HANDLE, OBJECT *> _element;
    GridRefManager<OBJECT> _element;
};
 
template<> struct ContainerMapList<TypeNull>                /* nothing is in type null */
{
};
template<class H, class T> struct ContainerMapList<TypeList<H, T> >
{
    ContainerMapList<H> _elements;
    ContainerMapList<T> _TailElements;
};
 
/*
 * @class ContaierArrayList is a multi-type container for
 * array of elements.
 */
template<class OBJECT> struct ContainerArrayList
{
    std::vector<OBJECT> _element;
};
 
// termination condition
template<> struct ContainerArrayList<TypeNull> { };
// recursion
template<class H, class T> struct ContainerArrayList<TypeList<H, T> >
{
    ContainerArrayList<H> _elements;
    ContainerArrayList<T> _TailElements;
};
 
/*
 * @class ContainerList is a simple list of different types of elements
 *
 */
template<class OBJECT> struct ContainerList
{
    OBJECT _element;
};
 
/* TypeNull is underfined */
template<> struct ContainerList<TypeNull> { };
template<class H, class T> struct ContainerList<TypeList<H, T> >
{
    ContainerList<H> _elements;
    ContainerMapList<T> _TailElements;
};
 
#include "TypeContainerFunctions.h"
 
/*
 * @class TypeMapContainer contains a fixed number of types and is
 * determined at compile time.  This is probably the most complicated
 * class and do its simplest thing, that is, holds objects
 * of different types.
 */
 
template<class OBJECT_TYPES>
class TypeMapContainer
{
public:
    template<class SPECIFIC_TYPE> size_t Count() const { return Skyfire::Count(i_elements, (SPECIFIC_TYPE*)NULL); }

    template<class SPECIFIC_TYPE> bool insert(SPECIFIC_TYPE* obj)
    {
        SPECIFIC_TYPE* t = Skyfire::Insert(i_elements, obj);
        return (t != NULL);
    }

    //template<class SPECIFIC_TYPE> bool remove(SPECIFIC_TYPE* obj)
    //{
    //    SPECIFIC_TYPE* t = Skyfire::Remove(i_elements, obj);
    //    return (t != NULL);
    //}
 
    ContainerMapList<OBJECT_TYPES>& GetElements(void) { return i_elements; }
    const ContainerMapList<OBJECT_TYPES>& GetElements(void) const { return i_elements; }
 
private:
    ContainerMapList<OBJECT_TYPES> i_elements;
};
#endif