vptr_utils.h

Go to the documentation of this file.

#ifndef VIRTMEM_VPTR_UTILS_H
#define VIRTMEM_VPTR_UTILS_H

#include "config/config.h"
#include "vptr.h"

#include <string.h>

namespace virtmem {

// Generic NULL type, partially based on https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/nullptr#Solution_and_Sample_Code
#ifndef VIRTMEM_CPP11
class NILL_t
{
    void operator&() const; // prevent taking address

public:
    template <typename T> inline operator T*(void) const { return 0; }
    template <typename C, typename M> inline operator M C::*(void) const { return 0; }
    template <typename T, typename A> inline operator VPtr<T, A>(void) const { return VPtr<T, A>(); }
    inline operator BaseVPtr(void) const { return BaseVPtr(); }
    template <typename T, typename A> inline operator typename VPtr<T, A>::ValueWrapper(void) const { return VPtr<T, A>::ValueWrapper(0); }
};
#else
typedef nullptr_t NILL_t;
#endif

extern const NILL_t NILL;

template <typename TV> class VPtrLock
{
    typedef typename TV::TPtr Ptr;

    TV virtPtr;
    Ptr data;
    VirtPageSize lockSize;
    bool readOnly;

public:
    VPtrLock(const TV &v, VirtPageSize s, bool ro=false) :
        virtPtr(v), lockSize(s), readOnly(ro) { lock(); }
    VPtrLock(void) : data(0), lockSize(0), readOnly(false) { }
    ~VPtrLock(void) { unlock(); } 
    VPtrLock(const VPtrLock &other) :
        virtPtr(other.virtPtr), lockSize(other.lockSize),
        readOnly(other.readOnly) { lock(); } 

    void lock(void)
    {
#ifdef VIRTMEM_WRAP_CPOINTERS
        if (virtPtr.isWrapped())
            data = virtPtr.unwrap();
        else
#endif
            data = static_cast<Ptr>(TV::getAlloc()->makeFittingLock(virtPtr.ptr, lockSize, readOnly));
    }

    void lock(const TV &v, VirtPageSize s, bool ro=false)
    {
        virtPtr = v; lockSize = s; readOnly = ro;
        lock();
    }

    void unlock(void)
    {
#ifdef VIRTMEM_WRAP_CPOINTERS
        if (!virtPtr.isWrapped() && data)
#else
        if (data)
#endif
        {
            TV::getAlloc()->releaseLock(virtPtr.ptr);
            data = 0;
        }
    }

    Ptr operator *(void) { return data; } 

    VirtPageSize getLockSize(void) const { return lockSize; }
};

// Shortcut
template <typename T> VPtrLock<T> makeVirtPtrLock(const T &w, VirtPageSize s, bool ro=false)
{ return VPtrLock<T>(w, s, ro); }

namespace private_utils {
// Ugly hack from http://stackoverflow.com/a/12141673
// a null pointer of T is used to get the offset of m. The char & is to avoid any dereference operator overloads and the
// char * subtraction to get the actual offset.
template <typename C, typename M> ptrdiff_t getMembrOffset(const M C::*m)
{ return ((char *)&((char &)((C *)(0)->*m)) - (char *)(0)); }
}

template <typename C, typename M, typename A> inline VPtr<M, A> getMembrPtr(const VPtr<C, A> &c, const M C::*m)
{ VPtr<M, A> ret; ret.setRawNum(c.getRawNum() + private_utils::getMembrOffset(m)); return ret; }

template <typename C, typename M, typename NC, typename NM, typename A> inline VPtr<NM, A> getMembrPtr(const VPtr<C, A> &c, const M C::*m, const NM NC::*nm)
{ VPtr<NM, A> ret = static_cast<VPtr<NM, A> >(static_cast<VPtr<char, A> >(getMembrPtr(c, m)) + private_utils::getMembrOffset(nm)); return ret; }

}

#include "vptr_utils.hpp"

#endif // VIRTMEM_VPTR_UTILS_H