Blackboard.h

Go to the documentation of this file.

// -*- mode:c++ -*-
//
// Copyright (C) 2004 Andras Varga
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//


#ifndef __INET_BLACKBOARD_H
#define __INET_BLACKBOARD_H

#include <map>
#include <vector>
#include <omnetpp.h>
#include "INETDefs.h"


class BlackboardAccess;


class INET_API Blackboard : public cSimpleModule
{
  public:
    typedef std::vector<BlackboardAccess *> SubscriberVector;

    class BBItem
    {
      private:
        friend class Blackboard;
        cPolymorphic *_item;
        std::string _label;
        SubscriberVector subscribers;
      public:
        const char *getLabel()  {return _label.c_str();}
        cPolymorphic *getData()  {return _item;}
        const cPolymorphic *getData() const  {return _item;}
    };

  protected:
    bool coreDebug;

    class Iterator;
    friend class Iterator;

    // blackboard items, with their subscriber lists
    typedef std::map<std::string, BBItem*> ContentsMap;
    ContentsMap contents;

    // those who have subscribed to publish()/withdraw() requests
    SubscriberVector registeredClients;

  public:
    typedef BBItem *BBItemRef;

    class iterator
    {
      private:
        ContentsMap::iterator it;
      public:
        iterator(ContentsMap::iterator it0) {it==it0;}
        BBItemRef operator*()  {return (*it).second;}
        iterator& operator++()  {++it; return *this;}
        iterator operator++(int)  {iterator x=iterator(it); ++it; return x;}
        iterator& operator--()  {--it; return *this;}
        iterator operator--(int)  {iterator x=iterator(it); --it; return x;}
        bool operator==(const iterator& i2)  {return it==i2.it;}
        bool operator!=(const iterator& i2)  {return it!=i2.it;}
    };

  public:
    Blackboard();
    virtual ~Blackboard();

  protected:
    virtual void initialize();

    virtual void handleMessage(cMessage *msg);

  public:
    virtual BBItemRef publish(const char *label, cPolymorphic *item);

    virtual void withdraw(BBItemRef bbItem);

    virtual void changed(BBItemRef bbItem, cPolymorphic *item=NULL);

    virtual BBItemRef subscribe(BlackboardAccess *bbClient, const char *label);

    virtual BBItemRef find(const char *label);

    virtual BBItemRef subscribe(BlackboardAccess *bbClient, BBItemRef bbItem);

    virtual void unsubscribe(BlackboardAccess *bbClient, BBItemRef bbItem);

    virtual void registerClient(BlackboardAccess *bbClient);

    virtual void removeClient(BlackboardAccess *bbClient);

    virtual void getBlackboardContent(BlackboardAccess *bbClient);

    iterator begin()  {return iterator(contents.begin());}

    iterator end()  {return iterator(contents.end());}
};

typedef Blackboard::BBItemRef BBItemRef;


class INET_API BlackboardAccess
{
  protected:
    Blackboard *bb;

  public:
    BlackboardAccess() {bb=NULL;}
    virtual ~BlackboardAccess() {}

    virtual Blackboard *getBlackboard();

    virtual bool blackboardItemChanged(BBItemRef item) = 0;
    virtual bool blackboardItemPublished(BBItemRef item) = 0;
    virtual bool blackboardItemWithdrawn(BBItemRef item) = 0;
};

#endif