script_modify.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_MODIFY_HEADER__
#define __SCRIPT_MODIFY_HEADER__

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

#include "script.h"
#include "script_read.h"

namespace hoa_script {

class ModifyScriptDescriptor : public ReadScriptDescriptor {
  friend class GameScript;
public:
  ~ModifyScriptDescriptor();

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

  void ModifyBool(const std::string& key, bool value)
    { _ModifyData(key, value); }

  void ModifyBool(int32 key, bool value)
    { _ModifyData(key, value); }
  
  void ModifyInt(const std::string& key, int32 value)
    { _ModifyData(key, value); }
  
  void ModifyInt(int32 key, int32 value)
    { _ModifyData(key, value); }
  
  void ModifyUInt(const std::string& key, uint32 value)
    { _ModifyData(key, value); }

  void ModifyUInt(int32 key, uint32 value)
    { _ModifyData(key, value); }

  void ModifyFloat(const std::string& key, float value)
    { _ModifyData(key, value); }
  
  void ModifyFloat(int32 key, float value)
    { _ModifyData(key, value); }
  
  void ModifyString(const std::string& key, const std::string& value)
    { _ModifyData(key, value); }
  
  void ModifyString(int32 key, const std::string& value)
    { _ModifyData(key, value); }

  void AddNewBool(const std::string& key, bool value)
    { _AddNewData(key, value); }

  void AddNewBool(int32 key, bool value)
    { _AddNewData(key, value); }
  
  void AddNewInt(const std::string& key, int32 value)
    { _AddNewData(key, value); }
  
  void AddNewInt(int32 key, int32 value)
    { _AddNewData(key, value); }
  
  void AddNewUInt(const std::string& key, uint32 value)
    { _AddNewData(key, value); }

  void AddNewUInt(int32 key, uint32 value)
    { _AddNewData(key, value); }

  void AddNewFloat(const std::string& key, float value)
    { _AddNewData(key, value); }
  
  void AddNewFloat(int32 key, float value)
    { _AddNewData(key, value); }
  
  void AddNewString(const std::string& key, const std::string& value)
    { _AddNewData(key, value); }
  
  void AddNewString(int32 key, const std::string& value)
    { _AddNewData(key, value); }

  // TODO: Add methods to allow the creation of new tables
//  void CreateNewTable(const std::string& key);
//  void CreateNewTable(uint32 key);
//  void EndNewTable();

  void CommitChanges(bool leave_closed = false);

private:
  void _CommitTable(WriteScriptDescriptor& file, const luabind::object& table);

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

  template <class T> void _AddNewData(const std::string& key, T value);
  template <class T> void _AddNewData(int32 key, T value);
}; // class ModifyScriptDescriptor

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

template <class T> void ModifyScriptDescriptor::_ModifyData(const std::string& key, T value) {
  // A pointer to the table where the object is contained
  luabind::object* table = NULL;

  if (_open_tables.empty() == false) // Retrieve the globals table
    table = new luabind::object(luabind::from_stack(_lstack, LUA_GLOBALSINDEX));
  else // Retrieve the most recently opened table from the top of the stack
    table = new luabind::object(luabind::from_stack(_lstack, private_script::STACK_TOP));

  if (luabind::type(*table) != LUA_TTABLE) {
    _error_messages << "* _ModifyData() failed because it could not construct the table "
      << "where the data resided: " << key << std::endl;
    delete(table);
    return;
  }

  for (luabind::iterator i(*table); i != private_script::TABLE_END; ++i) {
    // Check to see if global value exists
    try {
      if (luabind::object_cast<std::string>(i.key()) == key) {
        *i = value;
        delete(table);
        return;
      }
    }
    catch (...)  {
      // A cast failure does not indicate an error, simply continue on with the next key
    }
  }

  // If the code reaches this far, then the variable could not be found
  _error_messages << "* _ModifyData() failed because in the active scope, it did not find the "
    << "table key: " << key << std::endl;
  delete(table);
} // template <class T> void ModifyScriptDescriptor::_ModifyData(const std::string& key, T value) {



template <class T> void ModifyScriptDescriptor::_ModifyData(int32 key, T value) {
  if (_open_tables.empty() == false) {
    _error_messages << "* _ModifyData() failed because there were no open tables when the "
      << "function was invoked for key: " << key << std::endl;
    return;
  }

  luabind::object table(luabind::from_stack(_lstack, private_script::STACK_TOP));

  if (luabind::type(table) != LUA_TTABLE) {
    _error_messages << "* _ModifyData() failed because the top of the stack was not a table "
      << "when trying to modify the data named: " << key << std::endl;
    return;
  }

  for (luabind::iterator i(table); i != private_script::TABLE_END; ++i) {
    // Check to see if global value exists
    try {
      if (luabind::object_cast<int32>(i.key()) == key) {
        *i = value;
        delete(table);
        return;
      }
    }
    catch (...)  {
      // A cast failure does not indicate an error, simply continue on with the next key
    }
  }

  // If the code reaches this far, then the variable could not be found
  _error_messages << "* _ModifyData() failed because in the active scope, it did not find the "
    << "table key: " << key << std::endl;
  delete(table);
} // template <class T> void ModifyScriptDescriptor::_ModifyData(int32 key, T value) {



template <class T> void ModifyScriptDescriptor::_AddNewData(const std::string& key, T value) {
  // A pointer to the table where the object is contained
  luabind::object* table = NULL;

  if (_open_tables.empty() == false) // Retrieve the globals table
    table = new luabind::object(luabind::from_stack(_lstack, LUA_GLOBALSINDEX));
  else // Retrieve the most recently opened table from the top of the stack
    table = new luabind::object(luabind::from_stack(_lstack, private_script::STACK_TOP));

  if (luabind::type(*table) != LUA_TTABLE) {
    _error_messages << "* _AddNewData() failed because the top of the stack was not a table "
      << "when trying to add the new data: " << key << std::endl;
    return;
  }

  // NOTE: If the key already exists in the table, its value will be overwritten here
  luabind::settable(*table, key, value);
} // template <class T> void ModifyScriptDescriptor::_AddNewData(const std::string& key, T value)



template <class T> void ModifyScriptDescriptor::_AddNewData(int32 key, T value) {
  if (_open_tables.empty() == false) {
    _error_messages << "* _AddNewData() failed because there were no open tables when the "
      << "function was invoked for key: " << key << std::endl;
    return;
  }

  // A pointer to the table where the object is contained
  luabind::object table(luabind::from_stack(_lstack, private_script::STACK_TOP));

  if (luabind::type(table) != LUA_TTABLE) {
    _error_messages << "* _AddNewData() failed because the top of the stack was not a table "
      << "when trying to add the new data: " << key << std::endl;
    return;
  }

  // NOTE: If the key already exists in the table, its value will be overwritten here
  luabind::settable(table, key, value);
} // template <class T> void ModifyScriptDescriptor::_AddNewData(int32 key, T value)

} // namespace hoa_script

#endif // __SCRIPT_MODIFY_HEADER

---