StdVectorConverterVisitor.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2021
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
// ArmarX
#include <RobotAPI/libraries/aron/core/data/variant/All.h>
#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
 
#include "StdVectorConverter.h"
 
namespace armarx::aron::data::converter
{
    namespace detail
    {
        template <typename T, size_t D>
        struct multidimensional_vector
        {
            static_assert(D > 0, "matrix dimensions must be positive");
            typedef std::vector<typename multidimensional_vector<T, D - 1>::type> type;
        };
 
        template <typename T>
        struct multidimensional_vector<T, 1>
        {
            typedef std::vector<T> type;
        };
 
        template <typename T, size_t D>
        class AronVectorConverterVisitorBase :
            public armarx::aron::data::RecursiveConstVariantVisitor
        {
        public:
            using VectorType = typename detail::multidimensional_vector<T, D>::type;
            using Input = armarx::aron::data::RecursiveConstVariantVisitor::Input;
 
            VectorType data;
            std::map<std::string, int> memberInfo;
 
        protected:
            int currentIndex = 0;
        };
    } // namespace detail
 
    template <typename T, size_t D>
    class AronVectorConverterVisitor : public detail::AronVectorConverterVisitorBase<T, D>
    {
    };
 
    template <>
    class AronVectorConverterVisitor<float, 1> :
        public detail::AronVectorConverterVisitorBase<float, 1>
    {
    public:
        using T = float;
 
        void
        visitNDArray(Input& aron) override
        {
            auto ndarray = armarx::aron::data::NDArray::DynamicCastAndCheck(aron);
 
            auto shape = ndarray->getShape();
            memberInfo[ndarray->getPath().toString()] = currentIndex;
 
            VectorType vec;
            vec = AronVectorConverter::ConvertTo1DVector<T>(ndarray);
            shape = {shape.empty() ? 0
                                   : std::accumulate(std::begin(shape),
                                                     std::prev(std::end(shape)),
                                                     1,
                                                     std::multiplies<int>())};
            shape.push_back(sizeof(T));
 
            data.insert(data.end(), vec.begin(), vec.end());
            currentIndex += shape.at(0);
        }
 
        void
        visitInt(Input& aron) override
        {
            auto a = armarx::aron::data::Int::DynamicCastAndCheck(aron);
            memberInfo[a->getPath().toString()] = currentIndex;
 
            data.push_back(T(a->getValue()));
        }
 
        void
        visitLong(Input& aron) override
        {
            auto a = armarx::aron::data::Long::DynamicCastAndCheck(aron);
            memberInfo[a->getPath().toString()] = currentIndex;
 
            data.push_back(T(a->getValue()));
        }
 
        void
        visitFloat(Input& aron) override
        {
            auto a = armarx::aron::data::Float::DynamicCastAndCheck(aron);
            memberInfo[a->getPath().toString()] = currentIndex;
 
            data.push_back(T(a->getValue()));
        }
 
        void
        visitDouble(Input& aron) override
        {
            auto a = armarx::aron::data::Double::DynamicCastAndCheck(aron);
            memberInfo[a->getPath().toString()] = currentIndex;
 
            data.push_back(T(a->getValue()));
        }
 
        void
        visitBool(Input& aron) override
        {
            auto a = armarx::aron::data::Bool::DynamicCastAndCheck(aron);
            memberInfo[a->getPath().toString()] = currentIndex;
 
            data.push_back(T(a->getValue()));
        }
    };
 
    template <>
    class AronVectorConverterVisitor<char, 2> :
        public detail::AronVectorConverterVisitorBase<char, 2>
    {
    public:
        using T = char;
 
    public:
        void
        visitNDArray(Input& aron) override
        {
            auto ndarray = armarx::aron::data::NDArray::DynamicCastAndCheck(aron);
 
            auto shape = ndarray->getShape();
            memberInfo[ndarray->getPath().toString()] = currentIndex;
 
            VectorType vec;
            vec = AronVectorConverter::ConvertTo2DVector<T>(ndarray);
            shape.push_back(1);
 
            data.insert(data.end(), vec.begin(), vec.end());
            currentIndex += shape.at(0);
        }
    };
 
} // namespace armarx::aron::data::converter