tools.hpp

Go to the documentation of this file.

 
#ifndef IFW_CORE_UTILS_TOOLS_HPP_
#define IFW_CORE_UTILS_TOOLS_HPP_
 
#include <limits.h>
#include <stdarg.h>
#include <string>
#include <map>
#include <list>
#include <fstream>
#include <variant>
 
#include <core/utils/base/base.hpp>
 
namespace ifw {
 
  // TODO: Remove this and replace calls to this function with (fmt::print(). fmtlib).
  std::string Write(const char* format, ...);
 
}
 
#define IFW_LOCATION {\
  std::string(__FILE__), \
  std::string(__FUNCTION__), \
  std::to_string(__LINE__)}
 
namespace core::utils::base {
 
    std::string ResolvePath(const std::string& filename);
 
    std::string GenUniqueId(const std::string& prefix = "");
 
    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);
 
    template <class TYPE>
    int32_t ElInVector(const std::vector<TYPE>& vect,
                       const TYPE& value) {
        int32_t i = 0;
        for (auto it = vect.begin(); it != vect.end(); it++, i++) {
            if (*it == value) {
                return i;
            }
        }
        return -1;
    }
 
    template <class TYPE>
    std::string DumpVector(const std::vector<TYPE>& vector,
                           const std::string& separator = "\n") {
      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) {
      return (map.find(key) != map.end());
    }
 
    namespace testutils {
 
      // TODO: Remove this function not needed (can use WAF_MODULE_PATH instead).
      std::string GetResDir(const std::string& module_path,
                            const std::string& test_res_dir); // = "test/resource");
 
      // TODO: Remove this function not needed (can use WAF_MODULE_PATH instead).
      void SetRootEnvVars(const std::string& module_path,
                          const std::string& test_res_dir,  // = "test/resource",
                          const std::vector<std::string>& cfgpath_dirs);
 
    } // namespace testutils
 
}
 
void IFW_DEBUG(const char* format, ...);
 
#endif // IFW_CORE_UTILS_TOOLS_HPP_