Variable.h

Go to the documentation of this file.

#ifndef MATIOCPP_VARIABLE_H
#define MATIOCPP_VARIABLE_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/MatvarHandler.h>
#include <matioCpp/SharedMatvar.h>
#include <matioCpp/WeakMatvar.h>
 
 
class matioCpp::Variable
{
 
    matioCpp::MatvarHandler* m_handler;
 
protected:
 
    bool initializeVariable(const std::string &name, const VariableType &variableType, const ValueType &valueType, matioCpp::Span<const size_t> dimensions, void *data);
 
    bool initializeComplexVariable(const std::string& name, const VariableType& variableType, const ValueType& valueType, matioCpp::Span<const size_t> dimensions, void *realData, void *imaginaryData);
 
 
    template<typename T>
    bool initializeComplexVector(const std::string& name, const Span<T> realInputVector, const Span<T> imaginaryInputVector)
    {
        if (realInputVector.size() != imaginaryInputVector.size())
        {
            std::string errorPrefix = "[ERROR][matioCpp::Variable::createComplexVector] ";
            if (name.empty())
            {
                std::cerr << errorPrefix << "The real and imaginary part have different size." << std::endl;
                return false;
            }
        }
        return initializeComplexVariable(name, VariableType::Vector, get_type<T>::valuetype, {realInputVector.size(), 1}, (void*)realInputVector.data(), (void*)imaginaryInputVector.data());
    }
 
    bool changeName(const std::string& newName);
 
    size_t getArrayNumberOfElements() const;
 
    bool setCellElement(size_t linearIndex, const Variable& newValue);
 
    Variable getCellElement(size_t linearIndex);
 
    const Variable getCellElement(size_t linearIndex) const;
 
    size_t getStructNumberOfFields() const;
 
    char * const *getStructFields() const;
 
    size_t getStructFieldIndex(const std::string& field) const;
 
    bool setStructField(size_t index, const Variable& newValue, size_t structPositionInArray = 0);
 
    bool addStructField(const std::string& newField);
 
    bool setStructField(const std::string &field, const Variable& newValue, size_t structPositionInArray = 0);
 
    Variable getStructField(size_t index, size_t structPositionInArray = 0);
 
    const Variable getStructField(size_t index, size_t structPositionInArray = 0) const;
 
    Struct getStructArrayElement(size_t linearIndex);
 
    const Struct getStructArrayElement(size_t linearIndex) const;
 
    virtual bool checkCompatibility(const matvar_t* inputPtr, matioCpp::VariableType variableType, matioCpp::ValueType valueType) const;
 
public:
 
    Variable();
 
    Variable(const matvar_t * inputVar);
 
    Variable(const Variable& other);
 
    Variable(Variable&& other);
 
    Variable(const MatvarHandler& handler);
 
    ~Variable();
 
    Variable& operator=(const Variable& other);
 
    Variable& operator=(Variable&& other);
 
    bool fromMatio(const matvar_t * inputVar);
 
    bool fromOther(const Variable& other);
 
    bool fromOther(Variable&& other);
 
    const matvar_t * toMatio() const;
 
    matvar_t * toMatio();
 
    std::string name() const;
 
    matioCpp::VariableType variableType() const;
 
    matioCpp::ValueType valueType() const;
 
    bool isComplex() const;
 
    matioCpp::Span<const size_t> dimensions() const;
 
    bool isValid() const;
 
    template<typename T>
    matioCpp::Element<T> asElement();
 
    template<typename T>
    const matioCpp::Element<T> asElement() const;
 
    template<typename T>
    matioCpp::Vector<T> asVector();
 
    template<typename T>
    const matioCpp::Vector<T> asVector() const;
 
    matioCpp::String asString();
 
    const matioCpp::String asString() const;
 
    matioCpp::String16 asString16();
 
    const matioCpp::String16 asString16() const;
 
    matioCpp::String32 asString32();
 
    const matioCpp::String32 asString32() const;
 
    template<typename T>
    matioCpp::MultiDimensionalArray<T> asMultiDimensionalArray();
 
    template<typename T>
    const matioCpp::MultiDimensionalArray<T> asMultiDimensionalArray() const;
 
    matioCpp::CellArray asCellArray();
 
    const matioCpp::CellArray asCellArray() const;
 
    matioCpp::Struct asStruct();
 
    const matioCpp::Struct asStruct() const;
 
    matioCpp::StructArray asStructArray();
 
    const matioCpp::StructArray asStructArray() const;
 
};
 
#endif