regClass.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 REGCLASS_H
#define REGCLASS_H

#include <net/tokenbuffer.h>
#include <net/message_types.h>
#include <map>
#include <set>
#include <memory>
#include <util/coExport.h>
#include <fstream>

class coCharBuffer;
namespace covise
{
class VRBClient;
}

namespace vrb
{
class clientRegClass;
class clientRegVar;
class serverRegVar;
class serverRegClass;
class regClassObserver;
class regVarObserver;
class VrbClientRegistry;
class SessionID;

template<class variableType>
class regClass
{
public:
    typedef std::map<const std::string, std::shared_ptr<variableType>> VariableMap;
    regClass<variableType>(const std::string &n, int ID)
        : name(n)
        , classID(ID)
        , isDel(false)
    {
    }
    int getID()
    {
        return (classID);
    }
    void setID(int id)
    {
        classID = id;
    }
    const std::string &getName()
    {
        return (name);
    }
    void append(variableType * var)
    {
        myVariables[var->getName()].reset(var);
    }
    variableType *getVar(const std::string &n)
    {
        auto it = myVariables.find(n);
        if (it == myVariables.end())
        {
            return (NULL);
        }
        return it->second.get();
    }
    void deleteVar(const std::string &n)
    {
        myVariables.erase(n);
    }
    void deleteAllNonStaticVars()
    {
        typename VariableMap::iterator it = myVariables.begin();
        while (it != myVariables.end())
        {
            if (it->second->isStatic())
            {
                it = myVariables.erase(it);
            }
            else
            {
                ++it;
            }
        }
    }
    bool isDeleted()
    {
        return isDel;
    }
    void setDeleted(bool isdeleted = true)
    {
        isDel = isdeleted;
        for (const auto var : myVariables)
        {
            var.second->setDeleted(isdeleted);
        }
    }
    void writeClass(std::ofstream &file) {
        file << name;
        file << "\n";
        file << "{";
        file << "\n";
        for (const auto var : myVariables)
        {
            var.second->writeVar(file);
            file << "\n";
        }
        file << "}";

    }
    void readVar(std::ifstream &file)
    {

        while (true)
        {
            std::string varName = "invalid";
            int valueSize = -1;
            file >> varName;
            if (varName == "}")
            {
                return;
            }
            varName.pop_back();
            file >> valueSize;
            char *value = new char[valueSize];
            file.read(value, valueSize);
            covise::TokenBuffer tb(value, valueSize);
            myVariables[varName] = createVar(varName, std::move(tb));
            delete[] value; //createVar did copy the tokenbuffer
        }

    };
    virtual std::shared_ptr<variableType> createVar(const std::string &name, covise::TokenBuffer &&value) = 0;
    ~regClass()
    {
    };
protected:
    std::string name;
    int classID = -1;
    bool isDel;
    VariableMap myVariables;
};

template<class classType>
class regVar
{
protected:
    covise::TokenBuffer value;
    std::string name;
    classType *myClass;
    bool staticVar;
    bool isDel;

public:

    regVar(classType *c, const std::string &n, covise::TokenBuffer &v, bool s = 1)
    {
        myClass = c;
        name = n;
        staticVar = s;
        setValue(v);
        isDel = false;
    }
    ~regVar()
    {
        value.delete_data();
    }
    covise::TokenBuffer &getValue()
    {
        value.rewind();
        return (value);
    };
    classType *getClass()
    {
        return (myClass);
    };
    inline void setValue(const covise::TokenBuffer &v)
    {
        value.copy(v);
    }
    int isStatic()
    {
        return (staticVar);
    };
    const std::string &getName()
    {
        return (name);
    };

    bool isDeleted()
    {
        return isDel;
    }
    void setDeleted(bool isdeleted = true)
    {
        isDel = isdeleted;
    }
    void writeVar(std::ofstream &file) 
    {
        file << "    " << name << "; ";
        int length = value.get_length();
        file << length;
        file.write(value.get_data(), value.get_length());
    }
};


class VRBEXPORT clientRegClass : public regClass<clientRegVar>
{
private:
    regClassObserver *_observer = nullptr; //local observer class
    int lastEditor;
    VrbClientRegistry *registry;
public:
    void sendMsg(covise::TokenBuffer &tb, covise::covise_msg_type type);
    clientRegClass(const std::string &n, int ID, VrbClientRegistry *reg);
    regClassObserver *getLocalObserver()
    {
        return _observer;
    }
    void attach(regClassObserver *ob)
    {
        _observer = ob;
    }
    int getLastEditor()
    {
        return lastEditor;
    }
    void setLastEditor(int lastEditor);
    void notifyLocalObserver();
    void resubscribe(const SessionID &sessionID);
    void subscribe(regClassObserver *obs, const SessionID &sessionID);
    VariableMap &getAllVariables();
    std::shared_ptr<clientRegVar> createVar(const std::string &name, covise::TokenBuffer &&value) override;
};
class VRBEXPORT clientRegVar : public regVar<clientRegClass>
{
private:
    regVarObserver *_observer;
    int lastEditor;
public:
    using regVar::regVar;
    regVarObserver * getLocalObserver()
    {
        return _observer;
    }
    void notifyLocalObserver();
    void subscribe(regVarObserver *ob, const SessionID &sessionID);

    //void attach(regVarObserver *ob)
    //{
    //    _observer = ob;
    //}
    int getLastEditor()
    {
        return lastEditor;
    }
    void setLastEditor(int lastEditor)
    {
        this->lastEditor = lastEditor;
    }
};




class VRBEXPORT regClassObserver
{
public:
    virtual void update(clientRegClass *theChangedClass) = 0;
};
class VRBEXPORT regVarObserver
{
public:
    virtual void update(clientRegVar *theChangedVar) = 0;
};
}
#endif