From a45694048d1f26e0ed317f661b464bae862fb8fa Mon Sep 17 00:00:00 2001 From: Alan Conway Date: Tue, 7 Aug 2007 22:28:06 +0000 Subject: * Summary: new Frame type to replace AMQFrame. Instead of holding a shared_ptr to a heap-allocated AMQBody subclass, it holds the body in-line in a boost::variant of all the concrete AMQBody subclasses. Actually there are nested variants, the compiler does not cope well with a single variant of 130-some types. Creating, encoding and decoding a local Frame doess 0 heap allocation apart from that done by the concrete AMQBody::encode/decode - e.g. method bodies with std::string fields. for method bodies All variants contain type boost::blank. This guarantees 0 heap alloocation by the variant and represents the "uninitialized" state. variant.h provides NoBlankVisitor to help write visitors for variants containing blank. * src/qpid/framing/MethodHolder.h, .cpp: Holds a variant containing a method body. * src/qpid/framing/Frame.h, .cpp: New Frame holds body in a variant rather than via heap allocation. * src/qpid/framing/variant.h: Utilities for using boost::variant. * src/qpid/framing/amqp_types.h: Added FrameType typedef. * src/qpid/framing/AMQMethodBody.h: Friends with MethodHolder. * src/Makefile.am: - Improved ruby generation rule. - Run method_variants template. - Added new source files - Pre-compiled header rule for method_variants.h * rubygen/templates/method_variants.rb: Generate variants to hold methods of each class, and MethodVariant to hold all the class variants. * rubygen/cppgen.rb: variant, tuple methods. * MethodBodyClass.h.tmpl: Added default constructor to method bodies. * amqpgen.rb (AmqpRoot::merge): fix bug in merge. git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@563683 13f79535-47bb-0310-9956-ffa450edef68 --- cpp/src/qpid/framing/AMQMethodBody.h | 1 + cpp/src/qpid/framing/Frame.cpp | 119 ++++++++++++++++++++++++++++++++++ cpp/src/qpid/framing/Frame.h | 72 ++++++++++++++++++++ cpp/src/qpid/framing/MethodHolder.cpp | 93 ++++++++++++++++++++++++++ cpp/src/qpid/framing/MethodHolder.h | 80 +++++++++++++++++++++++ cpp/src/qpid/framing/amqp_types.h | 1 + cpp/src/qpid/framing/variant.h | 92 ++++++++++++++++++++++++++ 7 files changed, 458 insertions(+) create mode 100644 cpp/src/qpid/framing/Frame.cpp create mode 100644 cpp/src/qpid/framing/Frame.h create mode 100644 cpp/src/qpid/framing/MethodHolder.cpp create mode 100644 cpp/src/qpid/framing/MethodHolder.h create mode 100644 cpp/src/qpid/framing/variant.h (limited to 'cpp/src/qpid') diff --git a/cpp/src/qpid/framing/AMQMethodBody.h b/cpp/src/qpid/framing/AMQMethodBody.h index 2b46c6ea00..cbfd438b48 100644 --- a/cpp/src/qpid/framing/AMQMethodBody.h +++ b/cpp/src/qpid/framing/AMQMethodBody.h @@ -80,6 +80,7 @@ class AMQMethodBody : public AMQBody virtual void printPrefix(std::ostream&) const {} + friend class MethodHolder; }; diff --git a/cpp/src/qpid/framing/Frame.cpp b/cpp/src/qpid/framing/Frame.cpp new file mode 100644 index 0000000000..7bdc0adf00 --- /dev/null +++ b/cpp/src/qpid/framing/Frame.cpp @@ -0,0 +1,119 @@ +/* + * + * 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 + +#include "Frame.h" +#include "qpid/QpidError.h" +#include "AMQRequestBody.h" +#include "AMQResponseBody.h" + + +namespace qpid { +namespace framing { + +namespace { +struct GetBodyVisitor : public NoBlankVisitor { + QPID_USING_NOBLANK(AMQBody*); + AMQBody* operator()(MethodHolder& h) const { return h.getMethod(); } + template AMQBody* operator()(T& t) const { return &t; } +}; +} + +AMQBody* Frame::getBody() { + return boost::apply_visitor(GetBodyVisitor(), body); +} + +const AMQBody* Frame::getBody() const { + return boost::apply_visitor(GetBodyVisitor(), const_cast(body)); +} + +void Frame::encode(Buffer& buffer) +{ + buffer.putOctet(getBody()->type()); + buffer.putShort(channel); + buffer.putLong(getBody()->size()); + getBody()->encode(buffer); + buffer.putOctet(0xCE); +} + +uint32_t Frame::size() const{ + return 1/*type*/ + 2/*channel*/ + 4/*body size*/ + getBody()->size() + + 1/*0xCE*/; +} + +bool Frame::decode(Buffer& buffer) +{ + if(buffer.available() < 7) + return false; + buffer.record(); + uint32_t frameSize = decodeHead(buffer); + if(buffer.available() < frameSize + 1){ + buffer.restore(); + return false; + } + decodeBody(buffer, frameSize); + uint8_t end = buffer.getOctet(); + if(end != 0xCE) THROW_QPID_ERROR(FRAMING_ERROR, "Frame end not found"); + return true; +} + +uint32_t Frame::decodeHead(Buffer& buffer){ + type = buffer.getOctet(); + channel = buffer.getShort(); + return buffer.getLong(); +} + +void Frame::decodeBody(Buffer& buffer, uint32_t size) +{ + switch(type) + { + case METHOD_BODY: + case REQUEST_BODY: + case RESPONSE_BODY: { + ClassId c=buffer.getShort(); + MethodId m=buffer.getShort(); + body = MethodHolder(c,m); + break; + } + case HEADER_BODY: + body = AMQHeaderBody(); + break; + case CONTENT_BODY: + body = AMQContentBody(); + break; + case HEARTBEAT_BODY: + body = AMQHeartbeatBody(); + break; + default: + THROW_QPID_ERROR( + FRAMING_ERROR, + boost::format("Unknown frame type %d") % type); + } + getBody()->decode(buffer, size); +} + +std::ostream& operator<<(std::ostream& out, const Frame& f) +{ + return out << "Frame[channel=" << f.getChannel() << "; " << f.body << "]"; +} + + +}} // namespace qpid::framing diff --git a/cpp/src/qpid/framing/Frame.h b/cpp/src/qpid/framing/Frame.h new file mode 100644 index 0000000000..4a504a6b41 --- /dev/null +++ b/cpp/src/qpid/framing/Frame.h @@ -0,0 +1,72 @@ +#ifndef _AMQFrame_ +#define _AMQFrame_ + +/* + * + * 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 "AMQDataBlock.h" +#include "AMQHeaderBody.h" +#include "AMQContentBody.h" +#include "AMQHeartbeatBody.h" +#include "MethodHolder.h" + +namespace qpid { +namespace framing { + +class Frame : public AMQDataBlock { + public: + typedef boost::variant Variant; + + Frame(ChannelId channel_=0, const Variant& body_=Variant()) + : body(body_), channel(channel_) {} + + void encode(Buffer& buffer); + bool decode(Buffer& buffer); + uint32_t size() const; + + uint16_t getChannel() const { return channel; } + + AMQBody* getBody(); + const AMQBody* getBody() const; + + template T* castBody() { + return boost::polymorphic_downcast(getBody()); + } + + Variant body; + + private: + uint32_t decodeHead(Buffer& buffer); + void decodeBody(Buffer& buffer, uint32_t size); + + uint8_t type; + uint16_t channel; +}; + +std::ostream& operator<<(std::ostream&, const Frame&); + +}} // namespace qpid::framing + + +#endif diff --git a/cpp/src/qpid/framing/MethodHolder.cpp b/cpp/src/qpid/framing/MethodHolder.cpp new file mode 100644 index 0000000000..27046af43c --- /dev/null +++ b/cpp/src/qpid/framing/MethodHolder.cpp @@ -0,0 +1,93 @@ +/* + * + * 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 "MethodHolder.h" +#include "amqp_types.h" +#include "qpid/framing/Buffer.h" +#include "qpid/framing/variant.h" + +using namespace boost; + +namespace qpid { +namespace framing { + +struct SetVariantVisitor : public NoBlankVisitor<> { + QPID_USING_NOBLANK(); + MethodId id; + SetVariantVisitor(MethodId m) : id(m) {} + template void operator()(T& t) const { setVariant(t, id); } +}; + +inline void setVariant(MethodVariant& var, ClassId c, MethodId m) { + setVariant(var,c); + boost::apply_visitor(SetVariantVisitor(m), var); +} + +void MethodHolder::setMethod(ClassId c, MethodId m) { + setVariant(method, c, m); +} + +MethodHolder::MethodHolder(ClassId c, MethodId m) { + setMethod(c,m); +} + +struct GetClassId : public NoBlankVisitor { + QPID_USING_NOBLANK(ClassId); + template ClassId operator()(const T&) const { + return T::CLASS_ID; + } +}; + +struct GetMethodId : public NoBlankVisitor { + QPID_USING_NOBLANK(ClassId); + template MethodId operator()(const T&) const { + return T::METHOD_ID; + } +}; + +void MethodHolder::encode(Buffer& b) const { + const AMQMethodBody* body = getMethod(); + b.putShort(body->amqpClassId()); + b.putShort(body->amqpMethodId()); + body->encodeContent(b); +} + +void MethodHolder::decode(Buffer& b) { + ClassId classId = b.getShort(); + ClassId methodId = b.getShort(); + setVariant(method, classId, methodId); + getMethod()->decodeContent(b); +} + +uint32_t MethodHolder::size() const { + return sizeof(ClassId)+sizeof(MethodId)+getMethod()->size(); +} + + +AMQMethodBody* MethodHolder::getMethod() { + return applyApplyVisitor(AddressVisitor(), method); +} + +const AMQMethodBody* MethodHolder::getMethod() const { + return const_cast(this)->getMethod(); +} + +}} // namespace qpid::framing diff --git a/cpp/src/qpid/framing/MethodHolder.h b/cpp/src/qpid/framing/MethodHolder.h new file mode 100644 index 0000000000..b93c6b83b1 --- /dev/null +++ b/cpp/src/qpid/framing/MethodHolder.h @@ -0,0 +1,80 @@ +#ifndef QPID_FRAMING_METHODBODYHOLDER_H +#define QPID_FRAMING_METHODBODYHOLDER_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 "qpid/framing/method_variants.h" + +#include + +namespace qpid { +namespace framing { + +class AMQMethodBody; + +/** + * Holder for arbitrary method body. + */ +class MethodHolder +{ + public: + MethodHolder() {} + MethodHolder(const MethodVariant& mv) : method(mv) {} + + /** Construct from a concrete method body type. + * ClassVariant::value is the containing class variant. + */ + template + MethodHolder(const T& t) + : method(typename ClassVariant::value(t)) {} + + /** Construct from class/method ID, set the method accordingly. */ + MethodHolder(ClassId, MethodId); + + /** Set the method to the type corresponding to ClassId, MethodId */ + void setMethod(ClassId, MethodId); + + AMQMethodBody* getMethod(); + const AMQMethodBody* getMethod() const; + + MethodVariant method; + + void encode(Buffer&) const; + void decode(Buffer&); + uint32_t size() const; +}; + +inline std::ostream& operator<<(std::ostream& out, const MethodHolder& h) { + return out << h.method; +} + + +}} // namespace qpid::framing + +namespace boost { +template<> struct has_nothrow_copy + : public boost::true_type {}; +} + + + +#endif /*!QPID_FRAMING_METHODBODYHOLDER_H*/ diff --git a/cpp/src/qpid/framing/amqp_types.h b/cpp/src/qpid/framing/amqp_types.h index ff75b28468..5ea08a69af 100644 --- a/cpp/src/qpid/framing/amqp_types.h +++ b/cpp/src/qpid/framing/amqp_types.h @@ -42,6 +42,7 @@ namespace qpid { namespace framing { using std::string; +typedef uint8_t FrameType; typedef uint16_t ChannelId; typedef uint64_t RequestId; typedef uint64_t ResponseId; diff --git a/cpp/src/qpid/framing/variant.h b/cpp/src/qpid/framing/variant.h new file mode 100644 index 0000000000..3cb8aece5d --- /dev/null +++ b/cpp/src/qpid/framing/variant.h @@ -0,0 +1,92 @@ +#ifndef QPID_FRAMING_VARIANT_H +#define QPID_FRAMING_VARIANT_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. + * + */ + +/**@file Tools for using boost::variant */ + +#include "qpid/QpidError.h" + +#include + +namespace qpid { +namespace framing { +class Buffer; + +/** boost::static_visitor that throws exception if variant contains blank. + * Sublclasses need to have a using() declaration, can be generated + * with QPID_USING_BLANK_THROW(R) + */ +template +struct NoBlankVisitor : public boost::static_visitor { + R foundBlank() const { + assert(0); + THROW_QPID_ERROR(INTERNAL_ERROR, "Invalid variant value."); + } + R operator()(const boost::blank&) const { return foundBlank(); } + R operator()(boost::blank&) const { return foundBlank(); } +}; + + +}} // qpid::framing + + +/** Generate using statement needed in visitors inheriting NoBlankVisitor + * @param R return type. + */ +#define QPID_USING_NOBLANK(R) using ::qpid::framing::NoBlankVisitor::operator() + +namespace qpid { +namespace framing { + +/** Convert the variant value to type R. */ +template struct ConvertVisitor : public NoBlankVisitor { + QPID_USING_NOBLANK(R); + template R operator()(T& t) const { return t; } +}; + +/** Convert address of variant value to type R. */ +template struct AddressVisitor : public NoBlankVisitor { + QPID_USING_NOBLANK(R); + template R operator()(T& t) const { return &t; } +}; + +/** Apply a visitor to the nested variant in a variant of variants */ +template +struct ApplyVisitor : public NoBlankVisitor { + QPID_USING_NOBLANK(typename V::result_type); + const V& visitor; + ApplyVisitor(const V& v) : visitor(v) {} + template typename V::result_type operator()(T& t) const { + return boost::apply_visitor(visitor, t); + } +}; + +/** Convenience function to construct and apply an ApplyVisitor */ +template +typename Visitor::result_type applyApplyVisitor(const Visitor& visitor, Visitable& visitable) { + return boost::apply_visitor(ApplyVisitor(visitor), visitable); +} + +}} // namespace qpid::framing + + +#endif /*!QPID_FRAMING_VARIANT_H*/ -- cgit v1.2.1