Theolizer  Version.1.2.0
serializer for C++ / Do you want to update your classes easily ?
core.h
1 //############################################################################
2 // Theolizerライブラリのコア部(基底シリアライザ)
3 /*
4  © 2016 Theoride Technology (http://theolizer.com/) All Rights Reserved.
5  "Theolizer" is a registered trademark of Theoride Technology.
6 
7  "Theolizer" License
8  In the case where you are in possession of a valid “Theolizer” License,
9  you may use this file in accordance with the terms and conditions of
10  the use license determined by Theoride Technology.
11 
12  General Public License Version 3 ("GPLv3")
13  You may use this file in accordance with the terms and conditions of
14  GPLv3 published by Free Software Foundation.
15  Please confirm the contents of GPLv3 at https://www.gnu.org/licenses/gpl.txt .
16  A copy of GPLv3 is also saved in a LICENSE.TXT file.
17 
18  商用ライセンス
19  あなたが有効なTheolizer商用ライセンスを保持している場合、
20  セオライド テクノロジーの定める使用許諾書の条件に従って、
21  このファイルを取り扱うことができます。
22 
23  General Public License Version 3(以下GPLv3)
24  Free Software Foundationが公表するGPLv3の使用条件に従って、
25  あなたはこのファイルを取り扱うことができます。
26  GPLv3の内容を https://www.gnu.org/licenses/gpl.txt にて確認して下さい。
27  またGPLv3のコピーをLICENSE.TXTファイルにおいてます。
28 */
29 //############################################################################
30 
31 #if !defined(THEOLIZER_INTERNAL_CORE_H)
32 #define THEOLIZER_INTERNAL_CORE_H
33 
34 #include "core_switcher.h"
35 
36 //############################################################################
37 // Begin
38 //############################################################################
39 
40 // ***************************************************************************
41 // 警告抑止
42 // ***************************************************************************
43 
44 #ifdef _MSC_VER
45  #pragma warning(push)
46  #pragma warning(disable:4127 4251)
47 #endif
48 
49 #ifndef THEOLIZER_INTERNAL_DOXYGEN
50 
51 //############################################################################
52 // バージョン対応用定義群
53 //############################################################################
54 
55 // ***************************************************************************
56 // TheolizerNonKeepStepクラス
57 // プリミティブ 部分特殊化
58 // その他 プライマリ
59 // ポインタ
60 // 非侵入型
61 // ***************************************************************************
62 
63 //----------------------------------------------------------------------------
64 // TheolizerNonKeepStep(プライマリ)の分岐処理
65 //----------------------------------------------------------------------------
66 
67 namespace theolizer
68 {
69 namespace internal
70 {
71 
72 // ---<<< プライマリー >>>---
73 
74 template<typename tType, class tEnable=void>
75 class TheolizerNonKeepStepPrimary
76 {
77  tType& mTarget;
78 public:
79  TheolizerNonKeepStepPrimary(tType& iTarget) : mTarget(iTarget) { }
80 
81 // ---<<< 値取り出し >>>---
82 
83  tType const& get() const { return mTarget; }
84  operator tType const&() const { return get(); }
85 };
86 
87 // ---<<< クラスへのポインタ用特殊化 >>>---
88 
89 template<typename tPointerType>
90 class TheolizerNonKeepStepPrimary
91 <
92  tPointerType,
93  theolizer::internal::EnableIf
94  <
95  std::is_pointer<tPointerType>::value
96  && std::is_class<typename std::remove_pointer<tPointerType>::type>::value
97  >
98 >
99 {
100  tPointerType& mPointer;
101  typedef typename std::remove_pointer<tPointerType>::type Type;
102 protected:
103  TheolizerNonKeepStepPrimary(tPointerType& iPointer) : mPointer(iPointer) { }
104 
105 public:
106 // ---<<< 値取り出し >>>---
107 
108  Type const* get() const { return mPointer; }
109  operator Type const*() const { return get(); }
110  Type const* operator->() const { return mPointer; }
111 };
112 
113 } // namespace internal
114 } // namespace theolizer
115 
116 //----------------------------------------------------------------------------
117 // プライマリー
118 //----------------------------------------------------------------------------
119 
120 template<class tClassType, class tEnable=void>
121 struct TheolizerNonKeepStep : public theolizer::internal::TheolizerNonKeepStepPrimary<tClassType>
122 {
123  static const bool kIsTheolizerNonKeepStep=true;
124  typedef tClassType Type;
125 
126 private:
127  typedef theolizer::internal::TrackingMode TrackingMode;
128  typedef TheolizerNonKeepStep<Type> This;
129 
130 // ---<<< 配列処理用 >>>---
131 
132  template<typename, std::size_t...> friend struct theolizer::internal::ArrayManager;
133  Type& getData() { return *mTarget; }
134 
135 // ---<<< 変更と引継ぎ >>>---
136 
137  // 削除時の実体
138  Type mValue;
139 
140  // ターゲット
141  Type* mTarget;
142 
143  typedef theolizer::internal::TheolizerNonKeepStepPrimary<tClassType> Base;
144 public:
145  // ターゲットからのコンストラクタ
146  explicit TheolizerNonKeepStep(Type& iTarget) :
147  Base(iTarget),
148  mValue(),
149  mTarget(&iTarget)
150  { }
151 
152  // 次からのコンストラクタ
153  explicit TheolizerNonKeepStep(This& iNext) :
154  Base(*iNext.mTarget),
155  mValue(),
156  mTarget(iNext.mTarget)
157  { }
158 
159  // ムーブ・コンストラクタ(配列処理用)
160  explicit TheolizerNonKeepStep(This&& iNext) :
161  Base(*iNext.mTarget),
162  mValue(),
163  mTarget(iNext.mTarget)
164  { }
165 
166  // デフォルト・コンストラクタ(次で削除されていた場合)
167  TheolizerNonKeepStep() :
168  Base(mValue),
169  mValue(),
170  mTarget(&mValue)
171  { }
172 
173 // ---<<< 保存／回復処理 >>>---
174 
175  template<bool tIsRegister, TrackingMode tTrackingMode, class tBaseSerializer>
176  void save(tBaseSerializer& iSerializer)
177  {
178 THEOLIZER_INTERNAL_VER_DEBUG((std::cout << "TheolizerNonKeepStep<tClassType>" << std::endl;));
179  theolizer::internal::Switcher<tBaseSerializer, Type, tIsRegister, tTrackingMode>::
180  save(iSerializer, *mTarget);
181  }
182 
183  template<bool tIsRegister, TrackingMode tTrackingMode, class tBaseSerializer>
184  void load(tBaseSerializer& iSerializer)
185  {
186  theolizer::internal::Switcher<tBaseSerializer, Type, tIsRegister, tTrackingMode>::
187  load(iSerializer, *mTarget);
188  }
189 };
190 
191 //----------------------------------------------------------------------------
192 // TheolizerNonKeepStep(特殊化)の分岐処理
193 //----------------------------------------------------------------------------
194 
195 namespace theolizer
196 {
197 namespace internal
198 {
199 
200 // ---<<< プライマリー >>>---
201 
202 template<typename tPrimitiveType, class tThis, class tEnable=void>
203 class TheolizerNonKeepStepSpecial { };
204 
205 // ---<<< 数値型用部分特殊化 >>>---
206 
207 template<typename tArithmeticType, class tThis>
208 class TheolizerNonKeepStepSpecial
209 <
210  tArithmeticType,
211  tThis,
212  theolizer::internal::EnableIf<std::is_arithmetic<tArithmeticType>::value>
213 >
214 {
215  typedef tArithmeticType Type;
216  typedef tThis This;
217  Type mData;
218 protected:
219  TheolizerNonKeepStepSpecial(Type iData=0) : mData(iData) { }
220  Type& getData() { return mData; }
221 
222  virtual This& operator=(Type iRhs)=0;
223  virtual ~TheolizerNonKeepStepSpecial() { }
224 };
225 
226 // ---<<< 文字列型用部分特殊化 >>>---
227 
228 template<typename tStringType, class tThis>
229 struct TheolizerNonKeepStepSpecial
230 <
231  tStringType,
232  tThis,
233  theolizer::internal::EnableIf<theolizer::internal::IsString<tStringType>::value>
234 > : public tStringType
235 {
236 protected:
237  TheolizerNonKeepStepSpecial(tStringType const& iString=tStringType()) : tStringType(iString){}
238  TheolizerNonKeepStepSpecial(tStringType&& iString) : tStringType(std::move(iString)) { }
239  tStringType& getData() { return *this; }
240 
241 private:
242  // 禁止するメソッド
243  // Iterators
244  using tStringType::begin;
245  using tStringType::end;
246  using tStringType::rbegin;
247  using tStringType::rend;
248 
249  // Capacity
250  using tStringType::resize;
251  using tStringType::clear;
252 
253  // Element access
254  using tStringType::operator[];
255  using tStringType::at;
256 
257  // Modifiers
258  using tStringType::operator+=;
259  using tStringType::append;
260  using tStringType::push_back;
261  using tStringType::assign;
262  using tStringType::insert;
263  using tStringType::erase;
264  using tStringType::replace;
265  using tStringType::swap;
266  using tStringType::pop_back;
267 };
268 
269 } // namespace internal
270 } // namespace theolizer
271 
272 //----------------------------------------------------------------------------
273 // TheolizerNonKeepStepプリミティブ用部分特殊化の実体部
274 //----------------------------------------------------------------------------
275 
276 template<typename tPrimitiveType>
277 struct THEOLIZER_INTERNAL_DLL TheolizerNonKeepStep
278 <
279  tPrimitiveType,
280  theolizer::internal::EnableIf<theolizer::internal::IsPrimitive<tPrimitiveType>::value>
281 > : public theolizer::internal::TheolizerNonKeepStepSpecial
282  <
283  tPrimitiveType,
284  TheolizerNonKeepStep<tPrimitiveType>
285  >
286 {
287  static const bool kIsTheolizerNonKeepStep=true;
288  typedef tPrimitiveType Type;
289 
290 private:
291  typedef TheolizerNonKeepStep<Type> This;
292  typedef theolizer::internal::TheolizerNonKeepStepSpecial<tPrimitiveType, This> Base;
293  typedef theolizer::internal::TrackingMode TrackingMode;
294  typedef theolizer::internal::BaseSerializer BaseSerializer;
295 
296 // ---<<< 配列処理用 >>>---
297 
298  template<typename, std::size_t...> friend struct theolizer::internal::ArrayManager;
299  Type& getData() { return mValue; }
300 
301 // ---<<< 変更と引継ぎ >>>---
302 
303  // 実体
304  Type& mValue;
305  Type mBackup;
306 
307  // 引継ぎ先（ターゲット or 次バージョンへのポインタ)
308  Type* mTarget;
309  This* mNextPtr;
310  bool mIsTarget;
311 
312  // 変更管理
313  bool mDoSucceed; // 引継ぎフラグ
314  bool mIsChanged; // これを含むクラスのupVersionにて変更された
315  unsigned mUpVersionCount;// upVersionカウンタ
316 
317 public:
318  // ターゲットからのコンストラクタ
319  explicit TheolizerNonKeepStep(Type& iTarget);
320 
321  // 次からのコンストラクタ
322  explicit TheolizerNonKeepStep(This& iNext);
323 
324  // ムーブ・コンストラクタ(配列処理用)
325  explicit TheolizerNonKeepStep(This&& iNext);
326 
327  // デフォルト・コンストラクタ(次で削除されていた場合)
328  TheolizerNonKeepStep();
329 
330  // 当プリミティブを含むクラスやその上位クラスのupVersionからの通常設定
331  This& operator=(Type iRhs);
332 
333  // 強制引継ぎ設定（他の変数から引き継ぐ）
334  void set(Type iValue, bool iDoSucceed); // iDoSucceedは引継ぎ元変数のmDoSucceed
335 
336 private:
337  // 前バージョンのデストラクタから呼ばれる引継ぎ処理
338  void succeed(Type iValue, bool iDoSucceed);
339 
340 public:
341  // デストラクタ(次バージョンへの引継ぎ実行)
342  ~TheolizerNonKeepStep();
343 
344 // ---<<< 値取り出し >>>---
345 
346  Type get() const { return mValue; }
347  operator Type() const { return get(); }
348  bool getDoSucceed() const { return mDoSucceed; }
349 
350  // 非constはライト・オンリー
351 private:
352  Type get() { return Type(); } // dummy
353  operator Type() { return get(); }
354 public:
355 
356 // ---<<< 保存／回復処理 >>>---
357 
358  // 保存
359  template<bool tIsRegister, TrackingMode tTrackingMode, class tBaseSerializer>
360  void save(tBaseSerializer& iSerializer)
361  {
362 THEOLIZER_INTERNAL_VER_DEBUG((
363  std::cout << "TheolizerNonKeepStep<tPrimitiveType>::save(" << mValue << ") "
364  << (void*)mTarget << std::endl;
365 ));
366  if (tTrackingMode == TrackingMode::etmDefault)
367  {
368  iSerializer.savePrimitive(mValue);
369  }
370  else
371  {
372 #if 0
373  BaseSerializer::AutoRestoreSave aAutoRestoreSave
374  (
375  iSerializer,
376  theolizer::internal::emOrder,
377  true
378  );
379  bool aIsSaved;
380  theolizer::internal::SerializeInfo& aSerializeInfo=
381  iSerializer.registerObject
382  (
383  mTarget,
384  typeid(mTarget),
385  tTrackingMode,
386  &aIsSaved
387  );
388 #else
389  bool aIsSaved;
390  theolizer::internal::SerializeInfo& aSerializeInfo=
391  iSerializer.registerObject
392  (
393  mTarget,
394  typeid(mTarget),
395  tTrackingMode,
396  &aIsSaved
397  );
398 
399  // 型のTypeIndex取り出し
400  std::size_t aTypeIndex = theolizer::internal::kInvalidSize;
401  if (iSerializer.mCheckMode == theolizer::CheckMode::TypeCheckInData)
402  {
403  aTypeIndex = theolizer::internal::getTypeIndex<tPrimitiveType>();
404  }
405 
406  // 開始／終了マーク処理
407  BaseSerializer::AutoRestoreSaveStructure aAutoRestoreSaveStructure
408  (
409  iSerializer,
410  theolizer::internal::emOrder,
411  theolizer::internal::Structure::Pointee,
412  aTypeIndex,
413  aSerializeInfo.mObjectId,
414  true
415  );
416 #endif
417 
418  iSerializer.writePreElement();
419  iSerializer.saveControl(aSerializeInfo.mObjectId);
420  // 未保存の時のみ保存する
421  if (!aIsSaved)
422  {
423  iSerializer.writePreElement();
424  iSerializer.savePrimitive(mValue);
425  }
426  }
427  }
428 
429  // 回復
430  template<bool tIsRegister, TrackingMode tTrackingMode, class tBaseSerializer>
431  void load(tBaseSerializer& iSerializer)
432  {
433  mDoSucceed=true;
434  if (tTrackingMode == TrackingMode::etmDefault)
435  {
436  iSerializer.loadPrimitive(mValue);
437  }
438  else
439  {
440 #if 0
441  BaseSerializer::AutoRestoreLoad aAutoRestoreLoad(iSerializer);
442  size_t aObjectId;
443 #else
444  // 型のTypeIndex取り出し
445  std::size_t aTypeIndex = theolizer::internal::kInvalidSize;
446  if (iSerializer.mCheckMode == theolizer::CheckMode::TypeCheckInData)
447  {
448  aTypeIndex = theolizer::internal::getTypeIndex<tPrimitiveType>();
449  }
450 
451  // 開始／終了マーク処理
452  size_t aObjectId= theolizer::internal::kInvalidSize;
453  BaseSerializer::AutoRestoreLoadStructure aAutoRestoreLoadStructure
454  (
455  iSerializer,
456  theolizer::internal::emOrder,
457  theolizer::internal::Structure::Pointee,
458  aTypeIndex,
459  &aObjectId
460  );
461 #endif
462  iSerializer.readPreElement();
463  iSerializer.loadControl(aObjectId);
464  bool aIsLoaded;
465  iSerializer.recoverObject
466  (
467  aObjectId,
468  reinterpret_cast<void*&>(mTarget),
469  typeid(mTarget),
470  tTrackingMode,
471  &aIsLoaded
472  );
473  // 未回復の時のみ回復する
474  if (!aIsLoaded)
475  {
476  iSerializer.readPreElement();
477  iSerializer.loadPrimitive(mValue);
478  }
479  }
480 THEOLIZER_INTERNAL_VER_DEBUG((
481  std::cout << "TheolizerNonKeepStep<tPrimitiveType>::load(" << mValue << ") "
482  << (void*)mTarget << std::endl;
483 ));
484  }
485 };
486 
487 #endif // THEOLIZER_INTERNAL_DOXYGEN
488 
489 namespace theolizer
490 {
491 namespace internal
492 {
493 #ifndef THEOLIZER_INTERNAL_DOXYGEN
494 
495 // ***************************************************************************
496 // Non-keep-step用定義
497 // ***************************************************************************
498 
499 #define THEOLIZER_INTERNAL_NON_KEEP_STEP(dType) \
500  TheolizerNonKeepStep<typename std::remove_reference<THEOLIZER_INTERNAL_UNPAREN dType>::type>
501 
502 // ***************************************************************************
503 // バージョン定義(クラス型)
504 // ***************************************************************************
505 
506 //----------------------------------------------------------------------------
507 // Element/EnumElementの基底クラス
508 //----------------------------------------------------------------------------
509 
510 struct ElementBase
511 {
512  // クラス/enum共通
513  virtual void writeMetaData
514  (
515  BaseSerializer& iSerializer,
516  VersionNoList const* iVersionNoList=nullptr
517  ) const = 0;
518 
519  // クラスのみ
520  virtual char const* getName() const {return "";}
521  virtual std::size_t getTypeIndex() const {return 0;}
522  virtual bool isBaseClass() const {return false;}
523  virtual Destinations const& getDestinations() const = 0;
524 };
525 
526 //----------------------------------------------------------------------------
527 // TheolizerVersion<>内の要素(メンバー変数)管理クラス
528 //----------------------------------------------------------------------------
529 
530 template<class tVersionType>
531 class Element : public ElementBase
532 {
533 private:
534  typedef typename tVersionType::Serializer Serializer;
535 
536 // ---<<< 記録用内部クラスの基底型 >>>---
537 
538  struct HolderBase
539  {
540  virtual size_t getTypeIndex() const =0;
541  virtual void saveElement(Serializer& iSerializer, tVersionType& iInstance) const=0;
542  virtual void loadElement(Serializer& iSerializer, tVersionType& iInstance) const=0;
543  virtual ~HolderBase() { }
544  };
545 
546 // ---<<< 記録用内部クラス >>>---
547 
548  template<typename tTypeFunc, typename tSaveFunc, typename tLoadFunc>
549  struct Holder : public HolderBase
550  {
551  tTypeFunc mTypeFunc; // TypeIndex関数
552  tSaveFunc mSaveFunc; // 要素保存関数
553  tLoadFunc mLoadFunc; // 要素回復関数
554 
555  Holder(tTypeFunc iTypeFunc, tSaveFunc iSaveFunc, tLoadFunc iLoadFunc) :
556  mTypeFunc(iTypeFunc),
557  mSaveFunc(iSaveFunc),
558  mLoadFunc(iLoadFunc)
559  { }
560 
561  ~Holder() = default;
562 
563  virtual size_t getTypeIndex() const
564  {
565  return mTypeFunc();
566  }
567 
568  virtual void saveElement(Serializer& iSerializer,
569  tVersionType& iInstance) const
570  {
571  mSaveFunc(iSerializer, iInstance);
572  }
573  virtual void loadElement(Serializer& iSerializer,
574  tVersionType& iInstance) const
575  {
576  mLoadFunc(iSerializer, iInstance);
577  }
578  };
579 
580 // ---<<< 記録領域 >>>---
581 
582  char const* const mName;
583  bool const mIsBaseClass;
584  Destinations mDestinations;
585  std::unique_ptr<HolderBase> mHolder;
586  char const* const mNextName;
587  TrackingMode mTrackingMode;
588  unsigned mVersionNo;
589 
590 // ---<<< コンストラクタ >>>---
591 
592 public:
593  Element() :
594  mName(),
595  mIsBaseClass(false),
596  mDestinations(),
597  mHolder(),
598  mNextName(),
599  mTrackingMode(),
600  mVersionNo(0)
601  { }
602 
603  template<typename tTypeFunc, typename tSaveFunc, typename tLoadFunc>
604  Element
605  (
606  char const* const iName,
607  bool iIsBaseClass,
608  std::initializer_list<Destination> const& iDestinationList,
609  tTypeFunc iTypeFunc,
610  tSaveFunc iSaveFunc,
611  tLoadFunc iLoadFunc,
612  char const* const iNextName,
613  TrackingMode iTrackingMode,
614  unsigned iVersionNo
615  ) : mName(iName),
616  mIsBaseClass(iIsBaseClass),
617  mDestinations(iDestinationList),
618  mHolder
619  (
620  new Holder<tTypeFunc, tSaveFunc, tLoadFunc>
621  (
622  iTypeFunc,
623  iSaveFunc,
624  iLoadFunc
625  )
626  ),
627  mNextName(iNextName),
628  mTrackingMode(iTrackingMode),
629  mVersionNo(iVersionNo)
630  { }
631 
632  // ムーブ・コンストラクタ
633  Element(Element&& iRhs) noexcept :
634  mName (iRhs.mName),
635  mIsBaseClass (iRhs.mIsBaseClass),
636  mDestinations(std::move(iRhs.mDestinations)),
637  mHolder (std::move(iRhs.mHolder)),
638  mNextName (iRhs.mNextName),
639  mTrackingMode(iRhs.mTrackingMode),
640  mVersionNo (iRhs.mVersionNo)
641  { }
642 
643 // ---<<< 基本サービス関数 >>>---
644 
645  const bool isSentinel() const {return mName == nullptr;}
646 
647  char const* getName() const {return mName;}
648  Destinations const& getDestinations() const
649  {
650  return mDestinations;
651  }
652  bool isBaseClass() const {return mIsBaseClass;}
653  size_t getTypeIndex() const
654  {
655  return mHolder->getTypeIndex();
656  }
657  void saveElement(Serializer& iSerializer, tVersionType& iInstance) const
658  {
659  mHolder->saveElement(iSerializer, iInstance);
660  }
661  void loadElement(Serializer& iSerializer, tVersionType& iInstance) const
662  {
663  mHolder->loadElement(iSerializer, iInstance);
664  }
665 
666 // ---<<< メタ・シリアライズ >>>---
667 
668  void writeMetaData
669  (
670  BaseSerializer& iSerializer,
671  VersionNoList const* iVersionNoList
672  ) const
673  {
674  // 要素毎の塊
675  iSerializer.writePreElement();
676  BaseSerializer::AutoRestoreSave aAutoRestoreSave(iSerializer, emOrder, true);
677 
678  // TypeInfo獲得
679  auto aTypeIndex=getTypeIndex();
680  auto aTypeInfo=TypeInfoList::getInstance().getList()[aTypeIndex];
681 
682  // 要素名
683  iSerializer.writePreElement();
684  iSerializer.saveControl(mName);
685 
686  // 次バージョン要素名
687  iSerializer.writePreElement();
688  iSerializer.saveControl(mNextName);
689 
690  // TypeKind
691  iSerializer.writePreElement();
692  iSerializer.saveControl(aTypeInfo->getTypeKind());
693 
694  // 形名(*/[]修飾付き)
695  iSerializer.writePreElement();
696  iSerializer.saveControl(aTypeInfo->getTypeName(*iVersionNoList));
697 
698  // バージョン番号
699  iSerializer.writePreElement();
700  iSerializer.saveControl(mVersionNo);
701 
702  // オブジェクト追跡指定
703  iSerializer.writePreElement();
704  iSerializer.saveControl(mTrackingMode);
705  }
706 };
707 
708 //----------------------------------------------------------------------------
709 // Element登録用マクロ
710 //----------------------------------------------------------------------------
711 
712 // ---<<< 基底クラス登録用マクロ >>>---
713 // RegisterPointee<>は、派生クラス登録(THEOLIZER_REGISTER_CLASS)時に
714 // 基底クラスへの登録処理が間に合わないケース対処のため、ここで呼び出す。
715 // boostのかなり特殊なテクニックを使っている。
716 //
717 // 2016/08/02現在、基底Serializerを非テンプレート化することで、
718 // 基底クラスへの登録を単純化できたので、登録場所はここである必要はない筈。
719 
720 #define THEOLIZER_INTERNAL_REGISTER_BASE(dSpec, dTrack, dId, dType, dVerNo, dName, dVer)\
721  { \
722  /*基底クラス名*/ "{" dName "}", \
723  /*Is基底クラス*/ true, \
724  /*保存先*/ {theolizerD::All}, \
725  /*TypeIndex関数*/ \
726  []() \
727  { \
728  typedef THEOLIZER_INTERNAL_UNPAREN dType Type; \
729  theolizer::internal:: \
730  RegisterType<tBaseSerializer, Type, ::tTheolizerVersion, true>::getInstance();\
731  return theolizer::internal::getTypeIndex<Type>(); \
732  }, \
733  /*保存関数*/ \
734  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance) \
735  { \
736  typedef THEOLIZER_INTERNAL_UNPAREN dVer VerType; \
737  THEOLIZER_INTERNAL_SAVE(iSerializer, \
738  static_cast<VerType&>(iInstance), dTrack); \
739  }, \
740  /*回復関数*/ \
741  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance) \
742  { \
743  typedef THEOLIZER_INTERNAL_UNPAREN dVer VerType; \
744  THEOLIZER_INTERNAL_LOAD(iSerializer, \
745  static_cast<VerType&>(iInstance), dTrack); \
746  }, \
747  /*public/private/protected(次バージョンの要素名)*/ \
748  #dSpec, \
749  /*(オブジェクト追跡モード)*/ \
750  theolizer::internal::etmDefault, \
751  /*バージョン番号*/ \
752  dVerNo \
753  }
754 
755 // ---<<< 基底クラス登録用マクロ2 >>>---
756 // 非侵入型手動の基底クラス用（ポリモーフィズム用の基底クラス・リストの定義）
757 // 保存／回復処理は手動なので保存／回復処理不要
758 
759 #define THEOLIZER_INTERNAL_REGISTER_MBASE(dSpec, dTrack, dType, dVerNo, dName, dVer)\
760  { \
761  /*基底クラス名*/ "{" dName "}", \
762  /*Is基底クラス*/ true, \
763  /*保存先*/ {theolizerD::All}, \
764  /*TypeIndex関数*/ \
765  []() \
766  { \
767  typedef THEOLIZER_INTERNAL_UNPAREN dType Type; \
768  theolizer::internal:: \
769  RegisterType<tBaseSerializer, Type, ::tTheolizerVersion, true>::getInstance();\
770  return theolizer::internal::getTypeIndex<Type>(); \
771  }, \
772  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance){}, \
773  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance){}, \
774  #dSpec, \
775  theolizer::internal::etmDefault, \
776  dVerNo \
777  }
778 
779 // ---<<< 要素登録用マクロ >>>---
780 
781 #define THEOLIZER_INTERNAL_REGISTER_ELEMENT(dName,dNextName,dTrack,dDest,dType,dVerNo,dVer)\
782  { \
783  /*要素名*/ THEOLIZER_INTERNAL_STRINGIZE(THEOLIZER_INTERNAL_UNPAREN dName),\
784  /*Is基底クラス*/ false, \
785  /*保存先*/ {THEOLIZER_INTERNAL_UNPAREN dDest}, \
786  /*TypeIndex関数*/ \
787  []() \
788  { \
789  using Type=THEOLIZER_INTERNAL_UNPAREN dType; \
790  return theolizer::internal::getTypeIndex<Type>(); \
791  }, \
792  /*保存関数*/ \
793  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance) \
794  { \
795  THEOLIZER_INTERNAL_SAVE(iSerializer, \
796  iInstance.THEOLIZER_INTERNAL_UNPAREN dName, dTrack); \
797  }, \
798  /*回復関数*/ \
799  [](tBaseSerializer& iSerializer, TheolizerVersion& iInstance) \
800  { \
801  THEOLIZER_INTERNAL_LOAD(iSerializer, \
802  iInstance.THEOLIZER_INTERNAL_UNPAREN dName, dTrack); \
803  }, \
804  /*(次バージョンの要素名)*/ \
805  #dNextName, \
806  /*(オブジェクト追跡モード)*/ \
807  theolizer::internal::dTrack, \
808  /*バージョン番号*/ \
809  dVerNo \
810  }
811 
812 // ---<<< 番兵 >>>---
813 
814 #define THEOLIZER_INTERNAL_REGISTER_SENTINEL(dVersion) \
815  { \
816  nullptr, \
817  false, \
818  {theolizerD::All}, \
819  [](){return size_t(0);}, \
820  [](tBaseSerializer& iSerializer, dVersion& iInstance){}, \
821  [](tBaseSerializer& iSerializer, dVersion& iInstance){}, \
822  nullptr, \
823  theolizer::internal::etmDefault, \
824  0 \
825  }
826 
827 // ***************************************************************************
828 // バージョン定義(enum型)
829 // ***************************************************************************
830 
831 //----------------------------------------------------------------------------
832 // TheolizerVersion<>内の要素(enum値)管理クラス
833 // mSymbols
834 // mName[0] 当enum値のシンポル名
835 // mName[1以上] 当enum値の別名
836 // mValues
837 // mValues[0] 当enum値の値
838 // mValues[1以上] 当enum値の別値
839 // mPrevValue 前バージョンの対応する値
840 //----------------------------------------------------------------------------
841 
842 template<typename tBaseType>
843 struct EnumElement : public ElementBase
844 {
845  std::vector<char const*> mSymbols;
846  std::vector<tBaseType> mValues;
847  tBaseType mPrevValue;
848 
849  EnumElement(
850  std::initializer_list<char const*> iSymbols,
851  std::initializer_list<tBaseType> iValues,
852  tBaseType iPrevValue) :
853  mSymbols(iSymbols),
854  mValues(iValues),
855  mPrevValue(iPrevValue)
856  { }
857 
858  const bool isSentinel() const {return *mSymbols[0] == 0;}
859 
860  // メタ・データ保存
861  void writeMetaData
862  (
863  BaseSerializer& iSerializer,
864  VersionNoList const*
865  ) const
866  {
867  // シンボル名リスト
868  {
869  iSerializer.writePreElement();
870  BaseSerializer::AutoRestoreSave aAutoRestoreSave(iSerializer,emOrder,true);
871  for (auto symbol : mSymbols)
872  {
873  iSerializer.writePreElement();
874  std::string aSymbol(symbol);
875  iSerializer.saveControl(aSymbol);
876  }
877  }
878  // シンボル値リスト
879  {
880  iSerializer.writePreElement();
881  BaseSerializer::AutoRestoreSave aAutoRestoreSave(iSerializer,emOrder,true);
882  for (auto value : mValues)
883  {
884  iSerializer.writePreElement();
885  iSerializer.saveControl(value);
886  }
887  }
888  // 次バージョン値
889  {
890  iSerializer.writePreElement();
891  iSerializer.saveControl(mPrevValue);
892  }
893  }
894 
895  // dummy
896  Destinations mDestinations;
897  Destinations const& getDestinations() const {return mDestinations;}
898 };
899 
900 // ***************************************************************************
901 // バージョン定義(共通)
902 // ***************************************************************************
903 
904 //----------------------------------------------------------------------------
905 // ClassTypeとEnumTypeのバージョン定義用クラス
906 // version.incにて部分特殊化する。
907 // tTypeがクラスの場合、ClassType用
908 // tTypeがenumの場合、 EnumType用
909 //----------------------------------------------------------------------------
910 
911 // ---<<< TheolizerVersion<>記述マクロ >>>---
912 
913 // 侵入型(class/struct用)
914 #define THEOLIZER_INTERNAL_VERTYPE_I(dClass, dVersionNo) \
915  THEOLIZER_INTERNAL_UNPAREN dClass::TheolizerVersion<tBaseSerializer, dVersionNo>
916 
917 // 非侵入型(現在はenum用、class/structにも使用可能)
918 #define THEOLIZER_INTERNAL_VERTYPE_N(dType, dVersionNo) \
919  TheolizerNonIntrusive<THEOLIZER_INTERNAL_UNPAREN dType>:: \
920  TheolizerVersion<tBaseSerializer, dVersionNo>
921 
922 //----------------------------------------------------------------------------
923 // THEOLIZER_GENERATED_BASE_LIST()とTHEOLIZER_GENERATED_ELEMENT_LIST()展開用
924 // ユーザ・ソースへ自動生成されたマクロを集約する
925 // version*.incにて展開される
926 // dAnnoパラメータにつけているTS:_STAFF_ONLY_XXXの'_'はマクロ展開防止用
927 //----------------------------------------------------------------------------
928 
929 // ---<<< THEOLIZER_INTERNAL_UNPARENとstd::remove_reference<>短縮 >>>---
930 
931 #define THEOLIZER_INTERNAL_UNREFERENCE(dType) \
932  typename std::remove_reference<THEOLIZER_INTERNAL_UNPAREN dType>::type
933 
934 // ---<<< バージョン・アップ／ダウンの足並みを揃えない基底クラス >>>---
935 // 手動型(非侵入型手動)
936 // remove_reference時、typenameが入るとダメなので、
937 // THEOLIZER_INTERNAL_UNREFERENCEを使わない。
938 // dIdは各TheolzierVersion<>において、基底クラスのバックアップ領域に付ける変数ID
939 
940 // 継続
941 #define THEOLIZER_INTERNAL_BASE_N(dSpec, dTrack, dId, dType, dName) \
942  THEOLIZER_INTERNAL_VERSION_B(dSpec, dTrack, dId, dType, 0, dName, \
943  (TheolizerBase<THEOLIZER_INTERNAL_UNPAREN dType>), \
944  TS:_THEOLIZER_INTERNAL_BASE_N(dSpec,dTrack,dId,dType,dName))
945 
946 // 次バージョンで削除
947 #define THEOLIZER_INTERNAL_BASE_N_DEL(dSpec, dTrack, dId, dType, dName) \
948  THEOLIZER_INTERNAL_VERSION_B_DEL(dSpec, dTrack, dId, dType, 0, dName, \
949  (TheolizerBase<THEOLIZER_INTERNAL_UNPAREN dType>), \
950  TS:_THEOLIZER_INTERNAL_BASE_N(dSpec,dTrack,dId,dType,dName))
951 
952 // ---<<< バージョン・アップ／ダウンの足並みを揃える基底クラス >>>---
953 // 半自動型(侵入型半自動)
954 
955 // 継続
956 #define THEOLIZER_INTERNAL_BASE_KI(dSpec, dTrack, dId, dType, dVerNo, dName)\
957  THEOLIZER_INTERNAL_VERSION_B(dSpec, dTrack, dId, dType, dVerNo, dName, \
958  (THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo)), \
959  TS:_THEOLIZER_INTERNAL_BASE_KI(dSpec,dTrack,dId,dType,dVerNo,dName))
960 
961 // 次バージョンで削除
962 #define THEOLIZER_INTERNAL_BASE_KI_DEL(dSpec, dTrack, dId, dType, dVerNo, dName)\
963  THEOLIZER_INTERNAL_VERSION_B_DEL(dSpec, dTrack, dId, dType, dVerNo, dName,\
964  (THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo)), \
965  TS:_THEOLIZER_INTERNAL_BASE_KI(dSpec,dTrack,dId,dType,dVerNo,dName))
966 
967 // ---<<< バージョン・アップ／ダウンの足並みを揃える基底クラス >>>---
968 // 完全自動型
969 
970 // 継続
971 #define THEOLIZER_INTERNAL_BASE_KN(dSpec, dTrack, dId, dType, dVerNo, dName)\
972  THEOLIZER_INTERNAL_VERSION_B(dSpec, dTrack, dId, dType, dVerNo, dName, \
973  (THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo)), \
974  TS:_THEOLIZER_INTERNAL_BASE_KN(dSpec,dTrack,dId,dType,dVerNo,dName))
975 
976 // 次バージョンで削除
977 #define THEOLIZER_INTERNAL_BASE_KN_DEL(dSpec, dTrack, dId, dType, dVerNo, dName)\
978  THEOLIZER_INTERNAL_VERSION_B_DEL(dSpec, dTrack, dId, dType, dVerNo, dName,\
979  (THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo)), \
980  TS:_THEOLIZER_INTERNAL_BASE_KN(dSpec,dTrack,dId,dType,dVerNo,dName))
981 
982 // ---<<< バージョン・アップ／ダウンの足並みを揃えない要素 >>>---
983 // プリミティブ、ポインタ、手動型
984 
985 // 継続
986 #define THEOLIZER_INTERNAL_ELEMENT_N(dName, dNextName, dTrack, dDest, dType)\
987  THEOLIZER_INTERNAL_VERSION_EN(dName, dNextName, dTrack, dDest, dType, \
988  (THEOLIZER_INTERNAL_NON_KEEP_STEP(dType)), \
989  TS:_THEOLIZER_INTERNAL_ELEMENT_N(dName,dNextName,dTrack,\\dDest,\\dType))
990 
991 // 次バージョンで削除
992 #define THEOLIZER_INTERNAL_ELEMENT_N_DEL(dName, dNextName, dTrack, dDest, dType)\
993  THEOLIZER_INTERNAL_VERSION_EN_DEL(dName, dNextName, dTrack, dDest, dType,\
994  (THEOLIZER_INTERNAL_NON_KEEP_STEP(dType)), \
995  TS:_THEOLIZER_INTERNAL_ELEMENT_N(dName,dNextName,dTrack,\\dDest,\\dType))
996 
997 // ---<<< THEOLIZER_INTERNAL_VERSION_EV/_DEL()展開用補助マクロ >>>---
998 
999 #define THEOLIZER_INTERNAL_NONE(dDef)
1000 #define THEOLIZER_INTERNAL_DEF(dDef) THEOLIZER_INTERNAL_UNPAREN dDef
1001 
1002 // ---<<< バージョン・アップ／ダウンの足並みを揃える要素 >>>---
1003 // 侵入型
1004 
1005 // 継続
1006 #define THEOLIZER_INTERNAL_ELEMENT_KI(dName, dNextName, dTrack, dDest, dType, dVerNo)\
1007  THEOLIZER_INTERNAL_VERSION_EV(dName, dNextName, dTrack, dDest, dType, dVerNo,\
1008  (THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo)), \
1009  TS:_THEOLIZER_INTERNAL_ELEMENT_KI(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo), NONE)
1010 
1011 // 次バージョンで削除
1012 #define THEOLIZER_INTERNAL_ELEMENT_KI_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo)\
1013  THEOLIZER_INTERNAL_VERSION_EV_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo,\
1014  (THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo)), \
1015  TS:_THEOLIZER_INTERNAL_ELEMENT_KI(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo))
1016 
1017 // ---<<< バージョン・アップ／ダウンの足並みを揃える要素 >>>---
1018 // enum型(非侵入型)／完全自動型
1019 
1020 // 継続
1021 #define THEOLIZER_INTERNAL_ELEMENT_KN(dName, dNextName, dTrack, dDest, dType, dVerNo)\
1022  THEOLIZER_INTERNAL_VERSION_EV(dName, dNextName, dTrack, dDest, dType, dVerNo,\
1023  (THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo)), \
1024  TS:_THEOLIZER_INTERNAL_ELEMENT_KN(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo), DEF)
1025 
1026 // 次バージョンで削除
1027 #define THEOLIZER_INTERNAL_ELEMENT_KN_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo)\
1028  THEOLIZER_INTERNAL_VERSION_EV_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo,\
1029  (THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo)), \
1030  TS:_THEOLIZER_INTERNAL_ELEMENT_KN(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo))
1031 
1032 // ---<<< バージョン・アップ／ダウンの足並みを揃えない生配列型要素 >>>---
1033 // プリミティブ、ポインタ、非侵入型
1034 // 生配列側は次元や要素数変更に対応するため、バージョンを持つ
1035 
1036 // 継続
1037 #define THEOLIZER_INTERNAL_ELEMENT_AN(dName, dNextName, dTrack, dDest, dType, ...) \
1038  THEOLIZER_INTERNAL_VERSION_EV(dName, dNextName, dTrack, dDest, \
1039  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), 0,\
1040  (typename theolizer::internal::ArrayManager< \
1041  THEOLIZER_INTERNAL_NON_KEEP_STEP(dType), __VA_ARGS__>::template \
1042  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1043  TS:_THEOLIZER_INTERNAL_ELEMENT_AN(dName,dNextName,dTrack,\\dDest,\\dType,__VA_ARGS__),\
1044  DEF)
1045 
1046 // 次バージョンで削除
1047 #define THEOLIZER_INTERNAL_ELEMENT_AN_DEL(dName, dNextName, dTrack, dDest, dType, ...)\
1048  THEOLIZER_INTERNAL_VERSION_EV_DEL(dName, dNextName, dTrack, dDest, \
1049  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), 0,\
1050  (typename theolizer::internal::ArrayManager< \
1051  THEOLIZER_INTERNAL_NON_KEEP_STEP(dType), __VA_ARGS__>::template \
1052  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1053  TS:_THEOLIZER_INTERNAL_ELEMENT_AN(dName,dNextName,dTrack,\\dDest,\\dType,__VA_ARGS__))
1054 
1055 // ---<<< バージョン・アップ／ダウンの足並みを揃える生配列型要素 >>>---
1056 // 侵入型
1057 
1058 // 継続
1059 #define THEOLIZER_INTERNAL_ELEMENT_AKI(dName, dNextName, dTrack, dDest, dType, dVerNo, ...)\
1060  THEOLIZER_INTERNAL_VERSION_EV(dName, dNextName, dTrack, dDest, \
1061  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), dVerNo,\
1062  (typename theolizer::internal::ArrayManager< \
1063  THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo), __VA_ARGS__>::template\
1064  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1065  TS:_THEOLIZER_INTERNAL_ELEMENT_AKI(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo,__VA_ARGS__), NONE)
1066 
1067 // 次バージョンで削除
1068 #define THEOLIZER_INTERNAL_ELEMENT_AKI_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo, ...)\
1069  THEOLIZER_INTERNAL_VERSION_EV_DEL(dName, dNextName, dTrack, dDest, \
1070  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), dVerNo,\
1071  (typename theolizer::internal::ArrayManager< \
1072  THEOLIZER_INTERNAL_VERTYPE_I(dType, dVerNo), __VA_ARGS__>::template\
1073  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1074  TS:_THEOLIZER_INTERNAL_ELEMENT_AKI(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo,__VA_ARGS__))
1075 
1076 // ---<<< バージョン・アップ／ダウンの足並みを揃える生配列型要素 >>>---
1077 // enum型(非侵入型)
1078 
1079 // 継続
1080 #define THEOLIZER_INTERNAL_ELEMENT_AKN(dName, dNextName, dTrack, dDest, dType, dVerNo, ...)\
1081  THEOLIZER_INTERNAL_VERSION_EV(dName, dNextName, dTrack, dDest, \
1082  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), dVerNo,\
1083  (typename theolizer::internal::ArrayManager< \
1084  THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo), __VA_ARGS__>::template\
1085  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1086  TS:_THEOLIZER_INTERNAL_ELEMENT_AKN(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo,__VA_ARGS__), DEF)
1087 
1088 // 次バージョンで削除
1089 #define THEOLIZER_INTERNAL_ELEMENT_AKN_DEL(dName, dNextName, dTrack, dDest, dType, dVerNo, ...)\
1090  THEOLIZER_INTERNAL_VERSION_EV_DEL(dName, dNextName, dTrack, dDest, \
1091  (theolizer::internal::Array<THEOLIZER_INTERNAL_UNPAREN dType, __VA_ARGS__>), dVerNo,\
1092  (typename theolizer::internal::ArrayManager< \
1093  THEOLIZER_INTERNAL_VERTYPE_N(dType, dVerNo), __VA_ARGS__>::template\
1094  TheolizerVersion<tBaseSerializer, THEOLIZER_GENERATED_VERSION_NO>),\
1095  TS:_THEOLIZER_INTERNAL_ELEMENT_AKN(dName,dNextName,dTrack,\\dDest,\\dType,dVerNo,__VA_ARGS__))
1096 
1097 // ---<<< ポリモーフィズム用(基底クラスのClassTypeInfo抽出) >>>---
1098 
1099 #define THEOLIZER_INTERNAL_MAKE_CLASS_TYPE(dType) \
1100  theolizer::internal::ClassTypeInfo \
1101  < \
1102  typename std::conditional \
1103  < \
1104  theolizer::internal::IsNonIntrusive<THEOLIZER_INTERNAL_UNPAREN dType>::value,\
1105  TheolizerNonIntrusive<THEOLIZER_INTERNAL_UNPAREN dType>, \
1106  THEOLIZER_INTERNAL_UNPAREN dType \
1107  >::type \
1108  >
1109 
1110 //############################################################################
1111 // ポリモーフィズム対応
1112 //############################################################################
1113 
1114 // ***************************************************************************
1115 // 基底Serializer × 派生クラスの組合せてのClassTypeInfoを実体化する
1116 // ***************************************************************************
1117 
1118 template<class tClass>
1119 class RegisterToBaseClass
1120 {
1121  RegisterToBaseClass()
1122  {
1123  theolizer::internal::RegisterType
1124  <
1125  theolizer::internal::BaseSerializer,
1126  tClass,
1127  ::tTheolizerVersion,
1128  true
1129  >::getInstance();
1130  }
1131 };
1132 
1133 // ***************************************************************************
1134 // ClassTypeInfoからのBaseSerializer呼び出し
1135 // ***************************************************************************
1136 
1137 //----------------------------------------------------------------------------
1138 // 型、および、インスタンス保存(保存したらtrue返却)
1139 //----------------------------------------------------------------------------
1140 
1141 template<class tClassType>
1142 bool ClassTypeInfo<tClassType>::saveTypeInstance
1143 (
1144  BaseSerializer& iSerializer,
1145  tClassType*& iPointer,
1146  std::type_index iStdTypeIndex
1147 )
1148 {
1149  unsigned aVersionNo=iSerializer.mVersionNoList.at(BaseTypeInfo::mTypeIndex);
1150 
1151  if (getTargetStdTypeIndex() == iStdTypeIndex)
1152  {
1153  if ((iSerializer.mCheckMode != CheckMode::TypeCheckByIndex)
1154  && (iSerializer.mCheckMode != CheckMode::InMemory))
1155  {
1156  // 型名保存
1157  std::string aTypeName=getTypeName(iSerializer.mVersionNoList);
1158  iSerializer.saveControl(aTypeName);
1159  }
1160  else
1161  {
1162  // TypeIndex保存
1163  iSerializer.saveControl(BaseTypeInfo::mTypeIndex);
1164  }
1165  // インスタンス保存
1166  iSerializer.writePreElement();
1167 
1168  tClassType::Theolizer::saveClass
1169  (
1170  iSerializer,
1171  iPointer,
1172  aVersionNo
1173  );
1174 return true;
1175  }
1176 
1177  for (auto&& aDrivedClass : mDrivedClassList)
1178  {
1179  if (aDrivedClass->saveTypeInstance(iSerializer, iPointer, iStdTypeIndex))
1180 return true;
1181  }
1182  return false;
1183 }
1184 
1185 //----------------------------------------------------------------------------
1186 // デフォルト・コンストラクタがある時のみコンストラクトする
1187 //----------------------------------------------------------------------------
1188 
1189 template
1190 <
1191  class tClassType,
1192  THEOLIZER_INTERNAL_OVERLOAD((!std::is_constructible<tClassType>::value))
1193 >
1194 tClassType* createClass(tClassType const*)
1195 {
1196  return nullptr;
1197 }
1198 
1199 template
1200 <
1201  class tClassType,
1202  THEOLIZER_INTERNAL_OVERLOAD((std::is_constructible<tClassType>::value))
1203 >
1204 tClassType* createClass(tClassType const*)
1205 {
1206  return new tClassType();
1207 }
1208 //----------------------------------------------------------------------------
1209 template
1210 <
1211  class tClassType,
1212  THEOLIZER_INTERNAL_OVERLOAD((!std::is_constructible<tClassType>::value))
1213 >
1214 tClassType* createClass2()
1215 {
1216  return nullptr;
1217 }
1218 
1219 template
1220 <
1221  class tClassType,
1222  THEOLIZER_INTERNAL_OVERLOAD((std::is_constructible<tClassType>::value))
1223 >
1224 tClassType* createClass2()
1225 {
1226  return new tClassType();
1227 }
1228 
1229 //----------------------------------------------------------------------------
1230 // 型、および、インスタンス回復(回復したらtrue返却)
1231 //----------------------------------------------------------------------------
1232 
1233 template<class tClassType>
1234 bool ClassTypeInfo<tClassType>::loadTypeInstance
1235 (
1236  BaseSerializer& iSerializer,
1237  tClassType*& iPointer,
1238  TypeIndexList& iTypeIndexList
1239 )
1240 {
1241  typedef typename tClassType::TheolizerTarget TheolizerTarget;
1242 
1243  std::size_t aFoundTypeIndex=0;
1244  bool aFound=false;
1245  bool aDoRelease=true;
1246  for (auto aTypeIndex : iTypeIndexList)
1247  {
1248  if (aTypeIndex != BaseTypeInfo::mTypeIndex)
1249  continue;
1250 
1251  if (!aFound)
1252  {
1253  aFound=true;
1254  aFoundTypeIndex=aTypeIndex;
1255  }
1256 
1257  // ポイント先領域のstd::type_indexと、シリアライズ・データ中のstd::type_indexが一致
1258  if ((iPointer != nullptr)
1259  && (std::type_index(typeid(*iPointer))
1260  == TypeInfoList::getInstance().getList()[aTypeIndex]->getStdTypeIndex(true)))
1261  { // この場合のみ領域開放しない
1262  aDoRelease=false;
1263  break;
1264  }
1265  }
1266 
1267  if (aFound)
1268  {
1269  // 参照経由で処理中の時、アドレス変更不可
1270  if (iSerializer.mRefProcessing)
1271  {
1272  if (aDoRelease)
1273  {
1274  THEOLIZER_INTERNAL_WRONG_USING(
1275  "Type of this instance(%1%) is different from saved.",
1276  getNameByTypeInfo(typeid(*iPointer)));
1277  }
1278  }
1279  else
1280  {
1281  if (aDoRelease)
1282  {
1283  // シリアライズ・データとポインタ指す先の型が異なる場合、解放する
1284  // ただし、std::shared_ptrが管理する領域の場合は、std::shared_ptr側で解放するので
1285  // ここでは解放しない。
1286  if (!iSerializer.mIsShared)
1287  {
1288  delete iPointer;
1289  }
1290  iPointer=nullptr;
1291  }
1292 
1293  // 自動型で、nullptrなら領域獲得
1294  if (tClassType::Theolizer::kIsAuto)
1295  {
1296  if (!iPointer)
1297  {
1298  iPointer=reinterpret_cast<tClassType*>(createClass2<TheolizerTarget>());
1299  }
1300  }
1301  }
1302 
1303  // インスタンス回復
1304  if (!iSerializer.readPreElement())
1305  {
1306  THEOLIZER_INTERNAL_DATA_ERROR(u8"Format Error.");
1307  }
1308 
1309  {
1310  // shared_ptr処理クリア
1311  AutoRestoreIsShared aAutoRestoreIsShared(iSerializer, false);
1312 
1313  // クラス・インスタンス回復
1314  tClassType::Theolizer::loadClass
1315  (
1316  iSerializer,
1317  iPointer,
1318  iSerializer.mVersionNoList.at(aFoundTypeIndex)
1319  );
1320  }
1321 return true;
1322  }
1323 
1324  for (auto&& aDrivedClass : mDrivedClassList)
1325  {
1326  if (aDrivedClass->loadTypeInstance(iSerializer, iPointer, iTypeIndexList))
1327 return true;
1328  }
1329 
1330  return false;
1331 }
1332 
1333 //----------------------------------------------------------------------------
1334 // 現インスタンスの先頭アドレス返却
1335 // ２番目以降の基底クラスへのポインタに対応するため
1336 //----------------------------------------------------------------------------
1337 
1338 template<class tClassType>
1339 void const* ClassTypeInfo<tClassType>::getDerivedPointer
1340 (
1341  typename tClassType::TheolizerTarget* iBasePointer
1342 )
1343 {
1344  if (getTargetStdTypeIndex() == std::type_index(typeid(*iBasePointer)))
1345 return iBasePointer;
1346 
1347  for (auto&& aDrivedClass : mDrivedClassList)
1348  {
1349  void const* ret=aDrivedClass->getDerivedPointer(iBasePointer);
1350  if (ret)
1351 return ret;
1352  }
1353 
1354  return nullptr;
1355 }
1356 
1357 //############################################################################
1358 // End
1359 //############################################################################
1360 
1361 #endif // THEOLIZER_INTERNAL_DOXYGEN
1362 } // namespace internal
1363 } // namespace theolizer
1364 
1365 // ***************************************************************************
1366 // 警告抑止解除
1367 // ***************************************************************************
1368 
1369 #ifdef _MSC_VER
1370  #pragma warning(pop)
1371 #endif
1372 
1373 #endif // THEOLIZER_INTERNAL_CORE_H
theolizer
theolizer名前空間
Definition: base.h:53
theolizer::CheckMode::TypeCheckByIndex
TypeIndexによる型チェック