shared.h

Go to the documentation of this file.

/*  Glass - a distributed computing library
    Copyright (C) 2003-2009 Bruno Barberi Gnecco
    Copyright (C) 2009-2010 Corollarium Technologies


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

#ifndef _GLASS_PLUGIN_SHARED_HH_
#define _GLASS_PLUGIN_SHARED_HH_

#include "exception.h"
#include "packager.h"
#include "types.h"
#include "plugin.h"
#include <boost/thread.hpp>
#include <map>
#include <set>

namespace libglass {

class _Shared;

class SharedBase : public PluginBase {
        PLUGIN(SharedBase);
private:
        std::map<const string *, _Shared *, StringPointerCompare> 
                                vars; 
protected:
        friend class _Shared;

        bool registerShared(_Shared *v);

        bool unregisterShared(_Shared *v);

        bool sendUpdate(_Shared *s);

        bool getUpdate(_Shared *s);

        bool sendUpdateAll(void);


// *********************************************************************
// Destructor should be PROTECTED to ensure singleton behaviour
// However, Microsoft compilers prior to VC v7.0 .NET are buggy and
// generate the following error
//   error C2248: 'AliasBase::~AliasBase' : cannot access protected member declared in class 'libglass::AliasBase'
// The only workaround is to make the destructor public - which kind
// of destroys the whole reason for implementing the singleton class
#if defined(_MSC_VER) && (_MSC_VER < 1300)  // earlier than .NET compiler (VC 7.0)
public:
#else
protected:
#endif
// *********************************************************************

        virtual ~SharedBase();


public:
};

class LIBGLASS_API _Shared : public PluginInterface {
public:
        typedef enum { NEVER, NEXT_ONLY, CHANGED, FORCED } UpdateMode;
                
protected:
        friend class SharedBase;
        friend class SharedPacket;

        SharedBase              *sb;            
        string                  name;           
        /* Ideally these should be separated in unions, but union members cannot
           have constructors. */
        /* client: */
        bool                    changed;        
        UpdateMode              updatemode;     
        boost::condition_variable       trigger;        
        /* server: */
        nodeId                  lastchanged;    
        std::set<nodeId>        owners;         
        chain                   currentdata;    
        chain                   nextdata;       
        _Shared(const string &name) throw(Exception);

        virtual ~_Shared();

        virtual chain pack(void) { return chain(); }

        virtual bool unpack(chain &s, unsigned int &used) { return false; }
public:

        void setUpdateMode(UpdateMode updatemode) {
                this->updatemode = updatemode;
        }

        UpdateMode getUpdateMode(void) const {
                return this->updatemode;
        }
        bool hasChanged(void) const {
                return changed;
        }

        bool sendUpdate(void);

        bool getUpdate(void);

        static bool sendUpdateAll(void);
};

template<typename T,
        Serializer(*packf, T) = toString<T>,
        Unserializer(*unpackf, T) = toString<T> >
class Shared : public _Shared {
protected:
        T                       data;

        chain pack(void) {
                chain c;
                packf(c, data, 1, NULL); // Provide default values for args 3 and 4 since required by MSVC
                return c;
        }

        bool unpack(chain &c, unsigned int &used) {
                unsigned int    initial = 0;
                return unpackf(c, initial, data, used, 1, NULL); // Provide default values for args 5 and 6 as required by MSVC
        }

public:
        Shared(const char *name, T data = T()) throw(Exception) : _Shared(name), 
                data(data) {
        
        }

/*      const T &operator=(const T &b) {
                data = b;
                changed = true;
                return this->data;
        } */

        const Shared &operator=(const T &b) {
                data = b;
                changed = true;
                return *this;
        }

        const Shared &operator=(const Shared &b) {
                data = b.data;
                changed = true;
                return *this;
        }

        void assign(T &b) {
                data = b;
                changed = true;
                return;
        }

        const T &getData(void) const {
                return data;
        }
        
        T operator*(void) const {
                return data;
        }
};

}//namespace


#endif // _GLASS_PLUGIN_SHARED_HH_

---