Public API Reference

cstool/rbuflock.h

Go to the documentation of this file.

/*
    Copyright (C) 2004 by Jorrit Tyberghein
              (C) 2004 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSTOOL_RBUFLOCK_H__
#define __CS_CSTOOL_RBUFLOCK_H__

#include "csutil/ref.h"
#include "ivideo/rndbuf.h"

template <class T, class TbufferKeeper = iRenderBuffer*>
class csRenderBufferLock
{
  TbufferKeeper buffer;
  T* lockBuf;
  size_t bufStride;
#ifdef CS_DEBUG
  size_t elements;
#endif
  size_t currElement;

  typedef csRenderBufferLock<T, TbufferKeeper> LockType;
  struct PointerProxy
  {
  #ifdef CS_DEBUG
    const LockType& parent;
    size_t elemNum;
  #else
    T* p;
  #endif

    PointerProxy (const LockType& parent, size_t elemNum) 
  #ifdef CS_DEBUG
      : parent (parent), elemNum (elemNum)
  #else
      : p (&parent.Get (elemNum))
  #endif
    { }
    T& operator*()
    {
  #ifdef CS_DEBUG
      return parent.Get (elemNum);
  #else
      return *p;
  #endif
    }
    const T& operator*() const
    {
  #ifdef CS_DEBUG
      return parent.Get (elemNum);
  #else
      return *p;
  #endif
    }
  };

  csRenderBufferLock() {}
  // Copying the locking stuff is somewhat nasty so ... prevent it
  csRenderBufferLock (const csRenderBufferLock& other) {}

  void Unlock ()
  {
    if (buffer) buffer->Release();
  }
public:
  csRenderBufferLock (iRenderBuffer* buf, 
    csRenderBufferLockType lock = CS_BUF_LOCK_NORMAL) : buffer(buf),
    lockBuf(0), bufStride(buf ? buf->GetElementDistance() : 0),
    currElement(0)
  {
#ifdef CS_DEBUG
    elements = buf ? buf->GetElementCount() : 0;
#endif
    CS_ASSERT (buffer != 0);
    lockBuf = 
      buffer ? ((T*)((uint8*)buffer->Lock (lock))) : (T*)-1;
  }
  
  ~csRenderBufferLock()
  {
    Unlock();
  }
  
  T* Lock () const
  {
    return lockBuf;
  }
  
  operator T* () const
  {
    return Lock();
  }

  T& operator*() const
  {
    return Get (currElement);
  }

  PointerProxy operator++ ()  
  {
    currElement++;
    return PointerProxy (*this, currElement);
  }

  PointerProxy operator++ (int)
  {
    size_t n = currElement;
    currElement++;
    return PointerProxy (*this, n);
  }

  PointerProxy operator+= (int n)
  {
    currElement += n;
    return PointerProxy (*this, currElement);
  }

  T& operator [] (size_t n) const
  {
    return Get (n);
  }

  T& Get (size_t n) const
  {
    CS_ASSERT (n < elements);
    return *((T*)((uint8*)Lock() + n * bufStride));
  }
  
  size_t GetSize() const
  {
    return buffer ? buffer->GetElementCount() : 0;
  }

  bool IsValid() const { return buffer.IsValid(); }
};

#endif // __CS_CSTOOL_RBUFLOCK_H__

---