bsProxyMsgs.h

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////////
//
// File: bsProxyMsgs.h
//
/*!
 * \file
 *
 * \brief BotSense client application - bsProxy server-terminated core messages.
 *
 * \warning This file was auto-generated on 2018.08.10 13:54:22 from the NetMsgs
 * XML specification bsProxyMsgs.xml.
 *
 * \par Copyright:
 * (C) 2018. RoadNarrows LLC
 * (http://www.roadnarrows.com)
 * All Rights Reserved
 */
///////////////////////////////////////////////////////////////////////////////


#ifndef _BSPROXYMSGS_H
#define _BSPROXYMSGS_H

#include "rnr/rnrconfig.h"
#include "rnr/netmsgs.h"

#include "botsense/BotSense.h"


C_DECLS_BEGIN

/*!
 * BsProxy Message Id Enumeration
 */
typedef enum
{
  BsProxyMsgIdNone                      = 0,    ///< no message
  BsProxyMsgIdRspOk                     = 1,    ///< RspOk
  BsProxyMsgIdRspErr                    = 2,    ///< RspErr
  BsProxyMsgIdReqLoopback               = 3,    ///< ReqLoopback
  BsProxyMsgIdRspLoopback               = 4,    ///< RspLoopback
  BsProxyMsgIdReqSetLogging             = 5,    ///< ReqSetLogging
  BsProxyMsgIdReqGetVersion             = 6,    ///< ReqGetVersion
  BsProxyMsgIdRspGetVersion             = 7,    ///< RspGetVersion
  BsProxyMsgIdReqMsgTrace               = 8,    ///< ReqMsgTrace
  BsProxyMsgIdReqDevOpen                = 9,    ///< ReqDevOpen
  BsProxyMsgIdRspDevOpen                = 10,   ///< RspDevOpen
  BsProxyMsgIdReqDevClose               = 11,   ///< ReqDevClose
  BsProxyMsgIdReqGetVConnList           = 12,   ///< ReqGetVConnList
  BsProxyMsgIdRspGetVConnList           = 13,   ///< RspGetVConnList
  BsProxyMsgIdReqGetVConnInfo           = 14,   ///< ReqGetVConnInfo
  BsProxyMsgIdRspGetVConnInfo           = 15,   ///< RspGetVConnInfo
  BsProxyMsgIdNumOf                     = 16    ///< number of message ids
} BsProxyMsgId_T;


//-----------------------------------------------------------------------------
// Message Types
//-----------------------------------------------------------------------------


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspErr Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! RspErr emsg maximum string length */
#define BSPROXY_RSPERR_EMSG_LEN (NMFVAL_LEN_MAX_STRING)

/*!
 * Message RspErr Structure
 */
typedef struct
{
  byte_t                  m_ecode;            ///< ecode
  char                    m_emsg[BSPROXY_RSPERR_EMSG_LEN+1];
                                              ///< emsg
} BsProxyRspErr_T;                            ///< RspErr structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqLoopback Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! ReqLoopback cdata maximum string length */
#define BSPROXY_REQLOOPBACK_CDATA_LEN (NMFVAL_LEN_MAX_STRING)

/*!
 * Message ReqLoopback Structure
 */
typedef struct
{
  char                    m_cdata[BSPROXY_REQLOOPBACK_CDATA_LEN+1];
                                              ///< cdata
} BsProxyReqLoopback_T;                       ///< ReqLoopback structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspLoopback Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! RspLoopback cdata maximum string length */
#define BSPROXY_RSPLOOPBACK_CDATA_LEN (NMFVAL_LEN_MAX_STRING)

/*!
 * Message RspLoopback Structure
 */
typedef struct
{
  char                    m_cdata[BSPROXY_RSPLOOPBACK_CDATA_LEN+1];
                                              ///< cdata
} BsProxyRspLoopback_T;                       ///< RspLoopback structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqSetLogging Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqSetLogging Structure
 */
typedef struct
{
  int                     m_level;            ///< level
} BsProxyReqSetLogging_T;                     ///< ReqSetLogging structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspGetVersion Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! RspGetVersion version maximum string length */
#define BSPROXY_RSPGETVERSION_VERSION_LEN (NMFVAL_LEN_MAX_STRING)

/*!
 * Message RspGetVersion Structure
 */
typedef struct
{
  char                    m_version[BSPROXY_RSPGETVERSION_VERSION_LEN+1];
                                              ///< version
} BsProxyRspGetVersion_T;                     ///< RspGetVersion structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqMsgTrace Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqMsgTrace Structure
 */
typedef struct
{
  byte_t                  m_vconn;            ///< vconn
  bool_t                  m_trace;            ///< trace
} BsProxyReqMsgTrace_T;                       ///< ReqMsgTrace structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqDevOpen Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! ReqDevOpen devname maximum string length */
#define BSPROXY_REQDEVOPEN_DEVNAME_LEN (NMFVAL_LEN_MAX_STRING)

