lua/Properties.h

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.
 */

#ifndef __SSRC_WSPR_LUA_PROPERTIES_H
#define __SSRC_WSPR_LUA_PROPERTIES_H

#include <ssrc/wispers/utility/Properties.h>
#include <ssrc/wispers/utility/ToString.h>

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

__BEGIN_NS_SSRC_WSPR_LUA

using NS_SSRC_WSPR_UTILITY::Properties;
using NS_SSRC_WSPR_UTILITY::properties_ptr;
using NS_SSRC_WSPR_UTILITY::primitive_property_vector;
using NS_SSRC_WSPR_UTILITY::property_vector;
using NS_SSRC_WSPR_UTILITY::ToString;

class PropertiesToTable {

  struct PushValue : public boost::static_visitor<void> {
    lua_State *state;
    mutable ToString string_cast;
    const PropertiesToTable & to_table;

    PushValue(lua_State *state, const PropertiesToTable & to_table) :
      state(state), to_table(to_table)
    { }

    void operator()(const bool v) const {
      lua_pushboolean(state, v);
    }

    void operator()(const std::int32_t v) const {
      lua_pushinteger(state, v);
    }

    void operator()(const std::uint32_t v) const {
      lua_pushinteger(state, v);
    }

    void operator()(const std::int64_t v) const {
      // TODO: Decide whether to use lightuserdata instead.
      const string & s = string_cast(v);
      lua_pushlstring(state, s.c_str(), s.size());
    }

    void operator()(const std::uint64_t v) const {
      // TODO: Decide whether to use lightuserdata instead.
      const string & s = string_cast(v);
      lua_pushlstring(state, s.c_str(), s.size());
    }

    void operator()(const double v) const {
      lua_pushnumber(state, v);
    }

    void operator()(const std::string & v) const {
      lua_pushlstring(state, v.c_str(), v.size());
    }

    void operator()(const primitive_property_vector & v) const;

    void operator()(const property_vector & v) const;

    void operator()(const Properties & properties) const;
  };


public:

  PushValue push;

  PropertiesToTable(lua_State *state) : push(state, *this) { }

  lua_State * state() const { return push.state; }

  void reset(lua_State *state) { push.state = state; }

  void enter(const std::string key, const Properties *properties,
             const bool) const;
  void leave(const std::string key, const Properties *properties,
             const bool) const;
};

inline void properties_to_table(const PropertiesToTable & to_table,
                                const Properties & properties)
{
  lua_newtable(to_table.state());
  if(!properties.is_leaf()) {
    properties.visit(to_table);
  }
}

inline void properties_to_table(lua_State *state,
                                const Properties & properties)
{
  properties_to_table(PropertiesToTable(state), properties);
}

void table_to_properties(lua_State *state, Properties & properties);

void swig_table_to_properties(void *state, Properties & properties);

properties_ptr load_properties(lua_State *state, const std::string & filename)
  SSRC_DECL_THROW(LuaCallError);

properties_ptr load_string_properties(lua_State *state,
                                      const std::string & code_str)
  SSRC_DECL_THROW(LuaCallError);

inline properties_ptr load_properties(const std::string & filename) {
  lua_State *state = luaL_newstate();
  luaL_openlibs(state);
  properties_ptr && properties = load_properties(state, filename);
  lua_close(state);
  return properties;
}

inline properties_ptr load_string_properties(const std::string & code_str) {
  lua_State *state = luaL_newstate();
  luaL_openlibs(state);
  properties_ptr && properties = load_string_properties(state, code_str);
  lua_close(state);
  return properties;
}

__END_NS_SSRC_WSPR_LUA

#endif