Qpid Proton C++  0.13.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
encoder.hpp
1 #ifndef PROTON_CODEC_ENCODER_HPP
2 #define PROTON_CODEC_ENCODER_HPP
3 
4 /*
5  *
6  * Licensed to the Apache Software Foundation (ASF) under one
7  * or more contributor license agreements. See the NOTICE file
8  * distributed with this work for additional information
9  * regarding copyright ownership. The ASF licenses this file
10  * to you under the Apache License, Version 2.0 (the
11  * "License"); you may not use this file except in compliance
12  * with the License. You may obtain a copy of the License at
13  *
14  * http://www.apache.org/licenses/LICENSE-2.0
15  *
16  * Unless required by applicable law or agreed to in writing,
17  * software distributed under the License is distributed on an
18  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19  * KIND, either express or implied. See the License for the
20  * specific language governing permissions and limitations
21  * under the License.
22  *
23  */
24 
25 #include "./data.hpp"
26 #include "../internal/type_traits.hpp"
27 #include "../types_fwd.hpp"
28 
29 namespace proton {
30 
31 namespace internal{
32 class scalar_base;
33 class value_base;
34 }
35 
36 namespace codec {
37 
44 class encoder : public data {
45  public:
47  explicit encoder(const data& d) : data(d) {}
48 
50  PN_CPP_EXTERN explicit encoder(internal::value_base& v);
51 
60  PN_CPP_EXTERN bool encode(char* buffer, size_t& size);
61 
64  PN_CPP_EXTERN void encode(std::string&);
65 
68  PN_CPP_EXTERN std::string encode();
69 
72  PN_CPP_EXTERN encoder& operator<<(bool);
73  PN_CPP_EXTERN encoder& operator<<(uint8_t);
74  PN_CPP_EXTERN encoder& operator<<(int8_t);
75  PN_CPP_EXTERN encoder& operator<<(uint16_t);
76  PN_CPP_EXTERN encoder& operator<<(int16_t);
77  PN_CPP_EXTERN encoder& operator<<(uint32_t);
78  PN_CPP_EXTERN encoder& operator<<(int32_t);
79  PN_CPP_EXTERN encoder& operator<<(wchar_t);
80  PN_CPP_EXTERN encoder& operator<<(uint64_t);
81  PN_CPP_EXTERN encoder& operator<<(int64_t);
82  PN_CPP_EXTERN encoder& operator<<(timestamp);
83  PN_CPP_EXTERN encoder& operator<<(float);
84  PN_CPP_EXTERN encoder& operator<<(double);
85  PN_CPP_EXTERN encoder& operator<<(decimal32);
86  PN_CPP_EXTERN encoder& operator<<(decimal64);
87  PN_CPP_EXTERN encoder& operator<<(decimal128);
88  PN_CPP_EXTERN encoder& operator<<(const uuid&);
89  PN_CPP_EXTERN encoder& operator<<(const std::string&);
90  PN_CPP_EXTERN encoder& operator<<(const symbol&);
91  PN_CPP_EXTERN encoder& operator<<(const binary&);
92  PN_CPP_EXTERN encoder& operator<<(const internal::scalar_base&);
93  PN_CPP_EXTERN encoder& operator<<(const null&);
95 
100  PN_CPP_EXTERN encoder& operator<<(const internal::value_base&);
101 
103  PN_CPP_EXTERN encoder& operator<<(const start&);
104 
106  PN_CPP_EXTERN encoder& operator<<(const finish&);
107 
109 
110  // Undefined template to prevent pointers being implicitly converted to bool.
111  template <class T> void* operator<<(const T*);
112 
113  template <class T> struct list_cref { T& ref; list_cref(T& r) : ref(r) {} };
114  template <class T> struct map_cref { T& ref; map_cref(T& r) : ref(r) {} };
115 
116  template <class T> struct array_cref {
117  start array_start;
118  T& ref;
119  array_cref(T& r, type_id el, bool described) : array_start(ARRAY, el, described), ref(r) {}
120  };
121 
122  template <class T> static list_cref<T> list(T& x) { return list_cref<T>(x); }
123  template <class T> static map_cref<T> map(T& x) { return map_cref<T>(x); }
124  template <class T> static array_cref<T> array(T& x, type_id element, bool described=false) {
125  return array_cref<T>(x, element, described);
126  }
127 
128  template <class T> encoder& operator<<(const map_cref<T>& x) {
129  state_guard sg(*this);
130  *this << start::map();
131  for (typename T::const_iterator i = x.ref.begin(); i != x.ref.end(); ++i)
132  *this << i->first << i->second;
133  *this << finish();
134  return *this;
135  }
136 
137  template <class T> encoder& operator<<(const list_cref<T>& x) {
138  state_guard sg(*this);
139  *this << start::list();
140  for (typename T::const_iterator i = x.ref.begin(); i != x.ref.end(); ++i)
141  *this << *i;
142  *this << finish();
143  return *this;
144  }
145 
146  template <class T> encoder& operator<<(const array_cref<T>& x) {
147  state_guard sg(*this);
148  *this << x.array_start;
149  for (typename T::const_iterator i = x.ref.begin(); i != x.ref.end(); ++i)
150  *this << *i;
151  *this << finish();
152  return *this;
153  }
155 
156  private:
157  template<class T, class U> encoder& insert(const T& x, int (*put)(pn_data_t*, U));
158  void check(long result);
159 };
160 
162 inline encoder& operator<<(encoder& e, const char* s) { return e << std::string(s); }
163 
165 template <class T> typename internal::enable_if<internal::is_unknown_integer<T>::value, encoder&>::type
166 operator<<(encoder& e, T i) {
167  using namespace internal;
168  return e << static_cast<typename integer_type<sizeof(T), is_signed<T>::value>::type>(i);
169 }
170 
172 
173 namespace is_encodable_impl { // Protected the world from wildcard operator<<
174 
175 using namespace internal;
176 
177 sfinae::no operator<<(sfinae::wildcard, sfinae::wildcard); // Fallback
178 
179 template<typename T> struct is_encodable : public sfinae {
180  static yes test(encoder);
181  static no test(...); // Failed test, no match.
182  static encoder &e;
183  static const T& t;
184  static bool const value = sizeof(test(e << t)) == sizeof(yes);
185 };
186 
187 // Avoid recursion
188 template <> struct is_encodable<value> : public true_type {};
189 
190 } // is_encodable_impl
191 
192 using is_encodable_impl::is_encodable;
193 
195 
196 } // codec
197 } // proton
198 
199 #endif
Experimental - Start encoding a complex type.
Definition: data.hpp:105
Experimental - Stream-like encoder from AMQP bytes to C++ values.
Definition: encoder.hpp:44
A sequence of values of the same type.
Definition: type_id.hpp:61
encoder & operator<<(encoder &e, const std::deque< T, A > &x)
std::deque&lt;T&gt; for most T is encoded as an amqp::ARRAY (same type elements)
Definition: deque.hpp:34
A 16-byte universally unique identifier.
Definition: uuid.hpp:34
64-bit decimal floating point.
Definition: decimal.hpp:51
encoder(const data &d)
Wrap Proton-C data object.
Definition: encoder.hpp:47
A std::string that represents the AMQP symbol type.
Definition: symbol.hpp:30
Arbitrary binary data.
Definition: binary.hpp:34
128-bit decimal floating point.
Definition: decimal.hpp:54
type_id
An identifier for AMQP types.
Definition: type_id.hpp:38
32-bit decimal floating point.
Definition: decimal.hpp:48
A 64-bit timestamp in milliseconds since the Unix epoch.
Definition: timestamp.hpp:30
A holder for any AMQP value, simple or complex.
Definition: value.hpp:69
std::string encode()
Encode the current values into a std::string.
Experimental - Finish inserting or extracting a complex type.
Definition: data.hpp:128