Fawkes API Fawkes Development Version

header.cpp

00001 
00002 /***************************************************************************
00003  *  bb_shmem_header.cpp - BlackBoard shared memory header
00004  *
00005  *  Created: Thu Oct 19 14:21:07 2006 (Anne's 25th Birthday)
00006  *  Copyright  2006  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/shmem/header.h>
00025 #include <utils/ipc/shm.h>
00026 #include <cstddef>
00027 
00028 namespace fawkes {
00029 
00030 /** @class BlackBoardSharedMemoryHeader <blackboard/shmem/header.h>
00031  * BlackBoard Shared Memory Header.
00032  * This class is used identify BlackBoard shared memory headers and
00033  * to interact with the management data in the shared memory segment.
00034  * The basic options stored in the header is a version identifier
00035  * and pointers to the list heads of the free and allocated chunk
00036  * lists.
00037  *
00038  * @author Tim Niemueller
00039  * @see SharedMemoryHeader
00040  */
00041 
00042 
00043 /** Constructor
00044  * @param data_size the size of the shared memory segment without the header
00045  *                  that should be allocated.
00046  * @param version The BB version to store in the shared memory segment to prevent
00047  *                conflicts with older software.
00048  */
00049 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(size_t data_size,
00050                                                            unsigned int version)
00051 {
00052   _data_size = data_size;
00053   _version   = version;
00054   data       = NULL;
00055 }
00056 
00057 
00058 /** Constructor.
00059  * @param version The BB version to store in the shared memory segment to prevent
00060  *                conflicts with older software.
00061  */
00062 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(unsigned int version)
00063 {
00064   _data_size = 0;
00065   _version   = version;
00066   data       = NULL;
00067 }
00068 
00069 
00070 /** Copy constructor.
00071  * @param h header to copy
00072  */
00073 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(const BlackBoardSharedMemoryHeader *h)
00074 {
00075   _data_size = h->_data_size;
00076   _version   = h->_version;
00077   data       = h->data;
00078 }
00079 
00080 
00081 /** Set SharedMemory instance.
00082  * This is needed for address conversion and must be set right after the constructor
00083  * call of SharedMemory!
00084  * @param shmem SharedMemory segment used for this header
00085  */
00086 void
00087 BlackBoardSharedMemoryHeader::set_shared_memory(SharedMemory *shmem)
00088 {
00089   this->shmem = shmem;
00090 }
00091 
00092 
00093 /** Destructor */
00094 BlackBoardSharedMemoryHeader::~BlackBoardSharedMemoryHeader()
00095 {
00096 }
00097 
00098 
00099 
00100 SharedMemoryHeader *
00101 BlackBoardSharedMemoryHeader::clone() const
00102 {
00103   return new BlackBoardSharedMemoryHeader(this);
00104 }
00105 
00106 
00107 /** Check if the given shared memory segment is a Fawkes BB segment
00108  * @param memptr Ptr to the segment
00109  * @return true if the version matches, false otherwise
00110  */
00111 bool
00112 BlackBoardSharedMemoryHeader::matches(void *memptr)
00113 {
00114   BlackBoardSharedMemoryHeaderData *md = (BlackBoardSharedMemoryHeaderData *)memptr;
00115   return (_version == md->version);
00116 }
00117 
00118 
00119 /** Check for equality of headers.
00120  * First checks if passed SharedMemoryHeader is an instance of
00121  * BlackBoardSharedMemoryHeader. If not returns false, otherwise it compares
00122  * version, data size and data pointer. If all match returns true,
00123  * false if any of them differs.
00124  * @param s shared memory header to compare to
00125  * @return true if the two instances identify the very same shared memory segments,
00126  * false otherwise
00127  */
00128 bool
00129 BlackBoardSharedMemoryHeader::operator==(const SharedMemoryHeader &s) const
00130 {
00131   const BlackBoardSharedMemoryHeader *h = dynamic_cast<const BlackBoardSharedMemoryHeader *>(&s);
00132   if ( ! h ) {
00133     return false;
00134   } else {
00135     return ( (_version == h->_version) &&
00136              (_data_size == h->_data_size) &&
00137              (data == h->data) );
00138   }
00139 }
00140 
00141 /** Get the size of the header data.
00142  * @return size of the header data
00143  */
00144 size_t
00145 BlackBoardSharedMemoryHeader::size()
00146 {
00147   return sizeof(BlackBoardSharedMemoryHeaderData);
00148 }
00149 
00150 
00151 /** Initialize shared memory segment
00152  * This copies basic management header data into the shared memory segment.
00153  * Basically sets the version and list heads to NULL
00154  * @param memptr pointer to the memory
00155  */
00156 void
00157 BlackBoardSharedMemoryHeader::initialize(void *memptr)
00158 {
00159   data = (BlackBoardSharedMemoryHeaderData *)memptr;
00160   data->version         = _version;
00161   data->shm_addr        = memptr;
00162   data->free_list_head  = NULL;
00163   data->alloc_list_head = NULL;
00164 }
00165 
00166 
00167 /** Set data of this header
00168  * Sets the internal pointer to the shared memory header data 
00169  * to the data retrieved from the shared memory segment.
00170  * @param memptr pointer to the memory
00171  */
00172 void
00173 BlackBoardSharedMemoryHeader::set(void *memptr)
00174 {
00175   data = (BlackBoardSharedMemoryHeaderData *)memptr;
00176 }
00177 
00178 
00179 void
00180 BlackBoardSharedMemoryHeader::reset()
00181 {
00182   data = NULL;
00183 }
00184 
00185 
00186 /** Data segment size.
00187  * @return size of the data segment without header
00188  */
00189 size_t
00190 BlackBoardSharedMemoryHeader::data_size()
00191 {
00192   return _data_size;
00193 }
00194 
00195 
00196 /** Get the head of the free chunks list.
00197  * @return pointer to the free list head, local pointer, already transformed,
00198  * you can use this without further conversion.
00199  */
00200 chunk_list_t *
00201 BlackBoardSharedMemoryHeader::free_list_head()
00202 {
00203   return (chunk_list_t *)shmem->ptr(data->free_list_head);
00204 }
00205 
00206 
00207 /** Get the head of the allocated chunks list.
00208  * @return pointer to the allocated list head, local pointer, already transformed,
00209  * you can use this without further conversion.
00210  */
00211 chunk_list_t *
00212 BlackBoardSharedMemoryHeader::alloc_list_head()
00213 {
00214   return (chunk_list_t *)shmem->ptr(data->alloc_list_head);
00215 }
00216 
00217 
00218 /** Set the head of the free chunks list.
00219  * @param flh pointer to the new free list head, must be a pointer to the local
00220  * shared memory segment. Will be transformed to a shared memory address.
00221  */
00222 void
00223 BlackBoardSharedMemoryHeader::set_free_list_head(chunk_list_t *flh)
00224 {
00225   data->free_list_head = (chunk_list_t *)shmem->addr(flh);
00226 }
00227 
00228 
00229 /** Set the head of the allocated chunks list.
00230  * @param alh pointer to the new allocated list head, must be a pointer to the local
00231  * shared memory segment. Will be transformed to a shared memory address.
00232  */
00233 void
00234 BlackBoardSharedMemoryHeader::set_alloc_list_head(chunk_list_t *alh)
00235 {
00236   data->alloc_list_head = (chunk_list_t *)shmem->addr(alh);
00237 }
00238 
00239 
00240 /** Get BlackBoard version.
00241  * @return BlackBoard version
00242  */
00243 unsigned int
00244 BlackBoardSharedMemoryHeader::version() const
00245 {
00246   return data->version;
00247 }
00248 
00249 } // end namespace fawkes
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends