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/Frame.cpp | 119 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 cpp/src/qpid/framing/Frame.cpp (limited to 'cpp/src/qpid/framing/Frame.cpp') 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 -- cgit v1.2.1