VTK
vtkVariantBoostSerialization.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkVariantBoostSerialization.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 /*
16  * Copyright (C) 2008 The Trustees of Indiana University.
17  * Use, modification and distribution is subject to the Boost Software
18  * License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)
19  */
32 #ifndef __vtkVariantBoostSerialization_h
33 #define __vtkVariantBoostSerialization_h
34 
35 #include "vtkSetGet.h"
36 #include "vtkType.h"
37 #include "vtkVariant.h"
38 #include "vtkVariantArray.h"
39 
40 // This include fixes header-ordering issues in Boost.Serialization
41 // prior to Boost 1.35.0.
42 #include <boost/archive/binary_oarchive.hpp>
43 
44 #include <boost/serialization/base_object.hpp>
45 #include <boost/serialization/export.hpp>
46 #include <boost/serialization/extended_type_info_no_rtti.hpp>
47 #include <boost/serialization/split_free.hpp>
48 
49 //----------------------------------------------------------------------------
50 // vtkStdString serialization code
51 //----------------------------------------------------------------------------
52 template<typename Archiver>
53 void serialize(Archiver& ar, vtkStdString& str,
54  const unsigned int vtkNotUsed(version))
55 {
56  ar & boost::serialization::base_object<vtkstd::string>(str);
57 }
58 
59 //----------------------------------------------------------------------------
60 // vtkVariant serialization code
61 //----------------------------------------------------------------------------
62 
63 template<typename Archiver>
64 void save(Archiver& ar, const vtkVariant& variant,
65  const unsigned int vtkNotUsed(version))
66 {
67  if (!variant.IsValid())
68  {
69  char null = 0;
70  ar & null;
71  return;
72  }
73 
74  // Output the type
75  char Type = variant.GetType();
76  ar & Type;
77 
78  // Output the value
79 #define VTK_VARIANT_SAVE(Value,Type,Function) \
80  case Value: \
81  { \
82  Type value = variant.Function(); \
83  ar & value; \
84  } \
85  return
86 
87  switch (Type)
88  {
90  VTK_VARIANT_SAVE(VTK_FLOAT,float,ToFloat);
91  VTK_VARIANT_SAVE(VTK_DOUBLE,double,ToDouble);
92  VTK_VARIANT_SAVE(VTK_CHAR,char,ToChar);
93  VTK_VARIANT_SAVE(VTK_UNSIGNED_CHAR,unsigned char,ToUnsignedChar);
94  VTK_VARIANT_SAVE(VTK_SHORT,short,ToShort);
95  VTK_VARIANT_SAVE(VTK_UNSIGNED_SHORT,unsigned short,ToUnsignedShort);
96  VTK_VARIANT_SAVE(VTK_INT,int,ToInt);
97  VTK_VARIANT_SAVE(VTK_UNSIGNED_INT,unsigned int,ToUnsignedInt);
98  VTK_VARIANT_SAVE(VTK_LONG,long,ToLong);
99  VTK_VARIANT_SAVE(VTK_UNSIGNED_LONG,unsigned long,ToUnsignedLong);
100 #if defined(VTK_TYPE_USE___INT64)
101  VTK_VARIANT_SAVE(VTK___INT64,vtkTypeInt64,ToTypeInt64);
102  VTK_VARIANT_SAVE(VTK_UNSIGNED___INT64,vtkTypeUInt64,ToTypeUInt64);
103 #endif
104 #if defined(VTK_TYPE_USE_LONG_LONG)
105  VTK_VARIANT_SAVE(VTK_LONG_LONG,long long,ToLongLong);
106  VTK_VARIANT_SAVE(VTK_UNSIGNED_LONG_LONG,unsigned long long,
107  ToUnsignedLongLong);
108 #endif
109  default:
110  cerr << "cannot serialize variant with type " << variant.GetType()
111  << '\n';
112  }
113 #undef VTK_VARIANT_SAVE
114 }
115 
116 template<typename Archiver>
117 void load(Archiver& ar, vtkVariant& variant,
118  const unsigned int vtkNotUsed(version))
119 {
120  char Type;
121  ar & Type;
122 
123 #define VTK_VARIANT_LOAD(Value,Type) \
124  case Value: \
125  { \
126  Type value; \
127  ar & value; \
128  variant = vtkVariant(value); \
129  } \
130  return
131 
132  switch (Type)
133  {
134  case 0: variant = vtkVariant(); return;
139  VTK_VARIANT_LOAD(VTK_UNSIGNED_CHAR,unsigned char);
141  VTK_VARIANT_LOAD(VTK_UNSIGNED_SHORT,unsigned short);
143  VTK_VARIANT_LOAD(VTK_UNSIGNED_INT,unsigned int);
145  VTK_VARIANT_LOAD(VTK_UNSIGNED_LONG,unsigned long);
146 #if defined(VTK_TYPE_USE___INT64)
147  VTK_VARIANT_LOAD(VTK___INT64,vtkTypeInt64);
148  VTK_VARIANT_LOAD(VTK_UNSIGNED___INT64,vtkTypeUInt64);
149 #endif
150 #if defined(VTK_TYPE_USE_LONG_LONG)
151  VTK_VARIANT_LOAD(VTK_LONG_LONG,long long);
152  VTK_VARIANT_LOAD(VTK_UNSIGNED_LONG_LONG,unsigned long long);
153 #endif
154  default:
155  cerr << "cannot deserialize variant with type " << Type << '\n';
156  variant = vtkVariant();
157  }
158 #undef VTK_VARIANT_LOAD
159 }
160 
161 BOOST_SERIALIZATION_SPLIT_FREE(vtkVariant)
162 
163 //----------------------------------------------------------------------------
164 // vtkVariantArray serialization code
165 //----------------------------------------------------------------------------
166 
167 template<typename Archiver>
168 void save(Archiver& ar, const vtkVariantArray& c_array,
169  const unsigned int vtkNotUsed(version))
170 {
171  vtkVariantArray& array = const_cast<vtkVariantArray&>(c_array);
172 
173  // Array name
174  vtkStdString name;
175  if(array.GetName()!=NULL) name=array.GetName();
176  ar & name;
177 
178  // Array data
179  vtkIdType n = array.GetNumberOfTuples();
180  ar & n;
181  for (vtkIdType i = 0; i < n; ++i)
182  {
183  ar & array.GetValue(i);
184  }
185 }
186 
187 template<typename Archiver>
188 void load(Archiver& ar, vtkVariantArray& array,
189  const unsigned int vtkNotUsed(version))
190 {
191  // Array name
192  vtkStdString name;
193  ar & name;
194  array.SetName(name.c_str());
195 
196  if(name.empty())
197  {
198  array.SetName(0);
199  }
200  else
201  {
202  array.SetName(name.c_str());
203  }
204 
205  // Array data
206  vtkIdType n;
207  ar & n;
208  array.SetNumberOfTuples(n);
209  vtkVariant value;
210  for (vtkIdType i = 0; i < n; ++i)
211  {
212  ar & value;
213  array.SetValue(i, value);
214  }
215 }
216 
217 BOOST_SERIALIZATION_SPLIT_FREE(vtkVariantArray)
218 
219 #endif
Wrapper around vtkstd::string to keep symbols short.
Definition: vtkStdString.h:45
#define VTK_VARIANT_SAVE(Value, Type, Function)
void load(Archiver &ar, vtkVariant &variant, const unsigned int vtkNotUsed(version))
#define VTK_UNSIGNED_INT
Definition: vtkType.h:32
void serialize(Archiver &ar, vtkStdString &str, const unsigned int vtkNotUsed(version))
An array holding vtkVariants.
vtkIdType GetNumberOfTuples()
#define VTK_UNSIGNED_SHORT
Definition: vtkType.h:30
int vtkIdType
Definition: vtkType.h:255
#define VTK_VARIANT_LOAD(Value, Type)
#define VTK_LONG_LONG
Definition: vtkType.h:45
#define VTK_UNSIGNED___INT64
Definition: vtkType.h:53
A atomic type representing the union of many types.
Definition: vtkVariant.h:72
#define VTK_STRING
Definition: vtkType.h:41
virtual void SetName(const char *)
#define VTK_DOUBLE
Definition: vtkType.h:36
#define VTK_FLOAT
Definition: vtkType.h:35
#define VTK_SHORT
Definition: vtkType.h:29
virtual char * GetName()
#define VTK_CHAR
Definition: vtkType.h:26
#define VTK_LONG
Definition: vtkType.h:33
void SetValue(vtkIdType id, vtkVariant value)
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:28
void save(Archiver &ar, const vtkVariant &variant, const unsigned int vtkNotUsed(version))
virtual void SetNumberOfTuples(vtkIdType number)
#define VTK_UNSIGNED_LONG
Definition: vtkType.h:34
vtkVariant & GetValue(vtkIdType id) const
unsigned int GetType() const
#define VTK_UNSIGNED_LONG_LONG
Definition: vtkType.h:46
#define VTK_INT
Definition: vtkType.h:31
#define VTK___INT64
Definition: vtkType.h:49
bool IsValid() const