vos/metaobjects/property/extrapolatedproperty.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 <tetron@interreality.org>
*/
#ifndef _EXTRAPOLATEDPROPERTY_HH_
#define _EXTRAPOLATEDPROPERTY_HH_

#include <typeinfo>
#include <set>
#include <vector>

#include "property.hh"

#include "bufferedproperty.hh"

#include "propertylistener.hh"

/** @class ExtrapolatedProperty extrapolatedproperty.hh vos/metaobjects/property/extrapolatedproperty.hh
 *
 * Use this Property subclass to store continusouly changing numerical values.
 * Scalars and vectors can be used.  The values are extrapolated by remote
 * objects, avoiding the need for repeated update messages.  
 *
 * @todo remove interfaces for setting datatype, it should always be
 * "text/x-vector-float".
 * @todo document this class better, incl. write otd.
 */

class PROPERTY_API ExtrapolatedProperty : public virtual Property
{
protected:
    typedef set<ExtrapolatedPropertyListener*, ExtrapolatedListenerSiteWrapper::Cmp> ExtrapolationListenerSet;
    ExtrapolationListenerSet extrapolationListeners;
    static set<ExtrapolatedProperty*> allexps;
    typedef set<ExtrapolatedProperty*> AllExpSet;
    vector<double> x;
    vector<double> dx;
    vector<double> ddx;
    double lastCheckpoint;
    ExtrapolatedProperty(MetaObject* superobject);
public:
    virtual ~ExtrapolatedProperty();
    static void registerExtenders();
    static void updateAll();
    virtual void update();
    virtual void set(const vector<double>& x, const vector<double>& dx, const vector<double>& ddx, double t = 0.0) = 0;
    static string stringifyVector(const vector<double>& x);
    static void stringToVector(const string& prop, vector<double>& x);
    void getBase(vector<double>& ax,
                 vector<double>& adx,
                 vector<double>& addx);
    void getCurrent(vector<double>& ax,
                    vector<double>& adx,
                    vector<double>& addx,
                    double& t);
    virtual double now();
    virtual void calculatePosition(vector<double>& newx, vector<double>& newdx, double& t);

    virtual void notifyObjectExcise(VOS::RefCounted *);
    virtual void doExcise();

    virtual void addExtrapolationListener(ExtrapolatedPropertyListener* x);
    virtual void removeExtrapolationListener(ExtrapolatedPropertyListener* x);
    virtual const string getType();


    /** Read current extrapolated values.
     * @bug You will not get valid data if there are no ExtrapolationListeners for
     * this extrapolated property!
     */
    virtual void readRaw(string& target, int start, int length);

    /** Read current extrapolated values.
     * @warning no data decoding is performed, this method is the
     * same as readRaw().
     * @bug You will not get valid data if there are no ExtrapolationListeners for
     * this extrapolated property!
     */
    virtual void read(string& target, int start, int length);

    /** Get length of property
     * @bug You will not get valid data if there are no ExtrapolationListeners for
     * this extrapolated property!
     */
    virtual int getRawLength();

    /** Get length of property
     * @warning no data decoding is performed, this method is the
     * same as getRawLength().
     * @bug You will not get valid data if there are no ExtrapolationListeners for
     * this extrapolated property!
     */
    virtual int getLength();

    /** Initialize property with x, dx, ddx and time values of (0.0).
        @see ExtrapolatedLocalProperty::initialize()
    */
    virtual void initialize();

    /** Initialize property with given vector size and value.
        t (time) is set to 0.
        @see ExtrapolatedLocalProperty::initialize(unsigned int, double)
        @param size     Size of x, dx and ddx vectors.
        @param val      Value for all variables. (Default is 0.0)
    */
    virtual void initialize(unsigned int size, double val = 0.0);

    /** Set dx value using current time step.
        @param val  New value
    */
    void setVelocity(const vector<double>& val);

    /** Set dx value using current time step.
        @param val  New value
    */
    void setVelocity(const double val);

    /** Set ddx value using current time step.
        @param val  New value
    */
    void setAcceleration(const vector<double>& val);

    /** Set ddx value using current time step.
        @param val  New value
    */
    void setAcceleration(const double val);

