Return-Path: X-Original-To: apmail-qpid-commits-archive@www.apache.org Delivered-To: apmail-qpid-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id A303518C51 for ; Tue, 29 Dec 2015 21:00:53 +0000 (UTC) Received: (qmail 64731 invoked by uid 500); 29 Dec 2015 21:00:53 -0000 Delivered-To: apmail-qpid-commits-archive@qpid.apache.org Received: (qmail 64647 invoked by uid 500); 29 Dec 2015 21:00:53 -0000 Mailing-List: contact commits-help@qpid.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@qpid.apache.org Delivered-To: mailing list commits@qpid.apache.org Received: (qmail 64629 invoked by uid 99); 29 Dec 2015 21:00:53 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 29 Dec 2015 21:00:53 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id F350CE05DB; Tue, 29 Dec 2015 21:00:52 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: aconway@apache.org To: commits@qpid.apache.org Date: Tue, 29 Dec 2015 21:00:52 -0000 Message-Id: X-Mailer: ASF-Git Admin Mailer Subject: [1/4] qpid-proton git commit: PROTON-1085: c++: Rename "atom" type to "scalar". Repository: qpid-proton Updated Branches: refs/heads/master fd52a332f -> 117bb7cb0 PROTON-1085: c++: Rename "atom" type to "scalar". Scalar is the term used in the AMQP standard. Project: http://git-wip-us.apache.org/repos/asf/qpid-proton/repo Commit: http://git-wip-us.apache.org/repos/asf/qpid-proton/commit/d2c5a5f2 Tree: http://git-wip-us.apache.org/repos/asf/qpid-proton/tree/d2c5a5f2 Diff: http://git-wip-us.apache.org/repos/asf/qpid-proton/diff/d2c5a5f2 Branch: refs/heads/master Commit: d2c5a5f2017ed95102b03b173ad050e616fab30b Parents: fd52a33 Author: Alan Conway Authored: Mon Dec 28 15:37:23 2015 -0500 Committer: Alan Conway Committed: Tue Dec 29 15:55:38 2015 -0500 ---------------------------------------------------------------------- proton-c/bindings/cpp/CMakeLists.txt | 4 +- proton-c/bindings/cpp/include/proton/atom.hpp | 122 ------------ proton-c/bindings/cpp/include/proton/scalar.hpp | 122 ++++++++++++ proton-c/bindings/cpp/include/proton/types.hpp | 14 +- proton-c/bindings/cpp/src/atom.cpp | 185 ------------------- proton-c/bindings/cpp/src/atom_test.cpp | 105 ----------- proton-c/bindings/cpp/src/scalar.cpp | 185 +++++++++++++++++++ proton-c/bindings/cpp/src/scalar_test.cpp | 105 +++++++++++ proton-c/bindings/cpp/src/types.cpp | 18 +- 9 files changed, 430 insertions(+), 430 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/CMakeLists.txt b/proton-c/bindings/cpp/CMakeLists.txt index 78df0b5..10d40f8 100644 --- a/proton-c/bindings/cpp/CMakeLists.txt +++ b/proton-c/bindings/cpp/CMakeLists.txt @@ -26,7 +26,7 @@ include_directories( set(qpid-proton-cpp-source src/acceptor.cpp - src/atom.cpp + src/scalar.cpp src/blocking_connection.cpp src/blocking_connection_impl.cpp src/blocking_fetcher.cpp @@ -170,4 +170,4 @@ endmacro(add_cpp_test) add_cpp_test(interop_test ${CMAKE_SOURCE_DIR}/tests) add_cpp_test(message_test) add_cpp_test(encode_decode_test) -add_cpp_test(atom_test) +add_cpp_test(scalar_test) http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/include/proton/atom.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/atom.hpp b/proton-c/bindings/cpp/include/proton/atom.hpp deleted file mode 100644 index ce2a385..0000000 --- a/proton-c/bindings/cpp/include/proton/atom.hpp +++ /dev/null @@ -1,122 +0,0 @@ -#ifndef ATOM_HPP -#define ATOM_HPP -/* - * 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 "proton/types.hpp" -#include - -namespace proton { - -class atom; - -/** atom holds an instance of an atomic proton type. */ -class atom : public comparable { - public: - PN_CPP_EXTERN atom(); - // Use default assign and copy. - - /// Type for the value in the atom, NULL_TYPE if empty() - PN_CPP_EXTERN type_id type() const; - /// True if the atom is empty. - PN_CPP_EXTERN bool empty() const; - - ///@name Create an atom, type() is deduced from the C++ type of the value. - ///@{ - PN_CPP_EXTERN explicit atom(bool); - PN_CPP_EXTERN explicit atom(uint8_t); - PN_CPP_EXTERN explicit atom(int8_t); - PN_CPP_EXTERN explicit atom(uint16_t); - PN_CPP_EXTERN explicit atom(int16_t); - PN_CPP_EXTERN explicit atom(uint32_t); - PN_CPP_EXTERN explicit atom(int32_t); - PN_CPP_EXTERN explicit atom(uint64_t); - PN_CPP_EXTERN explicit atom(int64_t); - PN_CPP_EXTERN explicit atom(wchar_t); - PN_CPP_EXTERN explicit atom(float); - PN_CPP_EXTERN explicit atom(double); - PN_CPP_EXTERN explicit atom(amqp_timestamp); - PN_CPP_EXTERN explicit atom(const amqp_decimal32&); - PN_CPP_EXTERN explicit atom(const amqp_decimal64&); - PN_CPP_EXTERN explicit atom(const amqp_decimal128&); - PN_CPP_EXTERN explicit atom(const amqp_uuid&); - PN_CPP_EXTERN explicit atom(const amqp_string&); - PN_CPP_EXTERN explicit atom(const amqp_symbol&); - PN_CPP_EXTERN explicit atom(const amqp_binary&); - PN_CPP_EXTERN explicit atom(const std::string& s); ///< Treated as an AMQP string - PN_CPP_EXTERN explicit atom(const char* s); ///< Treated as an AMQP string - ///@} - - /// Assign to an atom using the same rules as construction. - template atom& operator=(T x) { return *this = atom(x); } - - ///@name get(T&) extracts the value if the types match exactly, - ///i.e. if `type() == type_id_of::value` - /// throws type_mismatch otherwise. - ///@{ - PN_CPP_EXTERN void get(bool&) const; - PN_CPP_EXTERN void get(uint8_t&) const; - PN_CPP_EXTERN void get(int8_t&) const; - PN_CPP_EXTERN void get(uint16_t&) const; - PN_CPP_EXTERN void get(int16_t&) const; - PN_CPP_EXTERN void get(uint32_t&) const; - PN_CPP_EXTERN void get(int32_t&) const; - PN_CPP_EXTERN void get(uint64_t&) const; - PN_CPP_EXTERN void get(int64_t&) const; - PN_CPP_EXTERN void get(wchar_t&) const; - PN_CPP_EXTERN void get(float&) const; - PN_CPP_EXTERN void get(double&) const; - PN_CPP_EXTERN void get(amqp_timestamp&) const; - PN_CPP_EXTERN void get(amqp_decimal32&) const; - PN_CPP_EXTERN void get(amqp_decimal64&) const; - PN_CPP_EXTERN void get(amqp_decimal128&) const; - PN_CPP_EXTERN void get(amqp_uuid&) const; - PN_CPP_EXTERN void get(amqp_string&) const; - PN_CPP_EXTERN void get(amqp_symbol&) const; - PN_CPP_EXTERN void get(amqp_binary&) const; - PN_CPP_EXTERN void get(std::string&) const; ///< Treated as an AMQP string - ///@} - - ///@ get() is like get(T&) but returns the value.. - template T get() const { T x; get(x); return x; } - - ///@name as_ methods do "loose" conversion, they will convert the atom's - ///value to the requested type if possible, else throw type_mismatch - ///@{ - PN_CPP_EXTERN int64_t as_int() const; ///< Allowed if type_id_integral(type()) - PN_CPP_EXTERN uint64_t as_uint() const; ///< Allowed if type_id_integral(type()) - PN_CPP_EXTERN double as_double() const; ///< Allowed if type_id_floating_point(type()) - PN_CPP_EXTERN std::string as_string() const; ///< Allowed if type_id_string_like(type()) - ///@} - - PN_CPP_EXTERN bool operator==(const atom& x) const; - /// Note if the values are of different type(), operator< will compare the type() - PN_CPP_EXTERN bool operator<(const atom& x) const; - - PN_CPP_EXTERN friend std::ostream& operator<<(std::ostream&, const atom&); - - private: - void ok(pn_type_t) const; - void set(const std::string&); - pn_atom_t atom_; - std::string str_; // Owner of string-like data. -}; - -} -#endif // ATOM_HPP http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/include/proton/scalar.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/scalar.hpp b/proton-c/bindings/cpp/include/proton/scalar.hpp new file mode 100644 index 0000000..0745281 --- /dev/null +++ b/proton-c/bindings/cpp/include/proton/scalar.hpp @@ -0,0 +1,122 @@ +#ifndef SCALAR_HPP +#define SCALAR_HPP +/* + * 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 "proton/types.hpp" +#include + +namespace proton { + +class scalar; + +/** scalar holds an instance of an atomic proton type. */ +class scalar : public comparable { + public: + PN_CPP_EXTERN scalar(); + // Use default assign and copy. + + /// Type for the value in the scalar, NULL_TYPE if empty() + PN_CPP_EXTERN type_id type() const; + /// True if the scalar is empty. + PN_CPP_EXTERN bool empty() const; + + ///@name Create an scalar, type() is deduced from the C++ type of the value. + ///@{ + PN_CPP_EXTERN explicit scalar(bool); + PN_CPP_EXTERN explicit scalar(uint8_t); + PN_CPP_EXTERN explicit scalar(int8_t); + PN_CPP_EXTERN explicit scalar(uint16_t); + PN_CPP_EXTERN explicit scalar(int16_t); + PN_CPP_EXTERN explicit scalar(uint32_t); + PN_CPP_EXTERN explicit scalar(int32_t); + PN_CPP_EXTERN explicit scalar(uint64_t); + PN_CPP_EXTERN explicit scalar(int64_t); + PN_CPP_EXTERN explicit scalar(wchar_t); + PN_CPP_EXTERN explicit scalar(float); + PN_CPP_EXTERN explicit scalar(double); + PN_CPP_EXTERN explicit scalar(amqp_timestamp); + PN_CPP_EXTERN explicit scalar(const amqp_decimal32&); + PN_CPP_EXTERN explicit scalar(const amqp_decimal64&); + PN_CPP_EXTERN explicit scalar(const amqp_decimal128&); + PN_CPP_EXTERN explicit scalar(const amqp_uuid&); + PN_CPP_EXTERN explicit scalar(const amqp_string&); + PN_CPP_EXTERN explicit scalar(const amqp_symbol&); + PN_CPP_EXTERN explicit scalar(const amqp_binary&); + PN_CPP_EXTERN explicit scalar(const std::string& s); ///< Treated as an AMQP string + PN_CPP_EXTERN explicit scalar(const char* s); ///< Treated as an AMQP string + ///@} + + /// Assign to an scalar using the same rules as construction. + template scalar& operator=(T x) { return *this = scalar(x); } + + ///@name get(T&) extracts the value if the types match exactly, + ///i.e. if `type() == type_id_of::value` + /// throws type_mismatch otherwise. + ///@{ + PN_CPP_EXTERN void get(bool&) const; + PN_CPP_EXTERN void get(uint8_t&) const; + PN_CPP_EXTERN void get(int8_t&) const; + PN_CPP_EXTERN void get(uint16_t&) const; + PN_CPP_EXTERN void get(int16_t&) const; + PN_CPP_EXTERN void get(uint32_t&) const; + PN_CPP_EXTERN void get(int32_t&) const; + PN_CPP_EXTERN void get(uint64_t&) const; + PN_CPP_EXTERN void get(int64_t&) const; + PN_CPP_EXTERN void get(wchar_t&) const; + PN_CPP_EXTERN void get(float&) const; + PN_CPP_EXTERN void get(double&) const; + PN_CPP_EXTERN void get(amqp_timestamp&) const; + PN_CPP_EXTERN void get(amqp_decimal32&) const; + PN_CPP_EXTERN void get(amqp_decimal64&) const; + PN_CPP_EXTERN void get(amqp_decimal128&) const; + PN_CPP_EXTERN void get(amqp_uuid&) const; + PN_CPP_EXTERN void get(amqp_string&) const; + PN_CPP_EXTERN void get(amqp_symbol&) const; + PN_CPP_EXTERN void get(amqp_binary&) const; + PN_CPP_EXTERN void get(std::string&) const; ///< Treated as an AMQP string + ///@} + + ///@ get() is like get(T&) but returns the value.. + template T get() const { T x; get(x); return x; } + + ///@name as_ methods do "loose" conversion, they will convert the scalar's + ///value to the requested type if possible, else throw type_mismatch + ///@{ + PN_CPP_EXTERN int64_t as_int() const; ///< Allowed if type_id_integral(type()) + PN_CPP_EXTERN uint64_t as_uint() const; ///< Allowed if type_id_integral(type()) + PN_CPP_EXTERN double as_double() const; ///< Allowed if type_id_floating_point(type()) + PN_CPP_EXTERN std::string as_string() const; ///< Allowed if type_id_string_like(type()) + ///@} + + PN_CPP_EXTERN bool operator==(const scalar& x) const; + /// Note if the values are of different type(), operator< will compare the type() + PN_CPP_EXTERN bool operator<(const scalar& x) const; + + PN_CPP_EXTERN friend std::ostream& operator<<(std::ostream&, const scalar&); + + private: + void ok(pn_type_t) const; + void set(const std::string&); + pn_atom_t atom_; + std::string str_; // Owner of string-like data. +}; + +} +#endif // SCALAR_HPP http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/include/proton/types.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/types.hpp b/proton-c/bindings/cpp/include/proton/types.hpp index 75bb226..645d9da 100644 --- a/proton-c/bindings/cpp/include/proton/types.hpp +++ b/proton-c/bindings/cpp/include/proton/types.hpp @@ -198,13 +198,13 @@ PN_CPP_EXTERN std::string type_name(type_id); ///@name Attributes of a type_id value, returns same result as the /// corresponding std::type_traits tests for the corresponding C++ types. ///@{ -PN_CPP_EXTERN bool type_id_atom(type_id); -PN_CPP_EXTERN bool type_id_integral(type_id); -PN_CPP_EXTERN bool type_id_signed(type_id); ///< CHAR and BOOL are not signed. -PN_CPP_EXTERN bool type_id_floating_point(type_id); -PN_CPP_EXTERN bool type_id_decimal(type_id); -PN_CPP_EXTERN bool type_id_string_like(type_id); ///< STRING, SYMBOL, BINARY -PN_CPP_EXTERN bool type_id_container(type_id); +PN_CPP_EXTERN bool type_id_is_scalar(type_id); +PN_CPP_EXTERN bool type_id_is_integral(type_id); +PN_CPP_EXTERN bool type_id_is_signed(type_id); ///< CHAR and BOOL are not signed. +PN_CPP_EXTERN bool type_id_is_floating_point(type_id); +PN_CPP_EXTERN bool type_id_is_decimal(type_id); +PN_CPP_EXTERN bool type_id_is_string_like(type_id); ///< STRING, SYMBOL, BINARY +PN_CPP_EXTERN bool type_id_is_container(type_id); ///@} /** Print the name of a type. */ http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/src/atom.cpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/src/atom.cpp b/proton-c/bindings/cpp/src/atom.cpp deleted file mode 100644 index 034b22c..0000000 --- a/proton-c/bindings/cpp/src/atom.cpp +++ /dev/null @@ -1,185 +0,0 @@ -/* - * 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 "proton/atom.hpp" -#include "proton/type_traits.hpp" - -#include - -namespace proton { - -atom::atom() { atom_.type = PN_NULL; } - -type_id atom::type() const { return type_id(atom_.type); } -bool atom::empty() const { return type() == NULL_TYPE; } - -atom::atom(bool x) { atom_.u.as_bool = x; atom_.type = PN_BOOL; } -atom::atom(uint8_t x) { atom_.u.as_ubyte = x; atom_.type = PN_UBYTE; } -atom::atom(int8_t x) { atom_.u.as_byte = x; atom_.type = PN_BYTE; } -atom::atom(uint16_t x) { atom_.u.as_ushort = x; atom_.type = PN_USHORT; } -atom::atom(int16_t x) { atom_.u.as_short = x; atom_.type = PN_SHORT; } -atom::atom(uint32_t x) { atom_.u.as_uint = x; atom_.type = PN_UINT; } -atom::atom(int32_t x) { atom_.u.as_int = x; atom_.type = PN_INT; } -atom::atom(uint64_t x) { atom_.u.as_ulong = x; atom_.type = PN_ULONG; } -atom::atom(int64_t x) { atom_.u.as_long = x; atom_.type = PN_LONG; } -atom::atom(wchar_t x) { atom_.u.as_char = pn_char_t(x); atom_.type = PN_CHAR; } -atom::atom(float x) { atom_.u.as_float = x; atom_.type = PN_FLOAT; } -atom::atom(double x) { atom_.u.as_double = x; atom_.type = PN_DOUBLE; } -atom::atom(amqp_timestamp x) { atom_.u.as_timestamp = x; atom_.type = PN_TIMESTAMP; } -atom::atom(const amqp_decimal32& x) { atom_.u.as_decimal32 = x; atom_.type = PN_DECIMAL32; } -atom::atom(const amqp_decimal64& x) { atom_.u.as_decimal64 = x; atom_.type = PN_DECIMAL64; } -atom::atom(const amqp_decimal128& x) { atom_.u.as_decimal128 = x; atom_.type = PN_DECIMAL128; } -atom::atom(const amqp_uuid& x) { atom_.u.as_uuid = x; atom_.type = PN_UUID; } - -void atom::set(const std::string& x) { str_ = x; atom_.u.as_bytes = pn_bytes(str_); } -atom::atom(const amqp_string& x) { set(x); atom_.type = PN_STRING; } -atom::atom(const amqp_symbol& x) { set(x); atom_.type = PN_SYMBOL; } -atom::atom(const amqp_binary& x) { set(x); atom_.type = PN_BINARY; } -atom::atom(const std::string& x) { *this = amqp_string(x); } -atom::atom(const char* x) { *this = amqp_string(x); } - -void atom::ok(pn_type_t t) const { - if (atom_.type != t) throw type_mismatch(type_id(t), type()); -} - -void atom::get(bool& x) const { ok(PN_BOOL); x = atom_.u.as_bool; } -void atom::get(uint8_t& x) const { ok(PN_UBYTE); x = atom_.u.as_ubyte; } -void atom::get(int8_t& x) const { ok(PN_BYTE); x = atom_.u.as_byte; } -void atom::get(uint16_t& x) const { ok(PN_USHORT); x = atom_.u.as_ushort; } -void atom::get(int16_t& x) const { ok(PN_SHORT); x = atom_.u.as_short; } -void atom::get(uint32_t& x) const { ok(PN_UINT); x = atom_.u.as_uint; } -void atom::get(int32_t& x) const { ok(PN_INT); x = atom_.u.as_int; } -void atom::get(wchar_t& x) const { ok(PN_CHAR); x = wchar_t(atom_.u.as_char); } -void atom::get(uint64_t& x) const { ok(PN_ULONG); x = atom_.u.as_ulong; } -void atom::get(int64_t& x) const { ok(PN_LONG); x = atom_.u.as_long; } -void atom::get(amqp_timestamp& x) const { ok(PN_TIMESTAMP); x = atom_.u.as_timestamp; } -void atom::get(float& x) const { ok(PN_FLOAT); x = atom_.u.as_float; } -void atom::get(double& x) const { ok(PN_DOUBLE); x = atom_.u.as_double; } -void atom::get(amqp_decimal32& x) const { ok(PN_DECIMAL32); x = atom_.u.as_decimal32; } -void atom::get(amqp_decimal64& x) const { ok(PN_DECIMAL64); x = atom_.u.as_decimal64; } -void atom::get(amqp_decimal128& x) const { ok(PN_DECIMAL128); x = atom_.u.as_decimal128; } -void atom::get(amqp_uuid& x) const { ok(PN_UUID); x = atom_.u.as_uuid; } -void atom::get(amqp_string& x) const { ok(PN_STRING); x = str_; } -void atom::get(amqp_symbol& x) const { ok(PN_SYMBOL); x = str_; } -void atom::get(amqp_binary& x) const { ok(PN_BINARY); x = str_; } -void atom::get(std::string& x) const { x = get(); } - -int64_t atom::as_int() const { - if (type_id_floating_point(type())) - return int64_t(as_double()); - switch (atom_.type) { - case PN_BOOL: return atom_.u.as_bool; - case PN_UBYTE: return atom_.u.as_ubyte; - case PN_BYTE: return atom_.u.as_byte; - case PN_USHORT: return atom_.u.as_ushort; - case PN_SHORT: return atom_.u.as_short; - case PN_UINT: return atom_.u.as_uint; - case PN_INT: return atom_.u.as_int; - case PN_CHAR: return atom_.u.as_char; - case PN_ULONG: return int64_t(atom_.u.as_ulong); - case PN_LONG: return atom_.u.as_long; - default: throw type_mismatch(LONG, type(), "cannot convert"); - } -} - -uint64_t atom::as_uint() const { - if (!type_id_integral(type())) - throw type_mismatch(ULONG, type(), "cannot convert"); - return uint64_t(as_int()); -} - -double atom::as_double() const { - if (type_id_integral(type())) { - return type_id_signed(type()) ? double(as_int()) : double(as_uint()); - } - switch (atom_.type) { - case PN_DOUBLE: return atom_.u.as_double; - case PN_FLOAT: return atom_.u.as_float; - default: throw type_mismatch(DOUBLE, type(), "cannot convert"); - } -} - -std::string atom::as_string() const { - if (type_id_string_like(type())) - return str_; - throw type_mismatch(DOUBLE, type(), "cannot convert"); -} - - -namespace { -template T type_switch(const atom& a, F f) { - switch(a.type()) { - case BOOLEAN: return f(a.get()); - case UBYTE: return f(a.get()); - case BYTE: return f(a.get()); - case USHORT: return f(a.get()); - case SHORT: return f(a.get()); - case UINT: return f(a.get()); - case INT: return f(a.get()); - case CHAR: return f(a.get()); - case ULONG: return f(a.get()); - case LONG: return f(a.get()); - case TIMESTAMP: return f(a.get()); - case FLOAT: return f(a.get()); - case DOUBLE: return f(a.get()); - case DECIMAL32: return f(a.get()); - case DECIMAL64: return f(a.get()); - case DECIMAL128: return f(a.get()); - case UUID: return f(a.get()); - case BINARY: return f(a.get()); - case STRING: return f(a.get()); - case SYMBOL: return f(a.get()); - default: - throw error("bad atom type"); - } -} - -struct equal_op { - const atom& a; - equal_op(const atom& a_) : a(a_) {} - template bool operator()(T x) { return x == a.get(); } -}; - -struct less_op { - const atom& a; - less_op(const atom& a_) : a(a_) {} - template bool operator()(T x) { return x < a.get(); } -}; - -struct ostream_op { - std::ostream& o; - ostream_op(std::ostream& o_) : o(o_) {} - template std::ostream& operator()(T x) { return o << x; } -}; - -} // namespace - -bool atom::operator==(const atom& x) const { - return type_switch(*this, equal_op(x)); -} - -bool atom::operator<(const atom& x) const { - return type_switch(*this, less_op(x)); -} - -std::ostream& operator<<(std::ostream& o, const atom& a) { - return type_switch(a, ostream_op(o)); -} - -} http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/src/atom_test.cpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/src/atom_test.cpp b/proton-c/bindings/cpp/src/atom_test.cpp deleted file mode 100644 index 0d85a36..0000000 --- a/proton-c/bindings/cpp/src/atom_test.cpp +++ /dev/null @@ -1,105 +0,0 @@ -/* - * 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 "test_bits.hpp" -#include "proton/type_traits.hpp" - -#include - -using namespace std; -using namespace proton; - -// Inserting and extracting simple C++ values. -template void type_test(T x, type_id tid, T y) { - atom v(x); - ASSERT_EQUAL(tid, v.type()); - ASSERT(!v.empty()); - ASSERT_EQUAL(x, v.get()); - - atom v2; - ASSERT(v2.type() == NULL_TYPE); - v2 = x; - ASSERT_EQUAL(tid, v2.type()); - ASSERT_EQUAL(x, v2.get()); - ASSERT_EQUAL(v, v2); - ASSERT_EQUAL(str(x), str(v)); - - v2 = y; - ASSERT(v != v2); - ASSERT(v < v2); - ASSERT(v2 > v); -} - -#define ASSERT_MISMATCH(EXPR) \ - try { (void)(EXPR); FAIL("expected type_mismatch: " #EXPR); } catch (type_mismatch) {} - -void convert_test() { - atom a; - ASSERT_EQUAL(NULL_TYPE, a.type()); - ASSERT(a.empty()); - ASSERT_MISMATCH(a.get()); - - a = amqp_binary("foo"); - ASSERT_MISMATCH(a.get()); - ASSERT_MISMATCH(a.as_int()); - ASSERT_MISMATCH(a.as_double()); - ASSERT_MISMATCH(a.get()); // No strict conversion - ASSERT_EQUAL(a.as_string(), std::string("foo")); // OK string-like conversion - - a = int16_t(42); - ASSERT_MISMATCH(a.get()); - ASSERT_MISMATCH(a.get()); - ASSERT_MISMATCH(a.as_string()); - ASSERT_EQUAL(a.as_int(), 42); - ASSERT_EQUAL(a.as_uint(), 42); - ASSERT_EQUAL(a.as_double(), 42); - - a = int16_t(-42); - ASSERT_EQUAL(a.as_int(), -42); - ASSERT_EQUAL(a.as_uint(), uint64_t(-42)); - ASSERT_EQUAL(a.as_double(), -42); -} - -int main(int, char**) { - int failed = 0; - RUN_TEST(failed, type_test(false, BOOLEAN, true)); - RUN_TEST(failed, type_test(amqp_ubyte(42), UBYTE, amqp_ubyte(50))); - RUN_TEST(failed, type_test(amqp_byte('x'), BYTE, amqp_byte('y'))); - RUN_TEST(failed, type_test(amqp_ushort(4242), USHORT, amqp_ushort(5252))); - RUN_TEST(failed, type_test(amqp_short(-4242), SHORT, amqp_short(3))); - RUN_TEST(failed, type_test(amqp_uint(4242), UINT, amqp_uint(5252))); - RUN_TEST(failed, type_test(amqp_int(-4242), INT, amqp_int(3))); - RUN_TEST(failed, type_test(amqp_ulong(4242), ULONG, amqp_ulong(5252))); - RUN_TEST(failed, type_test(amqp_long(-4242), LONG, amqp_long(3))); - RUN_TEST(failed, type_test(wchar_t(23), CHAR, wchar_t(24))); - RUN_TEST(failed, type_test(amqp_float(1.234), FLOAT, amqp_float(2.345))); - RUN_TEST(failed, type_test(amqp_double(11.2233), DOUBLE, amqp_double(12))); - RUN_TEST(failed, type_test(amqp_timestamp(0), TIMESTAMP, amqp_timestamp(1))); - RUN_TEST(failed, type_test(amqp_decimal32(0), DECIMAL32, amqp_decimal32(1))); - RUN_TEST(failed, type_test(amqp_decimal64(0), DECIMAL64, amqp_decimal64(1))); - pn_decimal128_t da = {0}, db = {1}; - RUN_TEST(failed, type_test(amqp_decimal128(da), DECIMAL128, amqp_decimal128(db))); - pn_uuid_t ua = {0}, ub = {1}; - RUN_TEST(failed, type_test(amqp_uuid(ua), UUID, amqp_uuid(ub))); - RUN_TEST(failed, type_test(amqp_string("aaa"), STRING, amqp_string("aaaa"))); - RUN_TEST(failed, type_test(amqp_symbol("aaa"), SYMBOL, amqp_symbol("aaaa"))); - RUN_TEST(failed, type_test(amqp_binary("aaa"), BINARY, amqp_binary("aaaa"))); - RUN_TEST(failed, type_test(std::string("xxx"), STRING, std::string("yyy"))); - return failed; -} http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/src/scalar.cpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/src/scalar.cpp b/proton-c/bindings/cpp/src/scalar.cpp new file mode 100644 index 0000000..13daf32 --- /dev/null +++ b/proton-c/bindings/cpp/src/scalar.cpp @@ -0,0 +1,185 @@ +/* + * 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 "proton/scalar.hpp" +#include "proton/type_traits.hpp" + +#include + +namespace proton { + +scalar::scalar() { atom_.type = PN_NULL; } + +type_id scalar::type() const { return type_id(atom_.type); } +bool scalar::empty() const { return type() == NULL_TYPE; } + +scalar::scalar(bool x) { atom_.u.as_bool = x; atom_.type = PN_BOOL; } +scalar::scalar(uint8_t x) { atom_.u.as_ubyte = x; atom_.type = PN_UBYTE; } +scalar::scalar(int8_t x) { atom_.u.as_byte = x; atom_.type = PN_BYTE; } +scalar::scalar(uint16_t x) { atom_.u.as_ushort = x; atom_.type = PN_USHORT; } +scalar::scalar(int16_t x) { atom_.u.as_short = x; atom_.type = PN_SHORT; } +scalar::scalar(uint32_t x) { atom_.u.as_uint = x; atom_.type = PN_UINT; } +scalar::scalar(int32_t x) { atom_.u.as_int = x; atom_.type = PN_INT; } +scalar::scalar(uint64_t x) { atom_.u.as_ulong = x; atom_.type = PN_ULONG; } +scalar::scalar(int64_t x) { atom_.u.as_long = x; atom_.type = PN_LONG; } +scalar::scalar(wchar_t x) { atom_.u.as_char = pn_char_t(x); atom_.type = PN_CHAR; } +scalar::scalar(float x) { atom_.u.as_float = x; atom_.type = PN_FLOAT; } +scalar::scalar(double x) { atom_.u.as_double = x; atom_.type = PN_DOUBLE; } +scalar::scalar(amqp_timestamp x) { atom_.u.as_timestamp = x; atom_.type = PN_TIMESTAMP; } +scalar::scalar(const amqp_decimal32& x) { atom_.u.as_decimal32 = x; atom_.type = PN_DECIMAL32; } +scalar::scalar(const amqp_decimal64& x) { atom_.u.as_decimal64 = x; atom_.type = PN_DECIMAL64; } +scalar::scalar(const amqp_decimal128& x) { atom_.u.as_decimal128 = x; atom_.type = PN_DECIMAL128; } +scalar::scalar(const amqp_uuid& x) { atom_.u.as_uuid = x; atom_.type = PN_UUID; } + +void scalar::set(const std::string& x) { str_ = x; atom_.u.as_bytes = pn_bytes(str_); } +scalar::scalar(const amqp_string& x) { set(x); atom_.type = PN_STRING; } +scalar::scalar(const amqp_symbol& x) { set(x); atom_.type = PN_SYMBOL; } +scalar::scalar(const amqp_binary& x) { set(x); atom_.type = PN_BINARY; } +scalar::scalar(const std::string& x) { *this = amqp_string(x); } +scalar::scalar(const char* x) { *this = amqp_string(x); } + +void scalar::ok(pn_type_t t) const { + if (atom_.type != t) throw type_mismatch(type_id(t), type()); +} + +void scalar::get(bool& x) const { ok(PN_BOOL); x = atom_.u.as_bool; } +void scalar::get(uint8_t& x) const { ok(PN_UBYTE); x = atom_.u.as_ubyte; } +void scalar::get(int8_t& x) const { ok(PN_BYTE); x = atom_.u.as_byte; } +void scalar::get(uint16_t& x) const { ok(PN_USHORT); x = atom_.u.as_ushort; } +void scalar::get(int16_t& x) const { ok(PN_SHORT); x = atom_.u.as_short; } +void scalar::get(uint32_t& x) const { ok(PN_UINT); x = atom_.u.as_uint; } +void scalar::get(int32_t& x) const { ok(PN_INT); x = atom_.u.as_int; } +void scalar::get(wchar_t& x) const { ok(PN_CHAR); x = wchar_t(atom_.u.as_char); } +void scalar::get(uint64_t& x) const { ok(PN_ULONG); x = atom_.u.as_ulong; } +void scalar::get(int64_t& x) const { ok(PN_LONG); x = atom_.u.as_long; } +void scalar::get(amqp_timestamp& x) const { ok(PN_TIMESTAMP); x = atom_.u.as_timestamp; } +void scalar::get(float& x) const { ok(PN_FLOAT); x = atom_.u.as_float; } +void scalar::get(double& x) const { ok(PN_DOUBLE); x = atom_.u.as_double; } +void scalar::get(amqp_decimal32& x) const { ok(PN_DECIMAL32); x = atom_.u.as_decimal32; } +void scalar::get(amqp_decimal64& x) const { ok(PN_DECIMAL64); x = atom_.u.as_decimal64; } +void scalar::get(amqp_decimal128& x) const { ok(PN_DECIMAL128); x = atom_.u.as_decimal128; } +void scalar::get(amqp_uuid& x) const { ok(PN_UUID); x = atom_.u.as_uuid; } +void scalar::get(amqp_string& x) const { ok(PN_STRING); x = str_; } +void scalar::get(amqp_symbol& x) const { ok(PN_SYMBOL); x = str_; } +void scalar::get(amqp_binary& x) const { ok(PN_BINARY); x = str_; } +void scalar::get(std::string& x) const { x = get(); } + +int64_t scalar::as_int() const { + if (type_id_is_floating_point(type())) + return int64_t(as_double()); + switch (atom_.type) { + case PN_BOOL: return atom_.u.as_bool; + case PN_UBYTE: return atom_.u.as_ubyte; + case PN_BYTE: return atom_.u.as_byte; + case PN_USHORT: return atom_.u.as_ushort; + case PN_SHORT: return atom_.u.as_short; + case PN_UINT: return atom_.u.as_uint; + case PN_INT: return atom_.u.as_int; + case PN_CHAR: return atom_.u.as_char; + case PN_ULONG: return int64_t(atom_.u.as_ulong); + case PN_LONG: return atom_.u.as_long; + default: throw type_mismatch(LONG, type(), "cannot convert"); + } +} + +uint64_t scalar::as_uint() const { + if (!type_id_is_integral(type())) + throw type_mismatch(ULONG, type(), "cannot convert"); + return uint64_t(as_int()); +} + +double scalar::as_double() const { + if (type_id_is_integral(type())) { + return type_id_is_signed(type()) ? double(as_int()) : double(as_uint()); + } + switch (atom_.type) { + case PN_DOUBLE: return atom_.u.as_double; + case PN_FLOAT: return atom_.u.as_float; + default: throw type_mismatch(DOUBLE, type(), "cannot convert"); + } +} + +std::string scalar::as_string() const { + if (type_id_is_string_like(type())) + return str_; + throw type_mismatch(DOUBLE, type(), "cannot convert"); +} + + +namespace { +template T type_switch(const scalar& a, F f) { + switch(a.type()) { + case BOOLEAN: return f(a.get()); + case UBYTE: return f(a.get()); + case BYTE: return f(a.get()); + case USHORT: return f(a.get()); + case SHORT: return f(a.get()); + case UINT: return f(a.get()); + case INT: return f(a.get()); + case CHAR: return f(a.get()); + case ULONG: return f(a.get()); + case LONG: return f(a.get()); + case TIMESTAMP: return f(a.get()); + case FLOAT: return f(a.get()); + case DOUBLE: return f(a.get()); + case DECIMAL32: return f(a.get()); + case DECIMAL64: return f(a.get()); + case DECIMAL128: return f(a.get()); + case UUID: return f(a.get()); + case BINARY: return f(a.get()); + case STRING: return f(a.get()); + case SYMBOL: return f(a.get()); + default: + throw error("bad scalar type"); + } +} + +struct equal_op { + const scalar& a; + equal_op(const scalar& a_) : a(a_) {} + template bool operator()(T x) { return x == a.get(); } +}; + +struct less_op { + const scalar& a; + less_op(const scalar& a_) : a(a_) {} + template bool operator()(T x) { return x < a.get(); } +}; + +struct ostream_op { + std::ostream& o; + ostream_op(std::ostream& o_) : o(o_) {} + template std::ostream& operator()(T x) { return o << x; } +}; + +} // namespace + +bool scalar::operator==(const scalar& x) const { + return type_switch(*this, equal_op(x)); +} + +bool scalar::operator<(const scalar& x) const { + return type_switch(*this, less_op(x)); +} + +std::ostream& operator<<(std::ostream& o, const scalar& a) { + return type_switch(a, ostream_op(o)); +} + +} http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/src/scalar_test.cpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/src/scalar_test.cpp b/proton-c/bindings/cpp/src/scalar_test.cpp new file mode 100644 index 0000000..c7de785 --- /dev/null +++ b/proton-c/bindings/cpp/src/scalar_test.cpp @@ -0,0 +1,105 @@ +/* + * 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 "test_bits.hpp" +#include "proton/type_traits.hpp" + +#include + +using namespace std; +using namespace proton; + +// Inserting and extracting simple C++ values. +template void type_test(T x, type_id tid, T y) { + scalar v(x); + ASSERT_EQUAL(tid, v.type()); + ASSERT(!v.empty()); + ASSERT_EQUAL(x, v.get()); + + scalar v2; + ASSERT(v2.type() == NULL_TYPE); + v2 = x; + ASSERT_EQUAL(tid, v2.type()); + ASSERT_EQUAL(x, v2.get()); + ASSERT_EQUAL(v, v2); + ASSERT_EQUAL(str(x), str(v)); + + v2 = y; + ASSERT(v != v2); + ASSERT(v < v2); + ASSERT(v2 > v); +} + +#define ASSERT_MISMATCH(EXPR) \ + try { (void)(EXPR); FAIL("expected type_mismatch: " #EXPR); } catch (type_mismatch) {} + +void convert_test() { + scalar a; + ASSERT_EQUAL(NULL_TYPE, a.type()); + ASSERT(a.empty()); + ASSERT_MISMATCH(a.get()); + + a = amqp_binary("foo"); + ASSERT_MISMATCH(a.get()); + ASSERT_MISMATCH(a.as_int()); + ASSERT_MISMATCH(a.as_double()); + ASSERT_MISMATCH(a.get()); // No strict conversion + ASSERT_EQUAL(a.as_string(), std::string("foo")); // OK string-like conversion + + a = int16_t(42); + ASSERT_MISMATCH(a.get()); + ASSERT_MISMATCH(a.get()); + ASSERT_MISMATCH(a.as_string()); + ASSERT_EQUAL(a.as_int(), 42); + ASSERT_EQUAL(a.as_uint(), 42); + ASSERT_EQUAL(a.as_double(), 42); + + a = int16_t(-42); + ASSERT_EQUAL(a.as_int(), -42); + ASSERT_EQUAL(a.as_uint(), uint64_t(-42)); + ASSERT_EQUAL(a.as_double(), -42); +} + +int main(int, char**) { + int failed = 0; + RUN_TEST(failed, type_test(false, BOOLEAN, true)); + RUN_TEST(failed, type_test(amqp_ubyte(42), UBYTE, amqp_ubyte(50))); + RUN_TEST(failed, type_test(amqp_byte('x'), BYTE, amqp_byte('y'))); + RUN_TEST(failed, type_test(amqp_ushort(4242), USHORT, amqp_ushort(5252))); + RUN_TEST(failed, type_test(amqp_short(-4242), SHORT, amqp_short(3))); + RUN_TEST(failed, type_test(amqp_uint(4242), UINT, amqp_uint(5252))); + RUN_TEST(failed, type_test(amqp_int(-4242), INT, amqp_int(3))); + RUN_TEST(failed, type_test(amqp_ulong(4242), ULONG, amqp_ulong(5252))); + RUN_TEST(failed, type_test(amqp_long(-4242), LONG, amqp_long(3))); + RUN_TEST(failed, type_test(wchar_t(23), CHAR, wchar_t(24))); + RUN_TEST(failed, type_test(amqp_float(1.234), FLOAT, amqp_float(2.345))); + RUN_TEST(failed, type_test(amqp_double(11.2233), DOUBLE, amqp_double(12))); + RUN_TEST(failed, type_test(amqp_timestamp(0), TIMESTAMP, amqp_timestamp(1))); + RUN_TEST(failed, type_test(amqp_decimal32(0), DECIMAL32, amqp_decimal32(1))); + RUN_TEST(failed, type_test(amqp_decimal64(0), DECIMAL64, amqp_decimal64(1))); + pn_decimal128_t da = {0}, db = {1}; + RUN_TEST(failed, type_test(amqp_decimal128(da), DECIMAL128, amqp_decimal128(db))); + pn_uuid_t ua = {0}, ub = {1}; + RUN_TEST(failed, type_test(amqp_uuid(ua), UUID, amqp_uuid(ub))); + RUN_TEST(failed, type_test(amqp_string("aaa"), STRING, amqp_string("aaaa"))); + RUN_TEST(failed, type_test(amqp_symbol("aaa"), SYMBOL, amqp_symbol("aaaa"))); + RUN_TEST(failed, type_test(amqp_binary("aaa"), BINARY, amqp_binary("aaaa"))); + RUN_TEST(failed, type_test(std::string("xxx"), STRING, std::string("yyy"))); + return failed; +} http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d2c5a5f2/proton-c/bindings/cpp/src/types.cpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/src/types.cpp b/proton-c/bindings/cpp/src/types.cpp index d8e40ce..fa7b0bd 100644 --- a/proton-c/bindings/cpp/src/types.cpp +++ b/proton-c/bindings/cpp/src/types.cpp @@ -95,15 +95,15 @@ std::string type_name(type_id t) { return "unknown"; } -static bool type_id_signed_int(type_id t) { return t == BYTE || t == SHORT || t == INT || t == LONG; } -static bool type_id_unsigned_int(type_id t) { return t == UBYTE || t == USHORT || t == UINT || t == ULONG; } -bool type_id_integral(type_id t) { return t == BOOLEAN || t == CHAR || type_id_unsigned_int(t) || type_id_signed_int(t); } -bool type_id_floating_point(type_id t) { return t == FLOAT || t == DOUBLE; } -bool type_id_decimal(type_id t) { return t == DECIMAL32 || t == DECIMAL64 || t == DECIMAL128; } -bool type_id_signed(type_id t) { return type_id_signed_int(t) || type_id_floating_point(t) || type_id_decimal(t); } -bool type_id_string_like(type_id t) { return t == BINARY || t == STRING || t == SYMBOL; } -bool type_id_container(type_id t) { return t == LIST || t == MAP || t == ARRAY || t == DESCRIBED; } -bool type_id_atom(type_id t) { return type_id_integral(t) || type_id_floating_point(t) || type_id_decimal(t) || type_id_string_like(t) || t == TIMESTAMP || t == UUID; } +static bool type_id_is_signed_int(type_id t) { return t == BYTE || t == SHORT || t == INT || t == LONG; } +static bool type_id_is_unsigned_int(type_id t) { return t == UBYTE || t == USHORT || t == UINT || t == ULONG; } +bool type_id_is_integral(type_id t) { return t == BOOLEAN || t == CHAR || type_id_is_unsigned_int(t) || type_id_is_signed_int(t); } +bool type_id_is_floating_point(type_id t) { return t == FLOAT || t == DOUBLE; } +bool type_id_is_decimal(type_id t) { return t == DECIMAL32 || t == DECIMAL64 || t == DECIMAL128; } +bool type_id_is_signed(type_id t) { return type_id_is_signed_int(t) || type_id_is_floating_point(t) || type_id_is_decimal(t); } +bool type_id_is_string_like(type_id t) { return t == BINARY || t == STRING || t == SYMBOL; } +bool type_id_is_container(type_id t) { return t == LIST || t == MAP || t == ARRAY || t == DESCRIBED; } +bool type_id_is_scalar(type_id t) { return type_id_is_integral(t) || type_id_is_floating_point(t) || type_id_is_decimal(t) || type_id_is_string_like(t) || t == TIMESTAMP || t == UUID; } std::ostream& operator<<(std::ostream& o,type_id t) { return o << type_name(t); } --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org For additional commands, e-mail: commits-help@qpid.apache.org