FiberTypeBase.hpp

#ifndef __FIBERTYPEBASE_HPP
#define __FIBERTYPEBASE_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/Interface.hpp>
#include <memcore/typemap.hpp>
#include <memcore/stringlist.hpp>
#include <memcore/Chunk.hpp>
 
#include <assert.h>
#include <string>
 
#include "FiberTypeIndex.hpp"
 
 
namespace Fiber
{
 
class   FIELD_API FiberTypeBase : protected FiberTypeIndex
                                , public MemCore::ReferenceBase<FiberTypeBase>
{
public:
        using WeakPtr_t = MemCore::WeakPtr<FiberTypeBase,FiberTypeBase>;
// MemCore::Interface<FiberTypeBase>::reference_domain_t>;
 
        FiberTypeBase(const FiberTypeIndex&FTI)
        : FiberTypeIndex(FTI)
        , ReferenceBase<FiberTypeBase>(this)
        {}
 
        bool    remember();
 
        virtual ~FiberTypeBase();
 
        virtual const std::type_info&getType() const = 0;
 
        virtual bool    isType(const std::type_info&theType) const = 0;
 
        template <class ...T>
        bool    isType() const
        {
                return (isType(typeid(T)) or ...);
        }
 
        virtual MemCore::RefPtr<MemCore::ChunkBase> newChunk(size_t N) const = 0;
 
        unsigned multiplicity() const
        {
                return FiberTypeIndex::multiplicity;
        }
 
 
        unsigned mem_size() const
        {
                return FiberTypeIndex::mem_size;
        }
 
        using   FiberTypeIndex::value_type_size;
 
        int     rank() const
        {
                return FiberTypeIndex::rank;
        }
 
        int     grade() const
        {
                return FiberTypeIndex::grade;
        }
 
        virtual int element_index(const int i[]) const = 0;
 
        unsigned array_element_size() const
        {
                return  FiberTypeIndex::array_element_size;
        }
 
 
        virtual WeakPtr_t element_type() const = 0;
 
        virtual std::string     coordinate_component_name(int i) const = 0;
 
        virtual const std::type_info&chart_type() const = 0;
 
        std::string chart_name() const
        {
                return FiberTypeIndex::chart_name;
        }
 
        std::string     component_name(unsigned ComponentId) const;
 
        int     chart_dimension() const
        {
                return FiberTypeIndex::chart_dimension;
        }
 
        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;
 
        const FiberTypeIndex&getFiberTypeIndex() const
        {
                return *this;
        }
 
static  WeakPtr_t find(const FiberTypeIndex&FTI);
static  WeakPtr_t find(const std::type_info&T);
 
#if (__cplusplus == 201703L)
#pragma message "Compiling with C++17 does not allow for fibertype comparisons."
#else
        auto operator<=>(const FiberTypeBase&FTB) const
        {
                return FiberTypeIndex::operator<=>(FTB);
        }
 
        auto operator==(const FiberTypeBase&FTB) const
        {
                return FiberTypeIndex::operator==(FTB);
        }
#endif
 
        void speak() const;
};
 
 
 
 
} /* namespace Fiber */
 
namespace std
{
 
FIELD_API string        to_string(const Fiber::FiberTypeBase&);
 
}
 
 
#endif /* __FIBERTYPEBASE_HPP */