glass.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_HH_
#define _GLASS_HH_

#include <boost/thread.hpp>
#include <list>
#include <map>

#include "types.h"
#include "exception.h"

namespace libglass {

class PluginManager;
class PluginInterface;
class PluginBase;
class Protocol;
class Packet;


#if defined(_MSC_VER)
// Instantiate std::map<Ta,Tb> template containers used by class Glass
LIBGLASS_IMP_TEMPLATE_STL_MAP(libglass::nodeFD, libglass::nodeId);
LIBGLASS_IMP_TEMPLATE_STL_MAP(libglass::nodeId, libglass::nodeFD);
LIBGLASS_IMP_TEMPLATE_STL_MAP(libglass::nodeId, libglass::nodeRelation);
#endif // _MSC_VER

class LIBGLASS_API Glass {

protected:
        /* Friend classes. */
        friend class GlassManager;
        friend class PluginInterface;
        friend class PluginManager;
        friend class Protocol;

        Protocol                        *protocol;      
        nodeId                          id;             
        PluginManager           *pm;            
        boost::thread::id       pt_id;          
        std::map<nodeFD, nodeId>        fdtoidmap;      
        std::map<nodeId, nodeFD>        idtofdmap;      
        std::map<nodeId, nodeRelation>  idtorelation;   
        void clean(void);

        virtual bool processPacket(Packet &p, bool rootOnly = false);
        
        virtual bool sendPacket(Packet &p);

        virtual bool rootPacket(Packet &p) = 0;

        PluginBase *getPlugin(PluginId id) const;

        PluginManager *getPluginManager(void) const;

        virtual nodeFD IdToFD(nodeId id);
        
        virtual nodeId FDToId(nodeFD fd);

        virtual nodeId registerNode(nodeFD fd) = 0;

        virtual bool setNode(nodeFD fd, nodeId id, nodeRelation r, 
                                bool force = false);

        virtual bool setRelation(nodeId id, nodeRelation r);

        virtual bool unregisterNode(nodeId id);

        virtual bool unregisterNode(nodeFD fd);

public:
        Glass(Protocol *p) throw(Exception);
        virtual ~Glass();

        nodeId getNodeId(void) const;

        nodeRelation getNodeRelation(nodeId id) const;

        void setCurrent(void);

        void lockCurrent(void);
        
        void unlockCurrent(void);

        virtual unsigned int getTotalNodes(void);

};

} // namespace

#endif // _GLASS_HH_

---