Newer
Older
#include "LibItsSremSsem_EncdecDeclarations.hh"
#include "SremCodec.hh"
#include "SsemCodec.hh"
#include "UpperTesterSremSsemCodec.hh"
#include "loggers.hh"
namespace LibItsSremSsem__EncdecDeclarations {
/****************************************************
* @desc External function to encode a SremReq type
* @param value to encode
* @return encoded value
****************************************************/
BITSTRING fx__enc__SremReq(const LibItsSremSsem__TestSystem::SremReq& p_sremReq)
{
loggers::get_instance().log_msg(">>> fx__enc__SremReq: ", p_sremReq);
OCTETSTRING os;
if (codec.encode(p_sremReq.msgOut(), os) == -1) {
loggers::get_instance().warning("fx__enc__SremReq: -1 result code was returned");
return int2bit(0, 1);
}
return oct2bit(os);
}
/****************************************************
* @desc External function to decode a SremReq type
* @param value to encode
* @return encoded value
****************************************************/
INTEGER fx__dec__SremReq(BITSTRING& b, LibItsSremSsem__TestSystem::SremReq& p)
{
loggers::get_instance().log(">>> fx__dec__SremReq");
SremCodec codec;
SREM__PDU__Descriptions::SREM srem;
OCTETSTRING is = bit2oct(b);
if (codec.decode(is, srem) == -1) {
loggers::get_instance().warning("fx__dec__SremReq: -1 result code was returned");
return -1;
}
p.msgOut() = srem;
return 0;
}
INTEGER fx__dec__SremInd(BITSTRING& b, LibItsSremSsem__TestSystem::SremInd& p_sremInd)
{
loggers::get_instance().log(">>> fx__dec__SremInd");
SremCodec codec;
SREM__PDU__Descriptions::SREM srem;
OCTETSTRING is = bit2oct(b);
// Calculate the size of the lower layers information
int s = (
LibItsSremSsem__TestSystem::SremInd_gnNextHeader_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_gnHeaderType_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_gnLifetime_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_btpInfo_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_ssp_raw_.fieldlength +
LibItsSremSsem__TestSystem::SremInd_its__aid_raw_.fieldlength
if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), srem) == -1) {
loggers::get_instance().warning("fx__dec__SremInd: -1 result code was returned");
return -1;
}
p_sremInd.msgIn() = srem;
// Decode lower layer data
TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));
loggers::get_instance().log_to_hexa("fx__dec__SremInd: ", decoding_buffer);
// gnNextHeader
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnNextHeader_raw_.fieldlength / 8)) {
p_sremInd.gnNextHeader().set_to_omit();
} else {
OCTETSTRING os;
os.decode(LibItsSremSsem__TestSystem::SremInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.gnNextHeader() = oct2int(os);
}
loggers::get_instance().log_msg("fx__dec__SremInd: gnNextHeader=", p_sremInd.gnNextHeader());
loggers::get_instance().log_to_hexa("fx__dec__SremInd: ", decoding_buffer);
// gnHeaderType
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnHeaderType_raw_.fieldlength / 8)) {
p_sremInd.gnHeaderType().set_to_omit();
} else {
OCTETSTRING os;
os.decode(LibItsSremSsem__TestSystem::SremInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.gnHeaderType() = oct2int(os);
}
loggers::get_instance().log_msg("fx__dec__Srem: gnHeaderType=", p_sremInd.gnHeaderType());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// gnHeaderSubtype
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
p_sremInd.gnHeaderSubtype().set_to_omit();
} else {
OCTETSTRING os;
os.decode(LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.gnHeaderSubtype() = oct2int(os);
}
loggers::get_instance().log_msg("fx__dec__Srem: gnHeaderSubtype=", p_sremInd.gnHeaderSubtype());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// gnLifetime
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnLifetime_raw_.fieldlength / 8)) {
p_sremInd.gnLifetime().set_to_omit();
} else {
INTEGER i;
i.decode(LibItsSremSsem__TestSystem::SremInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.gnLifetime() = i;
}
loggers::get_instance().log_msg("fx__dec__Srem: gnLifetime=", p_sremInd.gnLifetime());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// gnTrafficClass
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_raw_.fieldlength / 8)) {
p_sremInd.gnTrafficClass().set_to_omit();
} else {
OCTETSTRING os;
os.decode(LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.gnTrafficClass() = oct2int(os);
}
loggers::get_instance().log_msg("fx__dec__Srem: gnTrafficClass=", p_sremInd.gnTrafficClass());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// btpDestinationPort
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_raw_.fieldlength / 8)) {
p_sremInd.btpDestinationPort().set_to_omit();
} else {
INTEGER i;
i.decode(LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.btpDestinationPort() = i;
}
loggers::get_instance().log_msg("fx__dec__Srem: btpDestinationPort=", p_sremInd.btpDestinationPort());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// btpInfo
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_btpInfo_raw_.fieldlength / 8)) {
p_sremInd.btpInfo().set_to_omit();
} else {
INTEGER i;
i.decode(LibItsSremSsem__TestSystem::SremInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.btpInfo() = i;
}
loggers::get_instance().log_msg("fx__dec__Srem: btpInfo=", p_sremInd.btpInfo());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// ssp
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_ssp_raw_.fieldlength / 8)) {
p_sremInd.ssp().set_to_omit();
} else {
BITSTRING bs;
bs.decode(LibItsSremSsem__TestSystem::SremInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.ssp() = bs;
}
loggers::get_instance().log_msg("fx__dec__Srem: ssp=", p_sremInd.ssp());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
// its__aid
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_its__aid_raw_.fieldlength / 8)) {
p_sremInd.its__aid().set_to_omit();
} else {
INTEGER i;
i.decode(LibItsSremSsem__TestSystem::SremInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_sremInd.its__aid() = i;
}
loggers::get_instance().log_msg("fx__dec__Srem: its_aid=", p_sremInd.its__aid());
loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);
return 0;
}
BITSTRING fx__enc__Srem(const SREM__PDU__Descriptions::SREM& p_srem)
{
loggers::get_instance().log_msg(">>> fx__enc__Srem: ", p_srem);
OCTETSTRING os;
codec.encode(p_srem, os);
return oct2bit(os);
}
INTEGER fx__dec__Srem(BITSTRING& b, SREM__PDU__Descriptions::SREM& p)
{
loggers::get_instance().log(">>> fx__dec__Srem");
OCTETSTRING is = bit2oct(b);
if (codec.decode(OCTETSTRING(is.lengthof(), static_cast<const unsigned char *>(is)), p) == -1) {
loggers::get_instance().warning("fx__dec__Srem: -1 result code was returned");
return -1;
}
return 0;
}
/****************************************************
* @desc External function to encode a SsemReq type
* @param value to encode
* @return encoded value
****************************************************/
BITSTRING fx__enc__SsemReq(const LibItsSremSsem__TestSystem::SsemReq& p_ssemReq)
loggers::get_instance().log_msg(">>> fx__enc__SsemReq: ", p_ssemReq);
if (codec.encode(p_ssemReq.msgOut(), os) == -1) {
loggers::get_instance().warning("fx__enc__SsemReq: -1 result code was returned");
return int2bit(0, 1);
}
return oct2bit(os);
}
/****************************************************
* @desc External function to decode a SsemReq type
* @param value to encode
* @return encoded value
****************************************************/
INTEGER fx__dec__SsemReq(BITSTRING& b, LibItsSremSsem__TestSystem::SsemReq& p)
{
loggers::get_instance().log(">>> fx__dec__SsemReq");
SsemCodec codec;
SSEM__PDU__Descriptions::SSEM ssem;
OCTETSTRING is = bit2oct(b);
if (codec.decode(is, ssem) == -1) {
loggers::get_instance().warning("fx__dec__SsemReq: -1 result code was returned");
return -1;
}
p.msgOut() = ssem;
return 0;
}
INTEGER fx__dec__SsemInd(BITSTRING& b, LibItsSremSsem__TestSystem::SsemInd& p_ssemInd)
{
loggers::get_instance().log(">>> fx__dec__SsemInd");
SsemCodec codec;
SSEM__PDU__Descriptions::SSEM ssem;
OCTETSTRING is = bit2oct(b);
// Calculate the size of the lower layers information
int s = (
LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_gnLifetime_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_btpInfo_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_ssp_raw_.fieldlength +
LibItsSremSsem__TestSystem::SsemInd_its__aid_raw_.fieldlength
) / 8;
// Decode CA message
if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), ssem) == -1) {
loggers::get_instance().warning("fx__dec__SsemSsemInd: -1 result code was returned");
return -1;
}
// Decode lower layer data
TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));
loggers::get_instance().log_to_hexa("fx__dec__SsemInd: ", decoding_buffer);
// gnNextHeader
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_raw_.fieldlength / 8)) {
p_ssemInd.gnNextHeader().set_to_omit();
os.decode(LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.gnNextHeader() = oct2int(os);
loggers::get_instance().log_msg("fx__dec__SsemInd: gnNextHeader=", p_ssemInd.gnNextHeader());
loggers::get_instance().log_to_hexa("fx__dec__SsemInd: ", decoding_buffer);
// gnHeaderType
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_raw_.fieldlength / 8)) {
p_ssemInd.gnHeaderType().set_to_omit();
os.decode(LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.gnHeaderType() = oct2int(os);
loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderType=", p_ssemInd.gnHeaderType());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// gnHeaderSubtype
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
p_ssemInd.gnHeaderSubtype().set_to_omit();
os.decode(LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.gnHeaderSubtype() = oct2int(os);
loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderSubtype=", p_ssemInd.gnHeaderSubtype());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// gnLifetime
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnLifetime_raw_.fieldlength / 8)) {
p_ssemInd.gnLifetime().set_to_omit();
i.decode(LibItsSremSsem__TestSystem::SsemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.gnLifetime() = i;
loggers::get_instance().log_msg("fx__dec__Ssem: gnLifetime=", p_ssemInd.gnLifetime());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// gnTrafficClass
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_raw_.fieldlength / 8)) {
p_ssemInd.gnTrafficClass().set_to_omit();
os.decode(LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.gnTrafficClass() = oct2int(os);
loggers::get_instance().log_msg("fx__dec__Ssem: gnTrafficClass=", p_ssemInd.gnTrafficClass());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// btpDestinationPort
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_raw_.fieldlength / 8)) {
p_ssemInd.btpDestinationPort().set_to_omit();
i.decode(LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.btpDestinationPort() = i;
loggers::get_instance().log_msg("fx__dec__Ssem: btpDestinationPort=", p_ssemInd.btpDestinationPort());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// btpInfo
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_btpInfo_raw_.fieldlength / 8)) {
p_ssemInd.btpInfo().set_to_omit();
i.decode(LibItsSremSsem__TestSystem::SsemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.btpInfo() = i;
loggers::get_instance().log_msg("fx__dec__Ssem: btpInfo=", p_ssemInd.btpInfo());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// ssp
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_ssp_raw_.fieldlength / 8)) {
p_ssemInd.ssp().set_to_omit();
bs.decode(LibItsSremSsem__TestSystem::SsemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.ssp() = bs;
loggers::get_instance().log_msg("fx__dec__Ssem: ssp=", p_ssemInd.ssp());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
// its__aid
if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_its__aid_raw_.fieldlength / 8)) {
p_ssemInd.its__aid().set_to_omit();
i.decode(LibItsSremSsem__TestSystem::SsemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
p_ssemInd.its__aid() = i;
loggers::get_instance().log_msg("fx__dec__Ssem: its_aid=", p_ssemInd.its__aid());
loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);
return 0;
}
BITSTRING fx__enc__Ssem(const SSEM__PDU__Descriptions::SSEM& p_ssem)
{
loggers::get_instance().log_msg(">>> fx__enc__Ssem: ", p_ssem);
OCTETSTRING os;
codec.encode(p_ssem, os);
return oct2bit(os);
}
INTEGER fx__dec__Ssem(BITSTRING& b, SSEM__PDU__Descriptions::SSEM& p_ssem)
{
loggers::get_instance().log(">>> fx__dec__Ssem");
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
OCTETSTRING is = bit2oct(b);
if (codec.decode(OCTETSTRING(is.lengthof(), static_cast<const unsigned char *>(is)), p_ssem) == -1) {
loggers::get_instance().warning("fx__dec__Ssem: -1 result code was returned");
return -1;
}
return 0;
}
BITSTRING fx__enc__UtSremInitialize (const LibItsSremSsem__TypesAndValues::UtSremInitialize& p_utSremInitialize)
{
loggers::get_instance().log_msg(">>> fx__enc__UtSremInitialize: ", p_utSremInitialize);
UpperTesterSremSsemCodec codec;
OCTETSTRING os;
codec.encode(p_utSremInitialize, os);
return oct2bit(os);
}
BITSTRING fx__enc__UtSremTrigger (const LibItsSremSsem__TypesAndValues::UtSremTrigger& p_utSremTrigger)
{
loggers::get_instance().log_msg(">>> fx__enc__UtSremTrigger: ", p_utSremTrigger);
UpperTesterSremSsemCodec codec;
OCTETSTRING os;
codec.encode(p_utSremTrigger, os);
return oct2bit(os);
}
/****************************************************
* @desc External function to decode a UtSremResults type
* @param value to encode
* @return encoded value
****************************************************/
INTEGER fx__dec__UtSremResults(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSremResults& p)
{
loggers::get_instance().log(">>> fx__dec__UtSremResults");
OCTETSTRING is = bit2oct(b);
std::unique_ptr<Base_Type> ptr = codec.decode(is);
if (ptr == nullptr) {
loggers::get_instance().warning("fx__dec__UtSremResults: -1 result code was returned");
return -1;
}
p = static_cast<LibItsSremSsem__TypesAndValues::UtSremResults&>(*ptr);
return 0;
}
/****************************************************
* @desc External function to decode a UtSremEventInd type
* @param value to encode
* @return encoded value
****************************************************/
INTEGER fx__dec__UtSremEventInd(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSremEventInd& p)
{
loggers::get_instance().log(">>> fx__dec__UtSremEventInd");
OCTETSTRING is = bit2oct(b);
std::unique_ptr<Base_Type> ptr = codec.decode(is);
if (ptr == nullptr) {
loggers::get_instance().warning("fx__dec__UtSremEventInd: -1 result code was returned");
return -1;
}
p = static_cast<LibItsSremSsem__TypesAndValues::UtSremEventInd&>(*ptr);
return 0;
}
/****************************************************
* @desc External function to decode a UtSsemEventInd type
* @param value to encode
* @return encoded value
****************************************************/
INTEGER fx__dec__UtSsemEventInd(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSsemEventInd& p)
{
loggers::get_instance().log(">>> fx__dec__UtSsemEventInd");
OCTETSTRING is = bit2oct(b);
std::unique_ptr<Base_Type> ptr = codec.decode(is);
if (ptr == nullptr) {
loggers::get_instance().warning("fx__dec__UtSsemEventInd: -1 result code was returned");
return -1;
}
p = static_cast<LibItsSremSsem__TypesAndValues::UtSsemEventInd&>(*ptr);