FiberType.hpp

#ifndef __FIBERTYPE_HPP
#define __FIBERTYPE_HPP "Created 27.02.2001 21:42:27 by werner"

#include "FieldAPI.h"

#include <eagle/MetaInfo.hpp>
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <memcore/typemap.hpp>

#include <assert.h>
#include <string>

namespace Fiber
{
        using std::type_info;
        using std::string;

class   FIELD_API FiberTypeBase : public MemCore::Interface<FiberTypeBase>
{
public:
        FiberTypeBase(bool isStaticObject);

        virtual ~FiberTypeBase();

        virtual const type_info&getType() const = 0;

        virtual unsigned multiplicity() const = 0;

        virtual unsigned mem_size() const = 0;

        virtual int rank() const = 0;

        virtual int grade() const = 0;

        virtual int element_index(const int i[]) const = 0;

        virtual unsigned element_size() const = 0;

        virtual const FiberTypeBase&element_type() const = 0;

        virtual const char*coordinate_component_name(int i) const = 0;

        virtual const type_info&chart_type() const = 0;

        string chart_name() const
        {
                return MemCore::Typename(chart_type() );
        }

        virtual int   chart_dimension() const = 0;

        virtual int indexing_scheme(int i) const = 0;

        bool is_lower_index(int i) const
        {
                return indexing_scheme(i)<0;
        }

        bool is_upper_index(int i) const
        {
                return indexing_scheme(i)>0;
        }

        virtual const char*nontensor() const = 0;

        std::string description() const;

        friend bool operator<(const FiberTypeBase&l, const FiberTypeBase&r);
};

struct  FIELD_API FTless
{
        bool operator()(const MemCore::WeakPtr<FiberTypeBase>&l, const MemCore::WeakPtr<FiberTypeBase>&r) const;
};


class   FIELD_API TypeAction : public MemCore::ReferenceBase<TypeAction>, public MemCore::Intercube
{
public:
        TypeAction();
        ~TypeAction();

static  MemCore::RefPtr<TypeAction> create(const MemCore::WeakPtr<FiberTypeBase>&FT);
static  MemCore::RefPtr<TypeAction> find(const MemCore::WeakPtr<FiberTypeBase>&FT);

        struct  FIELD_API Iterator
        {
                virtual ~Iterator() = 0;

                virtual bool apply(const MemCore::WeakPtr<FiberTypeBase>&FTB, 
                                   const MemCore::RefPtr<TypeAction>&TA) = 0;
        };

static  int iterate(const type_info&atomic_type, int multiplicity, Iterator&it);

        struct  FIELD_API TypeIterator
        {
                virtual ~TypeIterator() = 0;

                virtual bool apply(const type_info&ti,
                                   const MemCore::WeakPtr<FiberTypeBase>&FTB, 
                                   const MemCore::RefPtr<TypeAction>&TA) = 0;
        };

static  int iterateAll(Iterator&it);
static  int iterate(TypeIterator&it, int multiplicity = 1);

static  int coordinate_iterate(const type_info&chart_type, int tensor_rank, int*indexing_scheme,
                               Iterator&it);

static  size_t coordinate_entries(const type_info&chart_type);

};


template <class T> struct SizeOf       { static size_t memsize() { return sizeof(T); } };
template <>        struct SizeOf<void> { static size_t memsize() { return 0;         } };

template <class T>
class   FiberType : public FiberTypeBase
{
public:
        FiberType(bool isStaticObject)
        : FiberTypeBase(isStaticObject)
        {}

//static        FiberType TypeInfo;

        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 };

        override const type_info&getType() const
        {
                return typeid(T); 
        }

        override unsigned element_size() const
        {
                return SizeOf<typename FiberInfo_t::element_t>::memsize();
        }

static  const FiberTypeBase&getFiberType()
        {
        static  FiberType<T> myType(true); 
                return myType;
        }

        override const FiberTypeBase&element_type() const
        {
                return FiberType<element_t>::getFiberType();
        }

        override unsigned multiplicity() const
        {
                return FiberInfo_t::MULTIPLICITY;
        }

        override int rank() const
        {
                return FiberInfo_t::RANK;
        }

        override int grade() const
        {
                return FiberInfo_t::GRADE;
        }

        override const char*coordinate_component_name(int i) const
        {
                return Eagle::CoordinateInfo<Chart_t>::coordinate_name(i);
        }

        override const type_info&chart_type() const
        {
                return typeid(Chart_t);
        }

        override int chart_dimension() const 
        {
                return Dims;
        }

        override int element_index(const int i[]) const
        {
                return Eagle::MetaInfoElementIndex<T>::element_index(i);
        }

        override unsigned mem_size() const
        {
                return SizeOf<T>::memsize();
        }

        override int indexing_scheme(int i) const
        {
                return Eagle::TypeIndexingScheme<T>::index(i);
        }

        override const char*nontensor() const
        {
                return 0;
//              return FiberInfoNonTensor<T>::object_name();
        }
};


struct  FIELD_API TypeList : public std::set<MemCore::WeakPtr<FiberTypeBase> >
{
        TypeList();

        ~TypeList(); 

        bool    contains(const type_info&what) const;

        void speak() const;
};

typedef TypeList TypeList_t;

extern FIELD_API bool   containsType(const TypeList_t&TL, const type_info&what);

template <class T>
struct AcceptType
{
        AcceptType(Fiber::TypeList_t&TL)
        {
                TL.insert( Fiber::FiberType< T >::getFiberType().self() );
        }

static void accept(Fiber::TypeList_t&TL)
        {
                TL.insert( Fiber::FiberType< T >::getFiberType().self() );
        } 
};


} /* namespace Fiber */ 


#endif /* __FIBERTYPE_HPP */