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(
    const std::string& str_version = get_version());
 
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);
 
MADARA_EXPORT 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 bool filename_has_redirect(const std::string& filename);
 
MADARA_EXPORT bool file_from_fragments(const std::string& filename,
    uint32_t crc, bool delete_incomplete = true, bool delete_fragments = true);
 
MADARA_EXPORT size_t get_file_progress(const std::string& filename,
    uint32_t crc, size_t expected_size, size_t fragment_size = 60000);
 
MADARA_EXPORT std::vector<int64_t> get_file_missing_fragments(
    const std::string& filename, uint32_t crc, size_t expected_size,
    int max_fragments = -1, size_t fragment_size = 60000);
 
MADARA_EXPORT std::string expand_envs(const std::string& source);
 
MADARA_EXPORT void strncpy_safe(char * dst, const char * src, size_t dst_size);
 
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);
 
std::vector <std::string> string_to_vector (const std::string & input,
  const std::string delimiter = "\n", bool strip_whitespace = true);
 
int64_t get_time(void);
 
TimeValue get_time_value(void);
 
TimeValue add_seconds(const TimeValue& start, double seconds);
 
Duration seconds_to_duration(double seconds);
 
int64_t seconds_to_nanoseconds(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);
 
MADARA_EXPORT Duration sleep_until(uint64_t wake);
 
MADARA_EXPORT Duration sleep_until(TimeValue wake);
 
bool approx_equal(double value1, double value2, double epsilon = 0.0001);
 
bool file_exists(const std::string& filename);
 
bool is_directory(const std::string& path);
 
unsigned int file_size(const std::string& filename);
 
size_t file_size(std::ifstream& input);
 
uint32_t file_crc(const std::string& filename, size_t max_block = 1000000);
 
MADARA_EXPORT void safe_clear(std::vector<std::string> & strings);
 
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_