ucommon

ucommon/mapped.h

Go to the documentation of this file.
00001 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
00002 //
00003 // This file is part of GNU uCommon C++.
00004 //
00005 // GNU uCommon C++ is free software: you can redistribute it and/or modify
00006 // it under the terms of the GNU Lesser General Public License as published
00007 // by the Free Software Foundation, either version 3 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // GNU uCommon C++ is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public License
00016 // along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
00017 
00029 #ifndef _UCOMMON_MAPPED_H_
00030 #define _UCOMMON_MAPPED_H_
00031 
00032 #ifndef _UCOMMON_LINKED_H_
00033 #include <ucommon/linked.h>
00034 #endif
00035 
00036 #ifndef _UCOMMON_THREAD_H_
00037 #include <ucommon/thread.h>
00038 #endif
00039 
00040 #ifndef _UCOMMON_STRING_H_
00041 #include <ucommon/string.h>
00042 #endif
00043 
00044 #ifndef _MSWINDOWS_
00045 #include <signal.h>
00046 #endif
00047 
00048 NAMESPACE_UCOMMON
00049 
00058 class __EXPORT MappedMemory
00059 {
00060 private:
00061     size_t mapsize;
00062     caddr_t map;
00063     fd_t fd;
00064 
00065 protected:
00066     size_t size, used;
00067     char idname[65];
00068     bool erase;
00069 
00070     MappedMemory();
00071 
00078     void create(const char *name, size_t size = (size_t)0);
00079 
00084     virtual void fault(void) const;
00085 
00086 public:
00093     MappedMemory(const char *name, size_t size);
00094 
00101     MappedMemory(const char *name);
00102 
00106     virtual ~MappedMemory();
00107 
00111     void release(void);
00112 
00119     static  void remove(const char *name);
00120 
00125     inline operator bool() const
00126         {return (size != 0);};
00127 
00132     inline bool operator!() const
00133         {return (size == 0);};
00134 
00142     void *sbrk(size_t size);
00143 
00149     void *offset(size_t offset) const;
00150 
00155     inline size_t len(void)
00156         {return size;};
00157 
00162     inline caddr_t getStart(void)
00163         {return map;};
00164 
00172     static void disable(void);
00173 };
00174 
00184 class __EXPORT MappedReuse : protected ReusableAllocator, protected MappedMemory
00185 {
00186 private:
00187     unsigned objsize;
00188     unsigned reading;
00189     mutex_t mutex;
00190 
00191 protected:
00192     MappedReuse(size_t osize);
00193 
00194     inline void create(const char *fname, unsigned count)
00195         {MappedMemory::create(fname, count * objsize);};
00196 
00197 public:
00210     MappedReuse(const char *name, size_t size, unsigned count);
00211 
00216     bool avail(void);
00217 
00222     ReusableObject *request(void);
00223 
00229     ReusableObject *get(void);
00230 
00238     ReusableObject *getTimed(timeout_t timeout);
00239 
00245     ReusableObject *getLocked(void);
00246 
00252     void removeLocked(ReusableObject *object);
00253 };
00254 
00261 template <class T>
00262 class mapped_array : public MappedMemory
00263 {
00264 protected:
00265     inline mapped_array() : MappedMemory() {};
00266 
00267     inline void create(const char *fn, unsigned members)
00268         {MappedMemory::create(fn, members * sizeof(T));};
00269 
00270 public:
00279     inline mapped_array(const char *name, unsigned number) :
00280         MappedMemory(name, number * sizeof(T)) {};
00281 
00286     inline void initialize(void)
00287         {new((caddr_t)offset(0)) T[size / sizeof(T)];};
00288 
00293     inline void *addLock(void)
00294         {return sbrk(sizeof(T));};
00295 
00301     inline T *operator()(unsigned member)
00302         {return static_cast<T*>(offset(member * sizeof(T)));}
00303 
00308     inline T *operator()(void)
00309         {return static_cast<T*>(sbrk(sizeof(T)));};
00310 
00316     inline T& operator[](unsigned member)
00317         {return *(operator()(member));};
00318 
00323     inline unsigned getSize(void)
00324         {return (unsigned)(size / sizeof(T));};
00325 };
00326 
00334 template <class T>
00335 class mapped_reuse : public MappedReuse
00336 {
00337 protected:
00338     inline mapped_reuse() :
00339         MappedReuse(sizeof(T)) {};
00340 
00341 public:
00349     inline mapped_reuse(const char *name, unsigned number) :
00350         MappedReuse(name, sizeof(T), number) {};
00351 
00356     inline void initialize(void)
00357         {new((caddr_t)pos(0)) T[size / sizeof(T)];};
00358 
00363     inline operator bool() const
00364         {return MappedReuse::avail();};
00365 
00370     inline bool operator!() const
00371         {return !MappedReuse::avail();};
00372 
00378     inline operator T*()
00379         {return mapped_reuse::get();};
00380 
00386     inline T* operator*()
00387         {return mapped_reuse::get();};
00388 
00394     inline T *pos(size_t member)
00395         {return static_cast<T*>(MappedReuse::offset(member * sizeof(T)));};
00396 
00402     inline T *get(void)
00403         {return static_cast<T*>(MappedReuse::get());};
00404 
00412     inline T *getTimed(timeout_t timeout)
00413         {return static_cast<T*>(MappedReuse::getTimed(timeout));};
00414 
00420     inline T *request(void)
00421         {return static_cast<T*>(MappedReuse::request());};
00422 
00428     inline void removeLocked(T *object)
00429         {MappedReuse::removeLocked(object);};
00430 
00436     inline T *getLocked(void)
00437         {return static_cast<T*>(MappedReuse::getLocked());};
00438 
00443     inline void release(T *object)
00444         {ReusableAllocator::release(object);};
00445 };
00446 
00453 template <class T>
00454 class mapped_view : protected MappedMemory
00455 {
00456 public:
00462     inline mapped_view(const char *name) :
00463         MappedMemory(name) {};
00464 
00470     inline volatile const T *operator()(unsigned member)
00471         {return static_cast<const T*>(offset(member * sizeof(T)));}
00472 
00478     inline volatile const T &operator[](unsigned member)
00479         {return *(operator()(member));};
00480 
00485     inline unsigned getCount(void)
00486         {return (unsigned)(size / sizeof(T));};
00487 };
00488 
00489 END_NAMESPACE
00490 
00491 #endif