alias.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_ALIAS_HH_
#define _GLASS_PLUGIN_ALIAS_HH_

#include <map>
#include <utility>
#include <set>
#include "plugin.h"
#include "exception.h"

namespace libglass {

class _Alias;
class AliasPacket;

class AliasBase : public PluginBase {
        PLUGIN(AliasBase);
private:
        std::map<const string *, _Alias *, StringPointerCompare> aliases;

protected:
        friend class _Alias;


        bool registerAlias(_Alias *a);

        bool unregisterAlias(_Alias *a);

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

public:
};



#if defined(_MSC_VER)
// Instantiate std::set<T> template containers used by class _Alias
LIBGLASS_IMP_TEMPLATE_STL_SET(nodeId);
// Instantiate std::map<Ta,Tb> template containers used by class _Alias
LIBGLASS_IMP_TEMPLATE_STL_MAP(libglass::nodeId, libglass::string);
#endif // _MSC_VER

class LIBGLASS_API _Alias : public PluginInterface {
private:
        void init(const string &name) throw(Exception);

protected:
        friend class AliasBase;
        friend class AliasPacket;

        AliasBase               *ab;            
        /* client */
        string                  name;           
        bool                    associated;     
        string                  current_association;    
//      string                  (*func)(nodeId);

        /* server */
        std::set<nodeId>        owners;         
        std::map<nodeId, string> associations;  
        _Alias(const char *aliasname) throw(Exception);
        _Alias(const string &) throw(Exception);

        virtual ~_Alias();

        bool _associate(const string &association);

        void unregisterNode(nodeId id);

public:
        string getName(void) const;

        bool associate(nodeId id, string &name);

        bool associate(nodeId id, const char *name);

        bool associate(std::map<nodeId, string> &map);

#ifdef TODO //how to propagate to other nodes?

        void associate(string (*func)(nodeId));
#endif

        bool dissociate(nodeId id);
};

template<typename T>
class Alias : public _Alias {
private:
        std::map<string, T>     aliases;
        T                       default_value;

public:
        Alias(const char *aliasname, T default_value) throw(Exception) :
                _Alias(aliasname), default_value(default_value) {
        }

        ~Alias() {
        }

        bool addAlias(string &name, T t)  {
                aliases[name] = t;
                return true;
        }

        bool addAlias(const char *name, T t)  {
                if (!name)
                        return false;
                aliases[string(name)] = t;
                return true;
        }

        bool deleteAlias(const char *name) {
                // todo
                // if (data == alias[name] ) ???
                return false;
        }

        bool checkAlias(void) const {
                return associated;
        }

        T getData(void) {
                if (associated == true) {
                        typename std::map<string, T>::iterator it;
                        it = aliases.find(current_association);
                        if (it == aliases.end()) {
                                /* we don't have a T associated with our alias */
                                return default_value;
                        }
                        return it->second;
                }
                return default_value;
        }
};

}//namespace


#endif // _GLASS_PLUGIN_ALIAS_HH_

---