CDAPMessage_m.h

Go to the documentation of this file.

//
// Generated file, do not edit! Created by nedtool 5.0 from DAF/CDAP/CDAPMessage.msg.
//

#ifndef __CDAPMESSAGE_M_H
#define __CDAPMESSAGE_M_H

#include <omnetpp.h>

// nedtool version check
#define MSGC_VERSION 0x0500
#if (MSGC_VERSION!=OMNETPP_VERSION)
#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
#endif



// cplusplus {{
    #include "APNamingInfo.h"
    #include "Address.h"
    typedef cObject* ObjectPtr;
// }}

enum opCode_t {
    UNKNOWN = 0,
    M_CONNECT = 1,
    M_CONNECT_R = 2,
    M_RELEASE = 3,
    M_RELEASE_R = 4,
    M_CREATE = 5,
    M_CREATE_R = 6,
    M_DELETE = 7,
    M_DELETE_R = 8,
    M_READ = 9,
    M_READ_R = 10,
    M_CANCELREAD = 11,
    M_CANCELREAD_R = 12,
    M_WRITE = 13,
    M_WRITE_R = 14,
    M_START = 15,
    M_START_R = 16,
    M_STOP = 17,
    M_STOP_R = 18
};

enum flagValues_t {
    F_SYNC = 1,
    F_RD_INCOMPLETE = 2
};

struct objVal_t
{
    objVal_t();
    uint32_t intval;
    int32_t sintval;
    uint64_t int64val;
    int64_t sint64val;
    ::omnetpp::opp_string strval;
    float floatval;
    double doubleval;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const objVal_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, objVal_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const objVal_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, objVal_t& obj) { __doUnpacking(b, obj); }

enum authTypes_t {
    AUTH_NONE = 0,
    AUTH_PASSWD = 1,
    AUTH_SSHRSA = 2,
    AUTH_SSHDSA = 3
};

enum resultVal_t {
    R_CLASSNOTFOUND = -5,
    R_OBJBADINST = -4,
    R_OBJNOTFOUND = -3,
    R_OS_ERR = -2,
    R_FAIL = -1,
    R_SUCCESS = 0,
    R_SYNC_UNIMP = 1,
    R_FILTER_FALSE = 2,
    R_FILTER_MIXED = 3
};

enum absSyntax_t {
    GPB = 0x08
};

struct authValue_t
{
    authValue_t();
    ::omnetpp::opp_string authName;
    ::omnetpp::opp_string authPassword;
    ::omnetpp::opp_string authOther;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const authValue_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, authValue_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const authValue_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, authValue_t& obj) { __doUnpacking(b, obj); }

struct result_t
{
    result_t();
    ::omnetpp::opp_string resultReason;
    int32_t resultValue;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const result_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, result_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const result_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, result_t& obj) { __doUnpacking(b, obj); }

struct auth_t
{
    auth_t();
    unsigned char authType;
    authValue_t authValue;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const auth_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, auth_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const auth_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, auth_t& obj) { __doUnpacking(b, obj); }

struct naming_t
{
    naming_t();
    ::omnetpp::opp_string AEInst;
    ::omnetpp::opp_string AEName;
    ::omnetpp::opp_string ApInst;
    ::omnetpp::opp_string ApName;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const naming_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, naming_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const naming_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, naming_t& obj) { __doUnpacking(b, obj); }

struct object_t
{
    object_t();
    ::omnetpp::opp_string objectClass;
    ::omnetpp::opp_string objectName;
    int objectInstance;
    ObjectPtr objectVal;
};

// helpers for local use
void __doPacking(omnetpp::cCommBuffer *b, const object_t& a);
void __doUnpacking(omnetpp::cCommBuffer *b, object_t& a);

inline void doParsimPacking(omnetpp::cCommBuffer *b, const object_t& obj) { __doPacking(b, obj); }
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, object_t& obj) { __doUnpacking(b, obj); }

enum headerBitLengths {
    hdrInt32 = 32,
    hdrFiltr = 128,
    hdrResult = 132,
    hdrAuth = 136,
    hdrNaming = 512
};

class CDAPMessage : public ::omnetpp::cPacket
{
  protected:
    ::omnetpp::opp_string displayString;
    unsigned int headerBitLength;
    Address srcAddr;
    Address dstAddr;
    int32_t opCode;
    int32_t invokeID;

  private:
    void copy(const CDAPMessage& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAPMessage&);

