cclassdescriptor.h

//==========================================================================
//  CCLASSDESCRIPTOR.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __OMNETPP_CCLASSDESCRIPTOR_H
#define __OMNETPP_CCLASSDESCRIPTOR_H

#include <string>
#include "cownedobject.h"
#include "simtime.h"
#include "opp_string.h"

namespace omnetpp {


class SIM_API cClassDescriptor : public cNoncopyableOwnedObject
{
  public:
    enum {
        FD_ISARRAY = 0x01,    
        FD_ISCOMPOUND = 0x02, 
        FD_ISPOINTER = 0x04,  
        FD_ISCOBJECT = 0x08,  
        FD_ISCOWNEDOBJECT = 0x10, 
        FD_ISEDITABLE = 0x20, 
        FD_NONE = 0x0
    };

  private:
    std::string baseClassName;
    cClassDescriptor *baseClassDesc;
    int inheritanceChainLength;
    int extendscObject;  // 0:false, 1:true, -1:unset

  protected:
    // utility functions for converting from/to strings
    static std::string long2string(long l);
    static long string2long(const char *s);
    static std::string ulong2string(unsigned long l);
    static unsigned long string2ulong(const char *s);
    static std::string int642string(int64_t l);
    static int64_t string2int64(const char *s);
    static std::string uint642string(uint64_t l);
    static uint64_t string2uint64(const char *s);
    static std::string bool2string(bool b);
    static bool string2bool(const char *s);
    static std::string double2string(double d);
    static double string2double(const char *s);
    static std::string simtime2string(SimTime t) {return t.ustr();}
    static simtime_t string2simtime(const char *s) {return SimTime::parse(s);}
    std::string enum2string(int e, const char *enumName) const;
    int string2enum(const char *s, const char *enumName) const;
    static std::string oppstring2string(const char *s) {return s?s:"";}
    static std::string oppstring2string(const opp_string& s) {return s.c_str();}
    static std::string oppstring2string(const std::string& s)  {return s;}
    static void string2oppstring(const char *s, opp_string& str) {str = s?s:"";}
    static void string2oppstring(const char *s, std::string& str) {str = s?s:"";}
    static const char **mergeLists(const char **list1, const char **list2);

  public:

    cClassDescriptor(const char *className, const char *baseClassName=nullptr);

    virtual ~cClassDescriptor();


    static cClassDescriptor *getDescriptorFor(const char *classname);

    static cClassDescriptor *getDescriptorFor(const cObject *object);


    virtual bool doesSupport(cObject *obj) const {return false;}

    virtual cClassDescriptor *getBaseClassDescriptor() const;

    bool extendsCObject() const;

    std::string getNamespace() const;

    int getInheritanceChainLength() const;

    virtual const char **getPropertyNames() const = 0;

    virtual const char *getProperty(const char *propertyname) const = 0;

    virtual int getFieldCount() const = 0;

    virtual const char *getFieldName(int field) const = 0;

    virtual int findField(const char *fieldName) const;

    virtual unsigned int getFieldTypeFlags(int field) const = 0;

    bool getFieldIsArray(int field) const {return getFieldTypeFlags(field) & FD_ISARRAY;}
    bool getFieldIsCompound(int field) const {return getFieldTypeFlags(field) & FD_ISCOMPOUND;}
    bool getFieldIsPointer(int field) const {return getFieldTypeFlags(field) & FD_ISPOINTER;}
    bool getFieldIsCObject(int field) const {return getFieldTypeFlags(field) & (FD_ISCOBJECT|FD_ISCOWNEDOBJECT);}
    bool getFieldIsCOwnedObject(int field) const {return getFieldTypeFlags(field) & FD_ISCOWNEDOBJECT;}
    bool getFieldIsEditable(int field) const {return getFieldTypeFlags(field) & FD_ISEDITABLE;}

    virtual const char *getFieldDeclaredOn(int field) const;

    virtual const char *getFieldTypeString(int field) const = 0;

    virtual const char **getFieldPropertyNames(int field) const = 0;

    virtual const char *getFieldProperty(int field, const char *propertyname) const = 0;

    virtual int getFieldArraySize(void *object, int field) const = 0;

    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const {return nullptr;}

    virtual std::string getFieldValueAsString(void *object, int field, int i) const = 0;

    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const = 0;

    virtual const char *getFieldStructName(int field) const = 0;

    virtual void *getFieldStructValuePointer(void *object, int field, int i) const = 0;
};

}  // namespace omnetpp


#endif