Utility.h

Go to the documentation of this file.

#ifndef _MADARA_UTILITY_H_
#define _MADARA_UTILITY_H_

#include <vector>
#include <string>
#include <cmath>
#include <limits.h>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include "madara/MadaraExport.h"
#include "madara/utility/StdInt.h"
#include "madara/knowledge/WaitSettings.h"
#include "madara/utility/IntTypes.h"

namespace madara
{
  namespace knowledge
  {
    class KnowledgeBase;
    struct WaitSettings;
  }

  namespace utility
  {
    typedef  std::chrono::steady_clock      Clock;

    typedef  std::chrono::nanoseconds       Duration;

    typedef  std::chrono::duration<double>  SecondsDuration;

    typedef std::chrono::time_point<Clock>  TimeValue;

    MADARA_EXPORT bool set_thread_priority (int priority = 20);
    
    MADARA_EXPORT std::string get_version (void);
    
    MADARA_EXPORT uint32_t get_uint_version (void);
    
    MADARA_EXPORT std::string to_string_version (uint32_t version);
    
    MADARA_EXPORT size_t string_replace (std::string & source,
      const std::string & old_phrase,
      const std::string & new_phrase,
      bool replace_all = true);
    
    std::string & upper (std::string & input);
    
    std::string & lower (std::string & input);
    
    std::string & dds_topicify (std::string & input);
    
    std::string & strip_white_space (std::string & input);
    
    MADARA_EXPORT std::string & strip_comments (std::string & input);
    
    MADARA_EXPORT std::string & string_remove (std::string & input,
      char unwanted);

    MADARA_EXPORT std::string & strip_extra_white_space (
      std::string & input);

    std::string strip_prefix (
      const std::string & input, const std::string & prefix);

    MADARA_EXPORT int split_hostport_identifier (const std::string & key, 
      std::string & host, std::string & port);
    
    MADARA_EXPORT int merge_hostport_identifier (std::string & key, 
      const std::string & host, const std::string & port);
    
    MADARA_EXPORT int merge_hostport_identifier (std::string & key, 
      const std::string & host, unsigned short u_port);
    
    MADARA_EXPORT void tokenizer (const std::string & input, 
      const ::std::vector< std::string> & splitters,
      ::std::vector< std::string> & tokens,
      ::std::vector< std::string> & pivot_list);

    MADARA_EXPORT std::string file_to_string (const std::string & filename);

    MADARA_EXPORT std::string extract_path (const std::string & name);
    
    MADARA_EXPORT std::string extract_filename (const std::string & name);

    MADARA_EXPORT std::string expand_envs (
      const std::string & source);

    char * get_var (const std::string & source, size_t cur, size_t & end);
    
    MADARA_EXPORT std::string clean_dir_name (const std::string & target);
    
    uint64_t endian_swap (uint64_t value);
    
    int64_t endian_swap (int64_t value);
    
    uint32_t endian_swap (uint32_t value);
    
    int32_t endian_swap (int32_t value);
    
    uint16_t endian_swap (uint16_t value);
    
    int16_t endian_swap (int16_t value);
    
    double endian_swap (double value);
    
    MADARA_EXPORT int  read_file (const std::string & filename,
      void *& buffer, size_t & size, bool add_zero_char = false);
    
    MADARA_EXPORT ssize_t write_file (const std::string & filename,
      void * buffer, size_t size);

    int64_t get_time (void);

    TimeValue get_time_value (void);

    TimeValue add_seconds (const TimeValue & start, double seconds);

    Duration seconds_to_duration (double seconds);

    SecondsDuration seconds_to_seconds_duration (double seconds);

    TimeValue seconds_to_time (double seconds);

    MADARA_EXPORT double rand_double (double floor = 0.0,
      double ceiling = 1.0, bool set_seed_to_time = true);
     
    MADARA_EXPORT int64_t rand_int (int64_t floor = 0,
      int64_t ceiling = RAND_MAX, bool set_seed_to_time = true);

    MADARA_EXPORT int64_t nearest_int (double input);

    MADARA_EXPORT bool begins_with (const std::string & input,
      const std::string & prefix);
    
    MADARA_EXPORT bool ends_with (const std::string & input,
      const std::string & ending);
    
    MADARA_EXPORT double sleep (double sleep_time);
    
    MADARA_EXPORT SecondsDuration sleep (const SecondsDuration & sleep_time);

    bool approx_equal (
      double value1, double value2, double epsilon = 0.0001);

    bool file_exists (const std::string & filename);

    unsigned int file_size (const std::string & filename);
    
    MADARA_EXPORT bool wait_true (knowledge::KnowledgeBase & knowledge,
      const std::string & variable,
      const knowledge::WaitSettings & settings =
        knowledge::WaitSettings ());

    

    MADARA_EXPORT bool wait_false (knowledge::KnowledgeBase & knowledge,
      const std::string & variable,
      const knowledge::WaitSettings & settings =
        knowledge::WaitSettings ());
    template <typename T>
    bool less_compare (const T & left, const T & right);

    template <typename T>
    bool greater_compare (const T & left, const T & right);

    template <typename T>
    void sift_down (T * input, int start, int end,
      bool (*comparator) (const T & left, const T & right) =
        greater_compare<T>);
    
    template <typename T>
    void heapify (T * input, int size,
     bool (*comparator) (const T & left, const T & right) =
        greater_compare<T>);

    template <typename T>
    void heap_sort (T * input, int size,
     bool (*comparator) (const T & left, const T & right) =
        greater_compare<T>);

    template <typename T>
    T bitmask_add (T mask, T values);
    
    template <typename T>
    bool bitmask_check (T mask, T values);
    
    template <typename T>
    T bitmask_remove (T mask, T values);

    std::pair<std::string, uint16_t> parse_address (std::string addr);
  }
}

#include "Utility.inl"

#endif // _MADARA_UTILITY_H_