script_read.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_READ_HEADER__
#define __SCRIPT_READ_HEADER__

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

#include "script.h"

namespace hoa_script {

namespace private_script {

const int32 INTEGER_TYPE    = 0x12345678;
const int32 UINTEGER_TYPE   = 0x87654321;
const int32 FLOAT_TYPE      = 0x12344321;

} // namespace private_script

class ReadScriptDescriptor : public ScriptDescriptor {
  friend class GameScript;
public:
  virtual ~ReadScriptDescriptor();

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

  bool DoesVariableExist(const std::string& key)
    { return _DoesDataExist(key, LUA_TNIL); }

  bool DoesVariableExist(int32 key)
    { return _DoesDataExist(key, LUA_TNIL); }

  bool DoesBoolExist(const std::string& key)
    { return _DoesDataExist(key, LUA_TBOOLEAN); }

  bool DoesBoolExist(int32 key)
    { return _DoesDataExist(key, LUA_TBOOLEAN); }

  bool DoesIntExist(const std::string& key)
    { return _DoesDataExist(key, private_script::INTEGER_TYPE); }

  bool DoesIntExist(int32 key)
    { return _DoesDataExist(key, private_script::INTEGER_TYPE); }

  bool DoesUIntExist(const std::string& key)
    { return _DoesDataExist(key, private_script::UINTEGER_TYPE); }

  bool DoesUIntExist(int32 key)
    { return _DoesDataExist(key, private_script::UINTEGER_TYPE); }

  bool DoesFloatExist(const std::string& key)
    { return _DoesDataExist(key, private_script::FLOAT_TYPE); }

  bool DoesFloatExist(int32 key)
    { return _DoesDataExist(key, private_script::FLOAT_TYPE); }

  bool DoesStringExist(const std::string& key)
    { return _DoesDataExist(key, LUA_TSTRING); }

  bool DoesStringExist(int32 key)
    { return _DoesDataExist(key, LUA_TSTRING); }

  bool DoesFunctionExist(const std::string& key)
    { return _DoesDataExist(key, LUA_TFUNCTION); }

  bool DoesFunctionExist(int32 key)
    { return _DoesDataExist(key, LUA_TFUNCTION); }

  bool DoesTableExist(const std::string& key)
    { return _DoesDataExist(key, LUA_TTABLE); }

  bool DoesTableExist(int32 key)
    { return _DoesDataExist(key, LUA_TTABLE); }

  bool ReadBool(const std::string& key)
    { return _ReadData<bool>(key, false); }

  bool ReadBool(int32 key)
    { return _ReadData<bool>(key, false); }

  int32 ReadInt(const std::string& key)
    { return _ReadData<int32>(key, 0); }

  int32 ReadInt(int32 key)
    { return _ReadData<uint32>(key, 0); }

  uint32 ReadUInt(const std::string& key)
    { return _ReadData<int32>(key, 0); }

  uint32 ReadUInt(int32 key)
    { return _ReadData<uint32>(key, 0); }

  float ReadFloat(const std::string& key)
    { return _ReadData<float>(key, 0.0f); }

  float ReadFloat(int32 key)
    { return _ReadData<float>(key, 0.0f); }

  std::string ReadString(const std::string& key)
    { return _ReadData<std::string>(key, ""); }

  std::string ReadString(int32 key)
    { return _ReadData<std::string>(key, ""); }

  hoa_utils::ustring ReadUString(const std::string& key)
    { return _ReadData<hoa_utils::ustring>(key, hoa_utils::MakeUnicodeString("")); }

  hoa_utils::ustring ReadUString(int32 key)
    { return _ReadData<hoa_utils::ustring>(key, hoa_utils::MakeUnicodeString("")); }

  void ReadBoolVector(const std::string& key, std::vector<bool>& vect)
    { _ReadDataVector<bool>(key, vect); }

  void ReadBoolVector(int32 key, std::vector<bool>& vect)
    { _ReadDataVector<bool>(key, vect); }

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

