Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	include/pinocchio/serialization/eigen.hpp	Lines:	36	47	76.6 %
Date:	2024-01-23 21:41:47	Branches:	38	96	39.6 %


//
// Copyright (c) 2017-2020 CNRS INRIA
//

#ifndef __pinocchio_serialization_eigen_matrix_hpp__
#define __pinocchio_serialization_eigen_matrix_hpp__

#include <Eigen/Dense>
#include "pinocchio/math/tensor.hpp"

#include <boost/serialization/split_free.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/array.hpp>

namespace boost
{
  namespace serialization
  {

    template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
    void save(Archive & ar, const Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int /*version*/)
    {
      Eigen::DenseIndex rows(m.rows()), cols(m.cols());
      if (Rows == Eigen::Dynamic)
        ar & BOOST_SERIALIZATION_NVP(rows);
      if (Cols == Eigen::Dynamic)
        ar & BOOST_SERIALIZATION_NVP(cols);
      ar & make_nvp("data",make_array(m.data(), (size_t)m.size()));
    }

    template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
    void load(Archive & ar, Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int /*version*/)
    {
      Eigen::DenseIndex rows = Rows, cols = Cols;
      if (Rows == Eigen::Dynamic)
        ar >> BOOST_SERIALIZATION_NVP(rows);
      if (Cols == Eigen::Dynamic)
        ar >> BOOST_SERIALIZATION_NVP(cols);
      m.resize(rows,cols);
      ar >> make_nvp("data",make_array(m.data(), (size_t)m.size()));
    }

    template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
    void serialize(Archive & ar, Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int version)
    {
      split_free(ar,m,version);
    }

    template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
    void save(Archive & ar, const Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int /*version*/)
    {
      Eigen::DenseIndex rows(m.rows()), cols(m.cols());
      if (PlainObjectBase::RowsAtCompileTime == Eigen::Dynamic)
        ar & BOOST_SERIALIZATION_NVP(rows);
      if (PlainObjectBase::ColsAtCompileTime == Eigen::Dynamic)
        ar & BOOST_SERIALIZATION_NVP(cols);
      ar & make_nvp("data",make_array(m.data(), (size_t)m.size()));
    }

    template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
    void load(Archive & ar, Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int /*version*/)
    {
      Eigen::DenseIndex rows = PlainObjectBase::RowsAtCompileTime, cols = PlainObjectBase::ColsAtCompileTime;
      if (PlainObjectBase::RowsAtCompileTime == Eigen::Dynamic)
        ar >> BOOST_SERIALIZATION_NVP(rows);
      if (PlainObjectBase::ColsAtCompileTime == Eigen::Dynamic)
        ar >> BOOST_SERIALIZATION_NVP(cols);
      m.resize(rows,cols);
      ar >> make_nvp("data",make_array(m.data(), (size_t)m.size()));
    }

    template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
    void serialize(Archive & ar, Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int version)
    {
      split_free(ar,m,version);
    }

#if !defined(PINOCCHIO_WITH_EIGEN_TENSOR_MODULE) && ((__cplusplus <= 199711L && EIGEN_COMP_MSVC < 1900) || defined(__CUDACC__) || defined(EIGEN_AVOID_STL_ARRAY))
    template <class Archive, typename _IndexType, std::size_t _NumIndices>
    void save(Archive & ar, const Eigen::array<_IndexType,_NumIndices> & a, const unsigned int /*version*/)
    {
      ar & make_nvp("array",make_array(&a.front(),_NumIndices));
    }

    template <class Archive, typename _IndexType, std::size_t _NumIndices>
    void load(Archive & ar, Eigen::array<_IndexType,_NumIndices> & a, const unsigned int /*version*/)
    {
      ar >> make_nvp("array",make_array(&a.front(),_NumIndices));
    }

    template <class Archive, typename _IndexType, std::size_t _NumIndices>
    void serialize(Archive & ar, Eigen::array<_IndexType,_NumIndices> & a, const unsigned int version)
    {
      split_free(ar,a,version);
    }
#else
  template <class Archive, class T, std::size_t N>
  void save(Archive& ar, const std::array<T,N> & a, const unsigned int version)
  {
    typedef std::array<T,N> Array;
    serialize(ar,const_cast<Array&>(a),version);
  }

  template <class Archive, class T, std::size_t N>
  void load(Archive& ar, std::array<T,N> & a, const unsigned int version)
  {
    serialize(ar,a,version);
  }
#endif

#ifdef PINOCCHIO_WITH_EIGEN_TENSOR_MODULE

