gmLuaUtils.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMALUA_UTILS_H_
#define _GEMALUA_UTILS_H_

#include "gmLuaEnv.h"
#include <luaEnv.h>
#include <luaTable.h>

#include <gmVector.h>
#include <gmModelData.h>
#include <gmTaskManager.h>

#include <gmCellGroupSet.h>
#include <gmLuaCellGroupSet.h>

#include <gmTrace.h>
#include <assert.h>
#include <luaProxy.h>

class GmGroupDumpItem;

namespace GmLuaUtils
{
  GML_API_EXPORT void fillVectorFromLua(lua_State* L, int stackPos, QString fname, GmVector& v);

  GML_API_EXPORT void checkAndLoadIntOption     (LuaTable& optionsTable, const char* fieldName, int*      option);
  GML_API_EXPORT void checkAndLoadUnsignedOption(LuaTable& optionsTable, const char* fieldName, unsigned* option);
  GML_API_EXPORT void checkAndLoadDoubleOption  (LuaTable& optionsTable, const char* fieldName, double*   option);

  GML_API_EXPORT void checkAndLoadTaskOptions(LuaTable& optionsTable, int* nworkers, int* ntasks,
                                              GmTaskManager::NodePartitionStrategy* nodeStrategy,
                                              GmTaskManager::CellPartitionStrategy* cellStrategy);

  GML_API_EXPORT int  stringOptionIndex(QString value, const char** optionNames, lua_State* L, const char* fieldName);

  template<class T, class M>
  void checkAndLoadStringOption(LuaTable& optionsTable, const char* fieldName, const char** optionNames, T* optionsObj, M method)
  {
    QString v = optionsTable.getField(fieldName).toString();
    if(v.isEmpty())  // If the field is missing from the table, keep the default
      return;

    // Set the value using the provided setter function. 
    // stringOptionIndex() calls luaL_error() if v is not found in optionNames
    (optionsObj->*method)(stringOptionIndex(v, optionNames, optionsTable.env()->state(), fieldName));  
  }


  template<class T, class P> T* parseMesh(lua_State* L, int index, const GmModelData* mdata, QString fname)
  {
    S_TRACE();
    assert(mdata);

    // String parameter
    if(lua_type(L, index) == LUA_TSTRING)
    {
      QString meshName = lua_tostring(L, index);
      GmMesh* mesh = mdata->meshes().value(meshName);

      if(!mesh)
        luaL_error(L, "%s", luaPrintable(QObject::tr("Mesh '%1' not found in call to %2").arg(meshName, fname)));

      T* tmesh = dynamic_cast<T*>(mesh);
      if(!tmesh)
        luaL_error(L, "%s", luaPrintable(QObject::tr("Mesh '%1' has an invalid type in call to %2").arg(meshName, fname)));

      return tmesh;
    }

    // Object parameter
    P* proxy = LuaProxy::toObjectOfClass<P>(L, index);
    if(!proxy)
      luaL_error(L, "%s", luaPrintable(QObject::tr("Error: Parameter %1 in call to %2 should be a valid mesh object (or a mesh name). Check mesh type.")
      .arg(index).arg(fname)));

    return dynamic_cast<T*>(proxy->mesh());
  }

  template<class T, class P> void parseMeshOrGroup(lua_State* L, int index, const GmModelData* mdata, QString fname, 
                                                   T** mesh, GmCellGroupSet** group)
  {
    S_TRACE();
    assert(mdata);
    assert(mesh && group);

    *group = NULL;

    // String parameter: must be a mesh name
    if(lua_type(L, index) == LUA_TSTRING)
    {
      QString meshName = lua_tostring(L, index);
      GmMesh* m        = mdata->meshes().value(meshName);

      if(!m)
        luaL_error(L, "%s", luaPrintable(QObject::tr("Mesh '%1' not found in call to %2").arg(meshName, fname)));

      T* tmesh = dynamic_cast<T*>(m);
      if(!tmesh)
        luaL_error(L, "%s", luaPrintable(QObject::tr("Mesh '%1' has an invalid type in call to %2").arg(meshName, fname)));

      *mesh = tmesh;
      return;
    }

    // Object parameter. Try a mesh
    P* proxy = LuaProxy::toObjectOfClass<P>(L, index);
    if(proxy)
    {
      *mesh = dynamic_cast<T*>(proxy->mesh());
      return;
    }

    // Not a mesh. Can still be a Cell group set
    GmLuaCellGroupSet* gproxy = LuaProxy::toObjectOfClass<GmLuaCellGroupSet>(L, index);
    if(!gproxy)
      luaL_error(L, "%s", luaPrintable(QObject::tr("Error: Parameter %1 in call to %2 should be a valid mesh object, a mesh name or a cell group set object. Check parameter type.")
                                                   .arg(index).arg(fname)));

    *group = gproxy->cellGroupSet();
    *mesh  = dynamic_cast<T*>((*group)->mesh());
    if(!*mesh)
      luaL_error(L, "%s", luaPrintable(QObject::tr("Cell group mesh has an invalid type in call to %1").arg(fname)));
  }

  template<const char* typeName> void pushGroupDumpItemProxy(lua_State* L, GmGroupDumpItem* ptr)
  {
    assert(L && ptr);
    LuaProxy::pushObject(L, new LuaSimpleTypedPtrProxy<GmGroupDumpItem, typeName>(ptr));
  }

  template <class T> T* getGroupDumpItemPtr(lua_State* L, int pos, QString tmsg, QString fmsg)
  {
    LuaSimplePtrProxy<GmGroupDumpItem>* proxy = LuaProxy::toObjectOfClass<LuaSimplePtrProxy<GmGroupDumpItem> >(L, pos);
    T* ptr = proxy ? dynamic_cast<T*>(proxy->get()) : NULL;

    if(!ptr)
      return luaL_error(L, "%s", luaPrintable(QObject::tr("Invalid %1 parameter in call to %2()").arg(tmsg, fmsg))), NULL;
    return ptr;
  }

}

#endif