utils.h

Go to the documentation of this file.

#ifndef DATATOOLS_UTILS_H
#define DATATOOLS_UTILS_H

// Standard Library:
#include <cstdlib>
#include <list>
#include <string>

// Third party:
// - Boost:
// #include <boost/property_tree/ptree.hpp>

// This Project:
#include <datatools/exception.h>
#include <datatools/bit_mask.h>

namespace datatools {

  enum return_code_type {
    SUCCESS = EXIT_SUCCESS, 
    ERROR   = EXIT_FAILURE, 
    FAILURE = EXIT_FAILURE  
  };

  enum compare_result_type {
    COMPARE_UNDEFINED = -2, 
    COMPARE_LESS      = -1, 
    COMPARE_EQUAL     =  0, 
    COMPARE_GREATER   =  1  
  };

  /* String constants */

  const std::string & empty_string();

  const std::string & none_label();

  const std::string & yes_label();

  const std::string & no_label();
  
  /* Single precision utility functions */

  void invalidate(float& value_);

  float invalid_real_single();

  bool is_valid(float value_);

  bool is_infinity(float value_);

  bool is_plus_infinity(float value_);

  bool is_minus_infinity(float value_);

  void plus_infinity(float& value_);

  void minus_infinity(float& value_);

  void infinity(float& value_);

  /* Double precision utility functions */

  void invalidate(double& value_);

  double invalid_real_double();

  double invalid_real();

  bool is_valid(double value_);

  bool is_infinity(double value_);

  bool is_plus_infinity(double value_);

  bool is_minus_infinity(double value_);

  bool is_normal(double value_);

  void plus_infinity(double& value_);

  void minus_infinity(double& value_);

  void infinity(double& value_);

  compare_result_type compare_real(double x1_, double x2_,
                                   double abs_eps_ = 0.0, double rel_eps_ = 0.0);

  /* String utility functions */

  enum name_validation_flags {
    NV_NO_COLON      = bit_mask::bit00, 
    NV_NO_DOT        = bit_mask::bit01, 
    NV_NO_HYPHEN     = bit_mask::bit02, 
    NV_NO_UNDERSCORE = bit_mask::bit03, 
    NV_LEADING_DIGIT = bit_mask::bit04, 
    NV_DEFAULT       = NV_NO_HYPHEN ,   
    NV_INSTANCE      = NV_NO_HYPHEN | NV_NO_COLON, 
    NV_MODEL         = NV_NO_HYPHEN     
  };

  bool name_validation(const std::string & name_, uint32_t flags_ = NV_DEFAULT);

  bool is_quoted(const std::string & text_, char q_ = '"');

  void add_quotes(const std::string & from_, std::string & to_, char q_ = '"');

  void add_quotes(std::string & text_, char q_ = '"');

  void remove_quotes(const std::string & from_, std::string & to_, char q_ = '"');

  void remove_quotes(std::string & text_, char q_ = '"');

  void remove_all_quotes(std::string & text_);

  /* Functions to expand string as path */

  bool resolve_library_info_path_keys(const std::string & library_topic_,
                                      std::string & install_path_key_,
                                      std::string & environ_path_key_);

  std::string fetch_path(const std::string & path_str_);

  bool fetch_path(std::string & word_, std::string & errmsg_);

  bool fetch_path_with_env(std::string& word_);

  bool fetch_path_with_env(std::string& word_, std::string & errmsg_);

  bool fetch_path_without_env(std::string& word_);

  bool fetch_path_with_env_p(std::string& word_,
                             const std::string & parent_path_);

  bool fetch_path_with_env_g(std::string& word_);

  bool fetch_path_with_env_pg(std::string& word_,
                              const std::string & parent_path_);

  bool has_global_path();

  void reset_global_path();

  void set_global_path(const std::string & gpath_);

  const std::string & get_global_path();

  std::string expand_path(const std::string& path_str_);

  void split_string(const std::string& word_,
                    const std::string& separators_,
                    std::list<std::string>& words_);

  /* Bit manipulation utility template functions */

  template<typename Integral>
  void set_bit(Integral & number_, int pos_)
  {
    DT_THROW_IF(pos_ < 0 || pos_ >= (int) sizeof(Integral) * 8,
                std::range_error,
                "Invalid bit position [pos = " << pos_ << "]");
    number_ |= 1 << pos_;
    return;
  }

  template<typename Integral>
  void unset_bit(Integral & number_, int pos_)
  {
    DT_THROW_IF(pos_ < 0 || pos_ >= (int) sizeof(Integral) * 8,
                std::range_error,
                "Invalid bit position [pos = " << pos_ << "]");
    number_ &= ~(1 << pos_);
    return;
  }


  template<typename Integral>
  void toggle_bit(Integral & number_, int pos_)
  {
    DT_THROW_IF(pos_ < 0 || pos_ >= (int) sizeof(Integral) * 8,
                std::range_error,
                "Invalid bit position [pos = " << pos_ << "]");
    number_ ^= 1 << pos_;
    return;
  }


  template<typename Integral>
  bool check_bit(Integral& number_, int pos_)
  {
    DT_THROW_IF(pos_ < 0 || pos_ >= (int) sizeof(Integral) * 8,
                std::range_error,
                "Invalid bit position [pos = " << pos_ << "]");

    if (number_ & (1 << pos_)) return false;
    return true;
  }

} // namespace datatools

#endif // DATATOOLS_UTILS_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --