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"
#include "any_ptr.h"
 
namespace omnetpp {
 
class cValue;
 
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_ISREPLACEABLE = 0x40,  
        FD_ISRESIZABLE = 0x80,    
        FD_NONE = 0x0
    };
 
  private:
    std::string baseClassName;
    cClassDescriptor *baseClassDesc = nullptr;
    int inheritanceChainLength = 1;
    int extendscObject = -1;  // 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;
    intval_t 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;}
    bool getFieldIsReplaceable(int field) const {return getFieldTypeFlags(field) & FD_ISREPLACEABLE;}
    bool getFieldIsResizable(int field) const {return getFieldTypeFlags(field) & FD_ISRESIZABLE;}
 
    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(any_ptr object, int field) const = 0;
 
    virtual void setFieldArraySize(any_ptr object, int field, int size) const = 0;
 
    virtual const char *getFieldDynamicTypeString(any_ptr object, int field, int i) const {return nullptr;}
 
    virtual std::string getFieldValueAsString(any_ptr object, int field, int i) const = 0;
 
    virtual void setFieldValueAsString(any_ptr object, int field, int i, const char *value) const = 0;
 
    virtual cValue getFieldValue(any_ptr object, int field, int i) const = 0;
 
    virtual void setFieldValue(any_ptr object, int field, int i, const cValue& value) const = 0;
 
    virtual const char *getFieldStructName(int field) const = 0;
 
    virtual any_ptr getFieldStructValuePointer(any_ptr object, int field, int i) const = 0;
 
    virtual void setFieldStructValuePointer(any_ptr object, int field, int i, any_ptr ptr) const = 0;
};
 
}  // namespace omnetpp
 
 
#endif