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   __msgmgr = new BlackBoardMessageManager(__notifier);
00063   __im = new BlackBoardInterfaceManager(__memmgr, __msgmgr, __notifier);
00064 
00065   __msgmgr->set_interface_manager(__im);
00066 
00067   __nethandler = NULL;
00068 }
00069 
00070 
00071 /** Heap Memory Constructor.
00072  * @param memsize size of memory in bytes
00073  */
00074 LocalBlackBoard::LocalBlackBoard(size_t memsize)
00075 {
00076   __memmgr = new BlackBoardMemoryManager(memsize);
00077 
00078   __msgmgr = new BlackBoardMessageManager(__notifier);
00079   __im = new BlackBoardInterfaceManager(__memmgr, __msgmgr, __notifier);
00080 
00081   __msgmgr->set_interface_manager(__im);
00082 
00083   __nethandler = NULL;
00084 }
00085 
00086 
00087 /** Destructor. */
00088 LocalBlackBoard::~LocalBlackBoard()
00089 {
00090   if ( __nethandler ) {
00091     __nethandler->cancel();
00092     __nethandler->join();
00093     delete __nethandler;
00094   }
00095   delete __im;
00096   delete __msgmgr;
00097   delete __memmgr;
00098 }
00099 
00100 
00101 Interface *
00102 LocalBlackBoard::open_for_reading(const char *type, const char *identifier)
00103 {
00104   try {
00105     return __im->open_for_reading(type, identifier);
00106   } catch (Exception &e) {
00107     throw;
00108   }
00109 }
00110 
00111 
00112 Interface *
00113 LocalBlackBoard::open_for_writing(const char *type, const char *identifier)
00114 {
00115   try {
00116     return __im->open_for_writing(type, identifier);
00117   } catch (Exception &e) {
00118     throw;
00119   }
00120 }
00121 
00122 
00123 std::list<Interface *>
00124 LocalBlackBoard::open_multiple_for_reading(const char *type_pattern,
00125                                            const char *id_pattern)
00126 {
00127   try {
00128     return __im->open_multiple_for_reading(type_pattern, id_pattern);
00129   } catch (Exception &e) {
00130     throw;
00131   }  
00132 }
00133 
00134 
00135 void
00136 LocalBlackBoard::close(Interface *interface)
00137 {
00138   __im->close(interface);
00139 }
00140 
00141 
00142 InterfaceInfoList *
00143 LocalBlackBoard::list_all()
00144 {
00145   return __im->list_all();
00146 }
00147 
00148 
00149 InterfaceInfoList *
00150 LocalBlackBoard::list(const char *type_pattern, const char *id_pattern)
00151 {
00152   return __im->list(type_pattern, id_pattern);
00153 }
00154 
00155 
00156 bool
00157 LocalBlackBoard::is_alive() const throw()
00158 {
00159   return true;
00160 }
00161 
00162 
00163 bool
00164 LocalBlackBoard::try_aliveness_restore() throw()
00165 {
00166   return true;
00167 }
00168 
00169 
00170 /** Cleanup orphaned BlackBoard segments.
00171  * This erase orphaned shared memory segments that belonged to a
00172  * BlackBoard.
00173  * @param magic_token magic token of shared memory segments
00174  * @param use_lister true to use a lister with console output
00175  */
00176 void
00177 LocalBlackBoard::cleanup(const char *magic_token, bool use_lister)
00178 {
00179   BlackBoardSharedMemoryHeader *bbsh = new BlackBoardSharedMemoryHeader( BLACKBOARD_VERSION );
00180   BlackBoardSharedMemoryLister *bblister = NULL;
00181   if ( use_lister ) {
00182     bblister = new BlackBoardSharedMemoryLister();
00183   }
00184   SharedMemory::erase_orphaned(magic_token, bbsh, bblister);
00185   delete bblister;
00186   delete bbsh;
00187 }
00188 
00189 
00190 /** Get memory manager.
00191  * CAUTION: This is NOT meant to be used in your application.
00192  * This returns a pointer to the used memory manager. The return type
00193  * is declared const. Use this only for debugging purposes to output info about
00194  * the BlackBoard memory.
00195  * @return const pointer to memory manager
00196  */
00197 const BlackBoardMemoryManager *
00198 LocalBlackBoard::memory_manager() const
00199 {
00200   return __memmgr;
00201 }
00202 
00203 
00204 /** Start network handler.
00205  * This will start the network handler thread and register it with the given hub.
00206  * @param hub hub to use and to register with
00207  */
00208 void
00209 LocalBlackBoard::start_nethandler(FawkesNetworkHub *hub)
00210 {
00211   if ( __nethandler ) {
00212     throw Exception("BlackBoardNetworkHandler already started");
00213   }
00214   __nethandler = new BlackBoardNetworkHandler(this, hub);
00215   __nethandler->start();
00216 }
00217 
00218 } // end namespace fawkes