summaryrefslogtreecommitdiff
path: root/cpp/src/qpid
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/src/qpid')
-rw-r--r--cpp/src/qpid/client/amqp0_10/Codecs.cpp38
-rw-r--r--cpp/src/qpid/framing/FieldValue.cpp3
-rw-r--r--cpp/src/qpid/messaging/Uuid.cpp140
-rw-r--r--cpp/src/qpid/messaging/Variant.cpp28
-rw-r--r--cpp/src/qpid/sys/windows/uuid.cpp3
-rw-r--r--cpp/src/qpid/sys/windows/uuid.h1
6 files changed, 198 insertions, 15 deletions
diff --git a/cpp/src/qpid/client/amqp0_10/Codecs.cpp b/cpp/src/qpid/client/amqp0_10/Codecs.cpp
index ff72dfbf4e..835d80185a 100644
--- a/cpp/src/qpid/client/amqp0_10/Codecs.cpp
+++ b/cpp/src/qpid/client/amqp0_10/Codecs.cpp
@@ -112,6 +112,13 @@ void setEncodingFor(Variant& out, uint8_t code)
}
}
+qpid::messaging::Uuid getUuid(FieldValue& value)
+{
+ unsigned char data[16];
+ value.getFixedWidthValue<16>(data);
+ return qpid::messaging::Uuid(data);
+}
+
Variant toVariant(boost::shared_ptr<FieldValue> in)
{
Variant out;
@@ -123,19 +130,21 @@ Variant toVariant(boost::shared_ptr<FieldValue> in)
case 0x03: out = in->getIntegerValue<uint8_t, 1>(); break;
case 0x04: break; //TODO: iso-8859-15 char
case 0x08: out = in->getIntegerValue<bool, 1>(); break;
- case 0x010: out.setEncoding(amqp0_10_binary);
- case 0x011: out = in->getIntegerValue<int16_t, 2>(); break;
- case 0x012: out = in->getIntegerValue<uint16_t, 2>(); break;
- case 0x020: out.setEncoding(amqp0_10_binary);
- case 0x021: out = in->getIntegerValue<int32_t, 4>(); break;
- case 0x022: out = in->getIntegerValue<uint32_t, 4>(); break;
- case 0x023: out = in->get<float>(); break;
- case 0x027: break; //TODO: utf-32 char
- case 0x030: out.setEncoding(amqp0_10_binary);
- case 0x031: out = in->getIntegerValue<int64_t, 8>(); break;
- case 0x038: out.setEncoding(amqp0_10_datetime); //treat datetime as uint64_t, but set encoding
- case 0x032: out = in->getIntegerValue<uint64_t, 8>(); break;
- case 0x033:out = in->get<double>(); break;
+ case 0x10: out.setEncoding(amqp0_10_binary);
+ case 0x11: out = in->getIntegerValue<int16_t, 2>(); break;
+ case 0x12: out = in->getIntegerValue<uint16_t, 2>(); break;
+ case 0x20: out.setEncoding(amqp0_10_binary);
+ case 0x21: out = in->getIntegerValue<int32_t, 4>(); break;
+ case 0x22: out = in->getIntegerValue<uint32_t, 4>(); break;
+ case 0x23: out = in->get<float>(); break;
+ case 0x27: break; //TODO: utf-32 char
+ case 0x30: out.setEncoding(amqp0_10_binary);
+ case 0x31: out = in->getIntegerValue<int64_t, 8>(); break;
+ case 0x38: out.setEncoding(amqp0_10_datetime); //treat datetime as uint64_t, but set encoding
+ case 0x32: out = in->getIntegerValue<uint64_t, 8>(); break;
+ case 0x33: out = in->get<double>(); break;
+
+ case 0x48: out = getUuid(*in); break;
//TODO: figure out whether and how to map values with codes 0x40-0xd8
@@ -197,12 +206,11 @@ boost::shared_ptr<FieldValue> toFieldValue(const Variant& in)
case VAR_DOUBLE: out = boost::shared_ptr<FieldValue>(new DoubleValue(in.asDouble())); break;
//TODO: check encoding (and length?) when deciding what AMQP type to treat string as
case VAR_STRING: out = boost::shared_ptr<FieldValue>(new Str16Value(in.asString())); break;
+ case VAR_UUID: out = boost::shared_ptr<FieldValue>(new UuidValue(in.asUuid().data())); break;
case VAR_MAP:
- //out = boost::shared_ptr<FieldValue>(toFieldValueCollection<FieldTableValue>(in.asMap(), &toFieldTableEntry));
out = boost::shared_ptr<FieldValue>(toFieldTableValue(in.asMap()));
break;
case VAR_LIST:
- //out = boost::shared_ptr<FieldValue>(toFieldValueCollection<ListValue>(in.asList(), &toFieldValue));
out = boost::shared_ptr<FieldValue>(toListValue(in.asList()));
break;
}
diff --git a/cpp/src/qpid/framing/FieldValue.cpp b/cpp/src/qpid/framing/FieldValue.cpp
index 9c5c0c36a2..0b49748de8 100644
--- a/cpp/src/qpid/framing/FieldValue.cpp
+++ b/cpp/src/qpid/framing/FieldValue.cpp
@@ -197,6 +197,9 @@ Integer8Value::Integer8Value(int8_t v) :
Integer16Value::Integer16Value(int16_t v) :
FieldValue(0x11, new FixedWidthValue<2>(v))
{}
+UuidValue::UuidValue(const unsigned char* v) :
+ FieldValue(0x48, new FixedWidthValue<16>(v))
+{}
void FieldValue::print(std::ostream& out) const {
data->print(out);
diff --git a/cpp/src/qpid/messaging/Uuid.cpp b/cpp/src/qpid/messaging/Uuid.cpp
new file mode 100644
index 0000000000..87eb34456f
--- /dev/null
+++ b/cpp/src/qpid/messaging/Uuid.cpp
@@ -0,0 +1,140 @@
+/*
+ *
+ * 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 "qpid/messaging/Uuid.h"
+#include "qpid/sys/uuid.h"
+#include <sstream>
+#include <iostream>
+#include <string.h>
+
+namespace qpid {
+namespace messaging {
+
+using namespace std;
+
+const size_t Uuid::SIZE=16;
+static const size_t UNPARSED_SIZE=36;
+
+Uuid::Uuid(bool unique)
+{
+ if (unique) {
+ generate();
+ } else {
+ clear();
+ }
+}
+
+Uuid::Uuid(const Uuid& other)
+{
+ ::memcpy(bytes, other.bytes, Uuid::SIZE);
+}
+
+Uuid::Uuid(const unsigned char* uuid)
+{
+ ::memcpy(bytes, uuid, Uuid::SIZE);
+}
+
+Uuid& Uuid::operator=(const Uuid& other)
+{
+ if (this == &other) return *this;
+ ::memcpy(bytes, other.bytes, Uuid::SIZE);
+ return *this;
+}
+
+void Uuid::generate()
+{
+ uuid_generate(bytes);
+}
+
+void Uuid::clear()
+{
+ uuid_clear(bytes);
+}
+
+// Force int 0/!0 to false/true; avoids compile warnings.
+bool Uuid::isNull() const
+{
+ return !!uuid_is_null(bytes);
+}
+
+Uuid::operator bool() const { return !isNull(); }
+bool Uuid::operator!() const { return isNull(); }
+
+size_t Uuid::size() const { return SIZE; }
+
+const unsigned char* Uuid::data() const
+{
+ return bytes;
+}
+
+bool operator==(const Uuid& a, const Uuid& b)
+{
+ return uuid_compare(a.bytes, b.bytes) == 0;
+}
+
+bool operator!=(const Uuid& a, const Uuid& b)
+{
+ return !(a == b);
+}
+
+bool operator<(const Uuid& a, const Uuid& b)
+{
+ return uuid_compare(a.bytes, b.bytes) < 0;
+}
+
+bool operator>(const Uuid& a, const Uuid& b)
+{
+ return uuid_compare(a.bytes, b.bytes) > 0;
+}
+
+bool operator<=(const Uuid& a, const Uuid& b)
+{
+ return uuid_compare(a.bytes, b.bytes) <= 0;
+}
+
+bool operator>=(const Uuid& a, const Uuid& b)
+{
+ return uuid_compare(a.bytes, b.bytes) >= 0;
+}
+
+ostream& operator<<(ostream& out, Uuid uuid)
+{
+ char unparsed[UNPARSED_SIZE + 1];
+ uuid_unparse(uuid.bytes, unparsed);
+ return out << unparsed;
+}
+
+istream& operator>>(istream& in, Uuid& uuid)
+{
+ char unparsed[UNPARSED_SIZE + 1] = {0};
+ in.get(unparsed, sizeof(unparsed));
+ if (uuid_parse(unparsed, uuid.bytes) != 0)
+ in.setstate(ios::failbit);
+ return in;
+}
+
+std::string Uuid::str() const
+{
+ std::ostringstream os;
+ os << *this;
+ return os.str();
+}
+
+}} // namespace qpid::messaging
diff --git a/cpp/src/qpid/messaging/Variant.cpp b/cpp/src/qpid/messaging/Variant.cpp
index 9c2f92f47a..116018f797 100644
--- a/cpp/src/qpid/messaging/Variant.cpp
+++ b/cpp/src/qpid/messaging/Variant.cpp
@@ -52,6 +52,7 @@ class VariantImpl
VariantImpl(const std::string&);
VariantImpl(const Variant::Map&);
VariantImpl(const Variant::List&);
+ VariantImpl(const Uuid&);
~VariantImpl();
VariantType getType() const;
@@ -68,6 +69,7 @@ class VariantImpl
float asFloat() const;
double asDouble() const;
std::string asString() const;
+ Uuid asUuid() const;
const Variant::Map& asMap() const;
Variant::Map& asMap();
@@ -130,6 +132,7 @@ VariantImpl::VariantImpl(double d) : type(VAR_DOUBLE) { value.d = d; }
VariantImpl::VariantImpl(const std::string& s) : type(VAR_STRING) { value.v = new std::string(s); }
VariantImpl::VariantImpl(const Variant::Map& m) : type(VAR_MAP) { value.v = new Variant::Map(m); }
VariantImpl::VariantImpl(const Variant::List& l) : type(VAR_LIST) { value.v = new Variant::List(l); }
+VariantImpl::VariantImpl(const Uuid& u) : type(VAR_UUID) { value.v = new Uuid(u); }
VariantImpl::~VariantImpl() {
switch (type) {
@@ -142,6 +145,9 @@ VariantImpl::~VariantImpl() {
case VAR_LIST:
delete reinterpret_cast<Variant::List*>(value.v);
break;
+ case VAR_UUID:
+ delete reinterpret_cast<Uuid*>(value.v);
+ break;
default:
break;
}
@@ -312,11 +318,19 @@ std::string VariantImpl::asString() const
case VAR_DOUBLE: return boost::lexical_cast<std::string>(value.d);
case VAR_FLOAT: return boost::lexical_cast<std::string>(value.f);
case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
+ case VAR_UUID: return reinterpret_cast<Uuid*>(value.v)->str();
case VAR_LIST: return toString(asList());
case VAR_MAP: return toString(asMap());
default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_STRING)));
}
}
+Uuid VariantImpl::asUuid() const
+{
+ switch(type) {
+ case VAR_UUID: return *reinterpret_cast<Uuid*>(value.v);
+ default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_UUID)));
+ }
+}
bool VariantImpl::isEqualTo(VariantImpl& other) const
{
@@ -336,6 +350,8 @@ bool VariantImpl::isEqualTo(VariantImpl& other) const
case VAR_FLOAT: return value.f == other.value.f;
case VAR_STRING: return *reinterpret_cast<std::string*>(value.v)
== *reinterpret_cast<std::string*>(other.value.v);
+ case VAR_UUID: return *reinterpret_cast<Uuid*>(value.v)
+ == *reinterpret_cast<Uuid*>(other.value.v);
case VAR_LIST: return equal(asList(), other.asList());
case VAR_MAP: return equal(asMap(), other.asMap());
}
@@ -412,6 +428,7 @@ std::string VariantImpl::getTypeName(VariantType type) const
case VAR_STRING: return "string";
case VAR_MAP: return "map";
case VAR_LIST: return "list";
+ case VAR_UUID: return "uuid";
}
return "<unknown>";//should never happen
}
@@ -433,6 +450,7 @@ VariantImpl* VariantImpl::create(const Variant& v)
case VAR_STRING: return new VariantImpl(v.asString());
case VAR_MAP: return new VariantImpl(v.asMap());
case VAR_LIST: return new VariantImpl(v.asList());
+ case VAR_UUID: return new VariantImpl(v.asUuid());
default: return new VariantImpl();
}
}
@@ -454,6 +472,7 @@ Variant::Variant(const char* s) : impl(new VariantImpl(std::string(s))) {}
Variant::Variant(const Map& m) : impl(new VariantImpl(m)) {}
Variant::Variant(const List& l) : impl(new VariantImpl(l)) {}
Variant::Variant(const Variant& v) : impl(VariantImpl::create(v)) {}
+Variant::Variant(const Uuid& u) : impl(new VariantImpl(u)) {}
Variant::~Variant() { if (impl) delete impl; }
@@ -548,6 +567,13 @@ Variant& Variant::operator=(const char* s)
return *this;
}
+Variant& Variant::operator=(const Uuid& u)
+{
+ if (impl) delete impl;
+ impl = new VariantImpl(u);
+ return *this;
+}
+
Variant& Variant::operator=(const Map& m)
{
if (impl) delete impl;
@@ -583,6 +609,7 @@ int64_t Variant::asInt64() const { return impl->asInt64(); }
float Variant::asFloat() const { return impl->asFloat(); }
double Variant::asDouble() const { return impl->asDouble(); }
std::string Variant::asString() const { return impl->asString(); }
+Uuid Variant::asUuid() const { return impl->asUuid(); }
const Variant::Map& Variant::asMap() const { return impl->asMap(); }
Variant::Map& Variant::asMap() { return impl->asMap(); }
const Variant::List& Variant::asList() const { return impl->asList(); }
@@ -604,6 +631,7 @@ Variant::operator int64_t() const { return asInt64(); }
Variant::operator float() const { return asFloat(); }
Variant::operator double() const { return asDouble(); }
Variant::operator const char*() const { return asString().c_str(); }
+Variant::operator Uuid() const { return asUuid(); }
std::ostream& operator<<(std::ostream& out, const Variant::Map& map)
{
diff --git a/cpp/src/qpid/sys/windows/uuid.cpp b/cpp/src/qpid/sys/windows/uuid.cpp
index 6ff3a3cb8a..af202d60b6 100644
--- a/cpp/src/qpid/sys/windows/uuid.cpp
+++ b/cpp/src/qpid/sys/windows/uuid.cpp
@@ -57,3 +57,6 @@ void uuid_unparse (const uuid_t uu, char *out) {
}
}
+int uuid_compare (const uuid_t a, const uuid_t b) {
+ return memcmp(a, b, qpid::sys::UuidSize) == 0;
+}
diff --git a/cpp/src/qpid/sys/windows/uuid.h b/cpp/src/qpid/sys/windows/uuid.h
index c79abe95c6..249c534b91 100644
--- a/cpp/src/qpid/sys/windows/uuid.h
+++ b/cpp/src/qpid/sys/windows/uuid.h
@@ -34,5 +34,6 @@ QPID_COMMON_EXTERN void uuid_generate (uuid_t out);
QPID_COMMON_EXTERN int uuid_is_null (const uuid_t uu); // Returns 1 if null, else 0
QPID_COMMON_EXTERN int uuid_parse (const char *in, uuid_t uu); // Returns 0 on success, else -1
QPID_COMMON_EXTERN void uuid_unparse (const uuid_t uu, char *out);
+QPID_COMMON_EXTERN void uuid_compare (const uuid_t a, const uuid_t b);
#endif /*!_sys_windows_uuid_h*/
View Lorry Controller Status