[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/messageblock.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/

#ifndef _MESSAGEBLOCK_HH_
#define _MESSAGEBLOCK_HH_

#include <iostream>
#include <deque>

#include <boost/thread/recursive_mutex.hpp>

#include <vos/vos/vosdefs.hh>
#include <vos/vutil/refcount.hh>

#define MSGENC_BINARY_SINGLE  1
#define MSGENC_BINARY_BLOCK   2
#define MSGENC_XML           '<'

namespace VOS
{
    class MessageBlock;
    class Message;

/**
    Stores some state information needed between calls to the Message parser, when
    a message has only been partially parsed.
    @internal
 */
struct parse_state_t
{
    MessageBlock* m;
    unsigned int chars_read;
    unsigned int expected_length;
    uint32_t nonce;
    bool done;
    void* extra;
    int read_quoted;
    std::istream* input;
};

    class MBParser
    {
    public:
        virtual ~MBParser() { }
        virtual int parseUpdate(const std::string& s, uint32_t& nonce) = 0;
        virtual size_t getBufferSize() = 0;
        virtual size_t getExpectedSize() = 0;
    };

    class BinaryParser : public MBParser
    {
    private:
        std::string parse_buffer;
        uint32_t msgsize;
        uint8_t encoding;
        MessageBlock* msgblock;
        void readMsgBlock(const uint8_t* s, size_t input_length);
        unsigned int readSingleMsg(const uint8_t* s, size_t input_length);

    public:
        BinaryParser(MessageBlock* mb);
        virtual ~BinaryParser() { }

        virtual int parseUpdate(const std::string& s, uint32_t& nonce);
        virtual size_t getBufferSize();
        virtual size_t getExpectedSize();
    };

    class XmlParser : public MBParser
    {
    private:
        std::string parse_buffer;
        uint32_t msgsize;
        MessageBlock* msgblock;
        std::string parseWord(size_t& pos);
        std::string parseStringAttr(size_t& pos);
        uint32_t parseNumberAttr(size_t& pos);
        void readMsgBlock(size_t& pos);
        void readSingleMsg(size_t& pos, uint32_t& nonce, bool withLength);

    public:
        XmlParser(MessageBlock* mb);
        virtual ~XmlParser() { }

        virtual int parseUpdate(const std::string& s, uint32_t& nonce);
        virtual size_t getBufferSize();
        virtual size_t getExpectedSize();
    };


/**  @class MessageBlock messageblock.hh vos/vos/messageblock.hh
     @ingroup libvos

     A message block is a list of messages which have been bundled
     together into a single block.  It is used for various purposes.
     One useful feature of a message block is that it is processed all
     at once: the first message will not be delivered until the entire
     message block has been received, parsed and queued.  This may be
     useful for supporting transactions.
 */
    class VOS_API MessageBlock : public VUtil::RefCounted
{
private:
    boost::recursive_mutex messageblock_mutex;

    MBParser* parser;
    std::deque<Message*> messages;
    std::string* formattedString;
    std::string name;

public:
    MessageBlock();
    ~MessageBlock();

    /** Set the message block name.  This means the message block will
        be saved with this name rather than executed immediately.
        @param s the name
    */
    void setName(const std::string& s);

    /** @return the message block name
    */
    std::string getName();

    /** Add a message to the message block.
        @param n The position to insert into.  May be negative, in which case the position
        will be counted from the end.  To append to the end, use -1.
        @param m the message to insert
    */
    void insertMessage(int n, Message* m);

    /** Add a message to the message block.
        @param m the message to insert
    */
    inline void appendMessage(Message* m) { insertMessage(-1, m); };

    /** Remove a message from the message block.
        @param n The position to remove.
    */
    void removeMessage(int n);

    /** Retrieve a message from this messageblock.
        @param n The desired position.  May be negative, in which case
        the position will be counted from the end.  The very
        last element can be accessed using -1.
        @return The message at the desired position, or 0 if the index is invalid.
    */
    VUtil::vRef<Message> getMessage(int n);

    /** @return The last message or a null vRef if the message block is empty. */
    VUtil::vRef<Message> lastMessage();

    /** @return the number of messages in the messageblock. */
    int numMessages();

    /** Get the XML-like textual representation of this messageblock,
        suitable for logging to the user
     */
    std::string getFormattedString();

    /** Get the binary representation of this messageblock,
        suitable for sending over the network.
     */
    std::string getBinaryEncoding();

    /** Internal parsing function.  Update the current partial parse
        of this messageblock with new data.
        @param s the new data
        @return The number of bytes from the beginning of 's' which
        were read in.
    */
    int parseUpdate(const std::string& s, uint32_t& nonce);

    /** @return the number of bytes received so far in the process of downloading
        this message or message block
    */
    unsigned int getReceivedBytes();

    /** @return the number of bytes expected in total for this message
        or message block
    */
    unsigned int getExpectedBytes();
};

}

#endif