FiberType.hpp

#ifndef __FIBERTYPE_HPP
#define __FIBERTYPE_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "FieldAPI.h"
 
#include <meta/LIST.hpp>
#include <eagle/MetaInfo.hpp>
#include <memcore/RefPtr.hpp>
#include <memcore/typemap.hpp>
#include <memcore/stringlist.hpp>
#include <memcore/Chunk.hpp>
 
#include <assert.h>
#include <string>
 
#include "FiberTypeIndex.hpp"
#include "FiberTypeBase.hpp"
 
namespace Fiber
{
 
 
template <class T>
struct SizeOf
{
static  size_t memsize() { return sizeof(T); }
 
static  MemCore::RefPtr<MemCore::Chunk<T> > newChunk(size_t N, bool ReserveOnly = false)
        {
                return new MemCore::Chunk<T>(N, ReserveOnly);
        }
};
 
#if 0
template <>        struct SizeOf<void>
{
static  size_t memsize() { return 0;         }
 
static  MemCore::NullPtr newChunk(size_t, bool=false)
        {
                return MemCore::NullPtr();
        }
};
#endif
 
 
 
template <class T>
class   FiberType : public FiberTypeBase
{
public:
 
        typedef Eagle::MetaInfo<T> FiberInfo_t;
        typedef typename FiberInfo_t::element_t element_t;
 
        typedef typename FiberInfo_t::Chart_t Chart_t;
 
        enum { Dims = Eagle::CoordinateInfo<Chart_t>::Dims };
 
 
static  FiberTypeIndex getFiberTypeIndex()
        {
                return
                {
                          FiberInfo_t::MULTIPLICITY
/* mem_size */          , unsigned( SizeOf<T>::memsize() )
/* rank */              , FiberInfo_t::RANK
/* grade*/              , FiberInfo_t::GRADE
/* element_size */      , unsigned( SizeOf<typename FiberInfo_t::element_t>::memsize() )
/* type_name */         , MemCore::Typename(typeid(T) )
/* element_type_name */ , MemCore::Typename(typeid(typename FiberInfo_t::element_t))
/* chart_name */        , MemCore::Typename(typeid(Chart_t) )
/* chart_dimension */   , Dims
                };
        }
 
 
        FiberType()
        : FiberTypeBase( getFiberTypeIndex() )
        {
                FiberTypeBase::remember();
        }
 
        FiberType(const FiberType&) = delete;
 
 
//static        FiberType TypeInfo;
 
        const std::type_info&getType() const override
        {
                return typeid(T);
        }
 
        MemCore::RefPtr<MemCore::ChunkBase> newChunk(size_t N) const override
        {
                return SizeOf<T>::newChunk(N);
        }
 
        bool    isType(const std::type_info&theType) const override
        {
                return theType == typeid(T);
        }
 
static  WeakPtr_t getFiberType()
        {
        static  MemCore::Auto<FiberType<T>> myType;
                return myType.self();
        }
 
        WeakPtr_t element_type() const override
        {
                return FiberType<element_t>::getFiberType();
        }
/*
        unsigned multiplicity() const override
        {
                return FiberInfo_t::MULTIPLICITY;
        }
 
        int rank() const override
        {
                return FiberInfo_t::RANK;
        }
*/
 
/*      int     grade() const override
        {
                return FiberInfo_t::GRADE;
        }
*/
        std::string     coordinate_component_name(int i) const override
        {
                return Eagle::CoordinateInfo<Chart_t>::coordinate_name(i);
        }
 
        const std::type_info&chart_type() const override
        {
                return typeid(Chart_t);
        }
/*
        std::string chart_name() const override
        {
                return MemCore::Typename(chart_type() );
        }
 
 
        int chart_dimension() const override
        {
                return Dims;
        }
*/
        int element_index(const int i[]) const override
        {
                return Eagle::MetaInfoElementIndex<T>::element_index(i);
        }
/*
        unsigned mem_size() const override
        {
                return unsigned( SizeOf<T>::memsize() );
        }
*/
 
        int indexing_scheme(int i) const override
        {
                return Eagle::TypeIndexingScheme<T>::index(i);
        }
 
        const char*nontensor() const override
        {
                return 0;
//              return FiberInfoNonTensor<T>::object_name();
        }
};
 
 
struct  FIELD_API TypeList : public std::set<MemCore::WeakPtr<FiberTypeBase> >
{
        TypeList();
 
        TypeList(const MemCore::WeakPtr<FiberTypeBase>&FTB);
 
        ~TypeList();
 
        bool    contains(const std::type_info&what) const;
 
        MemCore::RefPtr<MemCore::StringList> asText() const;
 
        std::string     str(const std::string&delimiter = ", ") const
        {
                if (auto S = asText())
                        return S->collapse(delimiter);
 
                return {};
        }
 
        void speak() const;
};
 
typedef TypeList TypeList_t;
 
extern FIELD_API bool   containsType(const TypeList_t&TL, const std::type_info&what);
 
template <class T, class ...more>
struct AcceptType : AcceptType<T>, AcceptType<more...>
{
        AcceptType(Fiber::TypeList_t&TL)
        : AcceptType<T>(TL)
        , AcceptType<more...>(TL)
        {}
 
static int      accept(Fiber::TypeList_t&TL)
        {
                return  AcceptType<T>::accept(TL) +
                        AcceptType<more...>::accept(TL);
        }
};
 
template <class T>
struct AcceptType<T>
{
        AcceptType(Fiber::TypeList_t&TL)
        {
                TL.insert( Fiber::FiberType< T >::getFiberType() );
        }
 
static  int     accept(Fiber::TypeList_t&TL)
        {
                TL.insert( Fiber::FiberType< T >::getFiberType() );
                return 1;
        }
};
 
 
template <class ...Type>
struct  AcceptType<META::LIST<Type...> > : AcceptType<Type...>
{
        AcceptType(Fiber::TypeList_t&TL)
        : AcceptType<Type...> (TL)
        {}
 
static  int     accept(Fiber::TypeList_t&TL)
        {
                return AcceptType<Type...>::accept( TL );
        }
};
 
 
} /* namespace Fiber */
 
namespace std
{
 
FIELD_API string        to_string(const Fiber::FiberTypeBase&);
 
}
 
 
#endif /* __FIBERTYPE_HPP */