/*! ReqDevOpen modname maximum string length */
#define BSPROXY_REQDEVOPEN_MODNAME_LEN (NMFVAL_LEN_MAX_STRING)

/*! ReqDevOpen argbuf maximum vector length */
#define BSPROXY_REQDEVOPEN_ARGBUF_LEN (NMFVAL_LEN_MAX_VECTOR)

/*!
 * Message ReqDevOpen Structure
 */
typedef struct
{
  bool_t                  m_trace;            ///< trace
  char                    m_devname[BSPROXY_REQDEVOPEN_DEVNAME_LEN+1];
                                              ///< devname
  char                    m_modname[BSPROXY_REQDEVOPEN_MODNAME_LEN+1];
                                              ///< modname
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      byte_t              m_buf[BSPROXY_REQDEVOPEN_ARGBUF_LEN];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_argbuf;                                 ///< vector
} BsProxyReqDevOpen_T;                        ///< ReqDevOpen structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspDevOpen Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspDevOpen Structure
 */
typedef struct
{
  byte_t                  m_vconn;            ///< vconn
} BsProxyRspDevOpen_T;                        ///< RspDevOpen structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqDevClose Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqDevClose Structure
 */
typedef struct
{
  byte_t                  m_vconn;            ///< vconn
} BsProxyReqDevClose_T;                       ///< ReqDevClose structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspGetVConnList Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspGetVConnList Structure
 */
typedef struct
{
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      byte_t              m_buf[BSPROXY_VCONN_CLIENT_MAX];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_vconn;                                  ///< vector
} BsProxyRspGetVConnList_T;                   ///< RspGetVConnList structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyReqGetVConnInfo Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqGetVConnInfo Structure
 */
typedef struct
{
  byte_t                  m_vconn;            ///< vconn
} BsProxyReqGetVConnInfo_T;                   ///< ReqGetVConnInfo structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsProxyRspGetVConnInfo Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! RspGetVConnInfo client maximum string length */
#define BSPROXY_RSPGETVCONNINFO_CLIENT_LEN (NMFVAL_LEN_MAX_STRING)

/*! RspGetVConnInfo devuri maximum string length */
#define BSPROXY_RSPGETVCONNINFO_DEVURI_LEN (NMFVAL_LEN_MAX_STRING)

/*! RspGetVConnInfo moduri maximum string length */
#define BSPROXY_RSPGETVCONNINFO_MODURI_LEN (NMFVAL_LEN_MAX_STRING)

/*! RspGetVConnInfo modver maximum string length */
#define BSPROXY_RSPGETVCONNINFO_MODVER_LEN (NMFVAL_LEN_MAX_STRING)

/*! RspGetVConnInfo moddate maximum string length */
#define BSPROXY_RSPGETVCONNINFO_MODDATE_LEN (NMFVAL_LEN_MAX_STRING)

/*!
 * Message RspGetVConnInfo Structure
 */
typedef struct
{
  byte_t                  m_vconn;            ///< vconn
  int                     m_rd;               ///< rd
  char                    m_client[BSPROXY_RSPGETVCONNINFO_CLIENT_LEN+1];
                                              ///< client
  char                    m_devuri[BSPROXY_RSPGETVCONNINFO_DEVURI_LEN+1];
                                              ///< devuri
  char                    m_moduri[BSPROXY_RSPGETVCONNINFO_MODURI_LEN+1];
                                              ///< moduri
  char                    m_modver[BSPROXY_RSPGETVCONNINFO_MODVER_LEN+1];
                                              ///< modver
  char                    m_moddate[BSPROXY_RSPGETVCONNINFO_MODDATE_LEN+1];
                                              ///< moddate
} BsProxyRspGetVConnInfo_T;                   ///< RspGetVConnInfo structure


//-----------------------------------------------------------------------------
// External Data
//-----------------------------------------------------------------------------

//
// BsProxy Message Definition Look-Up Table.
// (indexed by BsProxyMsgId_T enum)
// 
extern const NMMsgDef_T *BsProxyMsgDefLookupTbl[];

//
// BsProxy Maximum Message Body Length (bytes) Look-Up Table.
// (indexed by BsProxyMsgId_T enum)
// 
extern size_t BsProxyMsgMaxLenLookupTbl[];


//-----------------------------------------------------------------------------
// Function Prototypes
//-----------------------------------------------------------------------------

extern const NMMsgDef_T * BsProxyLookupMsgDef( BsProxyMsgId_T eMsgId );

extern size_t BsProxyLookupMsgMaxLen( BsProxyMsgId_T eMsgId );

extern int BsProxyPackMsg( BsProxyMsgId_T eMsgId,
                           void * pStruct,
                           byte_t buf[],
                           size_t bufSize,
                           bool_t bTrace );

extern int BsProxyUnpackMsg( BsProxyMsgId_T eMsgId,
                             byte_t buf[],
                             size_t uMsgLen,
                             void * pStruct,
                             bool_t bTrace );