    /** Set x value using current time step.
        @param val New value
    */
    void setPosition(const vector<double>& val);

    /** Set x value using current time step.
        @param val New value
    */
    void setPosition(const double val);

    /** Get current x */
    void getCurrentPos(vector<double>& x);

    /** Get current velocity */
    void getVelocity(double& v);

    /** Get current velocity */
    void getVelocity(vector<double>& v);

    /** Get current acceleration */
    void getAcceleration(double& a);

    /** Get current acceleration */
    void getAcceleration(vector<double>& a);
};









/** @class ExtrapolatedLocalProperty extrapolatedproperty.hh vos/metaobjects/property/extrapolatedproperty.hh
 */

class PROPERTY_API ExtrapolatedLocalProperty : public virtual ExtrapolatedProperty, public virtual BufferedLocalProperty
{
private:
    bool extrap_base_changed;
public:
    ExtrapolatedLocalProperty(MetaObject* superobject);
    ExtrapolatedLocalProperty(MetaObject* superobject, const string& d, const string& dt = "?");
    virtual ~ExtrapolatedLocalProperty();
    static MetaObject* new_ExtrapolatedLocalProperty(MetaObject* superobject, const string& type);

    virtual void set(const vector<double>& x, const vector<double>& dx, const vector<double>& ddx, double t = 0.0);
    virtual void write(int start, const string& newdata);
    virtual void replace(const string& newdata, const string& newtype = "?");

    /* try to coax the compiler into working */
    virtual void readRaw(string& target, int start, int length) {
        ExtrapolatedProperty::readRaw(target, start, length);
    }
    virtual int getRawLength() {
        return ExtrapolatedProperty::getRawLength();
    }
    virtual int getLength() {
        return ExtrapolatedProperty::getLength();
    }
    virtual void read(string& target, int start, int length) {
        ExtrapolatedProperty::read(target, start, length);
    }




    virtual void flush();

    virtual void sendMessage(Message* m);

    /** Initialize property with x, dx, ddx and time values of (0.0).
        Set no access control.
        @see ExtrapolatedProperty::initialize()
    */
    virtual void initialize() {
        insertPropertyAccessControl(-1, &NoPropertyAccessControl::static_);
        ExtrapolatedProperty::initialize();
    }

    /** Initialize property with given vector size and value.
        t (time) is set to 0.
        Set no access control.
        @see ExtrapolatedProperty::initialize(unsigned int, double)
        @param size     Size of x, dx and ddx vectors.
        @param val      Value for all variables. (Default is 0.0)
    */
    virtual void initialize(unsigned int size, double val = 0.0) {
        insertPropertyAccessControl(-1, &NoPropertyAccessControl::static_);
        ExtrapolatedProperty::initialize(size, val);
    }
};


/** @class ExtrapolatedProperty extrapolatedproperty.hh vos/metaobjects/property/extrapolatedproperty.hh
 */
class PROPERTY_API ExtrapolatedRemoteProperty : public virtual ExtrapolatedProperty, public virtual BufferedRemoteProperty
{
public:
    ExtrapolatedRemoteProperty(MetaObject* superobject);
    virtual ~ExtrapolatedRemoteProperty();
    static MetaObject* new_ExtrapolatedRemoteProperty(MetaObject* superobject, const string& type);

    virtual void set(const vector<double>& x, const vector<double>& dx, const vector<double>& ddx, double t = 0.0);
    virtual void sendUpdateMessage(Message* m);

    virtual void addExtrapolationListener(ExtrapolatedPropertyListener* x);
    virtual void removeExtrapolationListener(ExtrapolatedPropertyListener* x);

    /** If there are any listeners, return current value, otherwise send a
     * message*/
    virtual void readRaw(string& target, int start, int length) ;

    /** If there are any listeners, return current value, otherwise send a
     * message*/
    virtual int getRawLength() ;

    /* try to coax the compiler into working */
    virtual int getLength() { return ExtrapolatedProperty::getLength(); }
    virtual void read(string& target, int start, int length) { ExtrapolatedProperty::read(target, start, length); }

};

#endif

---