Teuchos - Trilinos Tools Package Version of the Day
Loading...
Searching...
No Matches
Teuchos_SerializationTraits.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Teuchos: Common Tools Package
5// Copyright (2004) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38//
39// ***********************************************************************
40// @HEADER
41
45#ifndef TEUCHOS_SERIALIZATION_TRAITS_HPP
46#define TEUCHOS_SERIALIZATION_TRAITS_HPP
47
50#include <climits> // SIZE_MAX, ULONG_MAX, etc.
51
52#ifdef HAVE_TEUCHOSCORE_QUADMATH
53#include <quadmath.h>
54#endif // HAVE_TEUCHOSCORE_QUADMATH
55
56#ifdef HAVE_TEUCHOS_QD
57#include <qd/dd_real.h>
58#include <qd/qd_real.h>
59#endif
60
61namespace Teuchos {
62
69template<typename T>
72 static inline T notDefined() {return(T::this_type_is_missing_a_specialization());}
73};
74
75
129template <typename Ordinal, typename T>
131public:
132
134
135
140 static const bool supportsDirectSerialization = false;
141
143
145
146
148 static Ordinal fromCountToDirectBytes(const Ordinal count) {
149 (void)count;
151 return 0;
152 }
153
155 static char* convertToCharPtr( T* ptr ) {
156 (void)ptr;
158 return 0;
159 }
160
162 static const char* convertToCharPtr( const T* ptr ) {
163 (void)ptr;
165 return 0;
166 }
167
169 static Ordinal fromDirectBytesToCount(const Ordinal bytes) {
170 (void)bytes;
172 return 0;
173 }
174
176 static T* convertFromCharPtr( char* ptr ) {
177 (void)ptr;
179 return 0;
180 }
181
183 static const T* convertFromCharPtr( const char* ptr ) {
184 (void)ptr;
186 return 0;
187 }
188
190
192
193
195 static Ordinal fromCountToIndirectBytes(const Ordinal count,
196 const T buffer[]) {
197 (void)count; (void)buffer;
199 return 0;
200 }
201
217 static void serialize (const Ordinal count,
218 const T buffer[],
219 const Ordinal bytes,
220 char charBuffer[])
221 {
222 (void)count; (void)buffer; (void)bytes; (void)charBuffer;
224 }
225
227 static Ordinal fromIndirectBytesToCount(const Ordinal bytes,
228 const char charBuffer[]) {
229 (void)bytes; (void)charBuffer;
231 return 0;
232 }
233
249 static void deserialize (const Ordinal bytes,
250 const char charBuffer[],
251 const Ordinal count,
252 T buffer[])
253 {
254 (void)bytes; (void)charBuffer; (void)count; (void)buffer;
256 }
257
259
260};
261
275template <typename Ordinal, typename T>
277
310template <typename Ordinal, typename T>
312public:
313 static const bool supportsDirectSerialization = true;
314 // Direct serialization
315 static Ordinal fromCountToDirectBytes(const Ordinal count)
316 { return sizeof(T)*count; }
317 static char* convertToCharPtr( T* ptr )
318 { return reinterpret_cast<char*>(ptr); }
319 static const char* convertToCharPtr( const T* ptr )
320 { return reinterpret_cast<const char*>(ptr); }
321 static Ordinal fromDirectBytesToCount(const Ordinal count)
322 { return count/sizeof(T); }
323 static T* convertFromCharPtr( char* ptr )
324 { return reinterpret_cast<T*>(ptr); }
325 static const T* convertFromCharPtr( const char* ptr )
326 { return reinterpret_cast<const T*>(ptr); }
327 // Indirect serialization
328 static Ordinal fromCountToIndirectBytes(const Ordinal count, const T buffer[])
329 { return fromCountToDirectBytes(count); }
330 static void serialize(
331 const Ordinal count, const T buffer[], const Ordinal bytes, char charBuffer[]
332 )
333 {
334#ifdef TEUCHOS_DEBUG
335 TEUCHOS_TEST_FOR_EXCEPT(bytes!=fromCountToDirectBytes(count));
336#else
337 (void)count;
338#endif
339 const char *_buffer = convertToCharPtr(buffer);
340 std::copy(_buffer,_buffer+bytes,charBuffer);
341 }
342 static Ordinal fromIndirectBytesToCount(const Ordinal bytes,
343 const char charBuffer[])
344 { return fromDirectBytesToCount(bytes); }
345 static void deserialize(
346 const Ordinal bytes, const char charBuffer[], const Ordinal count, T buffer[]
347 )
348 {
349#ifdef TEUCHOS_DEBUG
350 TEUCHOS_TEST_FOR_EXCEPT(count!=fromDirectBytesToCount(bytes));
351#endif
352 char *_buffer = convertToCharPtr(buffer);
353 std::copy(charBuffer,charBuffer+bytes,_buffer);
354 }
355};
356
357// Whether 'char' is signed or unsigned depends on the implementation.
358// However, on some systems (e.g., Clang 3.1 on Intel Mac), partially
359// specializing for signed char and unsigned char, but not for char,
360// does not work. Thus, we include specializations for all three
361// possibilities.
362template<typename Ordinal>
363class SerializationTraits<Ordinal,char>
364 : public DirectSerializationTraits<Ordinal,char>
365{};
366
367template<typename Ordinal>
368class SerializationTraits<Ordinal,signed char>
369 : public DirectSerializationTraits<Ordinal,signed char>
370{};
371
372template<typename Ordinal>
373class SerializationTraits<Ordinal,unsigned char>
374 : public DirectSerializationTraits<Ordinal,unsigned char>
375{};
376
377template<typename Ordinal>
378class SerializationTraits<Ordinal,short int>
379 : public DirectSerializationTraits<Ordinal,short int>
380{};
381
382template<typename Ordinal>
383class SerializationTraits<Ordinal,unsigned short int>
384 : public DirectSerializationTraits<Ordinal,unsigned short int>
385{};
386
387template<typename Ordinal>
388class SerializationTraits<Ordinal,int>
389 : public DirectSerializationTraits<Ordinal,int>
390{};
391
392template<typename Ordinal>
393class SerializationTraits<Ordinal,unsigned int>
394 : public DirectSerializationTraits<Ordinal,unsigned int>
395{};
396
397template<typename Ordinal>
398class SerializationTraits<Ordinal,long int>
399 : public DirectSerializationTraits<Ordinal,long int>
400{};
401
402template<typename Ordinal>
403class SerializationTraits<Ordinal,unsigned long int>
404 : public DirectSerializationTraits<Ordinal,long unsigned int>
405{};
406
407template<typename Ordinal>
408class SerializationTraits<Ordinal,float>
409 : public DirectSerializationTraits<Ordinal,float>
410{};
411
412template<typename Ordinal>
413class SerializationTraits<Ordinal,double>
414 : public DirectSerializationTraits<Ordinal,double>
415{};
416
417#ifdef HAVE_TEUCHOS_LONG_DOUBLE
418template<typename Ordinal>
419class SerializationTraits<Ordinal,long double>
420 : public DirectSerializationTraits<Ordinal,long double>
421{};
422#endif
423
424
425// FIXME: How do we know that P1 and P2 are directly serializable?
426template<typename Ordinal, typename P1, typename P2>
427class SerializationTraits<Ordinal,std::pair<P1,P2> >
428 : public DirectSerializationTraits<Ordinal,std::pair<P1,P2> >
429{};
430
431#ifdef HAVE_TEUCHOSCORE_QUADMATH
432template<typename Ordinal>
433class SerializationTraits<Ordinal,__float128>
434 : public DirectSerializationTraits<Ordinal,__float128>
435{};
436#endif // HAVE_TEUCHOSCORE_QUADMATH
437
438#ifdef HAVE_TEUCHOS_QD
439template<typename Ordinal>
440class SerializationTraits<Ordinal,dd_real>
441 : public DirectSerializationTraits<Ordinal,dd_real>
442{};
443
444template<typename Ordinal>
445class SerializationTraits<Ordinal,qd_real>
446 : public DirectSerializationTraits<Ordinal,qd_real>
447{};
448#endif
449
450#ifdef HAVE_TEUCHOS_COMPLEX
451
452template<typename Ordinal>
453class SerializationTraits<Ordinal,std::complex<float> >
454 : public DirectSerializationTraits<Ordinal,std::complex<float> >
455{};
456
457template<typename Ordinal>
458class SerializationTraits<Ordinal,std::complex<double> >
459 : public DirectSerializationTraits<Ordinal,std::complex<double> >
460{};
461
462#endif // HAVE_TEUCHOS_COMPLEX
463
464// Partial specialization for long long.
465// On platforms with sizeof(ptrdiff_t) <= sizeof(long long),
466// this should take care of the ptrdiff_t specialization as well,
467// since we've covered all built-in signed integer types above
468// with size <= sizeof(long long).
469template<typename Ordinal>
470class SerializationTraits<Ordinal, long long int>
471 : public DirectSerializationTraits<Ordinal, long long int>
472{};
473
474// Partial specialization for unsigned long long.
475// On platforms with sizeof(size_t) <= sizeof(unsigned long long),
476// this should take care of the size_t specialization as well,
477// since we've covered all built-in unsigned integer types above
478// with size <= sizeof(unsigned long long).
479template<typename Ordinal>
480class SerializationTraits<Ordinal, unsigned long long int>
481 : public DirectSerializationTraits<Ordinal, unsigned long long int>
482{};
483
484} // namespace Teuchos
485
486#endif // TEUCHOS_SERIALIZATION_TRAITS_HPP
Teuchos header file which uses auto-configuration information to include necessary C++ headers.
Standard test and throw macros.
Serialization traits for objects that support direct serialization.
Serialization traits class for types T that use value semantics.
static const bool supportsDirectSerialization
Whether the type T supports direct serialization.
static void serialize(const Ordinal count, const T buffer[], const Ordinal bytes, char charBuffer[])
Serialize to an indirect char[] buffer.
static Ordinal fromIndirectBytesToCount(const Ordinal bytes, const char charBuffer[])
Return the number of objects for bytes of storage.
static Ordinal fromCountToDirectBytes(const Ordinal count)
Return the number of bytes for count objects.
static Ordinal fromDirectBytesToCount(const Ordinal bytes)
Return the number of objects for bytes of storage.
static void deserialize(const Ordinal bytes, const char charBuffer[], const Ordinal count, T buffer[])
Deserialize from an indirect char[] buffer.
static char * convertToCharPtr(T *ptr)
Convert the pointer type to char*.
static T * convertFromCharPtr(char *ptr)
Convert the pointer type from char*.
static const char * convertToCharPtr(const T *ptr)
Convert the pointer type to const char*.
static const T * convertFromCharPtr(const char *ptr)
Convert the pointer type from char*.
static Ordinal fromCountToIndirectBytes(const Ordinal count, const T buffer[])
Return the number of bytes for count objects.
Serialization class for types T that use value semantics.
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
This macro is designed to be a short version of TEUCHOS_TEST_FOR_EXCEPTION() that is easier to call.
The Teuchos namespace contains all of the classes, structs and enums used by Teuchos,...
Report an error if a specialization of SerializationTraits is missing.
static T notDefined()
This function should not compile if there is an attempt to instantiate!