/*!
 * \brief Pack a BsProxyRspErr ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspErr( BsProxyRspErr_T * pStruct,
                                   byte_t buf[],
                                   size_t bufSize,
                                   bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspErr, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspErr ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspErr( byte_t buf[],
                                     size_t uMsgLen,
                                     BsProxyRspErr_T * pStruct,
                                     bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspErr, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqLoopback ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqLoopback( BsProxyReqLoopback_T * pStruct,
                                        byte_t buf[],
                                        size_t bufSize,
                                        bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqLoopback, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqLoopback ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqLoopback( byte_t buf[],
                                          size_t uMsgLen,
                                          BsProxyReqLoopback_T * pStruct,
                                          bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqLoopback, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyRspLoopback ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspLoopback( BsProxyRspLoopback_T * pStruct,
                                        byte_t buf[],
                                        size_t bufSize,
                                        bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspLoopback, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspLoopback ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspLoopback( byte_t buf[],
                                          size_t uMsgLen,
                                          BsProxyRspLoopback_T * pStruct,
                                          bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspLoopback, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqSetLogging ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqSetLogging( BsProxyReqSetLogging_T * pStruct,
                                          byte_t buf[],
                                          size_t bufSize,
                                          bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqSetLogging, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqSetLogging ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqSetLogging( byte_t buf[],
                                            size_t uMsgLen,
                                            BsProxyReqSetLogging_T * pStruct,
                                            bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqSetLogging, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyRspGetVersion ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspGetVersion( BsProxyRspGetVersion_T * pStruct,
                                          byte_t buf[],
                                          size_t bufSize,
                                          bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspGetVersion, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspGetVersion ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspGetVersion( byte_t buf[],
                                            size_t uMsgLen,
                                            BsProxyRspGetVersion_T * pStruct,
                                            bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspGetVersion, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqMsgTrace ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqMsgTrace( BsProxyReqMsgTrace_T * pStruct,
                                        byte_t buf[],
                                        size_t bufSize,
                                        bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqMsgTrace, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqMsgTrace ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqMsgTrace( byte_t buf[],
                                          size_t uMsgLen,
                                          BsProxyReqMsgTrace_T * pStruct,
                                          bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqMsgTrace, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqDevOpen ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqDevOpen( BsProxyReqDevOpen_T * pStruct,
                                       byte_t buf[],
                                       size_t bufSize,
                                       bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqDevOpen, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqDevOpen ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqDevOpen( byte_t buf[],
                                         size_t uMsgLen,
                                         BsProxyReqDevOpen_T * pStruct,
                                         bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqDevOpen, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyRspDevOpen ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspDevOpen( BsProxyRspDevOpen_T * pStruct,
                                       byte_t buf[],
                                       size_t bufSize,
                                       bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspDevOpen, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspDevOpen ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspDevOpen( byte_t buf[],
                                         size_t uMsgLen,
                                         BsProxyRspDevOpen_T * pStruct,
                                         bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspDevOpen, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqDevClose ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqDevClose( BsProxyReqDevClose_T * pStruct,
                                        byte_t buf[],
                                        size_t bufSize,
                                        bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqDevClose, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqDevClose ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqDevClose( byte_t buf[],
                                          size_t uMsgLen,
                                          BsProxyReqDevClose_T * pStruct,
                                          bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqDevClose, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyRspGetVConnList ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspGetVConnList( BsProxyRspGetVConnList_T * pStruct,
                                            byte_t buf[],
                                            size_t bufSize,
                                            bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspGetVConnList, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspGetVConnList ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspGetVConnList( byte_t buf[],
                                              size_t uMsgLen,
                                              BsProxyRspGetVConnList_T * pStruct,
                                              bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspGetVConnList, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyReqGetVConnInfo ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackReqGetVConnInfo( BsProxyReqGetVConnInfo_T * pStruct,
                                            byte_t buf[],
                                            size_t bufSize,
                                            bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdReqGetVConnInfo, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyReqGetVConnInfo ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackReqGetVConnInfo( byte_t buf[],
                                              size_t uMsgLen,
                                              BsProxyReqGetVConnInfo_T * pStruct,
                                              bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdReqGetVConnInfo, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsProxyRspGetVConnInfo ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyPackRspGetVConnInfo( BsProxyRspGetVConnInfo_T * pStruct,
                                            byte_t buf[],
                                            size_t bufSize,
                                            bool_t bTrace )
{
  return BsProxyPackMsg(BsProxyMsgIdRspGetVConnInfo, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsProxyRspGetVConnInfo ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsProxyUnpackRspGetVConnInfo( byte_t buf[],
                                              size_t uMsgLen,
                                              BsProxyRspGetVConnInfo_T * pStruct,
                                              bool_t bTrace )
{
  return BsProxyUnpackMsg(BsProxyMsgIdRspGetVConnInfo, buf, uMsgLen, pStruct, bTrace);
}


C_DECLS_END


#endif // _BSPROXYMSGS_H