LuaValue.hpp

Go to the documentation of this file.

/******************************************************************************\
* LuaValue.hpp                                                                 *
* A class that somewhat mimics a Lua value.                                    *
*                                                                              *
*                                                                              *
* Copyright (C) 2005-2007 by Leandro Motta Barros.                             *
*                                                                              *
* Permission is hereby granted, free of charge, to any person obtaining a copy *
* of this software and associated documentation files (the "Software"), to     *
* deal in the Software without restriction, including without limitation the   *
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  *
* sell copies of the Software, and to permit persons to whom the Software is   *
* furnished to do so, subject to the following conditions:                     *
*                                                                              *
* The above copyright notice and this permission notice shall be included in   *
* all copies or substantial portions of the Software.                          *
*                                                                              *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR   *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,     *
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE *
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      *
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS *
* IN THE SOFTWARE.                                                             *
\******************************************************************************/

#ifndef _DILUCULUM_LUA_VALUE_HPP_
#define _DILUCULUM_LUA_VALUE_HPP_

#include <lua.hpp>
#include <map>
#include <stdexcept>
#include <string>
#include <boost/variant.hpp>
#include <Diluculum/LuaUserData.hpp>
#include <Diluculum/Types.hpp>


namespace Diluculum
{
   // Some forward declarations.
   class LuaValue;


   class LuaValue
   {
      public:
         LuaValue() { };

         LuaValue (bool b)
            : value_(b)
         { }

         LuaValue (float n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (double n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (long double n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (short n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (unsigned short n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (int n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (unsigned n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (long n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (unsigned long n)
            : value_(static_cast<lua_Number>(n))
         { }

         LuaValue (const std::string& s)
            : value_(s)
         { }

         LuaValue (const char* s)
            : value_(std::string(s))
         { }

         LuaValue (const LuaValueMap& t)
            : value_(t)
         { }

         LuaValue (lua_CFunction f)
            : value_(f)
         { }

         LuaValue (const LuaUserData& ud)
            : value_(ud)
         { }

         LuaValue (const LuaValueList& v);

         const LuaValueList& operator= (const LuaValueList& rhs);

         int type() const;

         std::string typeName() const;

         lua_Number asNumber() const;

         const std::string& asString() const;

         bool asBoolean() const;

         LuaValueMap asTable() const;

         lua_CFunction asFunction() const;

         const LuaUserData& asUserData() const;

         LuaUserData& asUserData();

         bool operator< (const LuaValue& rhs) const;

         bool operator> (const LuaValue& rhs) const;

         bool operator== (const LuaValue& rhs) const;

         bool operator!= (const LuaValue& rhs) const
         { return !(*this == rhs); }

         LuaValue& operator[] (const LuaValue& key);

         const LuaValue& operator[] (const LuaValue& key) const;

      private:
         class NilType { };

         boost::variant <NilType, lua_Number, std::string, bool, LuaValueMap,
                         lua_CFunction, LuaUserData> value_;
   };



   const LuaValue Nil;

   const LuaValueMap EmptyLuaValueMap;

   const LuaValue EmptyTable (EmptyLuaValueMap);

} // namespace Diluculum


#endif // _DILUCULUM_LUA_VALUE_HPP_

---