switches.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>
#include <vector>

#include <cstring>

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

using namespace Doomwad;

const std::string Switches::NAME = "SWITCHES";

const int16 Switch::SHAREWARE = 0x0001;
const int16 Switch::DOOM      = 0x0002;
const int16 Switch::DOOM2     = 0x0003;
const int16 Switch::TERMINATE = 0x0000;
const int16 Switch::DEFAULT   = Switch::DOOM2;
const size_t Switch::LENGTH   = 0x00000014;

Switch::Switch (void) throw () : type (DEFAULT)
{
  return;
}

Switch::Switch (const std::string &_off, const std::string &_on, int16 _type) : on (_on), off (_off), type (_type)
{
  return;
}

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

bool Switch::write (Lump &lump, Lump::size_type i) const throw ()
{
  try
  {
    lump.setString (this->off, i);
    lump.setString (this->on, i + 9);
    lump.setInt16 (this->type, i + 18);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

bool Switch::read (const Lump &lump, Lump::size_type i) throw ()
{
  try
  {
    this->off  = lump.getString (i);
    this->on   = lump.getString (i + 9);
    this->type = lump.getInt16 (i + 18);
  }
  catch (std::range_error &e)
  {
    return false;
  }
  return true;
}

std::string Switch::toString (void) const throw ()
{
  std::ostringstream str;
  str << "On=" << this->on << ":Off=" << this->off << ":Type=" << this->type << '\n';
  return str.str ();
}

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

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

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

bool Switches::setFromLump (const Lump &lump) throw ()
{
  size_t i = 0;
  Switch temp;
  if (lump.size () % Switch::LENGTH != 0) return false;

  this->clear ();
  for (i = 0; i < lump.size () && lump[i] != Switch::TERMINATE; i += Switch::LENGTH)
  {
    temp.read (lump, i);
    this->insert (this->end (), temp);
  }

  return true;
}

Lump Switches::toLump (void) const throw ()
{
  Lump lump (NAME, (this->size () + 1) * Switch::LENGTH);
  Switch final ("", "", Switch::TERMINATE);

  size_t i = 0;
  for (const_iterator iter = this->begin (); iter != this->end (); ++iter, i += Switch::LENGTH)
    iter->write (lump, i);

  final.write (lump, i);

  return lump;
}

std::string Switches::toString (void) const throw ()
{
  std::ostringstream str;
  bool first = true;
  for (const_iterator i = this->begin (); i != this->end (); ++i, first = false)
  {
    if (!first) str << '\n';
    str << i->toString ();
  }
  return str.str ();
}

---