remotevar.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_REMOTE_VAR_HH_
#define _GLASS_PLUGIN_REMOVE_VAR_HH_

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

namespace libglass {

class _Remote;

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

        bool registerRemote(_Remote *v);

        bool unregisterRemote(_Remote *v);

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


public:
};


#if defined(_MSC_VER)
// Instantiate std::set<T> template containers used by class _Remote
IMP_TEMPLATE_STL_SET(nodeId);
#endif // _MSC_VER

class LIBGLASS_API _Remote : public PluginInterface {
protected:
        friend class RemoteBase;
        friend class RemoteVarPacket;

        RemoteBase              *rb;            
        string                  name;           
        /* client: */
        boost::mutex            mutex;          
        /* server: */
        std::set<nodeId>        owners;         
        _Remote(const char *name) throw(Exception);

        virtual ~_Remote();

        virtual chain pack(void);

        virtual bool unpack(chain &s, unsigned int &used);

        bool _setValue(chain &c, nodeId id);

        bool _getValue(chain &c, nodeId id);

public:
        
        bool setValue(nodeId id);

        bool getValue(nodeId id);
};

template<typename T,
        Serializer(*packf, T) = rawPack<T>,
        Unserializer(*unpackf, T) = rawUnpack<T> >
class Remote : public _Remote {
protected:
        T                       data;

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

        bool unpack(chain &c, unsigned int &used) {
                unsigned int    initial;
                bool            b;

/* TODO: I think the find() should not be done here, but elsewhere. initial
could be given as a parameter, but is it necessary? */
                initial = c.find('\0');
                if (initial == chain::npos) {
                        return false;
                }
                initial++;

                mutex.lock();
                try {
                        b = unpackf(c, initial, data, used, 1, NULL); // Provide default values for args 5 and 6 as required by MSVC
                }
                catch (...) {
                        mutex.unlock();
                        throw;
                }
                mutex.unlock();
                return b;
        }

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

        bool setData(T &b, nodeId id = nobodyId) {
                if (id == nobodyId) {
                        data = b;
                        return true;
                }
                else {
                        chain c;
                        packf(c, b);
                        return _setValue(c, id);
                }
        }

        const T &getData(nodeId id = nobodyId) const throw(Exception) {
                if (id == nobodyId) {
                        return data;
                }
                else {
                        chain           c;
                        unsigned int    used;

                        if (!_getValue(c, id)) {
                                throw Exception("Could not get remote value.");
                        }
                        return unpack(c, used);
                }
        }

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

        void lock(void) {
                mutex.lock();
        }

        void unlock(void) {
                mutex.unlock();
        }
};

}//namespace



#endif // _GLASS_PLUGIN_REMOTE_VAR_HH_

---