  void ReadIntVector(int32 key, std::vector<int32>& vect)
    { _ReadDataVector<int32>(key, vect); }

  void ReadUIntVector(const std::string& key, std::vector<uint32>& vect)
    { _ReadDataVector<uint32>(key, vect); }

  void ReadUIntVector(int32 key, std::vector<uint32>& vect)
    { _ReadDataVector<uint32>(key, vect); }

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

  void ReadFloatVector(int32 key, std::vector<float>& vect)
    { _ReadDataVector<float>(key, vect); }

  void ReadStringVector(const std::string& key, std::vector<std::string>& vect)
    { _ReadDataVector<std::string>(key, vect); }

  void ReadStringVector(int32 key, std::vector<std::string>& vect)
    { _ReadDataVector<std::string>(key, vect); }

  void ReadUStringVector(const std::string& key, std::vector<hoa_utils::ustring>& vect)
    { _ReadDataVector<hoa_utils::ustring>(key, vect); }

  void ReadUStringVector(int32 key, std::vector<hoa_utils::ustring>& vect)
    { _ReadDataVector<hoa_utils::ustring>(key, vect); }

  luabind::object ReadFunctionPointer(const std::string& key);

  luabind::object ReadFunctionPointer(int32 key);


  void OpenTable(const std::string& table_name);

  void OpenTable(int32 table_name);

  void CloseTable();

  void CloseAllTables();

  uint32 GetTableSize(const std::string& table_name);

  uint32 GetTableSize(int32 table_name);

  uint32 GetTableSize();

  void ReadTableKeys(std::vector<std::string>& keys)
    { _ReadTableKeys(keys); }

  void ReadTableKeys(std::vector<int32>& keys)
    { _ReadTableKeys(keys); }

  void ReadTableKeys(std::vector<uint32>& keys)
    { _ReadTableKeys(keys); }

  void ReadTableKeys(const std::string& table_name, std::vector<std::string>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }

  void ReadTableKeys(const std::string& table_name, std::vector<int32>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }

  void ReadTableKeys(const std::string& table_name, std::vector<uint32>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }

  void ReadTableKeys(int32 table_name, std::vector<std::string>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }

  void ReadTableKeys(int32 table_name, std::vector<int32>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }

  void ReadTableKeys(int32 table_name, std::vector<uint32>& keys)
    { OpenTable(table_name); _ReadTableKeys(keys); CloseTable(); }


  lua_State* GetLuaState()
    { return _lstack; }

  void DEBUG_PrintLuaStack();

  void DEBUG_PrintGlobals();
  
protected:
  lua_State *_lstack;

  bool _DoesDataExist(const std::string& key, int32 type);
  bool _DoesDataExist(int32 key, int32 type);

  bool _CheckDataType(int32 type, luabind::object& obj_check);

  template <class T> T _ReadData(const std::string& key, T default_value);
  template <class T> T _ReadData(int32 key, T default_value);

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

