SharedState.h

Go to the documentation of this file.

/* This file is part of COVISE.

   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.

 * License: LGPL 2+ */

#ifndef VRB_SHAREDSTATE_H
#define VRB_SHAREDSTATE_H
    
#include <vector>
#include <string>
#include <functional>
#include <cassert>

#include <net/tokenbuffer.h>
#include <util/coExport.h>
#include "regClass.h"
#include "SharedStateSerializer.h"
#include "SessionID.h"



namespace vrb
{

class clientRegVar;

enum SharedStateType
{
    USE_COUPLING_MODE, //0  write/read in/from private or puplic session depending on coupling mode 
    NEVER_SHARE, //1        only write to private session to save the state on the server
    ALWAYS_SHARE, //2       always write to public session and share the state within the group
    SHARE_WITH_ALL //3      write to session 0 to share the state within all sessions
};

class  VRBEXPORT SharedStateBase : public regVarObserver
{
public:
    SharedStateBase(std::string name, SharedStateType mode);

    virtual ~SharedStateBase();

    void setUpdateFunction(std::function<void(void)> function);

    bool valueChangedByOther() const;

    std::string getName() const;

    void update(clientRegVar *theChangedRegEntry) override;
    void setID(SessionID &id);
    void setMute(bool m);
    bool getMute();
    void resubscribe(SessionID& id);
    //send value to local registry and vrb if syncInterval allows it
    void frame(double time);
    void setSyncInterval(float time);
    float getSyncInerval();
    //unmute and send value to vrb
    void becomeMaster();
protected:
    //convert tokenbuffer to datatype of the sharedState
    virtual void deserializeValue(covise::TokenBuffer &data) = 0;
    void subscribe(covise::TokenBuffer &&val);
    void setVar(covise::TokenBuffer &&val);
    const std::string className = "SharedState";
    std::string variableName;
    bool doSend = false;
    bool doReceive = false;
    bool valueChanged = false;
    std::function<void(void)> updateCallback;

    VrbClientRegistry *m_registry = nullptr;

private:
    SessionID sessionID = 0; 
    bool muted = false;
    bool send = false;
    float syncInterval = 0.1f;
    double lastUpdateTime = 0.0;
    covise::TokenBuffer tb_value;
};

template <class T>
class  SharedState : public SharedStateBase
{
public:
    SharedState<T>(std::string name, T value = T(), SharedStateType mode = USE_COUPLING_MODE)
        : SharedStateBase(name, mode)
        , m_value(value)
    {
        assert(m_registry);
        covise::TokenBuffer data;
        serializeWithType(data, m_value);
        subscribe(std::move(data));
    }

    SharedState<T> &operator=(T value)
    {
        if (m_value != value)
        {
            m_value = value;
            push();
        }
        return *this;
    }

    operator T() const
    {
        return m_value;
    }

    void deserializeValue(covise::TokenBuffer &data) override
    {
        deserializeWithType(data, m_value);
    }

    void push()
    {
        valueChanged = false;
        covise::TokenBuffer data;
        serializeWithType(data, m_value);
        setVar(std::move(data));
    }

    const T &value() const
    {
        return m_value;
    }

private:
    T m_value; 

};
}
#endif