Teuchos - Trilinos Tools Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
48 #include "Teuchos_ConfigDefs.hpp"
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 
61 namespace Teuchos {
62 
69 template<typename T>
72  static inline T notDefined() {return(T::this_type_is_missing_a_specialization());}
73 };
74 
75 
129 template <typename Ordinal, typename T>
131 public:
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 
275 template <typename Ordinal, typename T>
277 
310 template <typename Ordinal, typename T>
312 public:
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.
362 template<typename Ordinal>
363 class SerializationTraits<Ordinal,char>
364  : public DirectSerializationTraits<Ordinal,char>
365 {};
366 
367 template<typename Ordinal>
368 class SerializationTraits<Ordinal,signed char>
369  : public DirectSerializationTraits<Ordinal,signed char>
370 {};
371 
372 template<typename Ordinal>
373 class SerializationTraits<Ordinal,unsigned char>
374  : public DirectSerializationTraits<Ordinal,unsigned char>
375 {};
376 
377 template<typename Ordinal>
378 class SerializationTraits<Ordinal,short int>
379  : public DirectSerializationTraits<Ordinal,short int>
380 {};
381 
382 template<typename Ordinal>
383 class SerializationTraits<Ordinal,unsigned short int>
384  : public DirectSerializationTraits<Ordinal,unsigned short int>
385 {};
386 
387 template<typename Ordinal>
388 class SerializationTraits<Ordinal,int>
389  : public DirectSerializationTraits<Ordinal,int>
390 {};
391 
392 template<typename Ordinal>
393 class SerializationTraits<Ordinal,unsigned int>
394  : public DirectSerializationTraits<Ordinal,unsigned int>
395 {};
396 
397 template<typename Ordinal>
398 class SerializationTraits<Ordinal,long int>
399  : public DirectSerializationTraits<Ordinal,long int>
400 {};
401 
402 template<typename Ordinal>
403 class SerializationTraits<Ordinal,unsigned long int>
404  : public DirectSerializationTraits<Ordinal,long unsigned int>
405 {};
406 
407 template<typename Ordinal>
408 class SerializationTraits<Ordinal,float>
409  : public DirectSerializationTraits<Ordinal,float>
410 {};
411 
412 template<typename Ordinal>
413 class SerializationTraits<Ordinal,double>
414  : public DirectSerializationTraits<Ordinal,double>
415 {};
416 
417 #ifdef HAVE_TEUCHOS_LONG_DOUBLE
418 template<typename Ordinal>
419 class 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?
426 template<typename Ordinal, typename P1, typename P2>
427 class SerializationTraits<Ordinal,std::pair<P1,P2> >
428  : public DirectSerializationTraits<Ordinal,std::pair<P1,P2> >
429 {};
430 
431 #ifdef HAVE_TEUCHOSCORE_QUADMATH
432 template<typename Ordinal>
433 class SerializationTraits<Ordinal,__float128>
434  : public DirectSerializationTraits<Ordinal,__float128>
435 {};
436 #endif // HAVE_TEUCHOSCORE_QUADMATH
437 
438 #ifdef HAVE_TEUCHOS_QD
439 template<typename Ordinal>
440 class SerializationTraits<Ordinal,dd_real>
441  : public DirectSerializationTraits<Ordinal,dd_real>
442 {};
443 
444 template<typename Ordinal>
445 class SerializationTraits<Ordinal,qd_real>
446  : public DirectSerializationTraits<Ordinal,qd_real>
447 {};
448 #endif
449 
450 #ifdef HAVE_TEUCHOS_COMPLEX
451 
452 template<typename Ordinal>
453 class SerializationTraits<Ordinal,std::complex<float> >
454  : public DirectSerializationTraits<Ordinal,std::complex<float> >
455 {};
456 
457 template<typename Ordinal>
458 class 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).
469 template<typename Ordinal>
470 class 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).
479 template<typename Ordinal>
480 class 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
Serialization traits for objects that support direct serialization.
static char * convertToCharPtr(T *ptr)
Convert the pointer type to char*.
static const char * convertToCharPtr(const T *ptr)
Convert the pointer type to const char*.
static T notDefined()
This function should not compile if there is an attempt to instantiate!
static Ordinal fromCountToIndirectBytes(const Ordinal count, const T buffer[])
Return the number of bytes for count objects.
static const bool supportsDirectSerialization
Whether the type T supports direct serialization.
Teuchos header file which uses auto-configuration information to include necessary C++ headers...
static void deserialize(const Ordinal bytes, const char charBuffer[], const Ordinal count, T buffer[])
Deserialize from an indirect char[] buffer.
Serialization class for types T that use value semantics.
static Ordinal fromIndirectBytesToCount(const Ordinal bytes, const char charBuffer[])
Return the number of objects for bytes of storage.
static T * convertFromCharPtr(char *ptr)
Convert the pointer type from char*.
static const T * convertFromCharPtr(const char *ptr)
Convert the pointer type from char*.
Report an error if a specialization of SerializationTraits is missing.
Serialization traits class for types T that use value semantics.
Standard test and throw macros.
static Ordinal fromDirectBytesToCount(const Ordinal bytes)
Return the number of objects for bytes of storage.
static void serialize(const Ordinal count, const T buffer[], const Ordinal bytes, char charBuffer[])
Serialize to an indirect char[] buffer.
#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...
static Ordinal fromCountToDirectBytes(const Ordinal count)
Return the number of bytes for count objects.