ssectors.cpp

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

// C++ headers
#include <exception>
#include <sstream>
#include <stdexcept>
#include <string>

// Doom headers
#include "global.hpp"
#include "lump.hpp"
#include "ssectors.hpp"
#include "wadentry.hpp"

using namespace Doomwad;

const size_t Ssector::LENGTH = 0x00000004;
const size_t GLSsector::LENGTH = 0x00000004;
const std::string Ssectors::NAME = "SSECTORS";
const std::string GLSsectors::NAME = "GL_SSECT";

Ssector::Ssector (uint16 _num, uint16 _first) throw () : numsegs (_num), firstseg (_first)
{
}

Ssector::~Ssector (void) throw ()
{
}

size_t Ssector::getLength (void) const throw ()
{
  return LENGTH;
}

bool Ssector::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setUInt16 (this->numsegs, i);
    lump.setUInt16 (this->firstseg, i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Ssector::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->numsegs  = lump.getUInt16 (i);
    this->firstseg = lump.getUInt16 (i + 2);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Ssector::toString (void) const throw ()
{
  std::ostringstream str;

  str << '(' << numsegs << ',' << firstseg << ')';

  return str.str ();
}

Ssectors::Ssectors (void) throw ()
{
  return;
}

Ssectors::Ssectors (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

Ssectors::~Ssectors (void) throw ()
{
  return;
}

bool Ssectors::setFromLump (const Lump &lump) throw ()
{
  const size_t q = lump.size ();

  if (q % Ssector::LENGTH != 0) return false;

  Ssector s;

  this->clear ();

  for (size_t i = 0; i < q; i += Ssector::LENGTH)
  {
    s.read (lump, i);
    this->push_back (s);
  }

  return true;
}

Lump Ssectors::toLump (void) const throw ()
{
  Lump lump (NAME, this->size () * Ssector::LENGTH);
  const_iterator iter = this->begin ();
  for (size_t i = 0; iter != this->end (); i += Ssector::LENGTH, ++iter)
  {
    iter->write (lump, i);
  }
  return lump;
}

std::string Ssectors::toString (void) const throw ()
{
  std::ostringstream str;
  for (const_iterator iter = this->begin (); iter != this->end (); ++iter)
    str << iter->toString () << '\n';
  return str.str ();
}

GLSsector::GLSsector (uint16 num, uint16 first) throw ()
{
  // TODO: implement
  num = first;
  return;
}

GLSsector::~GLSsector (void) throw ()
{
  return;
}

size_t GLSsector::getLength (void) const throw ()
{
  return LENGTH;
}

bool GLSsector::write (Lump &lump, Lump::size_type i) const throw ()
{
  // TODO: implement
  i = lump.size ();
  return true;
}

bool GLSsector::read (const Lump &lump, Lump::size_type i) throw ()
{
  // TODO: implement
  i = lump.size ();
  return true;
}

std::string GLSsector::toString (void) const throw ()
{
  // TODO: implement
  std::ostringstream str;
  return str.str ();
}

GLSsectors::GLSsectors (void) throw ()
{
  return;
}

GLSsectors::GLSsectors (const Lump &lump) throw ()
{
  this->setFromLump (lump);
  return;
}

GLSsectors::~GLSsectors (void) throw ()
{
  return;
}

bool GLSsectors::setFromLump (const Lump &lump) throw ()
{
  // TODO: implement
  lump.size ();
  return true;
}

Lump GLSsectors::toLump (void) const throw ()
{
  // TODO: implement
  Lump lump (NAME);
  return lump;
}

std::string GLSsectors::toString (void) const throw ()
{
  // TODO: implement
  std::ostringstream str;
  return str.str ();
}

---