bsSerialMsgs.h

Go to the documentation of this file.

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


#ifndef _BSSERIALMSGS_H
#define _BSSERIALMSGS_H

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

#include "botsense/BotSense.h"


C_DECLS_BEGIN

/*!
 * BsSerial Message Id Enumeration
 */
typedef enum
{
  BsSerialMsgIdNone                     = 0,    ///< no message
  BsSerialMsgIdReqOpenArgs              = 1,    ///< ReqOpenArgs
  BsSerialMsgIdReqRead                  = 2,    ///< ReqRead
  BsSerialMsgIdReqTrans                 = 3,    ///< ReqTrans
  BsSerialMsgIdRspRead                  = 4,    ///< RspRead
  BsSerialMsgIdReqWrite                 = 5,    ///< ReqWrite
  BsSerialMsgIdRspWrite                 = 6,    ///< RspWrite
  BsSerialMsgIdNumOf                    = 7     ///< number of message ids
} BsSerialMsgId_T;


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


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialReqOpenArgs Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqOpenArgs Structure
 */
typedef struct
{
  uint_t                  m_baudrate;         ///< baudrate
  byte_t                  m_bytesize;         ///< bytesize
  char                    m_parity;           ///< parity
  byte_t                  m_stopbits;         ///< stopbits
  bool_t                  m_rtscts;           ///< rtscts
  bool_t                  m_xonxoff;          ///< xonxoff
} BsSerialReqOpenArgs_T;                      ///< ReqOpenArgs structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialReqRead Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqRead Structure
 */
typedef struct
{
  byte_t                  m_readlen;          ///< readlen
} BsSerialReqRead_T;                          ///< ReqRead structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialReqTrans Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! ReqTrans writebuf maximum vector length */
#define BSSERIAL_REQTRANS_WRITEBUF_LEN (NMFVAL_LEN_MAX_VECTOR)

/*!
 * Message ReqTrans Structure
 */
typedef struct
{
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      byte_t              m_buf[BSSERIAL_REQTRANS_WRITEBUF_LEN];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_writebuf;                               ///< vector
  byte_t                  m_readlen;          ///< readlen
} BsSerialReqTrans_T;                         ///< ReqTrans structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialRspRead Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! RspRead readbuf maximum vector length */
#define BSSERIAL_RSPREAD_READBUF_LEN (NMFVAL_LEN_MAX_VECTOR)

/*!
 * Message RspRead Structure
 */
typedef struct
{
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      byte_t              m_buf[BSSERIAL_RSPREAD_READBUF_LEN];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_readbuf;                                ///< vector
} BsSerialRspRead_T;                          ///< RspRead structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialReqWrite Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*! ReqWrite writebuf maximum vector length */
#define BSSERIAL_REQWRITE_WRITEBUF_LEN (NMFVAL_LEN_MAX_VECTOR)

/*!
 * Message ReqWrite Structure
 */
typedef struct
{
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      byte_t              m_buf[BSSERIAL_REQWRITE_WRITEBUF_LEN];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_writebuf;                               ///< vector
} BsSerialReqWrite_T;                         ///< ReqWrite structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsSerialRspWrite Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspWrite Structure
 */
typedef struct
{
  byte_t                  m_byteswritten;     ///< byteswritten
} BsSerialRspWrite_T;                         ///< RspWrite structure


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

//
// BsSerial Message Definition Look-Up Table.
// (indexed by BsSerialMsgId_T enum)
// 
extern const NMMsgDef_T *BsSerialMsgDefLookupTbl[];

//
// BsSerial Maximum Message Body Length (bytes) Look-Up Table.
// (indexed by BsSerialMsgId_T enum)
// 
extern size_t BsSerialMsgMaxLenLookupTbl[];


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

extern const NMMsgDef_T * BsSerialLookupMsgDef( BsSerialMsgId_T eMsgId );

extern size_t BsSerialLookupMsgMaxLen( BsSerialMsgId_T eMsgId );

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

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

/*!
 * \brief Pack a BsSerialReqOpenArgs 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 BsSerialPackReqOpenArgs( BsSerialReqOpenArgs_T * pStruct,
                                         byte_t buf[],
                                         size_t bufSize,
                                         bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdReqOpenArgs, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialReqOpenArgs 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 BsSerialUnpackReqOpenArgs( byte_t buf[],
                                           size_t uMsgLen,
                                           BsSerialReqOpenArgs_T * pStruct,
                                           bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdReqOpenArgs, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsSerialReqRead 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 BsSerialPackReqRead( BsSerialReqRead_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdReqRead, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialReqRead 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 BsSerialUnpackReqRead( byte_t buf[],
                                       size_t uMsgLen,
                                       BsSerialReqRead_T * pStruct,
                                       bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdReqRead, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsSerialReqTrans 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 BsSerialPackReqTrans( BsSerialReqTrans_T * pStruct,
                                      byte_t buf[],
                                      size_t bufSize,
                                      bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdReqTrans, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialReqTrans 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 BsSerialUnpackReqTrans( byte_t buf[],
                                        size_t uMsgLen,
                                        BsSerialReqTrans_T * pStruct,
                                        bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdReqTrans, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsSerialRspRead 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 BsSerialPackRspRead( BsSerialRspRead_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdRspRead, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialRspRead 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 BsSerialUnpackRspRead( byte_t buf[],
                                       size_t uMsgLen,
                                       BsSerialRspRead_T * pStruct,
                                       bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdRspRead, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsSerialReqWrite 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 BsSerialPackReqWrite( BsSerialReqWrite_T * pStruct,
                                      byte_t buf[],
                                      size_t bufSize,
                                      bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdReqWrite, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialReqWrite 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 BsSerialUnpackReqWrite( byte_t buf[],
                                        size_t uMsgLen,
                                        BsSerialReqWrite_T * pStruct,
                                        bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdReqWrite, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsSerialRspWrite 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 BsSerialPackRspWrite( BsSerialRspWrite_T * pStruct,
                                      byte_t buf[],
                                      size_t bufSize,
                                      bool_t bTrace )
{
  return BsSerialPackMsg(BsSerialMsgIdRspWrite, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsSerialRspWrite 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 BsSerialUnpackRspWrite( byte_t buf[],
                                        size_t uMsgLen,
                                        BsSerialRspWrite_T * pStruct,
                                        bool_t bTrace )
{
  return BsSerialUnpackMsg(BsSerialMsgIdRspWrite, buf, uMsgLen, pStruct, bTrace);
}


C_DECLS_END


#endif // _BSSERIALMSGS_H