  public:
    CDAPMessage(const char *name=nullptr, int kind=0);
    CDAPMessage(const CDAPMessage& other);
    virtual ~CDAPMessage();
    CDAPMessage& operator=(const CDAPMessage& other);
    virtual CDAPMessage *dup() const {return new CDAPMessage(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual const char * getDisplayString() const;
    virtual void setDisplayString(const char * displayString);
    virtual unsigned int getHeaderBitLength() const;
    virtual void setHeaderBitLength(unsigned int headerBitLength);
    virtual Address& getSrcAddr();
    virtual const Address& getSrcAddr() const {return const_cast<CDAPMessage*>(this)->getSrcAddr();}
    virtual void setSrcAddr(const Address& srcAddr);
    virtual Address& getDstAddr();
    virtual const Address& getDstAddr() const {return const_cast<CDAPMessage*>(this)->getDstAddr();}
    virtual void setDstAddr(const Address& dstAddr);
    virtual int32_t getOpCode() const;
    virtual void setOpCode(int32_t opCode);
    virtual int32_t getInvokeID() const;
    virtual void setInvokeID(int32_t invokeID);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAPMessage& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAPMessage& obj) {obj.parsimUnpack(b);}

class CDAP_M_Connect : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    int32_t absSyntax;
    auth_t auth;
    APNamingInfo src;
    APNamingInfo dst;

  private:
    void copy(const CDAP_M_Connect& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Connect&);

  public:
    CDAP_M_Connect(const char *name=nullptr, int kind=0);
    CDAP_M_Connect(const CDAP_M_Connect& other);
    virtual ~CDAP_M_Connect();
    CDAP_M_Connect& operator=(const CDAP_M_Connect& other);
    virtual CDAP_M_Connect *dup() const {return new CDAP_M_Connect(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual int32_t getAbsSyntax() const;
    virtual void setAbsSyntax(int32_t absSyntax);
    virtual auth_t& getAuth();
    virtual const auth_t& getAuth() const {return const_cast<CDAP_M_Connect*>(this)->getAuth();}
    virtual void setAuth(const auth_t& auth);
    virtual APNamingInfo& getSrc();
    virtual const APNamingInfo& getSrc() const {return const_cast<CDAP_M_Connect*>(this)->getSrc();}
    virtual void setSrc(const APNamingInfo& src);
    virtual APNamingInfo& getDst();
    virtual const APNamingInfo& getDst() const {return const_cast<CDAP_M_Connect*>(this)->getDst();}
    virtual void setDst(const APNamingInfo& dst);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Connect& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Connect& obj) {obj.parsimUnpack(b);}

class CDAP_M_Connect_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    int32_t absSyntax;
    result_t result;
    auth_t auth;
    APNamingInfo src;
    APNamingInfo dst;

  private:
    void copy(const CDAP_M_Connect_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Connect_R&);

  public:
    CDAP_M_Connect_R(const char *name=nullptr, int kind=0);
    CDAP_M_Connect_R(const CDAP_M_Connect_R& other);
    virtual ~CDAP_M_Connect_R();
    CDAP_M_Connect_R& operator=(const CDAP_M_Connect_R& other);
    virtual CDAP_M_Connect_R *dup() const {return new CDAP_M_Connect_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual int32_t getAbsSyntax() const;
    virtual void setAbsSyntax(int32_t absSyntax);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Connect_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
    virtual auth_t& getAuth();
    virtual const auth_t& getAuth() const {return const_cast<CDAP_M_Connect_R*>(this)->getAuth();}
    virtual void setAuth(const auth_t& auth);
    virtual APNamingInfo& getSrc();
    virtual const APNamingInfo& getSrc() const {return const_cast<CDAP_M_Connect_R*>(this)->getSrc();}
    virtual void setSrc(const APNamingInfo& src);
    virtual APNamingInfo& getDst();
    virtual const APNamingInfo& getDst() const {return const_cast<CDAP_M_Connect_R*>(this)->getDst();}
    virtual void setDst(const APNamingInfo& dst);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Connect_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Connect_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Release : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;

  private:
    void copy(const CDAP_M_Release& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Release&);

  public:
    CDAP_M_Release(const char *name=nullptr, int kind=0);
    CDAP_M_Release(const CDAP_M_Release& other);
    virtual ~CDAP_M_Release();
    CDAP_M_Release& operator=(const CDAP_M_Release& other);
    virtual CDAP_M_Release *dup() const {return new CDAP_M_Release(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Release& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Release& obj) {obj.parsimUnpack(b);}

class CDAP_M_Release_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    result_t result;

  private:
    void copy(const CDAP_M_Release_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Release_R&);

  public:
    CDAP_M_Release_R(const char *name=nullptr, int kind=0);
    CDAP_M_Release_R(const CDAP_M_Release_R& other);
    virtual ~CDAP_M_Release_R();
    CDAP_M_Release_R& operator=(const CDAP_M_Release_R& other);
    virtual CDAP_M_Release_R *dup() const {return new CDAP_M_Release_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Release_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Release_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Release_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Create : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Create& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Create&);

  public:
    CDAP_M_Create(const char *name=nullptr, int kind=0);
    CDAP_M_Create(const CDAP_M_Create& other);
    virtual ~CDAP_M_Create();
    CDAP_M_Create& operator=(const CDAP_M_Create& other);
    virtual CDAP_M_Create *dup() const {return new CDAP_M_Create(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Create*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Create& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Create& obj) {obj.parsimUnpack(b);}

class CDAP_M_Create_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Create_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Create_R&);

  public:
    CDAP_M_Create_R(const char *name=nullptr, int kind=0);
    CDAP_M_Create_R(const CDAP_M_Create_R& other);
    virtual ~CDAP_M_Create_R();
    CDAP_M_Create_R& operator=(const CDAP_M_Create_R& other);
    virtual CDAP_M_Create_R *dup() const {return new CDAP_M_Create_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Create_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Create_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Create_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Create_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Delete : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Delete& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Delete&);

  public:
    CDAP_M_Delete(const char *name=nullptr, int kind=0);
    CDAP_M_Delete(const CDAP_M_Delete& other);
    virtual ~CDAP_M_Delete();
    CDAP_M_Delete& operator=(const CDAP_M_Delete& other);
    virtual CDAP_M_Delete *dup() const {return new CDAP_M_Delete(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Delete*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Delete& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Delete& obj) {obj.parsimUnpack(b);}

class CDAP_M_Delete_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Delete_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Delete_R&);

  public:
    CDAP_M_Delete_R(const char *name=nullptr, int kind=0);
    CDAP_M_Delete_R(const CDAP_M_Delete_R& other);
    virtual ~CDAP_M_Delete_R();
    CDAP_M_Delete_R& operator=(const CDAP_M_Delete_R& other);
    virtual CDAP_M_Delete_R *dup() const {return new CDAP_M_Delete_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Delete_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Delete_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Delete_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Delete_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Read : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Read& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Read&);

  public:
    CDAP_M_Read(const char *name=nullptr, int kind=0);
    CDAP_M_Read(const CDAP_M_Read& other);
    virtual ~CDAP_M_Read();
    CDAP_M_Read& operator=(const CDAP_M_Read& other);
    virtual CDAP_M_Read *dup() const {return new CDAP_M_Read(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Read*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Read& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Read& obj) {obj.parsimUnpack(b);}

class CDAP_M_Read_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Read_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Read_R&);

  public:
    CDAP_M_Read_R(const char *name=nullptr, int kind=0);
    CDAP_M_Read_R(const CDAP_M_Read_R& other);
    virtual ~CDAP_M_Read_R();
    CDAP_M_Read_R& operator=(const CDAP_M_Read_R& other);
    virtual CDAP_M_Read_R *dup() const {return new CDAP_M_Read_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Read_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Read_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Read_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Read_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_CancelRead : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    result_t result;

  private:
    void copy(const CDAP_M_CancelRead& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_CancelRead&);

  public:
    CDAP_M_CancelRead(const char *name=nullptr, int kind=0);
    CDAP_M_CancelRead(const CDAP_M_CancelRead& other);
    virtual ~CDAP_M_CancelRead();
    CDAP_M_CancelRead& operator=(const CDAP_M_CancelRead& other);
    virtual CDAP_M_CancelRead *dup() const {return new CDAP_M_CancelRead(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_CancelRead*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_CancelRead& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_CancelRead& obj) {obj.parsimUnpack(b);}

class CDAP_M_CancelRead_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    result_t result;

  private:
    void copy(const CDAP_M_CancelRead_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_CancelRead_R&);

  public:
    CDAP_M_CancelRead_R(const char *name=nullptr, int kind=0);
    CDAP_M_CancelRead_R(const CDAP_M_CancelRead_R& other);
    virtual ~CDAP_M_CancelRead_R();
    CDAP_M_CancelRead_R& operator=(const CDAP_M_CancelRead_R& other);
    virtual CDAP_M_CancelRead_R *dup() const {return new CDAP_M_CancelRead_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_CancelRead_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_CancelRead_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_CancelRead_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Write : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Write& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Write&);

  public:
    CDAP_M_Write(const char *name=nullptr, int kind=0);
    CDAP_M_Write(const CDAP_M_Write& other);
    virtual ~CDAP_M_Write();
    CDAP_M_Write& operator=(const CDAP_M_Write& other);
    virtual CDAP_M_Write *dup() const {return new CDAP_M_Write(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Write*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Write& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Write& obj) {obj.parsimUnpack(b);}

class CDAP_M_Write_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Write_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Write_R&);

  public:
    CDAP_M_Write_R(const char *name=nullptr, int kind=0);
    CDAP_M_Write_R(const CDAP_M_Write_R& other);
    virtual ~CDAP_M_Write_R();
    CDAP_M_Write_R& operator=(const CDAP_M_Write_R& other);
    virtual CDAP_M_Write_R *dup() const {return new CDAP_M_Write_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Write_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Write_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Write_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Write_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Start : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Start& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Start&);

  public:
    CDAP_M_Start(const char *name=nullptr, int kind=0);
    CDAP_M_Start(const CDAP_M_Start& other);
    virtual ~CDAP_M_Start();
    CDAP_M_Start& operator=(const CDAP_M_Start& other);
    virtual CDAP_M_Start *dup() const {return new CDAP_M_Start(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Start*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Start& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Start& obj) {obj.parsimUnpack(b);}

class CDAP_M_Start_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Start_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Start_R&);

  public:
    CDAP_M_Start_R(const char *name=nullptr, int kind=0);
    CDAP_M_Start_R(const CDAP_M_Start_R& other);
    virtual ~CDAP_M_Start_R();
    CDAP_M_Start_R& operator=(const CDAP_M_Start_R& other);
    virtual CDAP_M_Start_R *dup() const {return new CDAP_M_Start_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Start_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Start_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Start_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Start_R& obj) {obj.parsimUnpack(b);}

class CDAP_M_Stop : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    int32_t scope;
    ::omnetpp::opp_string filter;

  private:
    void copy(const CDAP_M_Stop& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Stop&);

  public:
    CDAP_M_Stop(const char *name=nullptr, int kind=0);
    CDAP_M_Stop(const CDAP_M_Stop& other);
    virtual ~CDAP_M_Stop();
    CDAP_M_Stop& operator=(const CDAP_M_Stop& other);
    virtual CDAP_M_Stop *dup() const {return new CDAP_M_Stop(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Stop*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual int32_t getScope() const;
    virtual void setScope(int32_t scope);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Stop& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Stop& obj) {obj.parsimUnpack(b);}

class CDAP_M_Stop_R : public ::CDAPMessage
{
  protected:
    int32_t flags;
    int32_t version;
    object_t objectItem;
    ::omnetpp::opp_string filter;
    result_t result;

  private:
    void copy(const CDAP_M_Stop_R& other);

  protected:
    // protected and unimplemented operator==(), to prevent accidental usage
    bool operator==(const CDAP_M_Stop_R&);

  public:
    CDAP_M_Stop_R(const char *name=nullptr, int kind=0);
    CDAP_M_Stop_R(const CDAP_M_Stop_R& other);
    virtual ~CDAP_M_Stop_R();
    CDAP_M_Stop_R& operator=(const CDAP_M_Stop_R& other);
    virtual CDAP_M_Stop_R *dup() const {return new CDAP_M_Stop_R(*this);}
    virtual void parsimPack(omnetpp::cCommBuffer *b) const;
    virtual void parsimUnpack(omnetpp::cCommBuffer *b);

    // field getter/setter methods
    virtual int32_t getFlags() const;
    virtual void setFlags(int32_t flags);
    virtual int32_t getVersion() const;
    virtual void setVersion(int32_t version);
    virtual object_t& getObjectItem();
    virtual const object_t& getObjectItem() const {return const_cast<CDAP_M_Stop_R*>(this)->getObjectItem();}
    virtual void setObjectItem(const object_t& objectItem);
    virtual const char * getFilter() const;
    virtual void setFilter(const char * filter);
    virtual result_t& getResult();
    virtual const result_t& getResult() const {return const_cast<CDAP_M_Stop_R*>(this)->getResult();}
    virtual void setResult(const result_t& result);
};

inline void doParsimPacking(omnetpp::cCommBuffer *b, const CDAP_M_Stop_R& obj) {obj.parsimPack(b);}
inline void doParsimUnpacking(omnetpp::cCommBuffer *b, CDAP_M_Stop_R& obj) {obj.parsimUnpack(b);}


#endif // ifndef __CDAPMESSAGE_M_H