+ return *Lua::checkUserData<SluiftComponent>(L, 1);

+ lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.moduleLibIndex);

+ lua_getfield(L, -1, "timeout");

+ int result = boost::numeric_cast<int>(lua_tointeger(L, -1));

+ lua_pop(L, 2);

+ return result;

+ if (!payloads.empty()) {

+ lua_createtable(L, boost::numeric_cast<int>(payloads.size()), 0);

+ for (size_t i = 0; i < payloads.size(); ++i) {

+ Sluift::globals.elementConvertor.convertToLua(L, payloads[i]);

+ lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

+ }

+ Lua::registerGetByTypeIndex(L, -1);

+ lua_setfield(L, -2, "payloads");

+ }

+ if (lua_type(L, index) == LUA_TTABLE) {

+ return boost::dynamic_pointer_cast<Payload>(Sluift::globals.elementConvertor.convertFromLua(L, index));

+ }

+ else if (lua_type(L, index) == LUA_TSTRING) {

+ return boost::make_shared<RawXMLPayload>(Lua::checkString(L, index));

+ }

+ else {

+ return boost::shared_ptr<Payload>();

+ }

+ index = Lua::absoluteOffset(L, index);

+ std::vector< boost::shared_ptr<Payload> > result;

+ lua_getfield(L, index, "payloads");

+ if (lua_istable(L, -1)) {

+ for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {

+ boost::shared_ptr<Payload> payload = getPayload(L, -1);

+ if (payload) {

+ result.push_back(payload);

+ }

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ SluiftComponent* component = getComponent(L);

+

+ std::string host;

+ int port = 0;

+ if (lua_istable(L, 2)) {

+ if (boost::optional<std::string> hostString = Lua::getStringField(L, 2, "host")) {

+ host = *hostString;

+ }

+ if (boost::optional<int> portInt = Lua::getIntField(L, 2, "port")) {

+ port = *portInt;

+ }

+ }

+ component->connect(host, port);

+ return 0;

+ Component, set_trace_enabled,

+ "Enable/disable tracing of the data sent/received.\n\n.",

+ "self\n"

+ "enable a boolean specifying whether to enable/disable tracing",

+ ""

+ getComponent(L)->setTraceEnabled(lua_toboolean(L, 1));

+ return 0;

+ Component, wait_connected,

+ "Block until the component is connected.\n\nThis is useful after an `async_connect`.",

+ "self",

+ ""

+ getComponent(L)->waitConnected(getGlobalTimeout(L));

+ return 0;

+ Component, is_connected,

+ "Checks whether this component is still connected.\n\nReturns a boolean.",

+ "self\n",

+ ""

+ lua_pushboolean(L, getComponent(L)->isConnected());

+ return 1;

+ Component, disconnect,

+ "Disconnect from the server",

+ "self\n",

+ ""

+ Sluift::globals.eventLoop.runOnce();

+ getComponent(L)->disconnect();

+ return 0;

+ Component, set_version,

+ "Sets the published version of this component.",

+ "self",

+ "name the name of the component software\n"

+ "version the version identifier of this component\n"

+ "os the OS this component is running on\n"

+ Sluift::globals.eventLoop.runOnce();

+ SluiftComponent* component = getComponent(L);

+ if (boost::shared_ptr<SoftwareVersion> version = boost::dynamic_pointer_cast<SoftwareVersion>(Sluift::globals.elementConvertor.convertFromLuaUntyped(L, 2, "software_version"))) {

+ component->setSoftwareVersion(version->getName(), version->getVersion(), version->getOS());

+ }

+ return 0;

+ Component, send_message,

+ "Send a message.",

+ "self\n"

+ "to the JID to send the message to\n"

+ "body the body of the message. Can alternatively be specified using the `body` option\n",

+

+ "to the JID to send the message to\n"

+ "body the body of the message\n"

+ "subject the subject of the MUC room to set\n"

+ "type the type of message to send (`normal`, `chat`, `error`, `groupchat`, `headline`)\n"

+ "payloads payloads to add to the message\n"

+ Sluift::globals.eventLoop.runOnce();

+ JID to;

+ boost::optional<std::string> from;

+ boost::optional<std::string> body;

+ boost::optional<std::string> subject;

+ std::vector<boost::shared_ptr<Payload> > payloads;

+ int index = 2;

+ Message::Type type = Message::Chat;

+ if (lua_isstring(L, index)) {

+ to = std::string(lua_tostring(L, index));

+ ++index;

+ if (lua_isstring(L, index)) {

+ body = lua_tostring(L, index);

+ ++index;

+ }

+ }

+ if (lua_istable(L, index)) {

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "to")) {

+ to = *value;

+ }

+

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "from")) {

+ from = value;

+ }

