diff options
Diffstat (limited to 'cpp/src/qpid/amqp_0_10')
| -rw-r--r-- | cpp/src/qpid/amqp_0_10/Codec.h | 187 | ||||
| -rw-r--r-- | cpp/src/qpid/amqp_0_10/Decimal.h | 52 | ||||
| -rw-r--r-- | cpp/src/qpid/amqp_0_10/built_in_types.h | 103 |
3 files changed, 342 insertions, 0 deletions
diff --git a/cpp/src/qpid/amqp_0_10/Codec.h b/cpp/src/qpid/amqp_0_10/Codec.h new file mode 100644 index 0000000000..e7f35e9288 --- /dev/null +++ b/cpp/src/qpid/amqp_0_10/Codec.h @@ -0,0 +1,187 @@ +#ifndef QPID_AMQP_0_10_CODEC_H +#define QPID_AMQP_0_10_CODEC_H + +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +#include "built_in_types.h" +#include "qpid/Serializer.h" +#include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/is_float.hpp> +#include <boost/type_traits/is_arithmetic.hpp> +#include <boost/detail/endian.hpp> +#include <boost/ref.hpp> + +namespace qpid { +namespace amqp_0_10 { + +/** + * AMQP 0-10 encoding and decoding. + */ +struct Codec +{ + template <class T> + static inline void endianize(T& value) { + +#ifdef BOOST_LITTLE_ENDIAN + std::reverse((char*)&value, (char*)&value+sizeof(value)); +#else + (void)value; // Avoid unused var warnings. +#endif + } + static inline void endianize(char&) {} + static inline void endianize(uint8_t&) {} + static inline void endianize(int8_t&) {} + + + template <class Out> struct Encode : public ConstSerializer<Encode<Out> > { + Out out; + + Encode(Out o) : out(o) {} + + using ConstSerializer<Encode<Out> >::operator(); + using ConstSerializer<Encode<Out> >::raw; + + template <class T> + typename boost::enable_if<boost::is_integral<T>, Encode&>::type + operator()(const T& x) { T xx(x); endianize(xx); return raw(xx); } + + // FIXME aconway 2008-02-20: correct float encoading + template <class T> + typename boost::enable_if<boost::is_float<T>, Encode&>::type + operator()(const T& x) { return raw(x); } + + + template<class T, class SizeType> + Encode& operator()(const CodableString<T,SizeType>& str) { + (*this)(SizeType(str.size())); + std::for_each(str.begin(), str.end(), *this); + return *this; + } + + private: + friend class ConstSerializer<Encode<Out> >; + + Encode& raw(const void* vp, size_t s) { + char* p = (char*) vp; + std::copy(p, p+s, out); + return *this; + } + + Encode& byte(char x) { out++ = x; return *this; } + }; + + template <class In> struct Decode : public Serializer<Decode<In> > { + In in; + Decode(In i) : in(i) {} + + using Serializer<Decode<In> >::operator(); + using Serializer<Decode<In> >::raw; + + template <class T> + typename boost::enable_if<boost::is_integral<T>, Decode&>::type + operator()(T& x) { + raw(&x, sizeof(x)); + endianize(x); + return *this; + } + + template <class T> + typename boost::enable_if<boost::is_float<T>, Decode&>::type + operator()(T& x) { return raw(&x, sizeof(x)); } + + template<class T, class SizeType> + Decode& operator()(CodableString<T,SizeType>& str) { + SizeType n; + (*this)(n); + str.resize(n); + std::for_each(str.begin(), str.end(), *this); + return *this; + } + + private: + friend class Serializer<Decode<In> >; + + Decode& raw(void* vp, size_t s) { + char* p=(char*)vp; + std::copy(in, in+s, p); + return *this; + } + + Decode& byte(char& x) { x = *in++; return *this; } + }; + + struct Size : public ConstSerializer<Size> { + Size() : size(0) {} + size_t size; + operator size_t() const { return size; } + + using ConstSerializer<Size>::operator(); + using ConstSerializer<Size>::raw; + + template <class T> + typename boost::enable_if<boost::is_arithmetic<T>, Size&>::type + operator()(const T&) { size += sizeof(T); return *this; } + + template <class T, size_t N> + Size& operator()(const boost::array<T,N>&) { + size += sizeof(boost::array<T,N>); + return *this; + } + + template<class T, class SizeType> + Size& operator()(const CodableString<T,SizeType>& str) { + size += sizeof(SizeType) + str.size()*sizeof(T); + return *this; + } + + + private: + friend class ConstSerializer<Size>; + + Size& raw(void*, size_t s) { size += s; return *this; } + + Size& byte(char) { ++size; return *this; } + }; + + template <class Out, class T> + static void encode(Out o, const T& x) { + Encode<Out>encode(o); + encode(x); + } + + template <class In, class T> + static void decode(In i, T& x) { + Decode<In> decode(i); + decode(x); + } + + template <class T> + static size_t size(const T& x) { + Size sz; + sz(x); + return sz; + } +}; + +}} // namespace qpid::amqp_0_10 + +#endif /*!QPID_AMQP_0_10_CODEC_H*/ diff --git a/cpp/src/qpid/amqp_0_10/Decimal.h b/cpp/src/qpid/amqp_0_10/Decimal.h new file mode 100644 index 0000000000..75cde94559 --- /dev/null +++ b/cpp/src/qpid/amqp_0_10/Decimal.h @@ -0,0 +1,52 @@ +#ifndef TESTS_DECIMAL_H +#define TESTS_DECIMAL_H + +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ +#include <ostream> + +namespace qpid { +namespace amqp_0_10 { + +template <class E, class M> struct Decimal { + E exponent; + M mantissa; + + Decimal() : exponent(0), mantissa(0) {} + + bool operator==(const Decimal& d) const { + return exponent == d.exponent && mantissa == d.mantissa; + } + + // TODO aconway 2008-02-20: We could provide arithmetic operators + // if anybody really cares about this type. + + template <class S> void serialize(S& s) { s(exponent)(mantissa); } +}; + +template<class E, class M> +inline std::ostream& operator<<(std::ostream& o, const Decimal<E,M>& d) { + M pow10=10^d.exponent; + return o << d.mantissa/pow10 << "." << d.mantissa%pow10; +} +}} + +#endif /*!TESTS_DECIMAL_H*/ diff --git a/cpp/src/qpid/amqp_0_10/built_in_types.h b/cpp/src/qpid/amqp_0_10/built_in_types.h new file mode 100644 index 0000000000..6cd9c72367 --- /dev/null +++ b/cpp/src/qpid/amqp_0_10/built_in_types.h @@ -0,0 +1,103 @@ +#ifndef QPID_AMQP_0_10_BUILT_IN_TYPES_H +#define QPID_AMQP_0_10_BUILT_IN_TYPES_H +// FIXME aconway 2008-02-20: separate _fwd.h from full include. +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +#include "Decimal.h" +#include "qpid/framing/SequenceNumber.h" +#include "qpid/framing/Uuid.h" +#include "qpid/sys/Time.h" +#include <boost/array.hpp> +#include <stdint.h> +#include <string> + +/**@file Mapping from built-in AMQP types to C++ types */ + +namespace qpid { +namespace amqp_0_10 { + +// Fixed size types +typedef void Void; + +typedef bool Bit; +typedef bool Boolean; +typedef char Char; +typedef int16_t Int16; +typedef int32_t Int32; +typedef int64_t Int64; +typedef int8_t Int8; +typedef uint16_t Uint16; +typedef uint32_t CharUtf32 ; +typedef uint32_t Uint32; +typedef uint64_t Uint64; +typedef uint8_t Bin8; +typedef uint8_t Uint8; + +typedef boost::array<uint8_t,128> Bin1024; +typedef boost::array<uint8_t,16> Bin128; +typedef boost::array<uint8_t,2> Bin16; +typedef boost::array<uint8_t,32> Bin256; +typedef boost::array<uint8_t,4> Bin32; +typedef boost::array<uint8_t,5> Bin40; +typedef boost::array<uint8_t,64> Bin512; +typedef boost::array<uint8_t,8> Bin64; +typedef boost::array<uint8_t,9> Bin72; + +typedef double Double; +typedef float Float; +typedef framing::SequenceNumber SequenceNo; +using framing::Uuid; +typedef sys::AbsTime DateTime; + +typedef Decimal<Uint8, Int32> Dec32; +typedef Decimal<Uint8, Int64> Dec64; + + +/** Template for length-prefixed strings/arrays. */ +template <class T, class SizeType> +struct CodableString : public std::basic_string<T> {}; + +// Variable width types +typedef CodableString<Uint8, Uint8> Vbin8; +typedef CodableString<char, Uint8> Str8Latin; +typedef CodableString<char, Uint8> Str8; +typedef CodableString<Uint16, Uint8> Str8Utf16; + +typedef CodableString<Uint8, Uint16> Vbin16; +typedef CodableString<char, Uint16> Str16Latin; +typedef CodableString<char, Uint16> Str16; +typedef CodableString<Uint16, Uint16> Str16Utf16; + +typedef CodableString<Uint8, Uint32> Vbin32; + +/** FIXME aconway 2008-02-20: todo +byte-ranges 2 byte ranges within a 64-bit payload +sequence-set 2 ranged set representation +map 0xa8 4 a mapping of keys to typed values +list 0xa9 4 a series of consecutive type-value pairs +array 0xaa 4 a defined length collection of values of a single type +struct32 0xab 4 a coded struct with a 32-bit size +*/ + +}} // namespace qpid::amqp_0_10 + +#endif /*!QPID_AMQP_0_10_BUILT_IN_TYPES_H*/ |