integration/luprex/core/cpp/util.hpp

#ifndef UTIL_HPP
#define UTIL_HPP

#include <string>
#include <set>
#include <algorithm>
#include <sstream>
#include <ostream>
#include <tuple>
#include <utility>

namespace util {

enum WorldType {
    WORLD_TYPE_STANDALONE,
    WORLD_TYPE_C_SYNC,
    WORLD_TYPE_S_SYNC,
    WORLD_TYPE_MASTER,
};

using stringvec = std::vector<std::string>;
using stringset = std::set<std::string>;
using HashValue = std::pair<uint64_t, uint64_t>;

// Split a string into multiple strings
stringvec split(const std::string &s, char sep);

// String to lowercase/uppercase
std::string tolower(std::string input);
std::string toupper(std::string input);

// Return true if the string can be parsed as an integer.
bool validinteger(const std::string &value);

// String to integer.  Returns errval if the number is not parseable.
int64_t strtoint(const std::string &value, int64_t errval);

// String to double.  Returns NAN if the number is not parseable.
double strtodouble(const std::string &value);

// Trim strings: left end, right end, both ends.
std::string ltrim(std::string s);
std::string rtrim(std::string s);
std::string trim(std::string s);

// Read a file as one big string.
std::string get_file_contents(const std::string &path);

// Read a file as a vector of lines.
stringvec   get_file_lines(const std::string &path);

// Get a file's fingerprint - ie, size and modification time.
std::string get_file_fingerprint(const std::string &path);

// Calculate distance between two points
double distance_squared(double x1, double y1, double x2, double y2);


// An XYZ coordinate, general purpose.
struct XYZ {
    float x, y, z;
    XYZ() { x=0; y=0; z=0; }
    XYZ(float ix, float iy, float iz) { x=ix; y=iy; z=iz; }
    bool operator ==(const XYZ &o) const { return x==o.x && y == o.y && z==o.z; }
    bool operator !=(const XYZ &o) const { return x!=o.x || y != o.y || z!=o.z; }
    std::string debug_string() const;
};

// These are formatting directives that can be sent to a std::ostream.
class hex64 {};
class hex32 {};
class hex16 {};
class hex8 {};

} // namespace util

std::ostream &operator<<(std::ostream &oss, const util::hex64 &v);
std::ostream &operator<<(std::ostream &oss, const util::hex32 &v);
std::ostream &operator<<(std::ostream &oss, const util::hex16 &v);
std::ostream &operator<<(std::ostream &oss, const util::hex8 &v);

#endif // UTIL_HPP