tools.hpp

Go to the documentation of this file.

#ifndef IFW_CTD_TOOLS_HPP_
#define IFW_CTD_TOOLS_HPP_

#include <limits.h>
#include <stdarg.h>
#include <string>
#include <map>
#include <list>
#include <fstream>
#include <variant>

#include "rad/logger.hpp"
#include "rad/exceptions.hpp"

// TODO: Should document which exceptions are thrown in the Doxygen doc (@throw <ex>).

namespace ifw {

  // TODO: Check if can be replaced with functions from fmtlib.net.
  std::string Write(const char* format, ...);

}

#define IFW_LOCATION {\
  std::string(__FILE__), \
  std::string(__FUNCTION__), \
  std::to_string(__LINE__)}


// TODO: Use "namespace ctd::defines {" (in CTD, DIT, TCCS).
namespace ctd {
  namespace defines {

    std::string GenUniqueId(const std::string& prefix = "");

    //    template <class TYPE>
    //    class List: public std::list<TYPE> {
    //    public:
    //      TYPE& operator[] (const int32_t index) {
    //        auto list_it = this->begin();
    //        std::advance(list_it, index);
    //        return *list_it;
    //      }
    //    };

    template <class TYPE>
    void CleanVector(const std::vector<TYPE>& vect,
                     const TYPE& pattern,
                     std::vector<TYPE>& clean_vect) {
        clean_vect.clear();
        for (const TYPE& el : vect) {
            if (el != pattern) {
                clean_vect.insert(el);
            }
        }

    }

    template <class TYPE>
    void CheckRange(const std::string& par,
                    TYPE value,
                    TYPE lower_limit,
                    TYPE upper_limit);

    template <class TYPE>
    void CheckRange(const std::string& par,
                   const TYPE& value,
                   std::vector<TYPE>& valid_values);

    //    /// @brief Check for specific element in the list.
    //    template <class TYPE>
    //    int32_t ElInList(const List<TYPE>& list,
    //                     const TYPE& value) {
    //      RAD_LOG_TRACE();

    //      int32_t i = 0;
    //      for (auto list_it = list.begin(); list_it != list.end(); list_it++, i++) {
    //          if (*list_it == value) {
    //              return i;
    //            }
    //        }
    //      return -1;
    //    }

    template <class TYPE>
    std::string DumpVector(const std::vector<TYPE>& vector,
                           const std::string& separator = "\n") {
      RAD_LOG_TRACE();

      std::stringstream tmp_buf;
      int32_t i = 0;
      for (auto it = vector.begin(); it != vector.end(); it++, i++) {
          tmp_buf << *it << separator;
        }
      return tmp_buf.str();
    }

    template <class MAP_TYPE>
    bool ElInMap(const std::string& key,
                 const MAP_TYPE& map) {
      RAD_LOG_TRACE();

      return (map.find(key) != map.end());
    }

  }
}

void IFW_DEBUG(const char* format, ...);


#endif // IFW_CTD_DEFINES_HPP_