    template <class Archive, typename _IndexType, int _NumIndices>
    void save(Archive & ar, const Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
    {
      save(ar,static_cast<const Eigen::array<_IndexType,_NumIndices> &>(ds),version);
    }

    template <class Archive, typename _IndexType, int _NumIndices>
    void load(Archive & ar, Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
    {
      load(ar,static_cast<Eigen::array<_IndexType,_NumIndices> &>(ds),version);
    }

    template <class Archive, typename _IndexType, int _NumIndices>
    void serialize(Archive & ar, Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
    {
      split_free(ar,static_cast<Eigen::array<_IndexType,_NumIndices> &>(ds),version);
    }

#endif

    template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
    void save(Archive & ar, const ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int /*version*/)
    {
      typedef ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> Tensor;
      const typename Tensor::Dimensions & dimensions = t.dimensions();

      ar & BOOST_SERIALIZATION_NVP(dimensions);
      ar & make_nvp("data",make_array(t.data(), (size_t)t.size()));
    }

    template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
    void load(Archive & ar, ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int /*version*/)
    {
      typedef ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> Tensor;
      typename Tensor::Dimensions dimensions;

      ar >> BOOST_SERIALIZATION_NVP(dimensions);
      t.resize(dimensions);

      ar >> make_nvp("data",make_array(t.data(), (size_t)t.size()));
    }

    template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
    void serialize(Archive & ar, ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int version)
    {
      split_free(ar,t,version);
    }

  }
}

#endif // ifndef __pinocchio_serialization_eigen_matrix_hpp__


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			//
2			// Copyright (c) 2017-2020 CNRS INRIA
3			//
4
5			#ifndef __pinocchio_serialization_eigen_matrix_hpp__
6			#define __pinocchio_serialization_eigen_matrix_hpp__
7
8			#include <Eigen/Dense>
9			#include "pinocchio/math/tensor.hpp"
10
11			#include <boost/serialization/split_free.hpp>
12			#include <boost/serialization/vector.hpp>
13			#include <boost/serialization/array.hpp>
14
15			namespace boost
16			{
17			namespace serialization
18			{
19
20			template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
21		7552	void save(Archive & ar, const Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int /version/)
22			{
23	✓✗✓✗	7552	Eigen::DenseIndex rows(m.rows()), cols(m.cols());
24			if (Rows == Eigen::Dynamic)
25	✓✗✓✗	524	ar & BOOST_SERIALIZATION_NVP(rows);
26			if (Cols == Eigen::Dynamic)
27	✓✗✓✗	938	ar & BOOST_SERIALIZATION_NVP(cols);
28	✓✗✓✓ ✗✓✓✗ ✓✓✗✓ ✗	7552	ar & make_nvp("data",make_array(m.data(), (size_t)m.size()));
29			}
30
31			template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
32		7504	void load(Archive & ar, Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int /version/)
33			{
34		7504	Eigen::DenseIndex rows = Rows, cols = Cols;
35			if (Rows == Eigen::Dynamic)
36	✓✗✓✗	476	ar >> BOOST_SERIALIZATION_NVP(rows);
37			if (Cols == Eigen::Dynamic)
38	✓✗✓✗	938	ar >> BOOST_SERIALIZATION_NVP(cols);
39	✓✗	7504	m.resize(rows,cols);
40	✓✗✓✓ ✗✓✓✗ ✓✓✗✓ ✗	7504	ar >> make_nvp("data",make_array(m.data(), (size_t)m.size()));
41			}
42
43			template <class Archive, typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
44		15056	void serialize(Archive & ar, Eigen::Matrix<Scalar,Rows,Cols,Options,MaxRows,MaxCols> & m, const unsigned int version)
45			{
46		15056	split_free(ar,m,version);
47			}
48
49			template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
50			void save(Archive & ar, const Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int /version/)
51			{
52			Eigen::DenseIndex rows(m.rows()), cols(m.cols());
53			if (PlainObjectBase::RowsAtCompileTime == Eigen::Dynamic)
54			ar & BOOST_SERIALIZATION_NVP(rows);
55			if (PlainObjectBase::ColsAtCompileTime == Eigen::Dynamic)
56			ar & BOOST_SERIALIZATION_NVP(cols);
57			ar & make_nvp("data",make_array(m.data(), (size_t)m.size()));
58			}
59
60			template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
61			void load(Archive & ar, Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int /version/)
62			{
63			Eigen::DenseIndex rows = PlainObjectBase::RowsAtCompileTime, cols = PlainObjectBase::ColsAtCompileTime;
64			if (PlainObjectBase::RowsAtCompileTime == Eigen::Dynamic)
65			ar >> BOOST_SERIALIZATION_NVP(rows);
66			if (PlainObjectBase::ColsAtCompileTime == Eigen::Dynamic)
67			ar >> BOOST_SERIALIZATION_NVP(cols);
68			m.resize(rows,cols);
69			ar >> make_nvp("data",make_array(m.data(), (size_t)m.size()));
70			}
71
72			template <class Archive, typename PlainObjectBase, int MapOptions, typename StrideType>
73			void serialize(Archive & ar, Eigen::Map<PlainObjectBase,MapOptions,StrideType> & m, const unsigned int version)
74			{
75			split_free(ar,m,version);
76			}
77
78			#if !defined(PINOCCHIO_WITH_EIGEN_TENSOR_MODULE) && ((__cplusplus <= 199711L && EIGEN_COMP_MSVC < 1900) \|\| defined(__CUDACC__) \|\| defined(EIGEN_AVOID_STL_ARRAY))
79			template <class Archive, typename _IndexType, std::size_t _NumIndices>
80			void save(Archive & ar, const Eigen::array<_IndexType,_NumIndices> & a, const unsigned int /version/)
81			{
82			ar & make_nvp("array",make_array(&a.front(),_NumIndices));
83			}
84
85			template <class Archive, typename _IndexType, std::size_t _NumIndices>
86			void load(Archive & ar, Eigen::array<_IndexType,_NumIndices> & a, const unsigned int /version/)
87			{
88			ar >> make_nvp("array",make_array(&a.front(),_NumIndices));
89			}
90
91			template <class Archive, typename _IndexType, std::size_t _NumIndices>
92			void serialize(Archive & ar, Eigen::array<_IndexType,_NumIndices> & a, const unsigned int version)
93			{
94			split_free(ar,a,version);
95			}
96			#else
97			template <class Archive, class T, std::size_t N>
98		84	void save(Archive& ar, const std::array<T,N> & a, const unsigned int version)
99			{
100			typedef std::array<T,N> Array;
101		84	serialize(ar,const_cast<Array&>(a),version);
102		84	}
103
104			template <class Archive, class T, std::size_t N>
105		84	void load(Archive& ar, std::array<T,N> & a, const unsigned int version)
106			{
107		84	serialize(ar,a,version);
108		84	}
109			#endif
110
111			#ifdef PINOCCHIO_WITH_EIGEN_TENSOR_MODULE
112
113			template <class Archive, typename _IndexType, int _NumIndices>
114			void save(Archive & ar, const Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
115			{
116			save(ar,static_cast<const Eigen::array<_IndexType,_NumIndices> &>(ds),version);
117			}
118
119			template <class Archive, typename _IndexType, int _NumIndices>
120			void load(Archive & ar, Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
121			{
122			load(ar,static_cast<Eigen::array<_IndexType,_NumIndices> &>(ds),version);
123			}
124
125			template <class Archive, typename _IndexType, int _NumIndices>
126		168	void serialize(Archive & ar, Eigen::DSizes<_IndexType,_NumIndices> & ds, const unsigned int version)
127			{
128		168	split_free(ar,static_cast<Eigen::array<_IndexType,_NumIndices> &>(ds),version);
129		168	}
130
131			#endif
132
133			template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
134		84	void save(Archive & ar, const ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int /version/)
135			{
136			typedef ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> Tensor;
137		84	const typename Tensor::Dimensions & dimensions = t.dimensions();
138
139	✓✗	84	ar & BOOST_SERIALIZATION_NVP(dimensions);
140	✓✗✓✗	84	ar & make_nvp("data",make_array(t.data(), (size_t)t.size()));
141		84	}
142
143			template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
144		84	void load(Archive & ar, ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int /version/)
145			{
146			typedef ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> Tensor;
147		84	typename Tensor::Dimensions dimensions;
148
149	✓✗✓✗	84	ar >> BOOST_SERIALIZATION_NVP(dimensions);
150	✓✗	84	t.resize(dimensions);
151
152	✓✗✓✗ ✓✗✓✗ ✓✗	84	ar >> make_nvp("data",make_array(t.data(), (size_t)t.size()));
153		84	}
154
155			template <class Archive, typename _Scalar, int _NumIndices, int _Options, typename _IndexType>
156		168	void serialize(Archive & ar, ::pinocchio::Tensor<_Scalar,_NumIndices,_Options,_IndexType> & t, const unsigned int version)
157			{
158		168	split_free(ar,t,version);
159		168	}
160
161			}
162			}
163
164			#endif // ifndef __pinocchio_serialization_eigen_matrix_hpp__