io.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele, Wadim Koslow
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
 
#ifndef MIO_IO_IO_H
#define MIO_IO_IO_H
 
#include "memilio/utils/metaprogramming.h"
#include "memilio/utils/compiler_diagnostics.h"
#include "memilio/math/eigen_util.h"
#include "boost/outcome/result.hpp"
#include "boost/outcome/try.hpp"
#include "boost/optional.hpp"
 
#include <bitset>
#include <concepts>
#include <cstddef>
#include <filesystem>
#include <string>
#include <tuple>
#include <iostream>
#include <type_traits>
#include <utility>
 
namespace mio
{
 
enum class StatusCode
{
    OK           = 0, //must be 0 because std::error_code stores ints and expects 0 to be no error
    UnknownError = 1, //errors must be non-zero
    OutOfRange,
    InvalidValue,
    InvalidFileFormat,
    KeyNotFound,
    InvalidType,
    FileNotFound,
};
 
enum IOFlags
{
    IOF_None = 0,
 
    IOF_OmitDistributions = 1 << 0,
 
    IOF_OmitValues = 1 << 1,
 
    IOF_IncludeTypeInfo = 1 << 2,
};
 
} // namespace mio
 
namespace std
{
 
//make enum compatible with std::error_code
template <>
struct is_error_code_enum<mio::StatusCode> : true_type {
};
 
} // namespace std
 
namespace mio
{
 
namespace details
{
class StatusCodeCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override final
    {
        return "StatusCode";
    }
 
    virtual std::string message(int c) const override final
    {
        switch (static_cast<StatusCode>(c)) {
        case StatusCode::OK:
            return "No error";
        case StatusCode::OutOfRange:
            return "Invalid range";
        case StatusCode::InvalidValue:
            return "Invalid value";
        case StatusCode::InvalidFileFormat:
            return "Invalid file format";
        case StatusCode::KeyNotFound:
            return "Key not found";
        case StatusCode::InvalidType:
            return "Invalid type";
        case StatusCode::FileNotFound:
            return "File not found";
        default:
            return "Unknown Error";
        }
    }
 
    virtual std::error_condition default_error_condition(int c) const noexcept override final
    {
        switch (static_cast<StatusCode>(c)) {
        case StatusCode::OK:
            return std::error_condition();
        case StatusCode::OutOfRange:
            return std::make_error_condition(std::errc::argument_out_of_domain);
        case StatusCode::InvalidValue:
        case StatusCode::InvalidFileFormat:
        case StatusCode::InvalidType:
        case StatusCode::KeyNotFound:
            return std::make_error_condition(std::errc::invalid_argument);
        case StatusCode::FileNotFound:
            return std::make_error_condition(std::errc::no_such_file_or_directory);
        default:
            return std::error_condition(c, *this);
        }
    }
};
} // namespace details
 
inline const details::StatusCodeCategory& status_code_category()
{
    static details::StatusCodeCategory c;
    return c;
}
 
inline std::error_code make_error_code(StatusCode e)
{
    return {static_cast<int>(e), status_code_category()};
}
 
class IOStatus
{
public:
    IOStatus() = default;
 
    IOStatus(std::error_code ec, std::string msg = {})
        : m_ec(ec)
        , m_msg(std::move(msg))
    {
    }
 
    bool operator==(const IOStatus& other) const
    {
        return other.m_ec == m_ec;
    }
    bool operator!=(const IOStatus& other) const
    {
        return !(*this == other);
    }
    const std::error_code& code() const
    {
        return m_ec;
    }
 
    const std::string& message() const
    {
        return m_msg;
    }
 
    bool is_ok() const
    {
        return !(bool)m_ec;
    }
    operator bool() const
    {
        return is_ok();
    }
    bool is_error() const
    {
        return !is_ok();
    }
 
    std::string formatted_message() const
    {
        if (is_error()) {
            return m_ec.message() + ": " + m_msg;
        }
        return {};
    }
 
private:
    std::error_code m_ec = {};
    std::string m_msg    = {};
};
 
