lump.hpp

Go to the documentation of this file.

// libdoomwad: manipulates Doom wad files.
// Copyright (C) 2005  John Gaughan
//
// This library 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 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// This library is distributed with the full text of the LGPL. Please see
// the accompanying file named COPYING.
// 
// You may contact the author at john@johngaughan.net

// C++ required.
#if !defined __cplusplus
#error C++ compiler required
#endif

// Include guard
#if !defined LUMP_H
#define LUMP_H

// C++ headers
#include <exception>
#include <iostream>
#include <iterator>
#include <fstream>
#include <new>
#include <stdexcept>
#include <string>

// Doom headers
#include "global.hpp"
#include "util.hpp"

namespace Doomwad
{
  class WadEntry; 

  EXPORT class Lump
  {
    public:

    typedef byte value_type;

    typedef value_type* pointer;

    typedef const value_type* const_pointer;

    typedef value_type& reference;

    typedef const value_type& const_reference;

    typedef size_t size_type;

    typedef __gnu_cxx::__normal_iterator<pointer,Lump> iterator;

    typedef __gnu_cxx::__normal_iterator<const_pointer,Lump> const_iterator;

    typedef std::reverse_iterator<iterator> reverse_iterator;

    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    static const size_t MAX_SIZE;

    static const size_t MIN_SIZE;

    protected:

    std::string m_name;

    size_t m_size;

    pointer m_data;

    public:

    // Constructors
    Lump (void) throw ();
    Lump (const Lump&) throw (std::bad_alloc);
    Lump (const std::string&, size_t = 0) throw (std::bad_alloc);
    Lump (const std::string&, size_t, const_pointer) throw (std::bad_alloc, std::invalid_argument);
    Lump (const_iterator&, const_iterator&) throw ();
    Lump (const WadEntry&) throw ();

    // Destructor
    virtual ~Lump (void) throw ();

    // Iterators
    iterator begin (void) throw ();
    iterator end (void) throw ();

    // Const iterators
    const_iterator begin (void) const throw ();
    const_iterator end (void) const throw ();

    // Reverse iterators
    reverse_iterator rbegin (void) throw ();
    reverse_iterator rend (void) throw ();

    // Const reverse iterators
    const_reverse_iterator rbegin (void) const throw ();
    const_reverse_iterator rend (void) const throw ();

    // Assignment and arithmetic
    virtual Lump& operator= (const Lump&) throw (std::bad_alloc);
    virtual Lump& operator= (const WadEntry&) throw (std::bad_alloc);
    virtual Lump& operator+= (const Lump&) throw (std::bad_alloc, std::range_error);
    virtual Lump operator+ (const Lump&) const throw (std::bad_alloc, std::range_error);

    // Comparison
    virtual bool operator== (const Lump&) const throw ();
    virtual bool operator!= (const Lump&) const throw ();

    // Casting
    operator std::string& (void) throw ();
    operator size_t (void) throw ();
    operator bool (void) throw ();

    // Array index
    reference operator[] (size_t) throw ();
    const_reference operator[] (size_t) const throw ();

    // Bounds-safe array index (a la std::vector)
    reference at (size_t) throw (std::out_of_range);
    const_reference at (size_t) const throw (std::out_of_range);

    // Append/assign data
    virtual bool append (const_pointer, size_t) throw (std::invalid_argument, std::range_error);
    virtual bool append (const_iterator&, const_iterator&) throw (std::range_error);
    virtual bool assign (const_pointer, size_t) throw (std::invalid_argument, std::bad_alloc);
    virtual bool assign (const_iterator&, const_iterator&) throw (std::bad_alloc);

    // Name management
    std::string getName (void) const throw ();
    bool setName (const std::string&) throw ();

    // Data management
    virtual const_pointer getData (void) throw ();

    // Size management
    virtual bool grow (size_t) throw (std::range_error, std::bad_alloc);
    virtual bool shrink (size_t) throw (std::range_error, std::bad_alloc);
    virtual bool setSize (size_t) throw (std::bad_alloc);

    // File stream input and output (binary)
    virtual bool readFromFile (std::ifstream&) throw (std::bad_alloc);
    virtual bool readFromFile (const std::string&) throw ();
    virtual bool writeToFile (std::ofstream&) const throw ();
    virtual bool writeToFile (const std::string&) const throw ();

    // Stream I/O
    virtual bool readFromStream (std::istream&, size_t) throw ();
    virtual bool writeToStream (std::ostream&) const throw ();
    virtual bool writeToTextStream (std::ostream&, size_t = 32, char = '.') const throw ();

    // Clear data
    virtual bool clear (void) throw ();
    bool clearData (void) throw ();
    bool clearName (void) throw ();

    // Get other information
    bool empty (void) const throw ();
    size_t size (void) const throw ();

    // Get integer types
    virtual byte getByte (size_t = 0) const throw (std::range_error);
    virtual word getWord (size_t = 0) const throw (std::range_error);
    virtual dword getDWord (size_t = 0) const throw (std::range_error);
    virtual qword getQWord (size_t = 0) const throw (std::range_error);
    virtual int8 getInt8 (size_t = 0) const throw (std::range_error);
    virtual uint8 getUInt8 (size_t = 0) const throw (std::range_error);
    virtual int16 getInt16 (size_t = 0) const throw (std::range_error);
    virtual uint16 getUInt16 (size_t = 0) const throw (std::range_error);
    virtual int32 getInt32 (size_t = 0) const throw (std::range_error);
    virtual uint32 getUInt32 (size_t = 0) const throw (std::range_error);
    virtual int64 getInt64 (size_t = 0) const throw (std::range_error);
    virtual uint64 getUInt64 (size_t = 0) const throw (std::range_error);

    // Set integer types
    virtual bool setByte (byte = 0, size_t = 0) throw (std::range_error);
    virtual bool setWord (word = 0, size_t = 0) throw (std::range_error);
    virtual bool setDWord (dword = 0, size_t = 0) throw (std::range_error);
    virtual bool setQWord (qword = 0, size_t = 0) throw (std::range_error);
    virtual bool setInt8 (int8 = 0, size_t = 0) throw (std::range_error);
    virtual bool setUInt8 (uint8 = 0, size_t = 0) throw (std::range_error);
    virtual bool setInt16 (int16 = 0, size_t = 0) throw (std::range_error);
    virtual bool setUInt16 (uint16 = 0, size_t = 0) throw (std::range_error);
    virtual bool setInt32 (int32 = 0, size_t = 0) throw (std::range_error);
    virtual bool setUInt32 (uint32 = 0, size_t = 0) throw (std::range_error);
    virtual bool setInt64 (int64 = 0, size_t = 0) throw (std::range_error);
    virtual bool setUInt64 (uint64 = 0, size_t = 0) throw (std::range_error);

    // Get string types
    virtual std::string getString (size_t = 0) const throw (std::range_error);
    virtual std::string getDString (size_t = 0) const throw (std::range_error);

    // Set string types
    virtual bool setString (const std::string&, size_t = 0) throw (std::range_error);
    virtual bool setDString (const std::string&, size_t = 0) throw (std::range_error);
  };
}
#include "wadentry.hpp"
#endif

---