+

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "body")) {

+ body = value;

+ }

+

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "type")) {

+ type = MessageConvertor::convertMessageTypeFromString(*value);

+ }

+

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "subject")) {

+ subject = value;

+ }

+

+ payloads = getPayloadsFromTable(L, index);

+ }

+

+ if (!to.isValid()) {

+ throw Lua::Exception("Missing 'to'");

+ }

+ if ((!body || body->empty()) && !subject && payloads.empty()) {

+ throw Lua::Exception("Missing any of 'body', 'subject' or 'payloads'");

+ }

+ Message::ref message = boost::make_shared<Message>();

+ message->setTo(to);

+ if (from && !from->empty()) {

+ message->setFrom(*from);

+ }

+ if (body && !body->empty()) {

+ message->setBody(*body);

+ }

+ if (subject) {

+ message->setSubject(*subject);

+ }

+ message->addPayloads(payloads.begin(), payloads.end());

+ message->setType(type);

+ getComponent(L)->getComponent()->sendMessage(message);

+ return 0;

+ Component, send_presence,

+ "Send presence.",

+

+ "self\n"

+ "body the text of the presence. Can alternatively be specified using the `status` option\n",

+

+ "to the JID to send the message to\n"

+ "from the JID to send the message from\n"

+ "status the text of the presence\n"

+ "show the availability of the presence (`online`, `ffc`, `away`, `xa`, `dnd`)\n"

+ "priority the priority of the presence\n"

+ "type the type of message to send (`available`, `error`, `probe`, `subscribe`, `subscribed`, `unavailable`, `unsubscribe`, `unsubscribed`)\n"

+ "payloads payloads to add to the presence\n"

+ Sluift::globals.eventLoop.runOnce();

+ boost::shared_ptr<Presence> presence = boost::make_shared<Presence>();

+

+ int index = 2;

+ if (lua_isstring(L, index)) {

+ presence->setStatus(lua_tostring(L, index));

+ ++index;

+ }

+ if (lua_istable(L, index)) {

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "to")) {

+ presence->setTo(*value);

+ }

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "from")) {

+ presence->setFrom(*value);

+ }

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "status")) {

+ presence->setStatus(*value);

+ }

+ if (boost::optional<int> value = Lua::getIntField(L, index, "priority")) {

+ presence->setPriority(*value);

+ }

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "type")) {

+ presence->setType(PresenceConvertor::convertPresenceTypeFromString(*value));

+ }

+ if (boost::optional<std::string> value = Lua::getStringField(L, index, "show")) {

+ presence->setShow(StatusShowConvertor::convertStatusShowTypeFromString(*value));

+ }

+ std::vector< boost::shared_ptr<Payload> > payloads = getPayloadsFromTable(L, index);

+ presence->addPayloads(payloads.begin(), payloads.end());

+ }

+

+ getComponent(L)->getComponent()->sendPresence(presence);

+ lua_pushvalue(L, 1);

+ return 0;

+ SluiftComponent* component = getComponent(L);

+

+ JID to;

+ if (boost::optional<std::string> toString = Lua::getStringField(L, 2, "to")) {

+ to = JID(*toString);

+ }

+

+ JID from;

+ if (boost::optional<std::string> fromString = Lua::getStringField(L, 2, "from")) {

+ from = JID(*fromString);

+ }

+

+ int timeout = getGlobalTimeout(L);

+ if (boost::optional<int> timeoutInt = Lua::getIntField(L, 2, "timeout")) {

+ timeout = *timeoutInt;

+ }

+

+ boost::shared_ptr<Payload> payload;

+ lua_getfield(L, 2, "query");

+ payload = getPayload(L, -1);

+ lua_pop(L, 1);

+

+ return component->sendRequest(

+ boost::make_shared< GenericRequest<Payload> >(type, from, to, payload, component->getComponent()->getIQRouter()), timeout).convertToLuaResult(L);

+ return sendQuery(L, IQ::Get);

+ return sendQuery(L, IQ::Set);

+ Component, send,

+ "Sends a raw string",

+ "self\n"

+ "data the string to send\n",

+ ""

+ Sluift::globals.eventLoop.runOnce();

+ getComponent(L)->getComponent()->sendData(std::string(Lua::checkString(L, 2)));

+ lua_pushvalue(L, 1);

+ return 0;

+ switch (event.type) {

+ case SluiftComponent::Event::MessageType: {

+ Message::ref message = boost::dynamic_pointer_cast<Message>(event.stanza);

+ Lua::Table result = boost::assign::map_list_of

+ ("type", boost::make_shared<Lua::Value>(std::string("message")))

+ ("from", boost::make_shared<Lua::Value>(message->getFrom().toString()))

+ ("to", boost::make_shared<Lua::Value>(message->getTo().toString()))

+ ("body", boost::make_shared<Lua::Value>(message->getBody().get_value_or("")))

+ ("message_type", boost::make_shared<Lua::Value>(MessageConvertor::convertMessageTypeToString(message->getType())));

+ Lua::pushValue(L, result);

+ addPayloadsToTable(L, message->getPayloads());

+ Lua::registerTableToString(L, -1);

+ break;

+ }

+ case SluiftComponent::Event::PresenceType: {

+ Presence::ref presence = boost::dynamic_pointer_cast<Presence>(event.stanza);

+ Lua::Table result = boost::assign::map_list_of

+ ("type", boost::make_shared<Lua::Value>(std::string("presence")))

+ ("from", boost::make_shared<Lua::Value>(presence->getFrom().toString()))

+ ("to", boost::make_shared<Lua::Value>(presence->getTo().toString()))

+ ("status", boost::make_shared<Lua::Value>(presence->getStatus()))

+ ("presence_type", boost::make_shared<Lua::Value>(PresenceConvertor::convertPresenceTypeToString(presence->getType())));

+ Lua::pushValue(L, result);

+ addPayloadsToTable(L, presence->getPayloads());

+ Lua::registerTableToString(L, -1);

+ break;

+ }

+ }

+ CallUnaryLuaPredicateOnEvent(lua_State* L, int index) : L(L), index(index) {

+ }

+

+ bool operator()(const SluiftComponent::Event& event) {

+ lua_pushvalue(L, index);

+ pushEvent(L, event);

+ if (lua_pcall(L, 1, 1, 0) != 0) {

+ throw Lua::Exception(lua_tostring(L, -1));

+ }

+ bool result = lua_toboolean(L, -1);

+ lua_pop(L, 1);

+ return result;

+ }

+

+ lua_State* L;

+ int index;

+ Sluift::globals.eventLoop.runOnce();

+ SluiftComponent* component = getComponent(L);

+

+ int timeout = getGlobalTimeout(L);

+ boost::optional<SluiftComponent::Event::Type> type;

+ int condition = 0;

+ if (lua_istable(L, 2)) {

+ if (boost::optional<std::string> typeString = Lua::getStringField(L, 2, "type")) {

+ if (*typeString == "message") {

+ type = SluiftComponent::Event::MessageType;

+ }

+ else if (*typeString == "presence") {

+ type = SluiftComponent::Event::PresenceType;

+ }

+ }

+ if (boost::optional<int> timeoutInt = Lua::getIntField(L, 2, "timeout")) {

+ timeout = *timeoutInt;

+ }

+ lua_getfield(L, 2, "if");

+ if (lua_isfunction(L, -1)) {

+ condition = Lua::absoluteOffset(L, -1);

+ }

+ }

+

+ boost::optional<SluiftComponent::Event> event;

+ if (condition) {

+ event = component->getNextEvent(timeout, CallUnaryLuaPredicateOnEvent(L, condition));

+ }

+ else if (type) {

+ event = component->getNextEvent(

+ timeout, lambda::bind(&SluiftComponent::Event::type, lambda::_1) == *type);

+ }

+ else {

+ event = component->getNextEvent(timeout);

+ }

+

+ if (event) {

+ pushEvent(L, *event);

+ }

+ else {

+ lua_pushnil(L);

+ }

+ return 1;

+ Component, jid,

+ "Returns the JID of this component",

+ "self\n",

+ ""

+ SluiftComponent* component = getComponent(L);

+ lua_pushstring(L, component->getComponent()->getJID().toString().c_str());

+ return 1;

+ SluiftComponent* component = getComponent(L);

+ delete component;

+ return 0;