Remote Call Framework 3.2
vector.hpp
1 
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2020, Delta V Software. All rights reserved.
6 // http://www.deltavsoft.com
7 //
8 // RCF is distributed under dual licenses - closed source or GPL.
9 // Consult your particular license for conditions of use.
10 //
11 // If you have not purchased a commercial license, you are using RCF
12 // under GPL terms.
13 //
14 // Version: 3.2
15 // Contact: support <at> deltavsoft.com
16 //
17 //******************************************************************************
18 
19 #ifndef INCLUDE_SF_VECTOR_HPP
20 #define INCLUDE_SF_VECTOR_HPP
21 
22 #include <type_traits>
23 #include <vector>
24 
25 #include <SF/Serializer.hpp>
26 #include <SF/SerializeStl.hpp>
27 
28 namespace SF {
29 
30  // std::vector
31 
32  template<typename T, typename A>
33  inline void serializeVector(
34  SF::Archive & ar,
35  std::vector<T,A> & vec,
36  RCF::FalseType *)
37  {
38  serializeStlContainer<PushBackSemantics, ReserveSemantics>(ar, vec);
39  }
40 
41  template<typename T, typename A>
42  inline void serializeVector(
43  SF::Archive & ar,
44  std::vector<T,A> & vec,
45  RCF::TrueType *)
46  {
47  serializeVectorFast(ar, vec);
48  }
49 
50  template<typename T, typename A>
51  inline void serialize(
52  SF::Archive & ar,
53  std::vector<T,A> & vec)
54  {
55  // We want fast vector serialization for vector<T>, if T is fundamental.
56  // Don't need to cover the case where T is a bool, as vector<bool> has
57  // its own serialize() function (see below).
58 
59  const bool IsBool = std::is_same<T, bool>::value;
60  static_assert( !IsBool, "This serialization function cannot be used for vector<bool>." );
61 
62  typedef typename std::is_fundamental<T>::type type;
63  serializeVector(ar, vec, (type *) 0);
64  }
65 
66  // Special case serialization for vector<bool>.
67  RCF_EXPORT void serialize(SF::Archive & ar, std::vector<bool> & bits);
68 
69  class I_VecWrapper
70  {
71  public:
72  virtual ~I_VecWrapper() {}
73 
74  virtual void resize(std::size_t newSize) = 0;
75  virtual std::uint32_t size() = 0;
76  virtual char * addressOfElement(std::size_t idx) = 0;
77  virtual std::uint32_t sizeofElement() = 0;
78  };
79 
80  template<typename Vec>
81  class VecWrapper : public I_VecWrapper
82  {
83  public:
84  VecWrapper(Vec & vec) : mVec(vec)
85  {
86  }
87 
88  void resize(std::size_t newSize)
89  {
90  mVec.resize(newSize);
91  }
92 
93  std::uint32_t size()
94  {
95  return static_cast<std::uint32_t>(mVec.size());
96  }
97 
98  char * addressOfElement(std::size_t idx)
99  {
100  return reinterpret_cast<char *>( &mVec[idx] );
101  }
102 
103  std::uint32_t sizeofElement()
104  {
105  typedef typename Vec::value_type ValueType;
106  return sizeof(ValueType);
107  }
108 
109  private:
110  Vec & mVec;
111  };
112 
113  RCF_EXPORT void serializeVectorFastImpl(
114  SF::Archive & ar,
115  I_VecWrapper & vec);
116 
117  template<typename T, typename A>
118  inline void serializeVectorFast(
119  SF::Archive & ar,
120  std::vector<T,A> & vec)
121  {
122  VecWrapper< std::vector<T,A> > vecWrapper(vec);
123  serializeVectorFastImpl(ar, vecWrapper);
124  }
125 
126 } // namespace SF
127 
128 #endif // ! INCLUDE_SF_VECTOR_HPP
Represents an archive, in which serialized objects are stored.
Definition: Archive.hpp:32
Definition: ByteBuffer.hpp:189