Vector.h

Go to the documentation of this file.

#ifndef MATIOCPP_VECTOR_H
#define MATIOCPP_VECTOR_H
 
/*
 * Copyright (C) 2020 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).
 */
 
 
#include <matioCpp/ForwardDeclarations.h>
#include <matioCpp/ConversionUtilities.h>
#include <matioCpp/Span.h>
#include <matioCpp/Variable.h>
#include <matioCpp/VectorIterator.h>
 
template<typename T>
class matioCpp::Vector : public matioCpp::Variable
{
public:
 
    using type = T; 
    using element_type = typename get_type<T>::type; 
    using value_type = std::remove_cv_t<element_type>; 
    using allocator_type = std::allocator<element_type>; 
    using index_type = size_t; 
    using reference = element_type&; 
    using pointer = typename std::allocator_traits<std::allocator<element_type>>::pointer; 
    using const_pointer = typename std::allocator_traits<std::allocator<element_type>>::const_pointer; 
    using iterator = vector_iterator<Vector<element_type>, false>; 
    using const_iterator = vector_iterator<Vector<element_type>, true>; 
    using reverse_iterator = std::reverse_iterator<iterator>; 
    using const_reverse_iterator =std::reverse_iterator<const_iterator>; 
    using string_input_type =  typename std::conditional<matioCpp::is_string16_compatible<T>::value, std::u16string,
                               typename std::conditional<matioCpp::is_string32_compatible<T>::value, std::u32string, std::string>::type>::type; 
    using string_output_type = typename std::conditional<matioCpp::is_string_compatible<T>::value, std::string,
                               typename std::conditional<matioCpp::is_string16_compatible<T>::value, std::u16string,
                               typename std::conditional<matioCpp::is_string32_compatible<T>::value, std::u32string, void>::type>::type>::type; 
    Vector();
 
    Vector(const std::string& name);
 
    Vector(const std::string& name, index_type dimensions);
 
    template<typename in = element_type,
             typename = typename std::enable_if<!std::is_same<element_type, const char>::value &&
                                                !std::is_same<element_type, const char16_t>::value &&
                                                !std::is_same<element_type, const char32_t>::value &&
                                                !std::is_same<value_type, bool>::value>::type>
    Vector(const std::string& name, Span<const element_type> inputVector);
 
    Vector(const std::string& name, const string_input_type &inputString);
 
    Vector(const std::string& name, const std::vector<bool>& inputVector);
 
    Vector(const Vector<T>& other);
 
    Vector(Vector<T>&& other);
 
    Vector(const MatvarHandler& handler);
 
    ~Vector();
 
    Vector<T>& operator=(const Vector<T>& other);
 
    Vector<T>& operator=(Vector<T>&& other);
 
    Vector<element_type>& operator=(const Span<element_type>& other);
 
    Vector<T>& operator=(const string_input_type &other);
 
    Vector<T>& operator=(const std::vector<bool>& other);
 
    matioCpp::Span<element_type> toSpan();
 
    const matioCpp::Span<const element_type> toSpan() const;
 
    bool setName(const std::string& newName);
 
    index_type size() const;
 
    void resize(index_type newSize);
 
    void clear();
 
    pointer data();
 
    const_pointer data() const;
 
    reference operator()(index_type el);
 
    value_type operator()(index_type el) const;
 
    string_output_type operator()() const;
 
    reference operator[](index_type el);
 
    value_type operator[](index_type el) const;
 
    iterator begin();
 
    iterator end();
 
    const_iterator begin() const;
 
    const_iterator end() const;
 
    const_iterator cbegin() const;
 
    const_iterator cend() const;
 
    reverse_iterator rbegin();
 
    reverse_iterator rend();
 
    const_reverse_iterator rbegin() const;
 
    const_reverse_iterator rend() const;
 
    const_reverse_iterator crbegin() const;
 
    const_reverse_iterator crend() const;
 
private:
 
    bool initializeVector(const std::string& name, Span<const element_type> inputVector);
 
    virtual bool checkCompatibility(const matvar_t* inputPtr, matioCpp::VariableType variableType, matioCpp::ValueType valueType) const final;
 
};
 
#include "impl/Vector.tpp"
 
#endif // MATIOCPP_VECTOR_H