| /** |
| * 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 <activemq/commands/WireFormatInfo.h> |
| |
| #include <activemq/state/CommandVisitor.h> |
| #include <activemq/wireformat/openwire/marshal/PrimitiveTypesMarshaller.h> |
| #include <decaf/lang/exceptions/NullPointerException.h> |
| |
| using namespace std; |
| using namespace decaf; |
| using namespace decaf::lang; |
| using namespace decaf::lang::exceptions; |
| using namespace activemq; |
| using namespace activemq::exceptions; |
| using namespace activemq::wireformat; |
| using namespace activemq::wireformat::openwire; |
| using namespace activemq::wireformat::openwire::marshal; |
| using namespace activemq::commands; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| WireFormatInfo::WireFormatInfo() : BaseCommand(), magic(), marshalledProperties(), properties(), version(5) { |
| |
| // Initialize the MAGIC buffer. |
| magic.push_back('A'); |
| magic.push_back('c'); |
| magic.push_back('t'); |
| magic.push_back('i'); |
| magic.push_back('v'); |
| magic.push_back('e'); |
| magic.push_back('M'); |
| magic.push_back('Q'); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| WireFormatInfo::~WireFormatInfo() { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| DataStructure* WireFormatInfo::cloneDataStructure() const { |
| WireFormatInfo* wireFormatInfo = new WireFormatInfo(); |
| |
| // Copy the data from the base class or classes |
| wireFormatInfo->copyDataStructure( this ); |
| |
| return wireFormatInfo; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::copyDataStructure(const DataStructure* src) { |
| |
| // Copy the data of the base class or classes |
| BaseCommand::copyDataStructure(src); |
| |
| const WireFormatInfo* srcPtr = dynamic_cast<const WireFormatInfo*>(src); |
| |
| if (srcPtr == NULL || src == NULL) { |
| throw NullPointerException(__FILE__, __LINE__, |
| "WireFormatInfo::copyDataStructure - src is NULL or invalid"); |
| } |
| |
| this->properties.copy(srcPtr->getProperties()); |
| this->version = srcPtr->getVersion(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| unsigned char WireFormatInfo::getDataStructureType() const { |
| return WireFormatInfo::ID_WIREFORMATINFO; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| std::string WireFormatInfo::toString() const { |
| |
| std::ostringstream stream; |
| |
| stream << "WireFormatInfo { " |
| << "commandId = " << this->getCommandId() << ", " |
| << "responseRequired = " << boolalpha << this->isResponseRequired() << ", "; |
| |
| std::vector<unsigned char> magic; |
| std::vector<unsigned char> marshalledProperties; |
| |
| stream << "Magic = [ "; |
| for (size_t imagic = 0; imagic < magic.size(); ++imagic) { |
| stream << magic[imagic]; |
| if (imagic < magic.size() - 1) { |
| stream << ", "; |
| } |
| } |
| |
| stream << "Version = " << version << ", "; |
| stream << "StackTraceEnabled = " << isStackTraceEnabled() << ", "; |
| stream << "TcpNoDelayEnabled = " << isTcpNoDelayEnabled() << ", "; |
| stream << "CacheEnabled = " << isCacheEnabled() << ", "; |
| stream << "CacheSize = " << getCacheSize() << ", "; |
| stream << "TightEncodingEnabled = " << isTightEncodingEnabled() << ", "; |
| stream << "SizePrefixDisabled = " << isSizePrefixDisabled() << ", "; |
| stream << "MaxInactivityDuration = " << getMaxInactivityDuration() << ", "; |
| stream << "MaxInactivityDuration = " << getMaxInactivityDurationInitalDelay(); |
| |
| stream << " }"; |
| |
| return stream.str(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::equals( const DataStructure* value ) const { |
| |
| const WireFormatInfo* wireFormatInfo = dynamic_cast<const WireFormatInfo*>(value); |
| |
| if (value == NULL || wireFormatInfo == NULL) { |
| return false; |
| } |
| |
| if (magic != wireFormatInfo->getMagic()) { |
| return false; |
| } |
| if (marshalledProperties != wireFormatInfo->getMarshalledProperties()) { |
| return false; |
| } |
| if (!properties.equals(wireFormatInfo->properties)) { |
| return false; |
| } |
| if (version != wireFormatInfo->getVersion()) { |
| return false; |
| } |
| if (isStackTraceEnabled() != wireFormatInfo->isStackTraceEnabled()) { |
| return false; |
| } |
| if (isTcpNoDelayEnabled() != wireFormatInfo->isTcpNoDelayEnabled()) { |
| return false; |
| } |
| if (isCacheEnabled() != wireFormatInfo->isCacheEnabled()) { |
| return false; |
| } |
| if (getCacheSize() != wireFormatInfo->getCacheSize()) { |
| return false; |
| } |
| if (isTightEncodingEnabled() != wireFormatInfo->isTightEncodingEnabled()) { |
| return false; |
| } |
| if (isSizePrefixDisabled() != wireFormatInfo->isSizePrefixDisabled()) { |
| return false; |
| } |
| if (!BaseCommand::equals(value)) { |
| return false; |
| } |
| if (getMaxInactivityDuration() != wireFormatInfo->getMaxInactivityDuration()) { |
| return false; |
| } |
| if (getMaxInactivityDurationInitalDelay() != wireFormatInfo->getMaxInactivityDurationInitalDelay()) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| decaf::lang::Pointer<commands::Command> WireFormatInfo::visit(activemq::state::CommandVisitor* visitor) { |
| return visitor->processWireFormat(this); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isValid() const { |
| |
| if (magic.size() != std::string("ActiveMQ").size()) { |
| return false; |
| } |
| |
| if (magic[0] != 'A' || |
| magic[1] != 'c' || |
| magic[2] != 't' || |
| magic[3] != 'i' || |
| magic[4] != 'v' || |
| magic[5] != 'e' || |
| magic[6] != 'M' || |
| magic[7] != 'Q') { |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isStackTraceEnabled() const { |
| |
| try { |
| return properties.getBool("StackTraceEnabled"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setStackTraceEnabled(bool stackTraceEnabled) { |
| |
| try { |
| properties.setBool("StackTraceEnabled", stackTraceEnabled); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isTcpNoDelayEnabled() const { |
| |
| try { |
| return properties.getBool("TcpNoDelayEnabled"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setTcpNoDelayEnabled(bool tcpNoDelayEnabled) { |
| |
| try { |
| properties.setBool("TcpNoDelayEnabled", tcpNoDelayEnabled); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isCacheEnabled() const { |
| |
| try { |
| return false; |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setCacheEnabled(bool cacheEnabled AMQCPP_UNUSED) { |
| |
| try { |
| // Turning this on is not supported as it causes the client to not work. |
| properties.setBool("CacheEnabled", false); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isTightEncodingEnabled() const { |
| |
| try { |
| return properties.getBool("TightEncodingEnabled"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setTightEncodingEnabled(bool tightEncodingEnabled) { |
| |
| try { |
| properties.setBool("TightEncodingEnabled", tightEncodingEnabled); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| bool WireFormatInfo::isSizePrefixDisabled() const { |
| |
| try { |
| return properties.getBool("SizePrefixDisabled"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setSizePrefixDisabled(bool sizePrefixDisabled) { |
| |
| try { |
| properties.setBool("SizePrefixDisabled", sizePrefixDisabled); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::beforeMarshal(WireFormat* wireFormat AMQCPP_UNUSED) { |
| |
| try { |
| marshalledProperties.clear(); |
| if (!properties.isEmpty()) { |
| marshal::PrimitiveTypesMarshaller::marshal(&properties, marshalledProperties); |
| } |
| } |
| AMQ_CATCH_RETHROW(decaf::io::IOException) |
| AMQ_CATCH_EXCEPTION_CONVERT(exceptions::ActiveMQException, decaf::io::IOException) |
| AMQ_CATCHALL_THROW(decaf::io::IOException) |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::afterUnmarshal(WireFormat* wireFormat AMQCPP_UNUSED) { |
| |
| try { |
| marshal::PrimitiveTypesMarshaller::unmarshal(&properties, marshalledProperties); |
| } |
| AMQ_CATCH_RETHROW(decaf::io::IOException) |
| AMQ_CATCH_EXCEPTION_CONVERT(exceptions::ActiveMQException, decaf::io::IOException) |
| AMQ_CATCHALL_THROW(decaf::io::IOException) |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| long long WireFormatInfo::getMaxInactivityDuration() const { |
| |
| try { |
| return properties.getLong("MaxInactivityDuration"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return 0LL; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setMaxInactivityDuration(long long maxInactivityDuration) { |
| try { |
| properties.setLong("MaxInactivityDuration", maxInactivityDuration); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| long long WireFormatInfo::getMaxInactivityDurationInitalDelay() const { |
| try { |
| return properties.getLong("MaxInactivityDurationInitalDelay"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return 0LL; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setMaxInactivityDurationInitalDelay(long long maxInactivityDurationInitalDelay) { |
| try { |
| properties.setLong("MaxInactivityDurationInitalDelay", maxInactivityDurationInitalDelay); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| int WireFormatInfo::getCacheSize() const { |
| try { |
| return properties.getInt("CacheSize"); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| |
| return 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| void WireFormatInfo::setCacheSize(int value) { |
| try { |
| properties.setInt("CacheSize", value); |
| } |
| AMQ_CATCH_NOTHROW(exceptions::ActiveMQException) |
| AMQ_CATCHALL_NOTHROW() |
| } |