inline void PrintTo(const IOStatus& status, std::ostream* os)
{
    *os << status.formatted_message();
}
 
inline const std::error_code& make_error_code(const IOStatus& status)
{
    return status.code();
}
 
template <class T>
using IOResult = boost::outcome_v2::unchecked<T, IOStatus>;
 
inline auto success()
{
    return boost::outcome_v2::success();
}
 
template <class T>
auto success(T&& t)
{
    return boost::outcome_v2::success(std::forward<T>(t));
}
 
inline auto failure(const IOStatus& s)
{
    return boost::outcome_v2::failure(s);
}
 
inline auto failure(std::error_code c, const std::string& msg = "")
{
    return failure(IOStatus{c, msg});
}
 
template <class T>
using Tag = boost::outcome_v2::in_place_type_t<T>;
 
//forward declaration only, see below
template <class IOContext, class T>
void serialize(IOContext& io, const T& t);
 
//forward declaration only, see below
template <class IOContext, class T>
IOResult<T> deserialize(IOContext& io, Tag<T> tag);
 
//utility for apply function implementation
namespace details
{
//multiple nested IOResults are redundant and difficult to use.
//so transform IOResult<IOResult<T>> into IOResult<T>.
template <class T>
struct FlattenIOResult {
    using Type = IOResult<T>;
};
template <class T>
struct FlattenIOResult<IOResult<T>> {
    using Type = typename FlattenIOResult<T>::Type;
};
template <class T>
using FlattenIOResultT = typename FlattenIOResult<T>::Type;
 
//check if a type is an IOResult or something else
template <class T>
struct IsIOResult : std::false_type {
};
template <class T>
struct IsIOResult<IOResult<T>> : std::true_type {
};
 
//if F(T...) returns an IOResult<U>, apply returns that directly
//if F(T...) returns a different type U, apply returns IOResult<U>
template <class F, class... T>
using ApplyResultT = FlattenIOResultT<std::invoke_result_t<F, T...>>;
 
template <class F, class... T>
ApplyResultT<F, T...> eval(F f, const IOResult<T>&... rs)
{
    if constexpr (IsIOResult<std::invoke_result_t<F, T...>>::value) {
        // case for functions that do internal validation
        return f(rs.value()...);
    }
    else {
        // case for functions that can't fail, because all values are acceptable
        return success(f(rs.value()...));
    }
}
 
} // namespace details
 
template <class IOContext, class F, class... T>
details::ApplyResultT<F, T...> apply(IOContext& io, F f, const IOResult<T>&... rs)
{
    //store the status of each argument in an array to check them.
    //it would be possible to write a recursive template that checks one argument
    //after the other without copying each status. This would probably be slightly faster
    //and easier to optimize for the compiler. but gdb crashes trying to resolve the
    //very long symbol in case of many arguments. Successful results are very cheap to copy
    //and slightly worse performance in the case of an error is probably acceptable.
 
    //check for errors in the arguments
    auto status   = std::array{(rs ? IOStatus{} : rs.error())...};
    auto iter_err = std::find_if(std::begin(status), std::end(status), [](auto& s) {
        return s.is_error();
    });
 
    //evaluate f if all succesful
    auto result =
        iter_err == std::end(status) ? details::eval(f, rs...) : details::ApplyResultT<F, T...>(failure(*iter_err));
 
    if (!result) {
        //save error in context
        //if the error was generated by the applied function, the context hasn't seen it yet.
        //this allows the context to fail fast and not continue to parse more.
        io.set_error(result.error());
    }
    return result;
}
 
template <class IOContext, class F, class... T>
details::ApplyResultT<F, T...> apply(IOContext& io, F f, const std::tuple<IOResult<T>...>& results)
{
    return std::apply(
        [&](auto&&... rs) {
            return apply(io, f, rs...);
        },
        results);
}
//detect a serialize member function
template <class T, class IOContext>
concept HasSerialize = requires(IOContext& ctxt, const T& t) { t.serialize(ctxt); };
 
