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

/home/tetron/hack/vos/libs/vos/vos/remoteproperty.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, 2002 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 
    Additions by Reed Hedges marked with initials "rh" and date.
*/
#ifndef _REMOTEPROPERTY_HH_
#define _REMOTEPROPERTY_HH_

#include <vos/vos/property.hh>

namespace VOS {
    class PropertyListener;
    class PropertyEvent;

    class VOS_API RemoteProperty : public Property
    {
    private:
        boost::mutex data_mutex;

        std::string cached_data;
        std::string cached_datatype;

        uint32_t outgoing_replace_nonce;

        bool doAsyncWrite;

        VUtil::ListenerBase<PropertyListener, PropertyEvent> propertyListeners;

        void updateHandler(Message* m);
        void startListeningHandler(Message* m);

    protected:
        RemoteProperty(VobjectBase* superobject);

    public:

        static MetaObject* new_RemoteProperty(VobjectBase* superobject, const std::string& type);

        /** Get length (bytes) of decoded data. */
        virtual int getLength();

        /** Read decoded data into target, possibly performing decode if necesary
         * @see read(std::string, int, int)
         */
        virtual void read(std::string& target);

        /** Read a substring of decoded data into target, possibly performing decode if necesary
         * @param target    Place data in this string
         * @param start     Byte offset to start reading
         * @param length    Number of bytes to read. If this parameter is -1, read
         *                  until the end of the data.
         */
        virtual void read(std::string& target, int start, int length);

        /** Return decoded data, possibly performing decode if necesary
         * @see read(std::string, int int)
         */
        virtual std::string read();

        /** Return substring of decoded data, possibly performing decode if necesary
            @see read(std::string, int int)
        */
        virtual std::string read(int start, int length);

        /** Write newdata into property value, starting at byte position start */
        virtual void write(int start, const std::string& newdata);

        /** Completely change the value and type of data stored in this property.
            @param newdata New data.
            @param newtype The type of the new datatype. If no type identifier was supplied, the previous one is kept.
            NOTE: the initial datatype (set by the constructor) is "?" which is (or should be) an invalid value for
            any application.
        */
        virtual void replace(const std::string& newdata, const std::string& newtype = "?");

        /** Return type of decoded data (usually a MIME type) */
        virtual const std::string getDataType();

        /** Add a new property listener to this property. This listener's methods
         * will be called when the property is modified.
         * @see PropertyListener
         * @param pl    The new property listener. If it is also a RefCounted
         * object, references will be acquired correctly.
         * @param refresh If given, determines whether the new property
         *   listener will be immediately notified of the current property
         *   value (before this method returns).
         */
        virtual void addPropertyListener(PropertyListener* pl, bool refresh = true);

        /** Remove the property listener 'pl' from this property.
         * @param pl    Listener to remove. If it is also a RefCounted object,
         * references will be released correctly.
         */
        virtual void removePropertyListener(PropertyListener* pl);

        /** Asynchronous replace means calls to "replace" will be
            assumed successful and immediately committed locally,
            without waiting for response from the remote site.
         */
        virtual void enableAsyncReplace(bool b);

        /** Return MetaObject type, "property" */
        virtual const std::string getVOSType();
    };
}

#endif