Fawkes API  Fawkes Development Version
local.cpp
00001 
00002 /***************************************************************************
00003  *  blackboard.cpp - BlackBoard plugin
00004  *
00005  *  Generated: Sat Sep 16 17:11:13 2006 (on train to Cologne)
00006  *  Copyright  2006-2007  Tim Niemueller [www.niemueller.de]
00007  *
00008  ****************************************************************************/
00009 
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023 
00024 #include <blackboard/local.h>
00025 #include <blackboard/bbconfig.h>
00026 #include <blackboard/internal/message_manager.h>
00027 #include <blackboard/internal/memory_manager.h>
00028 #include <blackboard/internal/interface_manager.h>
00029 #include <blackboard/internal/notifier.h>
00030 #include <blackboard/net/handler.h>
00031 
00032 // for -C: bb_cleanup
00033 #include <utils/ipc/shm.h>
00034 #include <blackboard/shmem/header.h>
00035 #include <blackboard/shmem/lister.h>
00036 
00037 #include <string>
00038 #include <cstring>
00039 
00040 namespace fawkes {
00041 
00042 /** @class LocalBlackBoard <blackboard/local.h>
00043  * Local BlackBoard.
00044  *
00045  * @see Interface
00046  * @see Message
00047  *
00048  * @author Tim Niemueller
00049  */
00050 
00051 
00052 /** Shared Memory Constructor.
00053  * @param memsize size of memory in bytes
00054  * @param magic_token magic token used for shared memory segment
00055  * @param master true to operate in master mode, false otherwise
00056  */
00057 LocalBlackBoard::LocalBlackBoard(size_t memsize,
00058                                  const char *magic_token, bool master)
00059 {
00060   __memmgr = new BlackBoardMemoryManager(memsize, BLACKBOARD_VERSION, master);
00061 
00062   __notifier = new BlackBoardNotifier();
00063   __msgmgr = new BlackBoardMessageManager(__notifier);
00064   __im = new BlackBoardInterfaceManager(__memmgr, __msgmgr, __notifier);
00065 
00066   __msgmgr->set_interface_manager(__im);
00067 
00068   __nethandler = NULL;
00069 }
00070 
00071 
00072 /** Heap Memory Constructor.
00073  * @param memsize size of memory in bytes
00074  */
00075 LocalBlackBoard::LocalBlackBoard(size_t memsize)
00076 {
00077   __memmgr = new BlackBoardMemoryManager(memsize);
00078 
00079   __notifier = new BlackBoardNotifier();
00080   __msgmgr = new BlackBoardMessageManager(__notifier);
00081   __im = new BlackBoardInterfaceManager(__memmgr, __msgmgr, __notifier);
00082 
00083   __msgmgr->set_interface_manager(__im);
00084 
00085   __nethandler = NULL;
00086 }
00087 
00088 
00089 /** Destructor. */
00090 LocalBlackBoard::~LocalBlackBoard()
00091 {
00092   if ( __nethandler ) {
00093     __nethandler->cancel();
00094     __nethandler->join();
00095     delete __nethandler;
00096   }
00097   delete __im;
00098   delete __msgmgr;
00099   delete __memmgr;
00100   delete __notifier;
00101 }
00102 
00103 
00104 Interface *
00105 LocalBlackBoard::open_for_reading(const char *type, const char *identifier)
00106 {
00107   try {
00108     return __im->open_for_reading(type, identifier);
00109   } catch (Exception &e) {
00110     throw;
00111   }
00112 }
00113 
00114 
00115 Interface *
00116 LocalBlackBoard::open_for_writing(const char *type, const char *identifier)
00117 {
00118   try {
00119     return __im->open_for_writing(type, identifier);
00120   } catch (Exception &e) {
00121     throw;
00122   }
00123 }
00124 
00125 
00126 std::list<Interface *>
00127 LocalBlackBoard::open_multiple_for_reading(const char *type, const char *id_pattern)
00128 {
00129   try {
00130     return __im->open_multiple_for_reading(type, id_pattern);
00131   } catch (Exception &e) {
00132     throw;
00133   }  
00134 }
00135 
00136 
00137 void
00138 LocalBlackBoard::close(Interface *interface)
00139 {
00140   __im->close(interface);
00141 }
00142 
00143 
00144 InterfaceInfoList *
00145 LocalBlackBoard::list_all()
00146 {
00147   return __im->list_all();
00148 }
00149 
00150 
00151 bool
00152 LocalBlackBoard::is_alive() const throw()
00153 {
00154   return true;
00155 }
00156 
00157 
00158 bool
00159 LocalBlackBoard::try_aliveness_restore() throw()
00160 {
00161   return true;
00162 }
00163 
00164 void
00165 LocalBlackBoard::register_listener(BlackBoardInterfaceListener *listener, unsigned int flags)
00166 {
00167   __notifier->register_listener(listener, flags);
00168 }
00169 
00170 
00171 void
00172 LocalBlackBoard::unregister_listener(BlackBoardInterfaceListener *listener)
00173 {
00174   __notifier->unregister_listener(listener);
00175 }
00176 
00177 
00178 void
00179 LocalBlackBoard::register_observer(BlackBoardInterfaceObserver *observer, unsigned int flags)
00180 {
00181   __notifier->register_observer(observer, flags);
00182 }
00183 
00184 
00185 void
00186 LocalBlackBoard::unregister_observer(BlackBoardInterfaceObserver *observer)
00187 {
00188   __notifier->unregister_observer(observer);
00189 }
00190 
00191 
00192 /** Cleanup orphaned BlackBoard segments.
00193  * This erase orphaned shared memory segments that belonged to a
00194  * BlackBoard.
00195  * @param magic_token magic token of shared memory segments
00196  * @param use_lister true to use a lister with console output
00197  */
00198 void
00199 LocalBlackBoard::cleanup(const char *magic_token, bool use_lister)
00200 {
00201   BlackBoardSharedMemoryHeader *bbsh = new BlackBoardSharedMemoryHeader( BLACKBOARD_VERSION );
00202   BlackBoardSharedMemoryLister *bblister = NULL;
00203   if ( use_lister ) {
00204     bblister = new BlackBoardSharedMemoryLister();
00205   }
00206   SharedMemory::erase_orphaned(magic_token, bbsh, bblister);
00207   delete bblister;
00208   delete bbsh;
00209 }
00210 
00211 
00212 /** Get memory manager.
00213  * CAUTION: This is NOT meant to be used in your application.
00214  * This returns a pointer to the used memory manager. The return type
00215  * is declared const. Use this only for debugging purposes to output info about
00216  * the BlackBoard memory.
00217  * @return const pointer to memory manager
00218  */
00219 const BlackBoardMemoryManager *
00220 LocalBlackBoard::memory_manager() const
00221 {
00222   return __memmgr;
00223 }
00224 
00225 
00226 /** Start network handler.
00227  * This will start the network handler thread and register it with the given hub.
00228  * @param hub hub to use and to register with
00229  */
00230 void
00231 LocalBlackBoard::start_nethandler(FawkesNetworkHub *hub)
00232 {
00233   if ( __nethandler ) {
00234     throw Exception("BlackBoardNetworkHandler already started");
00235   }
00236   __nethandler = new BlackBoardNetworkHandler(this, hub);
00237   __nethandler->start();
00238 }
00239 
00240 } // end namespace fawkes