CTR-Pia  5.4.3
Game Communication Engine
 全て クラス ネームスペース 関数 変数 型定義 列挙型 列挙型の値 ページ
clone_SerializePolicyDefinition.h
1 /*--------------------------------------------------------------------------------*
2  Copyright (C)Nintendo All rights reserved.
3 
4  These coded instructions, statements, and computer programs contain proprietary
5  information of Nintendo and/or its licensed developers and are protected by
6  national and international copyright laws. They may not be disclosed to third
7  parties or copied or duplicated in any form, in whole or in part, without the
8  prior written consent of Nintendo.
9 
10  The content herein is highly confidential and should be handled accordingly.
11  *--------------------------------------------------------------------------------*/
12 
13 
14 #pragma once
15 
16 #include <nn/pia/clone/clone_Definitions.h>
17 #include <nn/pia/common/common_ByteOrder.h>
18 
19 namespace nn
20 {
21 namespace pia
22 {
23 namespace clone
24 {
25 
26 /*!
27 @brief クローンエレメントに設定する値のシリアライズ・デシリアライズの方法を定義します。
28 
29 @tparam Type_ シリアライズ対象のデータ型です。
30 
31 @details このクラスが実装されているのは、 Type が uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t, float, double のものだけです。
32 任意の型に対してこのクラスを使用するためには、その型に対応したシリアライズ関数とデシリアライズ関数を実装し、シリアライズ後のサイズを GetSerializedSize() の戻り値として定義する必要があります。
33 
34 例えば、
35 @code
36 struct StructValue
37 {
38  uint32_t v1;
39  float v2;
40 };
41 @endcode
42 という型に対して、
43 @code
44 template<>
45 void nn::pia::clone::SerializePolicy<StructValue>::Serialize(void* pBuffer, const Type& value)
46 {
47  uint8_t* offset = reinterpret_cast<uint8_t*>(pBuffer);
48  clone::SerializePolicy<uint32_t>::Serialize(offset, value.v1);
49  offset += 4;
50  clone::SerializePolicy<float>::Serialize(offset, value.v2);
51 }
52 
53 template<>
54 void nn::pia::clone::SerializePolicy<StructValue>::Deserialize(Type* pValue, const void* cpData)
55 {
56  const uint8_t* offset = reinterpret_cast<const uint8_t*>(cpData);
57  clone::SerializePolicy<uint32_t>::Deserialize(&pValue->v1, offset);
58  offset += 4;
59  clone::SerializePolicy<float>::Deserialize(&pValue->v2, offset);
60 }
61 
62 template<>
63 uint32_t nn::pia::clone::SerializePolicy<StructValue>::GetSerializedSize()
64 {
65  return 4 + 4;
66 }
67 @endcode
68 と実装する必要があります。
69 
70 異種プラットフォーム間マッチメイクによる異なるプラットフォーム間での通信を行う際には、パディングによる構造体のサイズ変動やエンディアンの不一致等が起こる可能性があります。
71 その場合に、Serialize / Deserialize / GetSerializedSize 関数で構造体のメモリコピーや sizeof() によるデータサイズ取得を行うように実装すると、正常に通信を行うことができません。
72 将来にわたって異種プラットフォーム間マッチメイクを行わない場合は、構造体のメモリコピーや sizeof() によるデータサイズ取得を行うように実装することも可能です。
73 */
74 template <typename Type_>
76 {
77  typedef Type_ Type;
78 public:
79  /*!
80  @brief シリアライズします。
81  @param[out] pBuffer 出力先バッファです。
82  @param[in] value シリアライズ対象のデータです。
83  */
84  static void Serialize(void* pBuffer, const Type& value);
85 
86  /*!
87  @brief デシリアライズします。
88  @param[out] pValue デシリアライズされたデータの保存先です。
89  @param[in] cpData デシリアライズするバイト列です。
90  */
91  static void Deserialize(Type* pValue, const void* cpData);
92 
93  /*!
94  @brief シリアライズされたサイズです。
95  @details @ref nn::pia::clone::CloneProtocol::GetElementSizeMax() "CloneProtocol::GetElementSizeMax()" より大きな値は使用できません。
96  @return シリアライズされたサイズです。
97  */
98  static uint32_t GetSerializedSize();
99 };
100 
101 template<>
102 inline void SerializePolicy<uint8_t>::Serialize(void* pBuffer, const Type& value)
103 {
104  common::ByteOrder::serializeU8(reinterpret_cast<uint8_t*>(pBuffer), value);
105 }
106 
107 template<>
108 inline void SerializePolicy<uint8_t>::Deserialize(Type* pValue, const void* cpData)
109 {
110  *pValue = common::ByteOrder::deserializeU8(reinterpret_cast<const uint8_t*>(cpData));
111 }
112 
113 template<>
115 {
116  return sizeof(uint8_t);
117 }
118 
119 template<>
120 inline void SerializePolicy<int8_t>::Serialize(void* pBuffer, const Type& value)
121 {
122  common::ByteOrder::serializeU8(reinterpret_cast<uint8_t*>(pBuffer), value);
123 }
124 
125 template<>
126 inline void SerializePolicy<int8_t>::Deserialize(Type* pValue, const void* cpData)
127 {
128  *pValue = common::ByteOrder::deserializeU8(reinterpret_cast<const uint8_t*>(cpData));
129 }
130 
131 template<>
133 {
134  return sizeof(int8_t);
135 }
136 
137 template<>
138 inline void SerializePolicy<uint16_t>::Serialize(void* pBuffer, const Type& value)
139 {
140  common::ByteOrder::serializeU16(reinterpret_cast<uint8_t*>(pBuffer), value);
141 }
142 
143 template<>
144 inline void SerializePolicy<uint16_t>::Deserialize(Type* pValue, const void* cpData)
145 {
146  *pValue = common::ByteOrder::deserializeU16(reinterpret_cast<const uint8_t*>(cpData));
147 }
148 
149 template<>
151 {
152  return sizeof(uint16_t);
153 }
154 
155 template<>
156 inline void SerializePolicy<int16_t>::Serialize(void* pBuffer, const Type& value)
157 {
158  common::ByteOrder::serializeU16(reinterpret_cast<uint8_t*>(pBuffer), value);
159 }
160 
161 template<>
162 inline void SerializePolicy<int16_t>::Deserialize(Type* pValue, const void* cpData)
163 {
164  *pValue = common::ByteOrder::deserializeU16(reinterpret_cast<const uint8_t*>(cpData));
165 }
166 
167 template<>
169 {
170  return sizeof(int16_t);
171 }
172 
173 template<>
174 inline void SerializePolicy<uint32_t>::Serialize(void* pBuffer, const Type& value)
175 {
176  common::ByteOrder::serializeU32(reinterpret_cast<uint8_t*>(pBuffer), value);
177 }
178 
179 template<>
180 inline void SerializePolicy<uint32_t>::Deserialize(Type* pValue, const void* cpData)
181 {
182  *pValue = common::ByteOrder::deserializeU32(reinterpret_cast<const uint8_t*>(cpData));
183 }
184 
185 template<>
187 {
188  return sizeof(uint32_t);
189 }
190 
191 template<>
192 inline void SerializePolicy<int32_t>::Serialize(void* pBuffer, const Type& value)
193 {
194  common::ByteOrder::serializeU32(reinterpret_cast<uint8_t*>(pBuffer), value);
195 }
196 
197 template<>
198 inline void SerializePolicy<int32_t>::Deserialize(Type* pValue, const void* cpData)
199 {
200  *pValue = common::ByteOrder::deserializeU32(reinterpret_cast<const uint8_t*>(cpData));
201 }
202 
203 template<>
205 {
206  return sizeof(int32_t);
207 }
208 
209 template<>
210 inline void SerializePolicy<uint64_t>::Serialize(void* pBuffer, const Type& value)
211 {
212  common::ByteOrder::serializeU64(reinterpret_cast<uint8_t*>(pBuffer), value);
213 }
214 
215 template<>
216 inline void SerializePolicy<uint64_t>::Deserialize(Type* pValue, const void* cpData)
217 {
218  *pValue = common::ByteOrder::deserializeU64(reinterpret_cast<const uint8_t*>(cpData));
219 }
220 
221 template<>
223 {
224  return sizeof(uint64_t);
225 }
226 
227 template<>
228 inline void SerializePolicy<int64_t>::Serialize(void* pBuffer, const Type& value)
229 {
230  common::ByteOrder::serializeU64(reinterpret_cast<uint8_t*>(pBuffer), value);
231 }
232 
233 template<>
234 inline void SerializePolicy<int64_t>::Deserialize(Type* pValue, const void* cpData)
235 {
236  *pValue = common::ByteOrder::deserializeU64(reinterpret_cast<const uint8_t*>(cpData));
237 }
238 
239 template<>
241 {
242  return sizeof(int64_t);
243 }
244 
245 template<>
246 inline void SerializePolicy<float>::Serialize(void* pBuffer, const Type& value)
247 {
248  common::ByteOrder::serializeU32(reinterpret_cast<uint8_t*>(pBuffer), reinterpret_cast<const uint32_t&>(value));
249 }
250 
251 template<>
252 inline void SerializePolicy<float>::Deserialize(Type* pValue, const void* cpData)
253 {
254  uint32_t valueU32 = common::ByteOrder::deserializeU32(reinterpret_cast<const uint8_t*>(cpData));
255  *pValue = *(reinterpret_cast<float*>(&valueU32));
256 }
257 
258 template<>
260 {
261  return sizeof(float);
262 }
263 
264 template<>
265 inline void SerializePolicy<double>::Serialize(void* pBuffer, const Type& value)
266 {
267  common::ByteOrder::serializeU64(reinterpret_cast<uint8_t*>(pBuffer), reinterpret_cast<const uint64_t&>(value));
268 }
269 
270 template<>
271 inline void SerializePolicy<double>::Deserialize(Type* pValue, const void* cpData)
272 {
273  uint64_t valueU64 = common::ByteOrder::deserializeU64(reinterpret_cast<const uint8_t*>(cpData));
274  *pValue = *(reinterpret_cast<double*>(&valueU64));
275 }
276 
277 template<>
279 {
280  return sizeof(double);
281 }
282 
283 }
284 }
285 } // end of namespace nn::pia::clone