mapped.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_MAPPED_H_
#define _UCOMMON_MAPPED_H_
 
#ifndef _UCOMMON_LINKED_H_
#include <ucommon/linked.h>
#endif
 
#ifndef _UCOMMON_THREAD_H_
#include <ucommon/thread.h>
#endif
 
#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif
 
#ifndef _MSWINDOWS_
#include <signal.h>
#endif
 
namespace ucommon {
 
class __EXPORT MappedMemory
{
private:
    size_t mapsize;
    caddr_t map;
    fd_t fd;
 
    __DELETE_COPY(MappedMemory);
 
protected:
    size_t size, used;
    char idname[65];
    bool erase;
 
    MappedMemory();
 
    void create(const char *name, size_t size = (size_t)0);
 
public:
    MappedMemory(const char *name, size_t size);
 
    MappedMemory(const char *name);
 
    virtual ~MappedMemory();
 
    void release(void);
 
    static  void remove(const char *name);
 
    inline operator bool() const
        {return (size != 0);}
 
    inline bool operator!() const
        {return (size == 0);}
 
    void *sbrk(size_t size);
 
    void *offset(size_t offset) const;
 
    bool copy(size_t offset, void *buffer, size_t size) const;
 
    inline size_t len(void) const
        {return size;}
 
    inline caddr_t addr(void)
        {return map;}
 
    static void disable(void);
};
 
class __EXPORT MappedReuse : protected ReusableAllocator, protected MappedMemory
{
private:
    unsigned objsize;
    unsigned reading;
    mutex_t mutex;
 
    __DELETE_DEFAULTS(MappedReuse);
 
protected:
    MappedReuse(size_t osize);
 
    inline void create(const char *fname, unsigned count)
        {MappedMemory::create(fname, count * objsize);}
 
public:
    MappedReuse(const char *name, size_t size, unsigned count);
 
    bool avail(void) const;
 
    ReusableObject *request(void);
 
    ReusableObject *get(void);
 
    ReusableObject *getTimed(timeout_t timeout);
 
    ReusableObject *getLocked(void);
 
    void removeLocked(ReusableObject *object);
};
 
template <class T>
class mapped_array : public MappedMemory
{
private:
    __DELETE_COPY(mapped_array);
 
protected:
    inline mapped_array() : MappedMemory() {}
 
    inline void create(const char *fn, unsigned members)
        {MappedMemory::create(fn, members * sizeof(T));}
 
public:
    inline mapped_array(const char *name, unsigned number) :
        MappedMemory(name, number * sizeof(T)) {}
 
    inline void initialize(void)
        {new((caddr_t)offset(0)) T[size / sizeof(T)];}
 
    inline void *addLock(void)
        {return sbrk(sizeof(T));}
 
    inline T *operator()(unsigned member)
        {return static_cast<T*>(offset(member * sizeof(T)));}
 
    inline T *operator()(void)
        {return static_cast<T*>(sbrk(sizeof(T)));}
 
    inline T& operator[](unsigned member)
        {return *(operator()(member));}
 
    inline unsigned max(void) const
        {return (unsigned)(size / sizeof(T));}
};
 
template <class T>
class mapped_reuse : public MappedReuse
{
private:
    __DELETE_COPY(mapped_reuse);
 
protected:
    inline mapped_reuse() :
        MappedReuse(sizeof(T)) {}
 
public:
    inline mapped_reuse(const char *name, unsigned number) :
        MappedReuse(name, sizeof(T), number) {}
 
    inline void initialize(void)
        {new((caddr_t)pos(0)) T[size / sizeof(T)];}
 
    inline operator bool() const
        {return MappedReuse::avail();}
 
    inline bool operator!() const
        {return !MappedReuse::avail();}
 
    inline operator T*()
        {return mapped_reuse::get();}
 
    inline T* operator*()
        {return mapped_reuse::get();}
 
    inline T *pos(size_t member)
        {return static_cast<T*>(MappedReuse::offset(member * sizeof(T)));}
 
    inline T *get(void)
        {return static_cast<T*>(MappedReuse::get());}
 
    inline T *getTimed(timeout_t timeout)
        {return static_cast<T*>(MappedReuse::getTimed(timeout));}
 
    inline T *request(void)
        {return static_cast<T*>(MappedReuse::request());}
 
    inline void removeLocked(T *object)
        {MappedReuse::removeLocked(object);}
 
    inline T *getLocked(void)
        {return static_cast<T*>(MappedReuse::getLocked());}
 
    inline void release(T *object)
        {ReusableAllocator::release(object);}
};
 
template <class T>
class mapped_view : protected MappedMemory
{
private:
    __DELETE_DEFAULTS(mapped_view);
 
public:
    inline mapped_view(const char *name) :
        MappedMemory(name) {}
 
    inline volatile const T *operator()(unsigned member)
        {return static_cast<const T*>(offset(member * sizeof(T)));}
 
    inline volatile const T &operator[](unsigned member)
        {return *(operator()(member));}
 
    inline volatile const T *get(unsigned member)
        {return static_cast<const T*>(offset(member * sizeof(T)));}
 
    inline void copy(unsigned member, T& buffer)
        {MappedMemory::copy(member * sizeof(T), &buffer, sizeof(T));}
 
    inline unsigned count(void) const
        {return (unsigned)(size / sizeof(T));}
};
 
} // namespace ucommon
 
#endif