/*
** Lua binding: Varconf
** Generated automatically by tolua++-1.0.92 on Fri Feb 21 16:23:06 2014.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "components/lua/tolua++.h"

/* Exported function */
TOLUA_API int  tolua_Varconf_open (lua_State* tolua_S);

#include <varconf/variable.h>

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_varconf__Variable (lua_State* tolua_S)
{
 varconf::Variable* self = (varconf::Variable*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"varconf::Variable");
 tolua_usertype(tolua_S,"varconf::VarBase");
}

/* method: scope of class  varconf::VarBase */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_VarBase_scope00
static int tolua_Varconf_varconf_VarBase_scope00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::VarBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::VarBase* self = (const varconf::VarBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'scope'", NULL);
#endif
  {
   const varconf::Scope tolua_ret = (const varconf::Scope)  self->scope();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'scope'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setScope of class  varconf::VarBase */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_VarBase_setScope00
static int tolua_Varconf_varconf_VarBase_setScope00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"varconf::VarBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  varconf::VarBase* self = (varconf::VarBase*)  tolua_tousertype(tolua_S,1,0);
  varconf::Scope s = ((varconf::Scope) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScope'", NULL);
#endif
  {
   self->setScope(s);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setScope'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new00
static int tolua_Varconf_varconf_Variable_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const bool b = ((const bool)  tolua_toboolean(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(b));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new00_local
static int tolua_Varconf_varconf_Variable_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const bool b = ((const bool)  tolua_toboolean(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(b));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new01
static int tolua_Varconf_varconf_Variable_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const int i = ((const int)  tolua_tonumber(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(i));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
  }
 }
 return 1;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new01_local
static int tolua_Varconf_varconf_Variable_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const int i = ((const int)  tolua_tonumber(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(i));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new02
static int tolua_Varconf_varconf_Variable_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const double d = ((const double)  tolua_tonumber(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(d));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
  }
 }
 return 1;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new02_local
static int tolua_Varconf_varconf_Variable_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const double d = ((const double)  tolua_tonumber(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(d));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new03
static int tolua_Varconf_varconf_Variable_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string s = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
   tolua_pushcppstring(tolua_S,(const char*)s);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_new03_local
static int tolua_Varconf_varconf_Variable_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string s = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   varconf::Variable* tolua_ret = (varconf::Variable*)  Mtolua_new((varconf::Variable)(s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)s);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Varconf_varconf_Variable_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_delete00
static int tolua_Varconf_varconf_Variable_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  varconf::Variable* self = (varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operatorbool of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable__bool00
static int tolua_Varconf_varconf_Variable__bool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  varconf::Variable* self = (varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operatorbool'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator  bool();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.bool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operatorint of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable__int00
static int tolua_Varconf_varconf_Variable__int00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  varconf::Variable* self = (varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operatorint'", NULL);
#endif
  {
   int tolua_ret = (int)  self->operator  int();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.int'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operatordouble of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable__double00
static int tolua_Varconf_varconf_Variable__double00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  varconf::Variable* self = (varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operatordouble'", NULL);
#endif
  {
   double tolua_ret = (double)  self->operator  double();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.double'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: as_string of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_as_string00
static int tolua_Varconf_varconf_Variable_as_string00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'as_string'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->as_string();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'as_string'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: is_bool of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_is_bool00
static int tolua_Varconf_varconf_Variable_is_bool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->is_bool();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: is_int of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_is_int00
static int tolua_Varconf_varconf_Variable_is_int00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->is_int();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: is_double of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_is_double00
static int tolua_Varconf_varconf_Variable_is_double00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_double'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->is_double();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_double'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: is_string of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_is_string00
static int tolua_Varconf_varconf_Variable_is_string00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->is_string();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: is_array of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_is_array00
static int tolua_Varconf_varconf_Variable_is_array00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_array'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->is_array();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_array'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: elem of class  varconf::Variable */
#ifndef TOLUA_DISABLE_tolua_Varconf_varconf_Variable_elem00
static int tolua_Varconf_varconf_Variable_elem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const varconf::Variable",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const varconf::Variable* self = (const varconf::Variable*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elem'", NULL);
#endif
  {
   varconf::VarBase& tolua_ret = (varconf::VarBase&)  self->elem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"varconf::VarBase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'elem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_Varconf_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"varconf",0);
  tolua_beginmodule(tolua_S,"varconf");
   tolua_constant(tolua_S,"GLOBAL",varconf::GLOBAL);
   tolua_constant(tolua_S,"USER",varconf::USER);
   tolua_constant(tolua_S,"INSTANCE",varconf::INSTANCE);
   tolua_cclass(tolua_S,"VarBase","varconf::VarBase","",NULL);
   tolua_beginmodule(tolua_S,"VarBase");
    tolua_function(tolua_S,"scope",tolua_Varconf_varconf_VarBase_scope00);
    tolua_function(tolua_S,"setScope",tolua_Varconf_varconf_VarBase_setScope00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"Variable","varconf::Variable","",tolua_collect_varconf__Variable);
   #else
   tolua_cclass(tolua_S,"Variable","varconf::Variable","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"Variable");
    tolua_function(tolua_S,"new",tolua_Varconf_varconf_Variable_new00);
    tolua_function(tolua_S,"new_local",tolua_Varconf_varconf_Variable_new00_local);
    tolua_function(tolua_S,".call",tolua_Varconf_varconf_Variable_new00_local);
    tolua_function(tolua_S,"new",tolua_Varconf_varconf_Variable_new01);
    tolua_function(tolua_S,"new_local",tolua_Varconf_varconf_Variable_new01_local);
    tolua_function(tolua_S,".call",tolua_Varconf_varconf_Variable_new01_local);
    tolua_function(tolua_S,"new",tolua_Varconf_varconf_Variable_new02);
    tolua_function(tolua_S,"new_local",tolua_Varconf_varconf_Variable_new02_local);
    tolua_function(tolua_S,".call",tolua_Varconf_varconf_Variable_new02_local);
    tolua_function(tolua_S,"new",tolua_Varconf_varconf_Variable_new03);
    tolua_function(tolua_S,"new_local",tolua_Varconf_varconf_Variable_new03_local);
    tolua_function(tolua_S,".call",tolua_Varconf_varconf_Variable_new03_local);
    tolua_function(tolua_S,"delete",tolua_Varconf_varconf_Variable_delete00);
    tolua_function(tolua_S,".bool",tolua_Varconf_varconf_Variable__bool00);
    tolua_function(tolua_S,".int",tolua_Varconf_varconf_Variable__int00);
    tolua_function(tolua_S,".double",tolua_Varconf_varconf_Variable__double00);
    tolua_function(tolua_S,"as_string",tolua_Varconf_varconf_Variable_as_string00);
    tolua_function(tolua_S,"is_bool",tolua_Varconf_varconf_Variable_is_bool00);
    tolua_function(tolua_S,"is_int",tolua_Varconf_varconf_Variable_is_int00);
    tolua_function(tolua_S,"is_double",tolua_Varconf_varconf_Variable_is_double00);
    tolua_function(tolua_S,"is_string",tolua_Varconf_varconf_Variable_is_string00);
    tolua_function(tolua_S,"is_array",tolua_Varconf_varconf_Variable_is_array00);
    tolua_function(tolua_S,"elem",tolua_Varconf_varconf_Variable_elem00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_Varconf (lua_State* tolua_S) {
 return tolua_Varconf_open(tolua_S);
};
#endif

