// This file was automatically generated on 26 May 2014 at 01:05:31 #include #include namespace Ndk { std::unique_ptr LuaBinding_Base::BindNetwork(LuaBinding& binding) { return std::make_unique(binding); } LuaBinding_Network::LuaBinding_Network(LuaBinding& binding) : LuaBinding_Base(binding) { /*********************************** Nz::AbstractSocket **********************************/ abstractSocket.Reset("AbstractSocket"); { abstractSocket.BindMethod("Close", &Nz::AbstractSocket::Close); abstractSocket.BindMethod("EnableBlocking", &Nz::AbstractSocket::EnableBlocking); abstractSocket.BindMethod("GetLastError", &Nz::AbstractSocket::GetLastError); abstractSocket.BindMethod("GetState", &Nz::AbstractSocket::GetState); abstractSocket.BindMethod("GetType", &Nz::AbstractSocket::GetType); abstractSocket.BindMethod("IsBlockingEnabled", &Nz::AbstractSocket::IsBlockingEnabled); abstractSocket.BindMethod("QueryAvailableBytes", &Nz::AbstractSocket::QueryAvailableBytes); } /*********************************** Nz::IpAddress **********************************/ ipAddress.Reset("IpAddress"); { ipAddress.SetConstructor([] (Nz::LuaState& lua, Nz::IpAddress* instance, std::size_t argumentCount) { std::size_t argCount = std::min(argumentCount, 9U); int argIndex = 1; switch (argCount) { case 0: Nz::PlacementNew(instance); return true; case 1: Nz::PlacementNew(instance, lua.CheckString(argIndex)); return true; case 4: case 5: { Nz::UInt8 a = lua.Check(&argIndex); Nz::UInt8 b = lua.Check(&argIndex); Nz::UInt8 c = lua.Check(&argIndex); Nz::UInt8 d = lua.Check(&argIndex); Nz::UInt16 port = lua.Check(&argIndex, 0); Nz::PlacementNew(instance, a, b, c, d, port); return true; } case 8: case 9: { Nz::UInt16 a = lua.Check(&argIndex); Nz::UInt16 b = lua.Check(&argIndex); Nz::UInt16 c = lua.Check(&argIndex); Nz::UInt16 d = lua.Check(&argIndex); Nz::UInt16 e = lua.Check(&argIndex); Nz::UInt16 f = lua.Check(&argIndex); Nz::UInt16 g = lua.Check(&argIndex); Nz::UInt16 h = lua.Check(&argIndex); Nz::UInt16 port = lua.Check(&argIndex, 0); Nz::PlacementNew(instance, a, b, c, d, e, f, g, h, port); return true; } } lua.Error("No matching overload for constructor"); return false; }); ipAddress.BindMethod("GetPort", &Nz::IpAddress::GetPort); ipAddress.BindMethod("GetProtocol", &Nz::IpAddress::GetProtocol); ipAddress.BindMethod("IsLoopback", &Nz::IpAddress::IsLoopback); ipAddress.BindMethod("IsValid", &Nz::IpAddress::IsValid); ipAddress.BindMethod("ToUInt32", &Nz::IpAddress::ToUInt32); ipAddress.BindMethod("__tostring", &Nz::IpAddress::ToString); ipAddress.BindStaticMethod("ResolveAddress", [] (Nz::LuaState& state) -> int { Nz::String service; Nz::ResolveError error = Nz::ResolveError_Unknown; int argIndex = 2; Nz::String hostName = Nz::IpAddress::ResolveAddress(state.Check(&argIndex), &service, &error); if (error == Nz::ResolveError_NoError) { state.Push(hostName); state.Push(service); return 2; } else { state.PushBoolean(false); state.Push(error); return 2; } }); ipAddress.BindStaticMethod("ResolveHostname", [] (Nz::LuaState& state) -> int { Nz::ResolveError error = Nz::ResolveError_Unknown; int argIndex = 2; Nz::NetProtocol protocol = state.Check(&argIndex); Nz::String hostname = state.Check(&argIndex); Nz::String service = state.Check(&argIndex, "http"); std::vector addresses = Nz::IpAddress::ResolveHostname(protocol, hostname, service, &error); if (error == Nz::ResolveError_NoError) { int index = 1; state.PushTable(addresses.size()); for (Nz::HostnameInfo& info : addresses) { state.PushInteger(index++); state.PushTable(0, 4); state.PushField("Address", std::move(info.address)); state.PushField("CanonicalName", std::move(info.canonicalName)); state.PushField("Protocol", std::move(info.protocol)); state.PushField("SocketType", std::move(info.socketType)); state.SetTable(); } return 1; } else { state.PushBoolean(false); state.Push(error); return 2; } }); } udpSocket.Reset("UdpSocket"); { udpSocket.Inherit(abstractSocket); udpSocket.BindDefaultConstructor(); udpSocket.BindMethod("Create", &Nz::UdpSocket::Create); udpSocket.BindMethod("EnableBroadcasting", &Nz::UdpSocket::EnableBroadcasting); udpSocket.BindMethod("GetBoundAddress", &Nz::UdpSocket::GetBoundAddress); udpSocket.BindMethod("GetBoundPort", &Nz::UdpSocket::GetBoundPort); udpSocket.BindMethod("IsBroadcastingEnabled", &Nz::UdpSocket::IsBroadcastingEnabled); udpSocket.BindMethod("QueryMaxDatagramSize", &Nz::UdpSocket::QueryMaxDatagramSize); udpSocket.BindMethod("Bind", [](Nz::LuaState& lua, Nz::UdpSocket& socket, std::size_t /*argumentCount*/) -> int { int argIndex = 2; if (lua.IsOfType(argIndex, "IpAddress")) return lua.Push(socket.Bind(*static_cast(lua.ToUserdata(argIndex)))); else return lua.Push(socket.Bind(lua.Check(&argIndex))); }); udpSocket.BindMethod("Receive", [](Nz::LuaState& lua, Nz::UdpSocket& socket, std::size_t /*argumentCount*/) -> int { Nz::IpAddress from; std::array buffer; std::size_t received; if (socket.Receive(buffer.data(), buffer.size(), &from, &received)) { lua.PushBoolean(true); lua.PushString(from.ToString()); lua.PushString(buffer.data(), received); return 3; } lua.PushBoolean(false); return 1; }); udpSocket.BindMethod("Send", [](Nz::LuaState& lua, Nz::UdpSocket& socket, std::size_t /*argumentCount*/) -> int { int argIndex = 2; Nz::String to = lua.Check(&argIndex); std::size_t bufferLength; const char* buffer = lua.CheckString(argIndex, &bufferLength); std::size_t sent; bool ret; if ((ret = socket.Send(Nz::IpAddress(to), buffer, bufferLength, &sent)) != true) sent = 0; return lua.Push(std::make_pair(ret, sent)); }); } } /*! * \brief Registers the classes that will be used by the Lua instance * * \param instance Lua instance that will interact with the Network classes */ void LuaBinding_Network::Register(Nz::LuaState& state) { // Classes abstractSocket.Register(state); ipAddress.Register(state); udpSocket.Register(state); // Enums // Nz::NetProtocol static_assert(Nz::NetProtocol_Max + 1 == 4, "Nz::NetProtocol has been updated but change was not reflected to Lua binding"); state.PushTable(0, 4); { state.PushField("Any", Nz::NetProtocol_Any); state.PushField("IPv4", Nz::NetProtocol_IPv4); state.PushField("IPv6", Nz::NetProtocol_IPv6); state.PushField("Unknown", Nz::NetProtocol_Unknown); } state.SetGlobal("NetProtocol"); // Nz::PacketPriority static_assert(Nz::PacketPriority_Max + 1 == 4, "Nz::PacketPriority has been updated but change was not reflected to Lua binding"); state.PushTable(0, 6); { state.PushField("High", Nz::PacketPriority_High); state.PushField("Highest", Nz::PacketPriority_Highest); state.PushField("Immediate", Nz::PacketPriority_Immediate); state.PushField("Medium", Nz::PacketPriority_Medium); state.PushField("Low", Nz::PacketPriority_Low); state.PushField("Lowest", Nz::PacketPriority_Lowest); } state.SetGlobal("PacketPriority"); // Nz::PacketReliability static_assert(Nz::PacketReliability_Max + 1 == 3, "Nz::PacketReliability has been updated but change was not reflected to Lua binding"); state.PushTable(0, 3); { state.PushField("Reliable", Nz::PacketReliability_Reliable); state.PushField("ReliableOrdered", Nz::PacketReliability_ReliableOrdered); state.PushField("Unreliable", Nz::PacketReliability_Unreliable); } state.SetGlobal("PacketReliability"); // Nz::ResolveError static_assert(Nz::ResolveError_Max + 1 == 9, "Nz::ResolveError has been updated but change was not reflected to Lua binding"); state.PushTable(0, 9); { state.PushField("Internal", Nz::ResolveError_Internal); state.PushField("ResourceError", Nz::ResolveError_ResourceError); state.PushField("NoError", Nz::ResolveError_NoError); state.PushField("NonRecoverable", Nz::ResolveError_NonRecoverable); state.PushField("NotFound", Nz::ResolveError_NotFound); state.PushField("NotInitialized", Nz::ResolveError_NotInitialized); state.PushField("ProtocolNotSupported", Nz::ResolveError_ProtocolNotSupported); state.PushField("TemporaryFailure", Nz::ResolveError_TemporaryFailure); state.PushField("Unknown", Nz::ResolveError_Unknown); } state.SetGlobal("ResolveError"); // Nz::SocketError static_assert(Nz::SocketError_Max + 1 == 15, "Nz::ResolveError has been updated but change was not reflected to Lua binding"); state.PushTable(0, 15); { state.PushField("AddressNotAvailable", Nz::SocketError_AddressNotAvailable); state.PushField("ConnectionClosed", Nz::SocketError_ConnectionClosed); state.PushField("ConnectionRefused", Nz::SocketError_ConnectionRefused); state.PushField("DatagramSize", Nz::SocketError_DatagramSize); state.PushField("Internal", Nz::SocketError_Internal); state.PushField("Packet", Nz::SocketError_Packet); state.PushField("NetworkError", Nz::SocketError_NetworkError); state.PushField("NoError", Nz::SocketError_NoError); state.PushField("NotInitialized", Nz::SocketError_NotInitialized); state.PushField("NotSupported", Nz::SocketError_NotSupported); state.PushField("ResolveError", Nz::SocketError_ResolveError); state.PushField("ResourceError", Nz::SocketError_ResourceError); state.PushField("TimedOut", Nz::SocketError_TimedOut); state.PushField("Unknown", Nz::SocketError_Unknown); state.PushField("UnreachableHost", Nz::SocketError_UnreachableHost); } state.SetGlobal("SocketError"); // Nz::SocketState static_assert(Nz::SocketState_Max + 1 == 5, "Nz::SocketState has been updated but change was not reflected to Lua binding"); state.PushTable(0, 5); { state.PushField("Bound", Nz::SocketState_Bound); state.PushField("Connecting", Nz::SocketState_Connecting); state.PushField("Connected", Nz::SocketState_Connected); state.PushField("NotConnected", Nz::SocketState_NotConnected); state.PushField("Resolving", Nz::SocketState_Resolving); } state.SetGlobal("SocketState"); // Nz::SocketType static_assert(Nz::SocketType_Max + 1 == 4, "Nz::SocketState has been updated but change was not reflected to Lua binding"); state.PushTable(0, 4); { state.PushField("Raw", Nz::SocketType_Raw); state.PushField("TCP", Nz::SocketType_TCP); state.PushField("UDP", Nz::SocketType_UDP); state.PushField("Unknown", Nz::SocketType_Unknown); } state.SetGlobal("SocketType"); } }