TypeManager.h

Go to the documentation of this file.

//
// Copyright (c) 2006-2007 Raphael David / CANTOR
//

#ifndef CMR_TYPE_MANAGER_INCLUDED
#define CMR_TYPE_MANAGER_INCLUDED

#include "commore/Commore.h"
#include "commore/Symbol.h"
#include "commore/Tuple.h"
#include "commore/CommBuffer.h"

#include "ArrayImpl.h"

//
// TypeManager is the base class for TypeManagerInfo
// It provides the static method get_type_info for getting
// informations about commore types.
//
struct TypeManager
{
    TypeManager(commore::Types  type, bool isList, bool complex, const char* typeName, bool isWord);
    virtual                    ~TypeManager() {}

    virtual               long write(commore::CommBuffer& b, void*) = 0;
    virtual               long read(const commore::CommBuffer& b, void*) = 0;
    virtual               long write_xml(commore::OBStream& o, void*) = 0;
    virtual               long read_xml(commore::XmlParser& i, void*) = 0;

    virtual               bool equal(void* v1, void* v2) = 0;

    virtual               void assign(void* v1, void* v2) = 0;


    virtual             size_t size()
    {
        return 0;
    };
    virtual               void construct(commore::Byte*, const commore::Byte* v = 0) {};
    virtual               void destroy(void*) {};
    virtual                int compare(const commore::Dummy&, const commore::Dummy&)
    {
        return 0;
    }
    virtual              void* get_default()
    {
        return 0;
    }

    static          TypeManager* get_type_info(commore::Types type);
    static          TypeManager* get_type_info(const commore::AChar* type_name);

    //
    // All T_List types
    //
    bool  isList_;

    //
    // Only Tuple is complex
    //
    bool  complex_;

    //
    // bool, int, long, float, double, timeperiod, timedate and all associated lists
    //
    bool  isWord_;

    commore::Types  type_;

    //
    // Short name for type name
    //
    commore::Symbol  symbType_;

    size_t hash_;

};
typedef TypeManager* PTypeManager;

//
// TypeManagerInfo object represents meta-informations about a primitive type.
// The class maintains a cache of TypeManagerInfo object, one per type, accessible
// with the static get_type_info method.
//
template< class T > struct TypeManagerInfo : public TypeManager
{
    TypeManagerInfo(commore::Types  type, const char* typeName, bool isWord, bool isList = false, bool complex = false)
        : TypeManager(type, isList, complex, typeName, isWord) {}

    long write_xml(commore::OBStream& o, void*);
    long read_xml(commore::XmlParser& i, void*);
    long write(commore::CommBuffer& b, void* value)
    {
        long r = 0;
        T* avalue = (T*)value;
        r += b.write(*avalue);
        return r;
    }
    long read(const commore::CommBuffer& b, void* value)
    {
        long r = b.read(*(T*)value);
        return r;
    }
    void assign(void* v1, void* v2)
    {
        *(T*)v1 = *(T*)v2;
    }
    bool equal(void* v1, void* v2)
    {
        return (bool)(*(T*)v1 == *(T*)v2);
    }
    size_t size()
    {
        size_t r = sizeof(T);
        r = r + (sizeof(int) - r % sizeof(int));
        return r;
    }
    void construct(commore::Byte* data, const commore::Byte* value)
    {
        if (value)
        {
            new(data) T(*(T*)value);
        }
        else
        {
            new(data) T();
        }
    }
    void destroy(void* data)
    {
        ((T*)data)->T::~T();
    }
    int compare(const commore::Dummy& v1, const commore::Dummy& v2)
    {
        const T& ov1 = (const T&)v1;
        const T& ov2 = (const T&)v2;
        if (ov1 < ov2)
        {
            return -1;
        }
        else if (ov1 == ov2)
        {
            return 0;
        }
        else
        {
            return 1;
        }
    }
    void* get_default()
    {
        static T default_;
        return &default_;
    }
};



#endif