//detect a static deserialize member function
template <class T, class IOContext>
concept HasDeserialize = requires(IOContext& ctxt) {
    { T::deserialize(ctxt) } -> std::same_as<IOResult<T>>;
};
 
//utility for (de-)serializing tuple-like objects
namespace details
{
template <size_t Idx>
std::string make_tuple_element_name()
{
    return "Element" + std::to_string(Idx);
}
 
//recursive tuple serialization for each tuple element
//store one tuple element after the other in the IOObject
template <size_t Idx, class IOObj, class Tup>
void serialize_tuple_element(IOObj& obj, const Tup& tup)
{
    if constexpr (Idx < std::tuple_size_v<Tup>) {
        //serialize one element, then recurse
        obj.add_element(make_tuple_element_name<Idx>(), std::get<Idx>(tup));
        serialize_tuple_element<Idx + 1>(obj, tup);
    }
    // else: end of recursion, no more elements to serialize
}
 
//recursive tuple deserialization for each tuple element
//read one tuple element after the other from the IOObject
//argument pack rs contains the elements that have been read already
template <class IOObj, class Tup, class... Ts>
IOResult<Tup> deserialize_tuple_element(IOObj& obj, Tag<Tup> tag, const IOResult<Ts>&... rs)
{
    if constexpr (sizeof...(Ts) < std::tuple_size_v<Tup>) {
        //get the next element of the tuple from the IO object
        const size_t Idx = sizeof...(Ts);
        auto r           = obj.expect_element(make_tuple_element_name<Idx>(), Tag<std::tuple_element_t<Idx, Tup>>{});
        //recurse, append the new element to the pack of arguments
        return deserialize_tuple_element(obj, tag, rs..., r);
    }
    else {
        //end of recursion
        //number of arguments in rs is the same as the size of the tuple
        //no more elements to read, so finalize the object
        return mio::apply(
            obj,
            [](const Ts&... ts) {
                return Tup(ts...);
            },
            rs...);
    }
}
 
} // namespace details
 
template <class IOContext, template <class...> class Tup, class... T>
    requires std::same_as<Tup<T...>, std::pair<T...>> || std::same_as<Tup<T...>, std::tuple<T...>>
void serialize_internal(IOContext& io, const Tup<T...>& tup)
{
    auto obj = io.create_object("Tuple");
    details::serialize_tuple_element<0>(obj, tup);
}
 
template <class IOContext, template <class...> class Tup, class... T>
    requires std::same_as<Tup<T...>, std::pair<T...>> || std::same_as<Tup<T...>, std::tuple<T...>>
IOResult<Tup<T...>> deserialize_internal(IOContext& io, Tag<Tup<T...>> tag)
{
    auto obj = io.expect_object("Tuple");
    return details::deserialize_tuple_element(obj, tag);
}
 
template <class IOContext, class M>
void serialize_internal(IOContext& io, const Eigen::EigenBase<M>& mat)
{
    auto obj = io.create_object("Matrix");
    obj.add_element("Rows", mat.rows());
    obj.add_element("Columns", mat.cols());
    obj.add_list("Elements", begin(static_cast<const M&>(mat)), end(static_cast<const M&>(mat)));
}
 
template <class IOContext, IsMatrixExpression M>
IOResult<M> deserialize_internal(IOContext& io, Tag<M> /*tag*/)
{
    auto obj      = io.expect_object("Matrix");
    auto rows     = obj.expect_element("Rows", Tag<Eigen::Index>{});
    auto cols     = obj.expect_element("Columns", Tag<Eigen::Index>{});
    auto elements = obj.expect_list("Elements", Tag<typename M::Scalar>{});
    return mio::apply(
        io,
        [](auto&& r, auto&& c, auto&& v) {
            auto m = M{r, c};
            for (auto i = Eigen::Index(0); i < r; ++i) {
                for (auto j = Eigen::Index(0); j < c; ++j) {
                    m(i, j) = v[i * c + j];
                }
            }
            return m;
        },
        rows, cols, elements);
}
 
