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

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

Go to the documentation of this file.

#ifndef _BASICLOCALPROPERTY_HH_
#define _BASICLOCALPROPERTY_HH_

#include <vos/vos/localproperty.hh>
#include <vos/vos/propertylistener.hh>


namespace VOS {

/** @class BasicLocalProperty basiclocalproperty.hh vos/metaobjects/property/basiclocalproperty.hh
    Base class for local properties.  Simply stores data and listeners.
    @ingroup libmetaobject_property
  */
    class VOS_API BasicLocalProperty : public LocalProperty, public PersistBlockListener
{
private:
    boost::recursive_mutex data_mutex;

    std::string data;
    std::string datatype;

    VUtil::ListenerBase<PropertyListener, PropertyEvent> propertyListeners;

protected:
    BasicLocalProperty(VobjectBase* superobject);

public:

    static MetaObject* new_BasicLocalProperty(VobjectBase* superobject, const std::string& calledtype);

    /** 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);

    virtual void write(int start, const std::string& newdata)
        { write(0, start, newdata); }

    virtual void replace(const std::string& newdata, const std::string& newtype = "?")
        { replace(0, newdata, newtype); }

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

    /** Completely change the value and type of data stored in this property.
        @param initiator Object requesting replacement, for access control check.
        @param newdata New data.
        @param newtype The type of the new datatype. If no type identifier was supplied, the previous one is kept.
    */
    virtual void replace(Vobject* initiator, const std::string& newdata, const std::string& newtype = "?");

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

    /** Set a subproperty on an object, returning relation between object and property.
     *  @param on   Object to set a subproperty on
     *  @param propname Name of the property to set
     *  @param propval  New value of the property
     *  @param valtype  Datatype of the new value
     *  @param pac  Property access control to add to the object it it had to be created (If property exists, this argument is ignored)
     *  @param letErrorThrough If given, determines whether exceptions will be
     *  caught in this method (false), or thrown out to the caller (true).
     *  @return object expressing relation between the object and the property
     */
    static VUtil::vRef<ParentChildRelation> setProperty(Vobject& on,
                                                 const std::string& propname,
                                                 const std::string& propval,
                                                 const std::string& valtype,
                                                 const std::string& pac,
                                                 bool letErrorThrough = false);

    /** 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 contents.
     */
    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);

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

    /** @see VUtil::ListenernBase::getAsynchronousEvents() */
    virtual bool getAsynchronousEvents() {
        return propertyListeners.getAsynchronousEvents();
    }
    /** @see VUtil::ListenernBase::setAsynchronousEvents() */
    virtual void setAsynchronousEvents(bool b) {
        propertyListeners.setAsynchronousEvents(b);
    }

    virtual void notifyBlockChanging(const std::string& key, const std::string& data);
    virtual void notifyBlockChanged(const std::string& key, const std::string& data);
};

}

#endif