| //==- Serialization.h - Generic Object Serialization to Bitcode ---*- C++ -*-=// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines traits for primitive types used for both object |
| // serialization and deserialization. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_BITCODE_SERIALIZE |
| #define LLVM_BITCODE_SERIALIZE |
| |
| #include "llvm/Bitcode/SerializationFwd.h" |
| |
| namespace llvm { |
| |
| /// SerializeTrait - SerializeTrait bridges between the Serializer/Deserializer |
| /// and the functions that serialize objects of specific types. The default |
| /// behavior is to call static methods of the class for the object being |
| /// serialized, but this behavior can be changed by specializing this |
| /// template. Classes only need to implement the methods corresponding |
| /// to the serialization scheme they want to support. For example, "Read" |
| /// and "ReadVal" correspond to different deserialization schemes which make |
| /// sense for different types; a class need only implement one of them. |
| /// Serialization and deserialization of pointers are specially handled |
| /// by the Serializer and Deserializer using the EmitOwnedPtr, etc. methods. |
| /// To serialize the actual object referred to by a pointer, the class |
| /// of the object either must implement the methods called by the default |
| /// behavior of SerializeTrait, or specialize SerializeTrait. This latter |
| /// is useful when one cannot add methods to an existing class (for example). |
| template <typename T> |
| struct SerializeTrait { |
| static inline void Emit(Serializer& S, const T& X) { X.Emit(S); } |
| static inline void Read(Deserializer& D, T& X) { X.Read(D); } |
| static inline T* Create(Deserializer& D) { return T::Create(D); } |
| |
| template <typename Arg1> |
| static inline T* Create(Deserializer& D, Arg1& arg1) { |
| return T::Create(D, arg1); |
| } |
| }; |
| |
| #define SERIALIZE_INT_TRAIT(TYPE)\ |
| template <> struct SerializeTrait<TYPE> {\ |
| static void Emit(Serializer& S, TYPE X);\ |
| static void Read(Deserializer& S, TYPE& X); }; |
| |
| SERIALIZE_INT_TRAIT(bool) |
| SERIALIZE_INT_TRAIT(unsigned char) |
| SERIALIZE_INT_TRAIT(unsigned short) |
| SERIALIZE_INT_TRAIT(unsigned int) |
| SERIALIZE_INT_TRAIT(unsigned long) |
| |
| SERIALIZE_INT_TRAIT(signed char) |
| SERIALIZE_INT_TRAIT(signed short) |
| SERIALIZE_INT_TRAIT(signed int) |
| SERIALIZE_INT_TRAIT(signed long) |
| |
| #undef SERIALIZE_INT_TRAIT |
| |
| } // end namespace llvm |
| |
| #endif |