Merge branch 'devel' into 'main'

# TITAN Test System Framework

This module provides the bases to start the development of any Conformance Testing project or Interoperability Testing project.

It contains:

- A set C/C++ modules such as logging, codec support,

- A set of TTCN-3 modules such as LibHttp

/*!

 * \file      base_time.hh

 * \brief     Header file for the control port base_time functionality.

 * \author    ETSI STF525

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once

#include <chrono>

/**

 * \class base_time

 * \brief This class provides time tools such as getting current time

 */

class base_time {

  const unsigned long long its_base_time_ms = 1072915200000L; //! Base time 01/01/2004 12:00am in millseconds

  unsigned long long leap_delay;

  static base_time *_instance;

private:

  base_time() : leap_delay{0} {}; //! Can not be created manually

public:

  static inline base_time &get_instance();

  virtual ~base_time() {

    if (_instance != nullptr)

      delete _instance;

  };

public:

  inline const unsigned long long get_current_time_ms() const;

  inline const unsigned long long get_its_base_time_ms() const;

  inline const unsigned long long get_its_current_time_ms() const;

  inline const unsigned long long get_its_current_time_us() const;

  inline const unsigned long long get_its_current_time_mod_ms() const;

  inline void                     set_leap_delay_us(const unsigned long long p_leap_delay);

  inline const unsigned long long get_leap_delay_us() const;

}; // End of class base_time

// static functions

base_time &base_time::get_instance() { return (_instance != nullptr) ? *_instance : *(_instance = new base_time()); }

const unsigned long long base_time::get_current_time_ms() const {

  return (leap_delay / 1000) + std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();

}

const unsigned long long base_time::get_its_base_time_ms() const { return base_time::its_base_time_ms; }

const unsigned long long base_time::get_its_current_time_ms() const {

  return (leap_delay / 1000) + std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() -

         base_time::its_base_time_ms;

}

const unsigned long long base_time::get_its_current_time_us() const {

  return leap_delay + std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count() -

         base_time::its_base_time_ms * 1000;

}

const unsigned long long base_time::get_its_current_time_mod_ms() const {

  return ((leap_delay / 1000) + std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() -

          base_time::its_base_time_ms) %

         65536;

}

void base_time::set_leap_delay_us(const unsigned long long p_leap_delay) { leap_delay = p_leap_delay; }

inline const unsigned long long base_time::get_leap_delay_us() const { return leap_delay; }

/*!

 * \file      codec_factory.hh

 * \brief     Header file for ITS abstract protocol codec definition.

 * \author    ETSI STF525

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once

#include <algorithm>

#include <map>

#include <string>

#include <vector>

#include "codec_gen.hh"

class Record_Type; //! TITAN forward declaration

/*!

 * \class codec_factory

 * \brief  This class provides a factory class to create codec class instances

 * \abstract

 */

class codec_factory {

public: //! \publicsection

  /*!

   * \fn codec_factory();

   * \brief  Default constructor

   */

  codec_factory(){};

  /*!

   * \fn codec* create_codec(const std::string & type, const std::string & param);

   * \brief  Create the codecs stack based on the provided codecs stack description (cf. remark)

   * \param[in] p_type The provided codecs stack description

   * \param[in] p_params Optional parameters

   * \return 0 on success, -1 otherwise

   * \remark The description below introduces codecs stack in case of ITS project:

   *     HTTP(codecs=xml:held_codec;html:html_codec,json:json_codec)/TCP(debug=1,server=httpbin.org,port=80,use_ssl=0)

   * \pure

   */

  virtual codec_gen<Record_Type, Record_Type> *create_codec() = 0;

}; // End of class codec_factory

/*!

 * \file      codec.hh

 * \brief     Header file for ITS abstract codec definition.

 * \author    ETSI STF525

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once

#include "params.hh"

class OCTETSTRING; //! Declare TITAN class

class CHARSTRING;  //! Declare TITAN class

class BITSTRING;   //! Declare TITAN class

/*!

 * \class codec

 * \brief  This class provides the interface for all ITS codecs, include UT and AC codecs

 * \abstract

 */