template <class IOContext, size_t N>
void serialize_internal(IOContext& io, const std::bitset<N> bitset)
{
    std::array<bool, N> bits;
    for (size_t i = 0; i < N; i++) {
        bits[i] = bitset[i];
    }
    auto obj = io.create_object("BitSet");
    obj.add_list("bitset", bits.begin(), bits.end());
}
 
template <class IOContext, size_t N>
IOResult<std::bitset<N>> deserialize_internal(IOContext& io, Tag<std::bitset<N>> tag)
{
    mio::unused(tag);
    auto obj  = io.expect_object("BitSet");
    auto bits = obj.expect_list("bitset", Tag<bool>{});
 
    return apply(
        io,
        [](auto&& bits_) -> IOResult<std::bitset<N>> {
            if (bits_.size() != N) {
                return failure(StatusCode::InvalidValue,
                               "Incorrent number of booleans to deserialize bitset. Expected " + std::to_string(N) +
                                   ", got " + std::to_string(bits_.size()) + ".");
            }
            std::bitset<N> bitset;
            for (size_t i = 0; i < N; i++) {
                bitset[i] = bits_[i];
            }
            return bitset;
        },
        bits);
}
 
template <class IOContext, class E>
    requires std::is_enum_v<E>
void serialize_internal(IOContext& io, E e)
{
    mio::serialize(io, std::underlying_type_t<E>(e));
}
 
template <class IOContext, class E>
    requires std::is_enum_v<E>
IOResult<E> deserialize_internal(IOContext& io, Tag<E> /*tag*/)
{
    BOOST_OUTCOME_TRY(auto&& i, mio::deserialize(io, mio::Tag<std::underlying_type_t<E>>{}));
    return success(E(i));
}
 
template <class IOContext, HasSerialize<IOContext> T>
void serialize_internal(IOContext& io, const T& t)
{
    t.serialize(io);
}
 
template <class IOContext, HasDeserialize<IOContext> T>
IOResult<T> deserialize_internal(IOContext& io, Tag<T> /*tag*/)
{
    return T::deserialize(io);
}
 
template <class C>
concept IsContainer =
    requires(C c, const C& cc) {
        cc.begin() != cc.end();
        C(c.begin(), c.end());
    }
    // Eigen types may pass as container, but we want to handle them separately
    && !std::is_base_of_v<Eigen::EigenBase<C>, C>;
 
template <class IOContext, IsContainer Container>
    requires(!HasSerialize<IOContext, Container>)
void serialize_internal(IOContext& io, const Container& container)
{
    auto obj = io.create_object("List");
    obj.add_list("Items", container.begin(), container.end());
} // namespace mio
 
template <class IOContext, IsContainer Container>
    requires(!HasSerialize<IOContext, Container>)
IOResult<Container> deserialize_internal(IOContext& io, Tag<Container> /*tag*/)
{
    auto obj = io.expect_object("List");
    auto i   = obj.expect_list("Items", Tag<typename Container::value_type>{});
    return apply(
        io,
        [](auto&& i_) {
            return Container(i_.begin(), i_.end());
        },
        i);
}
 
template <class IOContext, class T>
void serialize(IOContext& io, const T& t)
{
    using mio::serialize_internal;
    serialize_internal(io, t);
}
 
template <class IOContext, class T>
IOResult<T> deserialize(IOContext& io, Tag<T> tag)
{
    using mio::deserialize_internal;
    return deserialize_internal(io, tag);
}
 
std::string get_current_dir_name();
 
IOResult<bool> create_directory(const std::filesystem::path& path, std::string& abs_path, bool create_parents = false);
 
IOResult<bool> create_directory(const std::filesystem::path& path, bool create_parents = false);
 
std::filesystem::path create_directories_or_exit(const std::filesystem::path& path, bool create_parents = true);
 
bool file_exists(std::string const& rel_path, std::string& abs_path);
 
} // namespace mio
 
#endif // MIO_IO_IO_H