io.cpp

Go to the documentation of this file.

/* Author: Zachary Kingston */

#include <cstdlib>
#include <memory>
#include <array>
#include <stdexcept>
#include <chrono>
#include <thread>

#include <boost/format.hpp>
#include <boost/filesystem.hpp>

#include <se2ez/core/io.h>

using namespace se2ez;

namespace
{
    boost::filesystem::path expandHome(const boost::filesystem::path &in)
    {
        const char *home = std::getenv("HOME");
        if (home == nullptr)
        {
            throw std::runtime_error("HOME Environment variable is not set! Cannot resolve ~ in path.");
            return in;
        }

        boost::filesystem::path out;
        for (const auto &p : in)
            out /= (p.string() == "~") ? home : p;

        return out;
    }

    boost::filesystem::path expandSymlinks(const boost::filesystem::path &in)
    {
        boost::filesystem::path out;
        for (const auto &p : in)
        {
            auto tmp = out / p;
            if (boost::filesystem::is_symlink(tmp))
                out = boost::filesystem::read_symlink(tmp);
            else
                out /= p;
        }

        return out;
    }

    boost::filesystem::path expandPath(const boost::filesystem::path &in)
    {
        boost::filesystem::path out = in;
        out = expandHome(out);
        out = expandSymlinks(out);

        return boost::filesystem::absolute(out);
    }

    // is lhs a prefix of rhs?
    // bool isPrefix(const std::string &lhs, const std::string &rhs)
    // {
    //     return std::equal(lhs.begin(), lhs.begin() + std::min(lhs.size(), rhs.size()), rhs.begin());
    // }

    // is lhs a suffix? of rhs?
    bool isSuffix(const std::string &lhs, const std::string &rhs)
    {
        return std::equal(lhs.rbegin(), lhs.rbegin() + std::min(lhs.size(), rhs.size()), rhs.rbegin());
    }

    bool isExtension(const std::string &path_string, const std::string &extension)
    {
        boost::filesystem::path path(path_string);
        const std::string last = boost::filesystem::extension(path);
        return isSuffix(extension, last);
    }
}  // namespace

const std::string io::resolvePath(const std::string &path)
{
    boost::filesystem::path file = expandPath(path).string();

    if (!boost::filesystem::exists(file))
        throw std::invalid_argument((boost::format("File `%1%` does not exist.") % path).str());

    return boost::filesystem::canonical(boost::filesystem::absolute(file)).string();
}

const std::string io::loadFileToString(const std::string &path)
{
    const std::string full_path = resolvePath(path);
    if (full_path.empty())
        return "";

    std::ifstream ifs(full_path.c_str(), std::ios::in | std::ios::binary | std::ios::ate);

    std::ifstream::pos_type size = ifs.tellg();
    ifs.seekg(0, std::ios::beg);

    std::vector<char> bytes(size);
    ifs.read(bytes.data(), size);

    return std::string(bytes.data(), size);
}

const std::string io::runCommand(const std::string &cmd)
{
    std::array<char, 128> buffer;
    std::string result;
    std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);
    if (!pipe)
        throw std::runtime_error((boost::format("Failed to run command `%1%`!") % cmd).str());

    while (!feof(pipe.get()))
    {
        if (fgets(buffer.data(), 128, pipe.get()) != nullptr)
            result += buffer.data();
    }

    return result;
}

const std::pair<bool, YAML::Node> io::loadFileToYAML(const std::string &path)
{
    YAML::Node file;
    const std::string full_path = resolvePath(path);
    if (full_path.empty())
        return std::make_pair(false, file);

    if (!isExtension(full_path, "yml") && !isExtension(full_path, "yaml"))
        return std::make_pair(false, file);

    try
    {
        return std::make_pair(true, YAML::LoadFile(full_path));
    }
    catch (std::exception &e)
    {
        return std::make_pair(false, file);
    }
}

bool io::YAMLToFile(const YAML::Node &node, const std::string &file)
{
    YAML::Emitter out;
    out << node;

    std::ofstream fout;
    io::createFile(fout, file);

    fout << out.c_str();
    fout.close();

    return true;
}

void io::createDirectory(const std::string &dir)
{
    boost::filesystem::create_directories(dir);
}

void io::createFile(std::ofstream &out, const std::string &file)
{
    boost::filesystem::path path(file);
    path = expandHome(path);
    path = expandSymlinks(path);

    const auto parent = path.parent_path().string();

    if (!parent.empty())
        io::createDirectory(parent);

    out.open(path.string(), std::ofstream::out | std::ofstream::trunc);
}

const std::pair<bool, std::vector<std::string>> io::listDirectory(const std::string &directory)
{
    std::vector<std::string> contents;

    const std::string full_path = resolvePath(directory);
    if (full_path.empty())
        return std::make_pair(false, contents);

    boost::filesystem::path path(full_path);
    if (!boost::filesystem::is_directory(path))
        return std::make_pair(false, contents);

    for (auto it = boost::filesystem::directory_iterator(path); it != boost::filesystem::directory_iterator();
         ++it)
        contents.emplace_back(expandPath(it->path()).string());

    return std::make_pair(true, contents);
}

boost::posix_time::ptime io::getDate()
{
    return boost::posix_time::microsec_clock::local_time();
}

std::vector<std::string> io::tokenize(const std::string &s, const std::string &separators)
{
    boost::char_separator<char> seps(separators.c_str());
    boost::tokenizer<boost::char_separator<char>> tokenizer(s, seps);
    return std::vector<std::string>(tokenizer.begin(), tokenizer.end());
}

void io::sleep(double seconds)
{
    std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<long int>(seconds * 1000)));
}