template <typename TPDUEnc, typename TPDUDec> class codec_gen {

protected:

  params *_params; //! Reference to params stack

                   // \todo Use smart pointer std::unique_ptr<params>

public: //! \publicsection

  /*!

   * \fn codec_gen();

   * \brief  Default constructor

   * \todo Remove logs

   */

  explicit codec_gen() : _params(nullptr){};

  /*!

   * \fn ~codec_gen();

   * \brief  Default destructor

   * \virtual

   * \todo Remove logs

   */

  virtual ~codec_gen(){};

  /*!

   * \fn int encode(const TPDUEnc& msg, OCTETSTRING& data);

   * \brief  Encode typed message into an octet string

   * \param[in] p_message The typed message to be encoded

   * \param[out] p_data The encoding result

   * \return 0 on success, -1 otherwise

   * \pure

   */

  virtual int encode(const TPDUEnc &p_message, OCTETSTRING &p_data) = 0;

  /*!

   * \fn int decode(const OCTETSTRING& p_, TPDUDec& p_message, params_its* p_params = NULL);

   * \brief  Encode typed message into an octet string format

   * \param[in] p_data The message in its octet string

   * \param[out] p_message The decoded typed message

   * \return 0 on success, -1 otherwise

   * \pure

   */

  virtual int decode(const OCTETSTRING &p_, TPDUDec &p_message, params *p_params = NULL) = 0;

}; // End of class codec_gen

/*!

 * \file      codec_stack_builder.hh

 * \brief     Header file for ITS protocol stack builder.

 * \author    ETSI STF525

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once

#include "codec_factory.hh"

class Record_Type; //! TITAN forward declaration

/*!

 * \class codec_stack_builder

 * \brief  This class provides a factory class to create Codec class instances

 */

class codec_stack_builder {

private:                                            //! \privatesection

  static codec_stack_builder *           _instance; //! Smart pointer to the unique instance of the logger framework

  std::map<std::string, codec_factory *> _codecs;   //! The list of the registered \see t_codec factories

  /*!

   * \brief Default constructor

   *        Create a new instance of the codec_stack_builder class

   * \private

   */

  codec_stack_builder(){}; // can not be created manually

public:                    //! \publicsection

  /*!

   * \fn codec_stack_builder* get_instance();

   * \brief Accessor for the unique instance of the logger framework

   * \static

   */

  static codec_stack_builder *get_instance() { return _instance ? _instance : _instance = new codec_stack_builder(); };

  /*!

   * \fn void register_codec_factory(const std::string & p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);

   * \brief Add a new codec factory

   * \param[in] p_type          The codec identifier (e.g. GN for the GeoNetworking codec...)

   * \param[in] p_codec_factory A reference to the \see codec_factory

   * \static

   */

  static void register_codec_factory(const std::string &p_type, codec_factory *p_codec_factory) {

    codec_stack_builder::get_instance()->_register_codec_factory(p_type, p_codec_factory);

  };

private: //! \privatesection

  /*!

   * \fn void _register_codec_factory(const std::string & p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);

   * \brief Add a new codec factory

   * \param[in] p_type          The codec identifier (e.g. GN for the GeoNetworking codec...)

   * \param[in] p_codec_factory A reference to the \see codec_factory

   */

  void _register_codec_factory(const std::string &p_type, codec_factory *p_codec_factory) { _codecs[p_type] = p_codec_factory; };

public: //! \publicsection

  /*!

   * \fn codec* get_codec(const char* p_codec_name);

   * \brief Retrieve the specified codec name from the list of the registered codecs

   * \param[in] p_codec_name The codec indentifier

   * \return The pointer to the codec object on success, nullptr otherwise

   */

  inline codec_gen<Record_Type, Record_Type> *get_codec(const char *p_codec_name) { // NOTE A virtual method cannot not be a template ==> polymorphism required here

    typename std::map<std::string, codec_factory *>::const_iterator it = _codecs.find(p_codec_name);

    if (it != _codecs.cend()) {

      return it->second->create_codec();

    }

    return nullptr;

  }

}; // End of class codec_stack_builder