1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef MOJO_PUBLIC_BINDINGS_LIB_BINDINGS_INTERNAL_H_ 6 #define MOJO_PUBLIC_BINDINGS_LIB_BINDINGS_INTERNAL_H_ 7 8 #include "mojo/public/system/core_cpp.h" 9 10 namespace mojo { 11 template <typename T, typename U> class TypeConverter {}; 12 13 namespace internal { 14 template <typename T> class Array_Data; 15 16 #pragma pack(push, 1) 17 18 struct StructHeader { 19 uint32_t num_bytes; 20 uint32_t num_fields; 21 }; 22 MOJO_COMPILE_ASSERT(sizeof(StructHeader) == 8, bad_sizeof_StructHeader); 23 24 struct ArrayHeader { 25 uint32_t num_bytes; 26 uint32_t num_elements; 27 }; 28 MOJO_COMPILE_ASSERT(sizeof(ArrayHeader) == 8, bad_sizeof_ArrayHeader); 29 30 template <typename T> 31 union StructPointer { 32 uint64_t offset; 33 T* ptr; 34 }; 35 MOJO_COMPILE_ASSERT(sizeof(StructPointer<char>) == 8, bad_sizeof_StructPointer); 36 37 template <typename T> 38 union ArrayPointer { 39 uint64_t offset; 40 Array_Data<T>* ptr; 41 }; 42 MOJO_COMPILE_ASSERT(sizeof(ArrayPointer<char>) == 8, bad_sizeof_ArrayPointer); 43 44 union StringPointer { 45 uint64_t offset; 46 Array_Data<char>* ptr; 47 }; 48 MOJO_COMPILE_ASSERT(sizeof(StringPointer) == 8, bad_sizeof_StringPointer); 49 50 #pragma pack(pop) 51 52 template <typename T> ResetIfNonNull(T * ptr)53void ResetIfNonNull(T* ptr) { 54 if (ptr) 55 *ptr = T(); 56 } 57 58 template <typename T> FetchAndReset(T * ptr)59T FetchAndReset(T* ptr) { 60 T temp = *ptr; 61 *ptr = T(); 62 return temp; 63 } 64 65 template <typename T> 66 class WrapperHelper { 67 public: Wrap(const typename T::Data * data)68 static const T Wrap(const typename T::Data* data) { 69 return T(typename T::Wrap(), const_cast<typename T::Data*>(data)); 70 } Unwrap(const T & object)71 static typename T::Data* Unwrap(const T& object) { 72 return const_cast<typename T::Data*>(object.data_); 73 } 74 }; 75 76 template <typename Data> Wrap(const Data * data)77inline const typename Data::Wrapper Wrap(const Data* data) { 78 return WrapperHelper<typename Data::Wrapper>::Wrap(data); 79 } 80 81 template <typename T> Unwrap(const T & object)82inline typename T::Data* Unwrap(const T& object) { 83 return WrapperHelper<T>::Unwrap(object); 84 } 85 86 template <typename T> struct TypeTraits { 87 static const bool kIsObject = true; 88 }; 89 template <> struct TypeTraits<bool> { 90 static const bool kIsObject = false; 91 }; 92 template <> struct TypeTraits<char> { 93 static const bool kIsObject = false; 94 }; 95 template <> struct TypeTraits<int8_t> { 96 static const bool kIsObject = false; 97 }; 98 template <> struct TypeTraits<int16_t> { 99 static const bool kIsObject = false; 100 }; 101 template <> struct TypeTraits<int32_t> { 102 static const bool kIsObject = false; 103 }; 104 template <> struct TypeTraits<int64_t> { 105 static const bool kIsObject = false; 106 }; 107 template <> struct TypeTraits<uint8_t> { 108 static const bool kIsObject = false; 109 }; 110 template <> struct TypeTraits<uint16_t> { 111 static const bool kIsObject = false; 112 }; 113 template <> struct TypeTraits<uint32_t> { 114 static const bool kIsObject = false; 115 }; 116 template <> struct TypeTraits<uint64_t> { 117 static const bool kIsObject = false; 118 }; 119 template <> struct TypeTraits<float> { 120 static const bool kIsObject = false; 121 }; 122 template <> struct TypeTraits<double> { 123 static const bool kIsObject = false; 124 }; 125 template <> struct TypeTraits<Handle> { 126 static const bool kIsObject = false; 127 }; 128 template <> struct TypeTraits<MessagePipeHandle> { 129 static const bool kIsObject = false; 130 }; 131 132 template <typename T> class ObjectTraits {}; 133 134 } // namespace internal 135 } // namespace mojo 136 137 #endif // MOJO_PUBLIC_BINDINGS_LIB_BINDINGS_INTERNAL_H_ 138