Properties.cc

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <ssrc/wispers/lua/Properties.h>

__BEGIN_NS_SSRC_WSPR_LUA

void PropertiesToTable::PushValue::operator()(const primitive_property_vector & v) const
{
  lua_createtable(state, v.size(), 0);
  int i = 1;
  for(primitive_property_vector::const_iterator && it = v.begin(), && end = v.end(); it != end; ++it)
  {
    lua_pushinteger(state, i++);
    boost::apply_visitor(*this, *it);
    lua_settable(state, -3);
  }
}

void PropertiesToTable::PushValue::operator()(const Properties & properties)
  const
{
  using NS_SSRC_WSPR_UTILITY::property_type;
  const property_type *v = properties.value();

  if(properties.is_leaf()) {
    if(v != 0) {
      boost::apply_visitor(*this, *v);
    } else {
      lua_pushnil(state);
    }
  } else {
    lua_newtable(state);

    if(v != 0) {
      boost::apply_visitor(*this, *v);
      lua_setfield(state, -2, "_value");
    }

    properties.visit(to_table);
  }
}

void PropertiesToTable::PushValue::operator()(const property_vector & v) const
{
  lua_createtable(state, v.size(), 0);
  int i = 1;
  for(property_vector::const_iterator && it = v.begin(), && end = v.end(); it != end; ++it)
  {
    lua_pushinteger(state, i++);
    PropertiesToTable::PushValue::operator()(*it);
    lua_settable(state, -3);
  }
}

void PropertiesToTable::enter(const std::string key,
                              const Properties *properties,
                              const bool)
  const
{
  using NS_SSRC_WSPR_UTILITY::property_type;
  const property_type *v = properties->value();

  if(!properties->is_leaf()) {
    lua_newtable(state());

    if(v != 0) {
      boost::apply_visitor(push, *v);
      lua_setfield(state(), -2, "_value");
    }
  } else {
    if(v != 0) {
      boost::apply_visitor(push, *v);
    } else {
      lua_pushnil(state());
    }
  }
}

void PropertiesToTable::leave(const std::string key,
                              const Properties *properties,
                              const bool)
  const
{
  lua_setfield(state(), -2, key.c_str());
}

void table_to_properties(lua_State *state, Properties & properties) {
  const size_t size = lua_objlen(state, -1);

  if(size == 0) {
    lua_pushnil(state);
    while(lua_next(state, -2)) {
      const int ltype = lua_type(state, -1);
      const string && key = convert<string>(state, -2);

      // TODO: key == "_value" should use set_value(v) instead of set(v, k)
      switch(ltype) {
      case LUA_TNUMBER:
        properties.set(convert<lua_Number>(state, -1), key);
        break;
      case LUA_TBOOLEAN:
        properties.set(convert<bool>(state, -1), key);
        break;
      case LUA_TSTRING:
        properties.set(convert<string>(state, -1), key);
        break; 
      case LUA_TTABLE: {
        Properties *node = properties.create_node(key);
        table_to_properties(state, *node);
      }
        break;
      default:
        break;
      };

      lua_pop(state, 1);
    }
  } else {
    lua_pushnil(state);
    // Determine type of array elements (primitive or table).
    if(lua_next(state, -2)) {
      if(lua_istable(state, -1)) {
        Properties *node;
        property_vector & v = properties.create_property_vector();
        v.reserve(size);
        do {
          v.push_back(node = new Properties);
          table_to_properties(state, *node);
          lua_pop(state, 1);
        } while(lua_next(state, -2));
      } else {
        primitive_property_vector & v =
          properties.create_primitive_property_vector();
        v.reserve(size);
        do {
          const int ltype = lua_type(state, -1);
          switch(ltype) {
          case LUA_TNUMBER: v.push_back(convert<lua_Number>(state, -1)); break;
          case LUA_TBOOLEAN: v.push_back(convert<bool>(state, -1)); break;
          case LUA_TSTRING: v.push_back(convert<string>(state, -1)); break;
          default: break;
          };
          lua_pop(state, 1);
        } while(lua_next(state, -2));
      }
    }
  }
}

void swig_table_to_properties(void *state, Properties & properties) {
  table_to_properties(reinterpret_cast<lua_State*>(state), properties);
}

namespace {
  inline properties_ptr load_properties(lua_State *state, int err)
    SSRC_DECL_THROW(LuaCallError)
  {
    if(err != 0) {
      string msg(lua_tostring(state, -1));
      lua_pop(state, 1);
      throw LuaCallError(msg, err);
    }

    pcall_nopop(0, LUA_MULTRET, state);

    if(!lua_istable(state, -1)) {
      lua_pop(state, 1);
      throw LuaCallError("properties definition does not return table",
                         LUA_ERRSYNTAX);
    }

    properties_ptr properties(new Properties);

    table_to_properties(state, *properties);
    lua_pop(state, 1);
  
    return properties;
  }
}

properties_ptr load_properties(lua_State *state, const std::string & filename)
  SSRC_DECL_THROW(LuaCallError)
{
  int err = luaL_loadfile(state, filename.c_str());
  return load_properties(state, err);
}

properties_ptr load_string_properties(lua_State *state,
                                      const std::string & code_str)
  SSRC_DECL_THROW(LuaCallError)
{
  int err = luaL_loadstring(state, code_str.c_str());
  return load_properties(state, err);
}

__END_NS_SSRC_WSPR_LUA