GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: include/pinocchio/serialization/joints-model.hpp Lines: 77 77 100.0 %
Date: 2024-01-23 21:41:47 Branches: 32 64 50.0 %

Line Branch Exec Source
1
//
2
// Copyright (c) 2019 INRIA
3
//
4
5
#ifndef __pinocchio_serialization_joints_model_hpp__
6
#define __pinocchio_serialization_joints_model_hpp__
7
8
namespace pinocchio
9
{
10
  template<typename Scalar, int Options, template<typename S, int O> class JointCollectionTpl>
11
  struct Serialize< JointModelCompositeTpl<Scalar,Options,JointCollectionTpl> >
12
  {
13
    template<typename Archive>
14
28
    static void run(Archive & ar,
15
                    JointModelCompositeTpl<Scalar,Options,JointCollectionTpl> & joint)
16
    {
17
      using boost::serialization::make_nvp;
18
19
28
      ar & make_nvp("m_nq",joint.m_nq);
20
28
      ar & make_nvp("m_nv",joint.m_nv);
21
28
      ar & make_nvp("m_idx_q",joint.m_idx_q);
22
28
      ar & make_nvp("m_nqs",joint.m_nqs);
23
28
      ar & make_nvp("m_idx_v",joint.m_idx_v);
24
28
      ar & make_nvp("m_nvs",joint.m_nvs);
25
28
      ar & make_nvp("njoints",joint.njoints);
26
27
28
      ar & make_nvp("joints",joint.joints);
28
28
      ar & make_nvp("jointPlacements",joint.jointPlacements);
29
28
    }
30
  };
31
}
32
33
namespace boost
34
{
35
  namespace serialization
36
  {
37
38
    // For some older version of gcc, we have to rely on an additional namespace
39
    // to avoid ambiguous call to boost::serialization::serialize
40
    namespace fix
41
    {
42
      template <class Archive, typename Derived>
43
2688
      void serialize(Archive & ar,
44
                     pinocchio::JointModelBase<Derived> & joint,
45
                     const unsigned int version)
46
      {
47
2688
        split_free(ar, joint, version);
48
2688
      }
49
    }
50
51
    template<class Archive, typename Derived>
52
1512
    void save(Archive & ar,
53
              const pinocchio::JointModelBase<Derived> & joint,
54
              const unsigned int /*version*/)
55
    {
56
1512
      const pinocchio::JointIndex i_id = joint.id();
57

1512
      const int i_q = joint.idx_q(), i_v = joint.idx_v();
58
59

1512
      ar & make_nvp("i_id",i_id);
60

1512
      ar & make_nvp("i_q",i_q);
61

1512
      ar & make_nvp("i_v",i_v);
62
1512
    }
63
64
    template<class Archive, typename Derived>
65
1176
    void load(Archive & ar,
66
              pinocchio::JointModelBase<Derived> & joint,
67
              const unsigned int /*version*/)
68
    {
69
      pinocchio::JointIndex i_id;
70
      int i_q, i_v;
71
72

1176
      ar & make_nvp("i_id",i_id);
73

1176
      ar & make_nvp("i_q",i_q);
74

1176
      ar & make_nvp("i_v",i_v);
75
76
1176
      joint.setIndexes(i_id,i_q,i_v);
77
1176
    }
78
79
    template <class Archive, typename Scalar, int Options, int axis>
80
1142
    void serialize(Archive & ar,
81
                   pinocchio::JointModelRevoluteTpl<Scalar,Options,axis> & joint,
82
                   const unsigned int version)
83
    {
84
      typedef pinocchio::JointModelRevoluteTpl<Scalar,Options,axis> JointType;
85
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
86
1142
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
87
1142
    }
88
89
    template <class Archive, typename Scalar, int Options, int axis>
90
84
    void serialize(Archive & ar,
91
                   pinocchio::JointModelRevoluteUnboundedTpl<Scalar,Options,axis> & joint,
92
                   const unsigned int version)
93
    {
94
      typedef pinocchio::JointModelRevoluteUnboundedTpl<Scalar,Options,axis> JointType;
95
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
96
84
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
97
84
    }
98
99
    template <class Archive, typename Scalar, int Options, int axis>
100
84
    void serialize(Archive & ar,
101
                   pinocchio::JointModelPrismaticTpl<Scalar,Options,axis> & joint,
102
                   const unsigned int version)
103
    {
104
      typedef pinocchio::JointModelPrismaticTpl<Scalar,Options,axis> JointType;
105
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
106
84
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
107
84
    }
108
109
    template <class Archive, typename Scalar, int Options>
110
62
    void serialize(Archive & ar,
111
                   pinocchio::JointModelFreeFlyerTpl<Scalar,Options> & joint,
112
                   const unsigned int version)
113
    {
114
      typedef pinocchio::JointModelFreeFlyerTpl<Scalar,Options> JointType;
115
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
116
62
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
117
62
    }
118
119
    template <class Archive, typename Scalar, int Options>
120
28
    void serialize(Archive & ar,
121
                   pinocchio::JointModelPlanarTpl<Scalar,Options> & joint,
122
                   const unsigned int version)
123
    {
124
      typedef pinocchio::JointModelPlanarTpl<Scalar,Options> JointType;
125
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
126
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
127
28
    }
128
129
    template <class Archive, typename Scalar, int Options>
130
28
    void serialize(Archive & ar,
131
                   pinocchio::JointModelSphericalTpl<Scalar,Options> & joint,
132
                   const unsigned int version)
133
    {
134
      typedef pinocchio::JointModelSphericalTpl<Scalar,Options> JointType;
135
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
136
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
137
28
    }
138
139
    template <class Archive, typename Scalar, int Options>
140
28
    void serialize(Archive & ar,
141
                   pinocchio::JointModelSphericalZYXTpl<Scalar,Options> & joint,
142
                   const unsigned int version)
143
    {
144
      typedef pinocchio::JointModelSphericalZYXTpl<Scalar,Options> JointType;
145
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
146
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
147
28
    }
148
149
    template <class Archive, typename Scalar, int Options>
150
28
    void serialize(Archive & ar,
151
                   pinocchio::JointModelTranslationTpl<Scalar,Options> & joint,
152
                   const unsigned int version)
153
    {
154
      typedef pinocchio::JointModelTranslationTpl<Scalar,Options> JointType;
155
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
156
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
157
28
    }
158
159
    template <class Archive, typename Scalar, int Options>
160
28
    void serialize(Archive & ar,
161
                   pinocchio::JointModelRevoluteUnalignedTpl<Scalar,Options> & joint,
162
                   const unsigned int version)
163
    {
164
      typedef pinocchio::JointModelRevoluteUnalignedTpl<Scalar,Options> JointType;
165
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
166
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
167
28
      ar & make_nvp("axis",joint.axis);
168
28
    }
169
170
    template <class Archive, typename Scalar, int Options>
171
28
    void serialize(Archive & ar,
172
                   pinocchio::JointModelRevoluteUnboundedUnalignedTpl<Scalar,Options> & joint,
173
                   const unsigned int version)
174
    {
175
      typedef pinocchio::JointModelRevoluteUnboundedUnalignedTpl<Scalar,Options> JointType;
176
      //      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
177
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
178
28
      ar & make_nvp("axis",joint.axis);
179
28
    }
180
181
    template <class Archive, typename Scalar, int Options>
182
28
    void serialize(Archive & ar,
183
                   pinocchio::JointModelPrismaticUnalignedTpl<Scalar,Options> & joint,
184
                   const unsigned int version)
185
    {
186
      typedef pinocchio::JointModelPrismaticUnalignedTpl<Scalar,Options> JointType;
187
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
188
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
189
28
      ar & make_nvp("axis",joint.axis);
190
28
    }
191
192
    template <class Archive, typename Scalar, int Options, template<typename S, int O> class JointCollectionTpl>
193
28
    void serialize(Archive & ar,
194
                   pinocchio::JointModelCompositeTpl<Scalar,Options,JointCollectionTpl> & joint,
195
                   const unsigned int version)
196
    {
197
      typedef pinocchio::JointModelCompositeTpl<Scalar,Options,JointCollectionTpl> JointType;
198
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
199
28
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
200
201
28
      ::pinocchio::Serialize<JointType>::run(ar,joint);
202
28
    }
203
204
    template <class Archive, typename Scalar, int Options, template<typename S, int O> class JointCollectionTpl>
205
1008
    void serialize(Archive & ar,
206
                   pinocchio::JointModelTpl<Scalar,Options,JointCollectionTpl> & joint,
207
                   const unsigned int version)
208
    {
209
      typedef pinocchio::JointModelTpl<Scalar,Options,JointCollectionTpl> JointType;
210
//      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
211
1008
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
212
213
      typedef typename JointCollectionTpl<Scalar,Options>::JointModelVariant JointModelVariant;
214
1008
      ar & make_nvp("base_variant",base_object<JointModelVariant>(joint));
215
1008
    }
216
217
    template <class Archive, typename JointModel>
218
84
    void serialize(Archive & ar,
219
                   pinocchio::JointModelMimic<JointModel> & joint,
220
                   const unsigned int version)
221
    {
222
      typedef pinocchio::JointModelMimic<JointModel> JointType;
223
      //      ar & make_nvp("base_class",base_object< pinocchio::JointModelBase<JointType> >(joint));
224
84
      fix::serialize(ar,*static_cast<pinocchio::JointModelBase<JointType> *>(&joint),version);
225
226
84
      ar & make_nvp("jmodel",joint.jmodel());
227
84
      ar & make_nvp("scaling",joint.scaling());
228
84
      ar & make_nvp("offset",joint.offset());
229
84
    }
230
231
  }
232
}
233
234
#endif // ifndef __pinocchio_serialization_joints_model_hpp__
235