ExogenousConversions.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 Fondazione Istituto Italiano di Tecnologia
 *
 * This software may be modified and distributed under the terms of the
 * BSD-2-Clause license (https://opensource.org/licenses/BSD-2-Clause).
 */
#ifndef MATIOCPP_EXOGENOUSCONVERSION_H
#define MATIOCPP_EXOGENOUSCONVERSION_H
 
#include <matioCpp/ForwardDeclarations.h>
#include <matioCpp/EigenConversions.h>
#include <matioCpp/Element.h>
#include <matioCpp/Struct.h>
#include <matioCpp/CellArray.h>
#include <matioCpp/Span.h>
#include <matioCpp/Vector.h>
#include <matioCpp/MultiDimensionalArray.h>
 
#include <visit_struct/visit_struct_intrusive.hpp>
 
#include "impl/ExogenousConversionHelpers.tpp"
 
namespace matioCpp
{
 
template <class Vector, typename = typename std::enable_if_t<is_vector_compatible<Vector>::value &&
                                                             !std::is_same<Vector, std::string>::value>>
inline matioCpp::Vector<typename std::remove_cv_t<typename  matioCpp::SpanUtils::container_data<Vector>::type>> make_variable(const std::string& name, const Vector& input);
 
matioCpp::String make_variable(const std::string& name, const std::string& input);
 
matioCpp::Vector<matioCpp::Logical> make_variable(const std::string& name, const std::vector<bool>& input);
 
template<typename type, typename = typename std::enable_if<std::is_fundamental<type>::value && !std::is_same<type, bool>::value>::type>
inline matioCpp::Element<type> make_variable(const std::string& name, const type& input);
 
matioCpp::Element<matioCpp::Logical> make_variable(const std::string& name, bool input);
 
matioCpp::CellArray make_variable(const std::string& name, const std::vector<std::string>& input);
 
template<typename Struct, typename = typename std::enable_if_t<visit_struct::traits::is_visitable<Struct>::value>>
inline matioCpp::Struct make_variable(const std::string& name, const Struct& input);
 
template<class iterator,
          typename = typename std::enable_if_t<is_pair_iterator_string<iterator>::value>>
inline matioCpp::Struct make_struct(const std::string& name, iterator begin, iterator end);
 
template<class iterator,
         typename std::enable_if_t<is_pair_iterator_string<iterator>::value>* = nullptr>
inline matioCpp::CellArray make_cell_array(const std::string& name, const iterator& begin, const iterator& end);
 
template<class iterator,
         typename std::enable_if_t<!is_pair<decltype(*std::declval<iterator>())>::value>* = nullptr>
inline matioCpp::CellArray make_cell_array(const std::string& name, const iterator& begin, const iterator& end);
 
template <typename Class, typename = void>
struct is_make_variable_callable : std::false_type
{};
 
template <typename Class>
struct is_make_variable_callable<Class, matioCpp::SpanUtils::void_t<decltype(matioCpp::make_variable(std::declval<std::string>(), std::declval<Class>()))>> : std::true_type
{
};
 
template <typename Class>
struct make_variable_output
{
    using type = typename std::conditional_t<matioCpp::is_make_variable_callable<Class>::value, decltype(matioCpp::make_variable(std::declval<std::string>(), std::declval<Class>())), void>;
};
 
}
 
#include "impl/ExogenousConversions.tpp"
 
#endif // MATIOCPP_EXOGENOUSCONVERSION_H