type.hh

Go to the documentation of this file.

/*
 * This file is part of rasdaman community.
 *
 * Rasdaman community is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Rasdaman community is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with rasdaman community.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Copyright 2003 - 2010 Peter Baumann / rasdaman GmbH.
 *
 * For more information please see <http://www.rasdaman.org>
 * or contact Peter Baumann via <baumann@rasdaman.com>.
*/
 
#ifndef D_TYPE_HH
#define D_TYPE_HH
 
#include "raslib/metaobject.hh"
#include "raslib/mddtypes.hh"
 
class r_Primitive_Type;
class r_Structure_Type;
class r_Marray_Type;
class r_Sinterval_Type;
class r_Minterval_Type;
class r_Point_Type;
class r_Oid_Type;
class r_String_Type;
class r_Base_Type;
class r_Collection_Type;
 
//@ManMemo: Module: {\bf raslib}
class r_Type : public r_Meta_Object
{
public:
    enum r_Type_Id
    {
        ULONG,
        USHORT,
        BOOL,
        LONG,
        SHORT,
        OCTET,
        DOUBLE,
        FLOAT,
        CHAR,
        COMPLEXTYPE1,
        COMPLEXTYPE2,
        CINT16,
        CINT32,
        STRUCTURETYPE,
        MARRAYTYPE,
        COLLECTIONTYPE,
        SINTERVALTYPE,
        MINTERVALTYPE,
        POINTTYPE,
        OIDTYPE,
        STRINGTYPE,
        UNKNOWNTYPE
    };
    r_Type() = default;
    explicit r_Type(const char *newTypeName);
    virtual ~r_Type() = default;
 
    virtual r_Type *clone() const = 0;
 
    virtual r_Type::r_Type_Id type_id() const = 0;
 
    virtual bool isStructType() const;
 
    virtual bool isBaseType() const;
 
    virtual bool isComplexType() const;
 
    virtual bool isMarrayType() const;
 
    virtual bool isPrimitiveType() const;
 
    virtual bool isSintervalType() const;
 
    virtual bool isMintervalType() const;
 
    virtual bool isCollectionType() const;
 
    virtual bool isPointType() const;
 
    virtual bool isOidType() const;
 
    virtual bool isStringType() const;
 
    static r_Type *get_any_type(const char *type_string);
    static r_Type *get_any_type(const std::string &type_string);
 
    virtual void convertToLittleEndian(char *cells, r_Area noCells) const = 0;
 
    virtual void convertToBigEndian(char *cells, r_Area noCells) const = 0;
 
private:
    //@Man: Methodes and structures for dl parser:
 
 
    enum DLTOKEN
    {
        DLMARRAY,
        DLSET,
        DLSTRUCT,
        DLCOMMA,
        DLLEP,
        DLREP,
        DLLAP,
        DLRAP,
        DLLCP,
        DLRCP,
        DLIDENTIFIER,
        DLCHAR,
        DLOCTET,
        DLSHORT,
        DLUSHORT,
        DLLONG,
        DLULONG,
        DLFLOAT,
        DLDOUBLE,
        DLBOOL,
        DLCOMPLEXTYPE1,
        DLCOMPLEXTYPE2,
        DLCINT16,
        DLCINT32,
        DLINTERVAL,
        DLMINTERVAL,
        DLPOINT,
        DLOID,
        DLSTRING,
        DLUNKNOWN
    };
    static DLTOKEN getNextToken(char *&pos, char *&identifier);
    static r_Collection_Type *getCollectionType(char *&pos);
    static r_Type *getType(char *&pos);
    static r_Marray_Type *getMarrayType(char *&pos);
    static r_Base_Type *getBaseType(char *&pos, int offset = 0);
    static r_Primitive_Type *getPrimitiveType(char *&pos);
    static r_Structure_Type *getStructureType(char *&pos, int offset = 0);
    static r_Sinterval_Type *getSintervalType(char *&pos);
    static r_Minterval_Type *getMintervalType(char *&pos);
    static r_Point_Type *getPointType(char *&pos);
    static r_Oid_Type *getOidType(char *&pos);
    static r_String_Type *getStringType(char *&pos);
 
 
};
 
extern std::ostream &operator<<(std::ostream &s, r_Type::r_Type_Id t);
 
//ULONG, USHORT, CHAR, BOOL, LONG, SHORT, OCTET,
//DOUBLE, FLOAT, COMPLEXTYPE1, COMPLEXTYPE2, CINT16, CINT32,
//STRUCTURETYPE, MARRAYTYPE, COLLECTIONTYPE,
//SINTERVALTYPE, MINTERVALTYPE, POINTTYPE, OIDTYPE,
//UNKNOWNTYPE
//};
 
//
// Generate a switch for all base r_Type_Id, and put the given code
// block in each case.
//
#define CODE(...) __VA_ARGS__
#define MAKE_SWITCH_TYPEID(cellType, T, code, codeDefault) \
    switch (cellType)                                      \
    {                                                      \
    case r_Type::r_Type_Id::ULONG:                         \
    {                                                      \
        using T = r_ULong;                                 \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::USHORT:                        \
    {                                                      \
        using T = r_UShort;                                \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::CHAR:                          \
    {                                                      \
        using T = r_Char;                                  \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::BOOL:                          \
    {                                                      \
        using T = r_Boolean;                               \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::LONG:                          \
    {                                                      \
        using T = r_Long;                                  \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::SHORT:                         \
    {                                                      \
        using T = r_Short;                                 \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::OCTET:                         \
    {                                                      \
        using T = r_Octet;                                 \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::DOUBLE:                        \
    {                                                      \
        using T = r_Double;                                \
        code break;                                        \
    }                                                      \
    case r_Type::r_Type_Id::FLOAT:                         \
    {                                                      \
        using T = r_Float;                                 \
        code break;                                        \
    }                                                      \
    default:                                               \
    {                                                      \
        codeDefault break;                                 \
    }                                                      \
    }
 
#endif