util.hpp

Go to the documentation of this file.

#ifndef CORAL_UTIL_HPP
#define CORAL_UTIL_HPP

#include <cstdint>
#include <string>
#include <utility>
#include <vector>

#include "coral/config.h"
#include "boost/filesystem/path.hpp"
#include "boost/noncopyable.hpp"


namespace coral
{

namespace util
{


void EncodeUint16(std::uint16_t source, char target[2]);


void EncodeUint32(std::uint32_t source, char target[4]);


void EncodeUint64(std::uint64_t source, char target[8]);


std::uint16_t DecodeUint16(const char source[2]);


std::uint32_t DecodeUint32(const char source[4]);


std::uint64_t DecodeUint64(const char source[8]);


int ArrayStringCmp(const char* array, size_t length, const char* stringz);


std::string RandomUUID();


std::string RandomString(size_t size, const char* charSet);

std::string Timestamp();


template<typename T1, typename T2>
T1 MoveAndReplace(T1& variable, const T2& replacement)
{
    auto tmp = std::move(variable);
    variable = replacement;
    return std::move(tmp);
}

template<typename T>
T MoveAndReplace(T& variable)
{
    return MoveAndReplace(variable, T());
}


template<typename F>
void LastCall(F& f)
{
    F tmp;
    swap(f, tmp);
    tmp();
}

template<typename F, typename... Args>
void LastCall(F& f, Args&&... args)
{
    F tmp;
    swap(f, tmp);
    tmp(std::forward<Args>(args)...);
}


template<typename Action>
class ScopeGuard : boost::noncopyable
{
public:
    explicit ScopeGuard(Action action) : m_active(true), m_action(action) { }

    ScopeGuard(ScopeGuard&& other)
        : m_active(MoveAndReplace(other.m_active, false)),
          m_action(std::move(other.m_action))
    { }

    ScopeGuard& operator=(ScopeGuard&& other)
    {
        m_active = MoveAndReplace(other.m_active, false);
        m_action = std::move(other.m_action);
    }

    ~ScopeGuard() { if (m_active) m_action(); }

private:
    bool m_active;
    Action m_action;
};

template<typename Action>
ScopeGuard<Action> OnScopeExit(Action action) { return ScopeGuard<Action>(action); }


void SpawnProcess(
    const std::string& program,
    const std::vector<std::string>& args);


boost::filesystem::path ThisExePath();


}}      // namespace
#endif  // header guard