MemoryBlock.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   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 __ccxx_MemoryBlock_hxx
#define __ccxx_MemoryBlock_hxx

#include <commonc++/Common.h++>
#include <commonc++/OutOfBoundsException.h++>

namespace ccxx {

  class COMMONCPP_API MemoryBlock
  {
    public:

    MemoryBlock(byte_t *base = NULL, size_t size = 0) throw()
      : _base(base),
        _size(size)
    { }

    virtual ~MemoryBlock() throw()
    { }

    inline void zero() throw()
    { fill(0); }

    void fill(byte_t value) throw();

    inline byte_t *getBase() throw()
    { return(_base); }

    inline const byte_t *getBase() const throw()
    { return(_base); }

    virtual inline void setBase(byte_t *base) throw()
    { _base = base; }

    inline size_t getSize() const throw()
    { return(_size); }

    inline void setSize(size_t size) throw()
    { _size = size; }

     bool operator==(const MemoryBlock& other) const throw();

    inline bool operator!=(const MemoryBlock& other) const throw()
    { return(! operator==(other)); }

    byte_t operator[](int index) const throw(OutOfBoundsException);

    byte_t& operator[](int index) throw(OutOfBoundsException);

    bool copyFrom(const MemoryBlock& other) throw();

    void moveFrom(MemoryBlock& other) throw();

    int indexOf(byte_t val, uint_t startIndex = 0) const throw();

    inline bool operator!() const throw()
    { return(_base == NULL); }

    protected:

    byte_t *_base;
    size_t _size;

    private:

    CCXX_COPY_DECLS(MemoryBlock);
  };

}; // namespace ccxx

#endif // __ccxx_MemoryBlock_hxx

/* end of header file */