  template <class T> void _ReadTableKeys(std::vector<T>& keys);
}; // class ReadScriptDescriptor

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

template <class T> T ReadScriptDescriptor::_ReadData(const std::string &key, T default_value) {
  // Check whether the user is trying to read a global variable or one stored in a table
  if (_open_tables.size() == 0) { // Variable is a global
    lua_getglobal(_lstack, key.c_str());
    luabind::object o(luabind::from_stack(_lstack, private_script::STACK_TOP));

    if (!o) {
      _error_messages << "* _ReadData() was unable to access the global variable: " << key << std::endl;
      return default_value;
    }

    try {
      T ret_val = luabind::object_cast<T>(o);
      lua_pop(_lstack, 1);
      return ret_val;
    }
    catch (...) {
      _error_messages << "* _ReadData() was unable to cast value to correct type for global variable: " << key << std::endl;
      return default_value;
    }
  }

  else { // Variable is a member of a table
    luabind::object o(luabind::from_stack(_lstack, private_script::STACK_TOP));
    if (luabind::type(o) != LUA_TTABLE) {
      _error_messages << "* _ReadData() failed because the top of the stack was not a table when trying to read variable: " << key << std::endl;
      return default_value;
    }

    try {
      return luabind::object_cast<T>(o[key]);
    }
    catch (...) {
      _error_messages << "* _ReadData() was unable to access the table variable: " << key << std::endl;
      return default_value;
    }
  }
  return default_value;
} // template <class T> T ReadScriptDescriptor::_ReadData(const char *key, T default_value)



template <class T> T ReadScriptDescriptor::_ReadData(int32 key, T default_value) {
  if (_open_tables.size() == 0) {
    _error_messages << "* _ReadData() failed because no tables were open when trying to access the table variable: "
      << key << std::endl;
    return default_value;
  }

  luabind::object o(luabind::from_stack(_lstack, private_script::STACK_TOP));
  if (luabind::type(o) != LUA_TTABLE) {
    _error_messages << "* _ReadData() failed because the top of the stack was not a table when trying to read variable: "
      << key << std::endl;
    return default_value;
  }

  try {
    return luabind::object_cast<T>(o[key]);
  }
  catch (...) {
    _error_messages << "* _ReadData() was unable to access the table variable: "
      << key << std::endl;
    return default_value;
  }

  return default_value;
} // template <class T> T ReadScriptDescriptor::_ReadData(int32 key, T default_value)



template <class T> void ReadScriptDescriptor::_ReadDataVector(const std::string& key, std::vector<T>& vect) {
  // Open the table and grab if off the stack
  OpenTable(key);
  _ReadDataVectorHelper(vect);
  CloseTable();
} // template <class T> void ReadScriptDescriptor::_ReadDataVector(std::string key, std::vector<T> &vect)



template <class T> void ReadScriptDescriptor::_ReadDataVector(int32 key, std::vector<T>& vect) {
  if (_open_tables.size() == 0) {
    _error_messages << "* _ReadDataVector() failed because no tables were open when trying to access the table variable: "
      << key << std::endl;;
    return;
  }

  // Open the table and grab if off the stack
  OpenTable(key);
  _ReadDataVectorHelper(vect);
  CloseTable();
} // template <class T> void ReadScriptDescriptor::_ReadDataVector(int32 key, std::vector<T> &vect)



template <class T> void ReadScriptDescriptor::_ReadDataVectorHelper(std::vector<T>& vect) {
  luabind::object o(luabind::from_stack(_lstack, private_script::STACK_TOP));

  if (luabind::type(o) != LUA_TTABLE) {
    _error_messages << "* _ReadDataVectorHelper() failed because the top of the stack was not a table" << std::endl;
    return;
  }
  
  // Iterate through all the items of the table and place it in the vector
  for (luabind::iterator it(o); it != private_script::TABLE_END; it++) {
    try {
      vect.push_back(luabind::object_cast<T>((*it)));
    }
    catch (...) {
      _error_messages << "* _ReadDataVectorHelper() failed due to a type cast failure when reading the table" << std::endl;
    }
  }
} // template <class T> void ReadScriptDescriptor::_ReadDataVectorHelper(std::vector<T>& vect)



template <class T> void ReadScriptDescriptor::_ReadTableKeys(std::vector<T>& keys) {
  keys.clear();

  if (_open_tables.size() == 0) {
    _error_messages << "* _ReadTableKeys() failed because there were no open tables to get the keys of" << std::endl;
    return;
  }

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

  if (luabind::type(table) != LUA_TTABLE) {
    _error_messages << "* _ReadTableKeys() failed because the top of the stack was not a table" << std::endl;
    return;
  }

  for (luabind::iterator i(table); i != private_script::TABLE_END; i++) {
    try {
      keys.push_back(luabind::object_cast<T>(i.key()));
    }
    catch (...) {
      _error_messages << "* _ReadTableKeys() failed due to a type cast failure when retrieving a table key" << std::endl;
      keys.clear();
      return;
    }
  }
} // template <class T> void ReadScriptDescriptor::ReadTableKeys(std::vector<T>& keys) {

} // namespace hoa_script

#endif // __SCRIPT_READ_HEADER__

---