script_write.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __SCRIPT_WRITE_HEADER__
#define __SCRIPT_WRITE_HEADER__

#include "utils.h"
#include "defs.h"

#include "script.h"

namespace hoa_script {

class WriteScriptDescriptor : public ScriptDescriptor {
  friend class GameScript;
public:
  ~WriteScriptDescriptor();

  bool OpenFile(const std::string& file_name);
  bool OpenFile();
  void CloseFile();


  void InsertNewLine();

  void WriteComment(const std::string& comment);

  void BeginCommentBlock();

  void EndCommentBlock();

  void WriteLine(const std::string& comment, bool new_line = true);

  void WriteBool(const std::string& key, bool value);
  void WriteBool(const int32 key, bool value);

  void WriteInt(const std::string& key, int32 value)
    { _WriteData(key, value); }

  void WriteInt(const int32 key, int32 value)
    { _WriteData(key, value); }

  void WriteUInt(const std::string& key, uint32 value)
    { _WriteData(key, value); }

  void WriteUInt(const int32 key, uint32 value)
    { _WriteData(key, value); }

  void WriteFloat(const std::string& key, float value)
    { _WriteData(key, value); }

  void WriteFloat(const int32 key, float value)
    { _WriteData(key, value); }

  void WriteString(const std::string& key, const std::string& value);
  void WriteString(const int32 key, const std::string& value);

  void WriteUString(const std::string& key, const std::string& value);
  void WriteUString(const int32 key, const std::string& value);

  void WriteBoolVector(const std::string &key, std::vector<bool> &vect);
  void WriteBoolVector(const int32 key, std::vector<bool> &vect);

  void WriteIntVector(const std::string &key, std::vector<int32> &vect)
    { _WriteDataVector(key, vect); }

  void WriteIntVector(const int32 key, std::vector<int32> &vect)
    { _WriteDataVector(key, vect); }

  void WriteUIntVector(const std::string &key, std::vector<int32> &vect)
    { _WriteDataVector(key, vect); }

  void WriteUIntVector(const int32 key, std::vector<int32> &vect)
    { _WriteDataVector(key, vect); }

  void WriteFloatVector(const std::string &key, std::vector<float> &vect)
    { _WriteDataVector(key, vect); }

  void WriteFloatVector(const int32 key, std::vector<float> &vect)
    { _WriteDataVector(key, vect); }

  void WriteStringVector(const std::string &key, std::vector<std::string> &vect);
  void WriteStringVector(const int32 key, std::vector<std::string> &vect);
  void WriteUStringVector(const std::string &key, std::vector<std::string> &vect);
  void WriteUStringVector(const int32 key, std::vector<std::string> &vect);

  void BeginTable(const std::string &key);
  void BeginTable(int32 key);
  void EndTable();

private:
  std::ofstream _outfile;

  bool _inside_comment_block;

  template <class T> void _WriteData(const std::string& key, T value);
  template <class T> void _WriteData(const int32 key, T value);

  template <class T> void _WriteDataVector(const std::string& key, std::vector<T> &vect);
  template <class T> void _WriteDataVector(const int32 key, std::vector<T> &vect);

  void _WriteTablePath();
}; // class WriteScriptDescriptor : public ScriptDescriptor

//-----------------------------------------------------------------------------
// Template Function Definitions
//-----------------------------------------------------------------------------

template <class T> void WriteScriptDescriptor::_WriteData(const std::string &key, T value) {
  if (_open_tables.size() == 0) {
    _outfile << key << " = " << value << std::endl;
  }
  else {
    _WriteTablePath();
    _outfile << '[' << key << ']' << " = " << value << std::endl;
  }
}


template <class T> void WriteScriptDescriptor::_WriteData(const int32 key, T value) {
  if (_open_tables.empty()) {
    _error_messages << "* WriteScriptDescriptor::_WriteData() failed because there were no "
      << "tables open when attempting to write the key/value: [" << key << "] = " << value << std::endl;
    return;
  }

  _WriteTablePath();
  _outfile << '[' << key << ']' << " = " << value << std::endl;
}



template <class T> void WriteScriptDescriptor::_WriteDataVector(const std::string& key, std::vector<T> &vect) {
  if (vect.empty()) {
    _error_messages << "* WriteScriptDescriptor::_WriteDataVector() failed because "
      << "the vector argument was empty for key name: " << key << std::endl;
    return;
  }

  if (_open_tables.size() == 0) {
    _outfile << key << " = { ";
  }
  else {
    _WriteTablePath();
    _outfile << '[' << key << "] = { ";
  }

  _outfile << vect[0];
  for (uint32 i = 1; i < vect.size(); i++) {
    _outfile << ", " << vect[i];
  }
  _outfile << " }" << std::endl;
}



template <class T> void WriteScriptDescriptor::_WriteDataVector(const int32 key, std::vector<T>& vect) {
  if (_open_tables.empty()) {
    _error_messages << "* WriteScriptDescriptor::_WriteDataVector() failed because there were no "
      << "tables open when attempting for key name: " << key << std::endl;
    return;
  }

  _WriteTablePath();
  _outfile << '[' << key << "] = { ";

  _outfile << vect[0];
  for (uint32 i = 1; i < vect.size(); i++) {
    _outfile << ", " << vect[i];
  }
  _outfile << " }" << std::endl;
}

} // namespace hoa_script

#endif // __SCRIPT_WRITE_HEADER_

---