src/main/activemq/wireformat/stomp/StompFrame.h

Go to the documentation of this file.

/*
 * 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.
 */

#ifndef _ACTIVEMQ_WIREFORMAT_STOMP_STOMPFRAMEWRAPPER_H_
#define _ACTIVEMQ_WIREFORMAT_STOMP_STOMPFRAMEWRAPPER_H_

#include <string>
#include <string.h>
#include <map>
#include <decaf/util/Properties.h>
#include <decaf/io/DataOutputStream.h>
#include <decaf/io/DataInputStream.h>
#include <activemq/util/Config.h>

namespace activemq{
namespace wireformat{
namespace stomp{

    class AMQCPP_API StompFrame{
    private:

        // String Name of this command.
        std::string command;

        // Properties of the Stomp Message
        decaf::util::Properties properties;

        // Byte data of Body.
        std::vector<unsigned char> body;

    public:

        StompFrame();

        virtual ~StompFrame();

        StompFrame* clone() const;

        void copy( const StompFrame* src );

        void setCommand( const std::string& cmd ){
            this->command = cmd;
        }

        const std::string& getCommand() const{
            return command;
        }

        bool hasProperty( const std::string& name ) const {
            return this->properties.hasProperty( name );
        }

        std::string getProperty( const std::string& name, const std::string& fallback = "" ) const {
            return this->properties.getProperty( name, fallback );
        }

        std::string removeProperty( const std::string& name ) {
            return this->properties.getProperty( name, "" );
        }

        void setProperty( const std::string& name, const std::string& value ) {
            this->properties.setProperty( name, value );
        }

        decaf::util::Properties& getProperties(){ return properties; }
        const decaf::util::Properties& getProperties() const {
            return properties;
        }

        const std::vector<unsigned char>& getBody() const{
            return body;
        }

        std::vector<unsigned char>& getBody(){
            return body;
        }

        std::size_t getBodyLength() const{ return body.size(); }

        void setBody( const unsigned char* bytes, std::size_t numBytes );

        void toStream( decaf::io::DataOutputStream* stream ) const;

        void fromStream( decaf::io::DataInputStream* stream );

    private:

        void readCommandHeader( decaf::io::DataInputStream* in );

        void readHeaders( decaf::io::DataInputStream* in );

        std::size_t readHeaderLine( std::vector<unsigned char>& buffer,
                                    decaf::io::DataInputStream* in );

        void readBody( decaf::io::DataInputStream* in );

    };

}}}

#endif /*_ACTIVEMQ_WIREFORMAT_STOMP_STOMPFRAMEWRAPPER_H_*/