+ class Completer {

+ public:

+ virtual ~Completer();

+ virtual std::vector<std::string> getCompletions(const std::string& buffer, int start, int end) = 0;

+ };

+ if (!lua_isstring(L, 1)) {

+ return 1;

+ }

+ lua_getglobal(L, "debug");

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

+ lua_pop(L, 1);

+ return 1;

+ }

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

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

+ lua_pop(L, 2);

+ return 1;

+ }

+ lua_pushvalue(L, 1);

+ lua_pushinteger(L, 2);

+ lua_call(L, 2, 1);

+ return 1;

+ terminal->setCompleter(this);

+ while (true) {

+ lua_settop(L, 0);

+ try {

+ if (!readCommand()) {

+ return;

+ }

+ int result = call(L, 0, true);

+ if (result != 0) {

+ throw std::runtime_error(getErrorMessage());

+ }

+

+ // Clear the previous results

+ for (int i = 0; i < previousNumberOfReturnArguments; ++i) {

+ lua_pushnil(L);

+ lua_setglobal(L, ("_" + boost::lexical_cast<std::string>(i+1)).c_str());

+ }

+

+ // Store the results

+ for (int i = 0; i < lua_gettop(L); ++i) {

+ lua_pushvalue(L, i+1);

+ lua_setglobal(L, ("_" + boost::lexical_cast<std::string>(i+1)).c_str());

+ }

+ previousNumberOfReturnArguments = lua_gettop(L);

+

+ // Print results

+ if (lua_gettop(L) > 0) {

+ lua_getglobal(L, "print");

+ lua_insert(L, 1);

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

+ throw std::runtime_error("Error calling 'print': " + getErrorMessage());

+ }

+ }

+ }

+ catch (const std::exception& e) {

+ terminal->printError(e.what());

+ }

+ }

+ std::string command = originalCommand;

+ // Replace '=' by 'return' (for compatibility with Lua console)

+ if (boost::algorithm::starts_with(command, "=")) {

+ command = "return " + command.substr(1);

+ }

+ std::string commandAsExpression = "return " + command;

+ // Try to load the command as an expression

+ if (luaL_loadbuffer(L, commandAsExpression.c_str(), commandAsExpression.size(), "=stdin") == 0) {

+ return 0;

+ }

+ lua_pop(L, 1);

+ // Try to load the command as a regular command

+ return luaL_loadbuffer(L, command.c_str(), command.size(), "=stdin");

+ boost::optional<std::string> line = terminal->readLine(getPrompt(true));

+ if (!line) {

+ return false;

+ }

+ std::string command = *line;

+ while (true) {

+ int result = tryLoadCommand(command);

+

+ // Check if we need to read more

+ if (result == LUA_ERRSYNTAX) {

+ std::string errorMessage(lua_tostring(L, -1));

+ if (boost::algorithm::ends_with(errorMessage, "'<eof>'")) {

+ lua_pop(L, 1);

+

+ // Read another line

+ boost::optional<std::string> line = terminal->readLine(getPrompt(false));

+ if (!line) {

+ return false;

+ }

+ command = command + "\n" + *line;

+ continue;

+ }

+ }

+ if (!command.empty()) {

+ terminal->addToHistory(command);

+ }

+ if (result != 0) {

+ throw std::runtime_error(getErrorMessage());

+ }

+ return true;

+ }

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

+ return "<null error>";

+ }

+ const char* errorMessage = lua_tostring(L, -1);

+ return errorMessage ? errorMessage : "<error is not a string>";

+ // Put traceback function on stack below call

+ int tracebackIndex = lua_gettop(L) - numberOfArguments;

+ lua_pushcfunction(L, traceback);

+ lua_insert(L, tracebackIndex);

+ int result = lua_pcall(L, numberOfArguments, keepResult ? LUA_MULTRET : 0, tracebackIndex);

+ // Remove traceback

+ lua_remove(L, tracebackIndex);

+ return result;

+ lua_getglobal(L,firstLine ? "_PROMPT" : "_PROMPT2");

+ const char* rawPrompt = lua_tostring(L, -1);

+ std::string prompt;

+ if (rawPrompt) {

+ prompt = std::string(rawPrompt);

+ }

+ else {

+ prompt = firstLine ? "> " : ">> ";

+ }

+ lua_pop(L, 1);

+ return prompt;

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

+ const char* rawKey = lua_tostring(L, -2);

+ if (rawKey) {

+ std::string key(rawKey);

+ if (boost::starts_with(key, match) && !(match == "" && boost::starts_with(key, "_"))) {

+ result.push_back(key);

+ }

+ }

+ }

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

+ const char* rawValue = lua_tostring(L, -1);

+ if (rawValue) {

+ std::string key(rawValue);

+ if (boost::starts_with(key, match) && !(match == "" && boost::starts_with(key, "_"))) {

+ result.push_back(key);

+ }

+ }

+ }

+ std::string prefix = input.substr(boost::numeric_cast<size_t>(start), boost::numeric_cast<size_t>(end - start));

+

+ std::vector<std::string> tokens;

+ if (end) {

+ tokens = Lua::tokenize(input.substr(0, boost::numeric_cast<size_t>(end)));

+ }

+

+ // Don't autocomplete strings

+ if (!tokens.empty() && ((*tokens.rbegin())[0] == '\'' || (*tokens.rbegin())[0] == '"')) {

+ return std::vector<std::string>();

+ }

+

+ std::vector<std::string> context;

+ for (std::vector<std::string>::reverse_iterator i = tokens.rbegin(); i != tokens.rend(); ++i) {

+ if (std::isalpha((*i)[0]) || (*i)[0] == '_') {

+ if (i != tokens.rbegin()) {

+ context.push_back(*i);

+ }

+ }

+ else if (*i != "." && *i != ":") {

+ break;

+ }

+ }

+

+ // Drill into context

+ int top = lua_gettop(L);

+ lua_pushglobaltable(L);

+ for (std::vector<std::string>::reverse_iterator i = context.rbegin(); i != context.rend(); ++i) {

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

+ lua_getfield(L, -1, i->c_str());

+ if (!lua_isnil(L, 1)) {

+ continue;

+ }

+ }

+ lua_settop(L, top);

+ return std::vector<std::string>();

+ }

+

+ // Collect all keys from the table

+ std::vector<std::string> result;

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

+ addMatchingTableKeys(L, prefix, result);

+ }

+

+ // Collect all keys from the metatable

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

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

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

+ addMatchingTableKeys(L, prefix, result);

+ }

+ lua_pop(L, 1);

+

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

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

+ lua_pushvalue(L, -3);

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

+ throw std::runtime_error("Error calling '_completions': " + getErrorMessage());

+ }

+ }

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

+ addMatchingTableValues(L, prefix, result);

+ }

+ lua_pop(L, 2);

+ }

+

+ lua_settop(L, top);

+

+ return result;

+ class Terminal;

+ class Console : public Completer {

+ public:

+ Console(lua_State* L, Terminal* terminal);

+ virtual ~Console();

+ void run();

+ static int call(lua_State* L, int numberOfArguments, bool keepResult);

+ private:

+ std::string getPrompt(bool firstLine) const;

+ std::string getErrorMessage() const;

+ bool readCommand();

+ int tryLoadCommand(const std::string& command);

+ virtual std::vector<std::string> getCompletions(const std::string&, int start, int end) SWIFTEN_OVERRIDE;

+ private:

+ lua_State* L;

+ Terminal* terminal;

+ int previousNumberOfReturnArguments;

+ };

+#if defined(SWIFTEN_PLATFORM_WINDOWS)

+ return 0;

+ rl_completion_append_character = 0;

+ rl_completion_suppress_append = 1;

+ static std::vector<std::string> completions;

+ if (state == 0) {

+ assert(globalInstance);

+ completions.clear();

+ if (globalInstance->getCompleter()) {

+ completions = globalInstance->getCompleter()->getCompletions(rl_line_buffer, completionStart, completionEnd);

+ }

+ }

+ if (boost::numeric_cast<size_t>(state) >= completions.size()) {

+ return 0;

+ }

+ return strdup(completions[boost::numeric_cast<size_t>(state)].c_str());

+ completionStart = start;

+ completionEnd = end;

+ return rl_completion_matches(text, getCompletions);

+ static EditlineTerminal instance;

+ globalInstance = &instance;

+ return instance;

+ rl_attempted_completion_function = getAttemptedCompletions;

+ rl_completion_entry_function = getEmptyCompletions; // Fallback. Do nothing.

+ // rl_basic_word_break is a cons char[] in MinGWEditLine.

+ // This one seems to work, although it doesn't on OS X for some reason.

+ rl_completer_word_break_characters = strdup(" \t\n.:+-*/><=;|&()[]{}");

+ rl_basic_word_break_characters = strdup(" \t\n.:+-*/><=;|&()[]{}");

+ std::cout << message << std::endl;

+ const char* line = readline(prompt.c_str());

+ return line ? std::string(line) : boost::optional<std::string>();

+ // MinGWEditLine copies the string, so this is safe

+ add_history(const_cast<char*>(line.c_str()));

+ add_history(line.c_str());

+ class EditlineTerminal : public Terminal {

+ public:

+ static EditlineTerminal& getInstance();

+ private:

+ EditlineTerminal();

+ virtual ~EditlineTerminal();

+ virtual boost::optional<std::string> readLine(const std::string& prompt) SWIFTEN_OVERRIDE;

+ virtual void printError(const std::string& message) SWIFTEN_OVERRIDE;

+ virtual void addToHistory(const std::string& command) SWIFTEN_OVERRIDE;

+ };

+ boost::shared_ptr<Body> result = boost::make_shared<Body>();

+ if (boost::optional<std::string> value = Lua::getStringField(L, -1, "text")) {

+ result->setText(*value);

+ }

+ return result;

+ lua_createtable(L, 0, 0);

+ if (!payload->getText().empty()) {

+ lua_pushstring(L, payload->getText().c_str());

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

+ }

+ class LuaElementConvertors;

+ class BodyConvertor : public GenericLuaElementConvertor<Body> {

+ public:

+ BodyConvertor();

+ virtual ~BodyConvertor();

+ virtual boost::shared_ptr<Body> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Body>) SWIFTEN_OVERRIDE;

+ };

+ if (action == "cancel") { return Command::Cancel; }

+ else if (action == "execute") { return Command::Execute; }

+ else if (action == "complete") { return Command::Complete; }

+ else if (action == "prev") { return Command::Prev; }

+ else if (action == "next") { return Command::Next; }

+ return Command::NoAction;

+ switch (action) {

+ case Command::Cancel: return "cancel";

+ case Command::Execute: return "execute";

+ case Command::Complete: return "complete";

+ case Command::Prev: return "prev";

+ case Command::Next: return "next";

+ case Command::NoAction: assert(false); return "";

+ }

+ assert(false);

+ return "";

+CommandConvertor::CommandConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<Command>("command"),

+ convertors(convertors) {

+ boost::shared_ptr<Command> result = boost::make_shared<Command>();

+

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

+ if (!lua_isnil(L, -1)) {

+ result->setNode(std::string(Lua::checkString(L, -1)));

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ result->setSessionID(std::string(Lua::checkString(L, -1)));

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ std::string statusText = Lua::checkString(L, -1);

+ Command::Status status = Command::NoStatus;

+ if (statusText == "executing") { status = Command::Executing; }

+ else if (statusText == "completed") { status = Command::Completed; }

+ else if (statusText == "canceled") { status = Command::Canceled; }

+ result->setStatus(status);

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ result->setAction(convertActionFromString(Lua::checkString(L, -1)));

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ result->setExecuteAction(convertActionFromString(Lua::checkString(L, -1)));

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ Lua::checkType(L, -1, LUA_TTABLE);

+ lua_pushnil(L);

+ for (lua_pushnil(L); lua_next(L, -2) != 0; ) {

+ result->addAvailableAction(convertActionFromString(Lua::checkString(L, -1)));

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ Lua::checkType(L, -1, LUA_TTABLE);

+ lua_pushnil(L);

+ for (lua_pushnil(L); lua_next(L, -2) != 0; ) {

+ Lua::checkType(L, -1, LUA_TTABLE);

+ std::string note;

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

+ if (!lua_isnil(L, -1)) {

+ note = Lua::checkString(L, -1);

+ }

+ lua_pop(L, 1);

+

+ Command::Note::Type noteType = Command::Note::Info;

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

+ if (!lua_isnil(L, -1)) {

+ std::string type = Lua::checkString(L, -1);

+ if (type == "info") { noteType = Command::Note::Info; }

+ else if (type == "warn") { noteType = Command::Note::Warn; }

+ else if (type == "error") { noteType = Command::Note::Error; }

+ }

+ lua_pop(L, 1);

+

+ result->addNote(Command::Note(note, noteType));

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<Form> form = boost::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"))) {

+ result->setForm(form);

+ }

+ }

+ lua_pop(L, 1);

+

+ return result;

+ Lua::Table result;

+ if (!payload->getNode().empty()) {

+ result["node"] = Lua::valueRef(payload->getNode());

+ }

+ if (!payload->getSessionID().empty()) {

+ result["session_id"] = Lua::valueRef(payload->getSessionID());

+ }

+ switch (payload->getStatus()) {

+ case Command::Executing: result["status"] = Lua::valueRef("executing"); break;

+ case Command::Completed: result["status"] = Lua::valueRef("completed"); break;

+ case Command::Canceled: result["status"] = Lua::valueRef("canceled"); break;

+ case Command::NoStatus: break;

+ }

+

+ if (!payload->getNotes().empty()) {

+ std::vector<Lua::Value> notes;

+ foreach (const Command::Note& note, payload->getNotes()) {

+ Lua::Table noteTable;

+ if (!note.note.empty()) {

+ noteTable["note"] = Lua::valueRef(note.note);

+ }

+ switch (note.type) {

+ case Command::Note::Info: noteTable["type"] = Lua::valueRef("info"); break;

+ case Command::Note::Warn: noteTable["type"] = Lua::valueRef("warn"); break;

+ case Command::Note::Error: noteTable["type"] = Lua::valueRef("error"); break;

+ }

+ notes.push_back(noteTable);

+ }

+ result["notes"] = Lua::valueRef(notes);

+ }

+

+ if (payload->getAction() != Command::NoAction) {

+ result["action"] = Lua::valueRef(convertActionToString(payload->getAction()));

+ }

+

+ if (payload->getExecuteAction() != Command::NoAction) {

+ result["execute_action"] = Lua::valueRef(convertActionToString(payload->getAction()));

+ }

+

+ if (!payload->getAvailableActions().empty()) {

+ std::vector<Lua::Value> availableActions;

+ foreach (const Command::Action& action, payload->getAvailableActions()) {

+ if (action != Command::NoAction) {

+ availableActions.push_back(convertActionToString(action));

+ }

+ }

+ result["available_actions"] = Lua::valueRef(availableActions);

+ }

+

+ Lua::pushValue(L, result);

+

+ if (payload->getForm()) {

+ bool result = convertors->convertToLuaUntyped(L, payload->getForm());

+ assert(result);

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

+ }

+ class LuaElementConvertors;

+ class CommandConvertor : public GenericLuaElementConvertor<Command> {

+ public:

+ CommandConvertor(LuaElementConvertors* convertors);

+ virtual ~CommandConvertor();

+ virtual boost::shared_ptr<Command> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Command>) SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+ class ParserClient : public XMLParserClient {

+ public:

+ ParserClient(lua_State* L) : L(L), currentIndex(1) {

+ }

+

+ virtual void handleStartElement(

+ const std::string& element, const std::string& ns,

+ const AttributeMap& attributes) SWIFTEN_OVERRIDE {

+ lua_checkstack(L, 6);

+ lua_pushnumber(L, currentIndex);

+ lua_newtable(L);

+ lua_pushstring(L, element.c_str());

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

+ if (!ns.empty()) {

+ lua_pushstring(L, ns.c_str());

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

+ }

+ if (!attributes.getEntries().empty()) {

+ lua_newtable(L);

+ int i = 1;

+ foreach(const AttributeMap::Entry& entry, attributes.getEntries()) {

+ lua_pushnumber(L, i);

+ lua_newtable(L);

+ lua_pushstring(L, entry.getAttribute().getName().c_str());

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

+ if (!entry.getAttribute().getNamespace().empty()) {

+ lua_pushstring(L, entry.getAttribute().getNamespace().c_str());

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

+ }

+ lua_pushstring(L, entry.getValue().c_str());

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

+ lua_settable(L, -3);

+ ++i;

+ }

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

+ }

+

+ indexStack.push_back(currentIndex);

+ currentIndex = 1;

+ lua_newtable(L);

+ }

+

+ virtual void handleEndElement(

+ const std::string&, const std::string&) SWIFTEN_OVERRIDE {

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

+ lua_settable(L, -3);

+ currentIndex = indexStack.back();

+ indexStack.pop_back();

+ currentIndex++;

+ }

+

+ virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE {

+ lua_checkstack(L, 2);

+ lua_pushnumber(L, currentIndex);

+ lua_pushstring(L, data.c_str());

+ lua_settable(L, -3);

+ currentIndex++;

+ }

+

+ private:

+ lua_State* L;

+ std::vector<int> indexStack;

+ int currentIndex;

+ };

+

+ std::string serializeElement(lua_State* L) {

+ std::string tag;

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

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

+ tag = lua_tostring(L, -1);

+ }

+ lua_pop(L, 1);

+

+ std::string ns;

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

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

+ ns = lua_tostring(L, -1);

+ }

+ lua_pop(L, 1);

+

+ XMLElement element(tag, ns);

+

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

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

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

+ for (lua_pushnil(L); lua_next(L, index) != 0; ) {

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

+ std::string attributeName;

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

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

+ attributeName = lua_tostring(L, -1);

+ }

+ lua_pop(L, 1);

+

+ std::string attributeValue;

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

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

+ attributeValue = lua_tostring(L, -1);

+ }

+ lua_pop(L, 1);

+

+ if (!attributeName.empty()) {

+ element.setAttribute(attributeName, attributeValue);

+ }

+ }

+ lua_pop(L, 1); // value

+ }

+ }

+ lua_pop(L, 1); // children

+

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

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

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

+ for (lua_pushnil(L); lua_next(L, index) != 0; ) {

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

+ element.addNode(boost::make_shared<XMLTextNode>(lua_tostring(L, -1)));

+ }

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

+ element.addNode(boost::make_shared<XMLRawTextNode>(serializeElement(L)));

+ }

+ lua_pop(L, 1); // value

+ }

+ }

+ lua_pop(L, 1); // children

+

+ return element.serialize();

+ }

+ if (!lua_istable(L, index) || type != "dom") {

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

+ }

+ return boost::make_shared<RawXMLPayload>(serializeElement(L).c_str());

+ lua_State* L, boost::shared_ptr<Element> element) {

+ // Serialize payload to XML

+ boost::shared_ptr<Payload> payload = boost::dynamic_pointer_cast<Payload>(element);

+ if (!payload) {

+ return boost::optional<std::string>();

+ }

+

+ PayloadSerializer* serializer = serializers.getPayloadSerializer(payload);

+ assert(serializer);

+ std::string serializedPayload = serializer->serialize(payload);

+

+ lua_newtable(L);

+

+ // Parse the payload again

+ ParserClient parserClient(L);

+ boost::shared_ptr<XMLParser> parser(parsers.createXMLParser(&parserClient));

+ bool result = parser->parse(serializedPayload);

+ assert(result);

+

+ // There can only be one element, so stripping the list

+ lua_pushnil(L);

+ lua_next(L, -2);

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

+

+ lua_replace(L, -3);

+ lua_settop(L, -2);

+

+ return std::string("dom");

+ class DOMElementConvertor : public LuaElementConvertor {

+ public:

+ DOMElementConvertor();

+ virtual ~DOMElementConvertor();

+ virtual boost::shared_ptr<Element> convertFromLua(lua_State*, int index, const std::string& type) SWIFTEN_OVERRIDE;

+ virtual boost::optional<std::string> convertToLua(lua_State*, boost::shared_ptr<Element>) SWIFTEN_OVERRIDE;

+ private:

+ PlatformXMLParserFactory parsers;

+ FullPayloadSerializerCollection serializers;

+ };

+ std::cerr << "Warning: Unable to convert type '" << type << "'" << std::endl;

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

+ // Should have been handled by the raw XML convertor

+ assert(false);

+ return NO_RESULT;

+ class DefaultElementConvertor : public LuaElementConvertor {

+ public:

+ DefaultElementConvertor();

+ virtual ~DefaultElementConvertor();

+ virtual boost::shared_ptr<Element> convertFromLua(lua_State*, int index, const std::string& type) SWIFTEN_OVERRIDE;

+ virtual boost::optional<std::string> convertToLua(lua_State*, boost::shared_ptr<Element>) SWIFTEN_OVERRIDE;

+ };

+ boost::shared_ptr<Delay> result = boost::make_shared<Delay>();

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

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

+ result->setStamp(stringToDateTime(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+

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

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

+ result->setFrom(lua_tostring(L, -1));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getFrom()) {

+ lua_pushstring(L, (*payload->getFrom()).toString().c_str());

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

+ }

+ lua_pushstring(L, dateTimeToString(payload->getStamp()).c_str());

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

+ class DelayConvertor : public GenericLuaElementConvertor<Delay> {

+ public:

+ DelayConvertor();

+ virtual ~DelayConvertor();

+ virtual boost::shared_ptr<Delay> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Delay>) SWIFTEN_OVERRIDE;

+ };

+ boost::shared_ptr<DiscoInfo> result = boost::make_shared<DiscoInfo>();

+ if (boost::optional<std::string> value = Lua::getStringField(L, -1, "node")) {

+ result->setNode(*value);

+ }

+

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

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

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

+ result->addIdentity(DiscoInfo::Identity(

+ Lua::getStringField(L, -1, "name").get_value_or(""),

+ Lua::getStringField(L, -1, "category").get_value_or("client"),

+ Lua::getStringField(L, -1, "type").get_value_or("pc"),

+ Lua::getStringField(L, -1, "language").get_value_or("")));

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+

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

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

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

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

+ result->addFeature(lua_tostring(L, -1));

+ }

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+

+ // TODO: Extension

+

+ return result;

+ lua_newtable(L);

+ if (!payload->getNode().empty()) {

+ lua_pushstring(L, payload->getNode().c_str());

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

+ }

+

+ const std::vector<DiscoInfo::Identity>& identities = payload->getIdentities();

+ if (!identities.empty()) {

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

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

+ lua_createtable(L, 0, 0);

+ if (!identities[i].getName().empty()) {

+ lua_pushstring(L, identities[i].getName().c_str());

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

+ }

+ if (!identities[i].getCategory().empty()) {

+ lua_pushstring(L, identities[i].getCategory().c_str());

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

+ }

+ if (!identities[i].getType().empty()) {

+ lua_pushstring(L, identities[i].getType().c_str());

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

+ }

+ if (!identities[i].getLanguage().empty()) {

+ lua_pushstring(L, identities[i].getLanguage().c_str());

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

+ }

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

+ }

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

+ }

+

+ const std::vector<std::string>& features = payload->getFeatures();

+ if (!features.empty()) {

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

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

+ lua_pushstring(L, features[i].c_str());

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

+ }

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

+ }

+

+ // TODO: Extension

+ return Documentation(

+ "DiscoInfo",

+ "Represents `disco#info` service discovery data.\n\n"

+ "This table has the following structure:\n\n"

+ "- `node`: string\n"

+ "- `identities`: array(table)\n"

+ " - `name`: string\n"

+ " - `category`: string\n"

+ " - `type`: string\n"

+ " - `language`: string\n"

+ "- `features`: array(string)\n"

+ );

+ class DiscoInfoConvertor : public GenericLuaElementConvertor<DiscoInfo> {

+ public:

+ DiscoInfoConvertor();

+ virtual ~DiscoInfoConvertor();

+ virtual boost::shared_ptr<DiscoInfo> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<DiscoInfo>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ };

+ boost::shared_ptr<DiscoItems> result = boost::make_shared<DiscoItems>();

+ if (boost::optional<std::string> value = Lua::getStringField(L, -1, "node")) {

+ result->setNode(*value);

+ }

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

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

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

+ result->addItem(DiscoItems::Item(

+ Lua::getStringField(L, -1, "name").get_value_or(""),

+ JID(Lua::getStringField(L, -1, "jid").get_value_or("")),

+ Lua::getStringField(L, -1, "node").get_value_or("")));

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_newtable(L);

+ if (!payload->getNode().empty()) {

+ lua_pushstring(L, payload->getNode().c_str());

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

+ }

+ const std::vector<DiscoItems::Item>& items = payload->getItems();

+ if (!items.empty()) {

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

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

+ lua_createtable(L, 0, 0);

+ if (!items[i].getName().empty()) {

+ lua_pushstring(L, items[i].getName().c_str());

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

+ }

+ if (!items[i].getNode().empty()) {

+ lua_pushstring(L, items[i].getNode().c_str());

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

+ }

+ if (items[i].getJID().isValid()) {

+ lua_pushstring(L, items[i].getJID().toString().c_str());

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

+ }

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

+ }

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

+ }

+ class DiscoItemsConvertor : public GenericLuaElementConvertor<DiscoItems> {

+ public:

+ DiscoItemsConvertor();

+ virtual ~DiscoItemsConvertor();

+ virtual boost::shared_ptr<DiscoItems> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<DiscoItems>) SWIFTEN_OVERRIDE;

+ };

+ convertors.push_back(boost::make_shared<PubSubRetractConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubAffiliationsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubPublishConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubItemsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerRedirectConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventRedirectConvertor>());

+ convertors.push_back(boost::make_shared<UserTuneConvertor>());

+ convertors.push_back(boost::make_shared<PubSubConfigureConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubEventDisassociateConvertor>());

+ convertors.push_back(boost::make_shared<PubSubOwnerAffiliationsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerConfigureConvertor>(this));

+ convertors.push_back(boost::make_shared<UserLocationConvertor>());

+ convertors.push_back(boost::make_shared<PubSubSubscribeOptionsConvertor>());

+ convertors.push_back(boost::make_shared<PubSubOwnerSubscriptionsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubDefaultConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventCollectionConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubEventSubscriptionConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventRetractConvertor>());

+ convertors.push_back(boost::make_shared<PubSubItemConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubUnsubscribeConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventDeleteConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubCreateConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerPurgeConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventItemsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOptionsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubEventItemConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerSubscriptionConvertor>());

+ convertors.push_back(boost::make_shared<IsodeIQDelegationConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerAffiliationConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventPurgeConvertor>());

+ convertors.push_back(boost::make_shared<PubSubAffiliationConvertor>());

+ convertors.push_back(boost::make_shared<PubSubSubscribeConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerDeleteConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubOwnerDefaultConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubSubscriptionsConvertor>(this));

+ convertors.push_back(boost::make_shared<PubSubEventAssociateConvertor>());

+ convertors.push_back(boost::make_shared<PubSubSubscriptionConvertor>(this));

+ convertors.push_back(boost::make_shared<SecurityLabelConvertor>());

+ convertors.push_back(boost::make_shared<PubSubEventConfigurationConvertor>(this));

+ int formIndex(lua_State* L) {

+ lua_getfield(L, 1, "fields");

+ if (lua_type(L, -1) != LUA_TTABLE) {

+ return 0;

+ }

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

+ lua_pushnil(L);

+ for (lua_pushnil(L); lua_next(L, index) != 0; ) {

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

+ if (lua_equal(L, -1, 2)) {

+ lua_pop(L, 1);

+ return 1;

+ }

+ lua_pop(L, 2);

+ }

+ return 0;

+ }

+

+ int formNewIndex(lua_State* L) {

+ lua_getfield(L, 1, "fields");

+ bool foundField = false;

+ if (lua_type(L, -1) == LUA_TTABLE) {

+ for (lua_pushnil(L); lua_next(L, -2) != 0; ) {

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

+ if (lua_equal(L, -1, 2)) {

+ lua_pushvalue(L, 3);

+ lua_setfield(L, -3, "value");

+ foundField = true;

+ lua_pop(L, 3);

+ break;

+ }

+ lua_pop(L, 2);

+ }

+ }

+ lua_pop(L, 1);

+

+ if (!foundField) {

+ lua_pushvalue(L, 2);

+ lua_pushvalue(L, 3);

+ lua_rawset(L, 1);

+ }

+ return 0;

+ }

+

+ Lua::Table convertFieldToLua(boost::shared_ptr<FormField> field) {

+ Lua::Table luaField = boost::assign::map_list_of("name", Lua::valueRef(field->getName()));

+ std::string type;

+ switch (field->getType()) {

+ case FormField::UnknownType: type = ""; break;

+ case FormField::BooleanType: type = "boolean"; break;

+ case FormField::FixedType: type = "fixed"; break;

+ case FormField::HiddenType: type = "hidden"; break;

+ case FormField::ListSingleType: type = "list-single"; break;

+ case FormField::TextMultiType: type = "text-multi"; break;

+ case FormField::TextPrivateType: type = "text-private"; break;

+ case FormField::TextSingleType: type = "text-single"; break;

+ case FormField::JIDSingleType: type = "jid-single"; break;

+ case FormField::JIDMultiType: type = "jid-multi"; break;

+ case FormField::ListMultiType: type = "list-multi"; break;

+ }

+ if (!type.empty()) {

+ luaField["type"] = Lua::valueRef(type);

+ }

+ if (!field->getLabel().empty()) {

+ luaField["label"] = Lua::valueRef(field->getLabel());

+ }

+ if (field->getRequired()) {

+ luaField["required"] = Lua::boolRef(field->getRequired());

+ }

+ if (!field->getDescription().empty()) {

+ luaField["description"] = Lua::valueRef(field->getDescription());

+ }

+ if (field->getType() == FormField::BooleanType) {

+ luaField["value"] = Lua::boolRef(field->getBoolValue());

+ }

+ else if (field->getValues().size() > 1) {

+ luaField["value"] = Lua::valueRef(Lua::Array(field->getValues().begin(), field->getValues().end()));

+ }

+ else if (field->getValues().size() == 1) {

+ luaField["value"] = Lua::valueRef(field->getValues()[0]);

+ }

+ if (!field->getOptions().empty()) {

+ Lua::Array options;

+ foreach(const FormField::Option& option, field->getOptions()) {

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

+ ("label", Lua::valueRef(option.label))

+ ("value", Lua::valueRef(option.value));

+ options.push_back(luaOption);

+ }

+ luaField["options"] = valueRef(options);

+ }

+ return luaField;

+ }

+

+ Lua::Array convertFieldListToLua(const std::vector< boost::shared_ptr<FormField> >& fieldList) {

+ Lua::Array fields;

+ foreach(boost::shared_ptr<FormField> field, fieldList) {

+ fields.push_back(convertFieldToLua(field));

+ }

+ return fields;

+ }

+

+

+ boost::shared_ptr<FormField> convertFieldFromLua(lua_State* L) {

+ boost::shared_ptr<FormField> result = boost::make_shared<FormField>();

+ FormField::Type fieldType = FormField::UnknownType;

+ boost::optional<std::string> type = Lua::getStringField(L, -1, "type");

+ if (type) {

+ if (*type == "boolean") {

+ fieldType = FormField::BooleanType;

+ }

+ if (*type == "fixed") {

+ fieldType = FormField::FixedType;

+ }

+ if (*type == "hidden") {

+ fieldType = FormField::HiddenType;

+ }

+ if (*type == "list-single") {

+ fieldType = FormField::ListSingleType;

+ }

+ if (*type == "text-multi") {

+ fieldType = FormField::TextMultiType;

+ }

+ if (*type == "text-private") {

+ fieldType = FormField::TextPrivateType;

+ }

+ if (*type == "text-single") {

+ fieldType = FormField::TextSingleType;

+ }

+ if (*type == "jid-single") {

+ fieldType = FormField::JIDSingleType;

+ }

+ if (*type == "jid-multi") {

+ fieldType = FormField::JIDMultiType;

+ }

+ if (*type == "list-multi") {

+ fieldType = FormField::ListMultiType;

+ }

+ }

+ result->setType(fieldType);

+ if (boost::optional<std::string> name = Lua::getStringField(L, -1, "name")) {

+ result->setName(*name);

+ }

+ if (boost::optional<std::string> description = Lua::getStringField(L, -1, "description")) {

+ result->setDescription(*description);

+ }

+ if (boost::optional<std::string> label = Lua::getStringField(L, -1, "label")) {

+ result->setLabel(*label);

+ }

+ if (boost::optional<bool> required = Lua::getBooleanField(L, -1, "required")) {

+ result->setRequired(*required);

+ }

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

+ result->addValue(*value);

+ }

+ else if (boost::optional<bool> value = Lua::getBooleanField(L, -1, "value")) {

+ result->setBoolValue(*value);

+ }

+ else {

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

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

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

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

+ result->addValue(lua_tostring(L, -1));

+ }

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+ }

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

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

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

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

+ FormField::Option option("", "");

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

+ option.value = *value;

+ }

+ if (boost::optional<std::string> label = Lua::getStringField(L, -1, "label")) {

+ option.label = *label;

+ }

+ result->addOption(option);

+ }

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ }

+

+ std::vector< boost::shared_ptr<FormField> > convertFieldListFromLua(lua_State* L) {

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

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

+ result.push_back(convertFieldFromLua(L));

+ lua_pop(L, 1);

+ }

+ return result;

+ }

+

+ boost::shared_ptr<Form> convertFormFromLua(lua_State* L) {

+ boost::shared_ptr<Form> result = boost::make_shared<Form>();

+ if (boost::optional<std::string> title = Lua::getStringField(L, -1, "title")) {

+ result->setTitle(*title);

+ }

+ if (boost::optional<std::string> instructions = Lua::getStringField(L, -1, "instructions")) {

+ result->setInstructions(*instructions);

+ }

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

+ Form::Type formType = Form::FormType;

+ if (*type == "submit") {

+ formType = Form::SubmitType;

+ }

+ else if (*type == "cancel") {

+ formType = Form::CancelType;

+ }

+ else if (*type == "result") {

+ formType = Form::ResultType;

+ }

+ result->setType(formType);

+ }

+

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

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

+ foreach (boost::shared_ptr<FormField> formField, convertFieldListFromLua(L)) {

+ result->addField(formField);

+ }

+ }

+ lua_pop(L, 1);

+

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

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

+ foreach (boost::shared_ptr<FormField> formField, convertFieldListFromLua(L)) {

+ result->addReportedField(formField);

+ }

+ }

+ lua_pop(L, 1);

+

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

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

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

+ result->addItem(convertFieldListFromLua(L));

+ lua_pop(L, 1);

+ }

+ }

+ lua_pop(L, 1);

+

+ return result;

+ }

+

+ void convertFormToLua(lua_State* L, boost::shared_ptr<Form> payload) {

+ std::string type;

+ switch (payload->getType()) {

+ case Form::FormType: type = "form"; break;

+ case Form::SubmitType: type = "submit"; break;

+ case Form::CancelType: type = "cancel"; break;

+ case Form::ResultType: type = "result"; break;

+ }

+

+ Lua::Table result = boost::assign::map_list_of("type", Lua::valueRef(type));

+ if (!payload->getTitle().empty()) {

+ result["title"] = Lua::valueRef(payload->getTitle());

+ }

+ if (!payload->getInstructions().empty()) {

+ result["instructions"] = Lua::valueRef(payload->getInstructions());

+ }

+ if (!payload->getFields().empty()) {

+ result["fields"] = valueRef(convertFieldListToLua(payload->getFields()));

+ }

+ if (!payload->getReportedFields().empty()) {

+ result["reported_fields"] = valueRef(convertFieldListToLua(payload->getReportedFields()));

+ }

+

+ if (!payload->getItems().empty()) {

+ Lua::Array luaItems;

+ foreach(const Form::FormItem& item, payload->getItems()) {

+ if (!item.empty()) {

+ luaItems.push_back(convertFieldListToLua(item));

+ }

+ }

+ result["items"] = valueRef(luaItems);

+ }

+

+ Lua::pushValue(L, result);

+

+ lua_newtable(L);

+ lua_pushcfunction(L, formIndex);

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

+ lua_pushcfunction(L, formNewIndex);

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

+ lua_setmetatable(L, -2);

+ }

+

+ int createSubmission(lua_State* L) {

+ boost::shared_ptr<Form> form = convertFormFromLua(L);

+

+ // Remove all redundant elements

+ form->setInstructions("");

+ form->setTitle("");

+ form->clearItems();

+ form->clearReportedFields();

+ std::vector< boost::shared_ptr<FormField> > fields(form->getFields());

+ form->clearFields();

+ foreach (boost::shared_ptr<FormField> field, fields) {

+ if (field->getType() == FormField::FixedType) {

+ continue;

+ }

+ field->clearOptions();

+ field->setLabel("");

+ field->setType(FormField::UnknownType);

+ field->setDescription("");

+ form->addField(field);

+ }

+ form->setType(Form::SubmitType);

+

+ // Convert back

+ convertFormToLua(L, form);

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

+

+ return 1;

+ }

+ return convertFormFromLua(L);

+ convertFormToLua(L, payload);

+ lua_pushstring(L, "create_submission");

+ lua_pushcfunction(L, createSubmission);

+ lua_rawset(L, -3);

+ class FormConvertor : public GenericLuaElementConvertor<Form> {

+ public:

+ FormConvertor();

+ virtual ~FormConvertor();

+ virtual boost::shared_ptr<Form> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Form>) SWIFTEN_OVERRIDE;

+ };

+ForwardedConvertor::ForwardedConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<Forwarded>("forwarded"),

+ convertors(convertors) {

+ boost::shared_ptr<Forwarded> result = boost::make_shared<Forwarded>();

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<Delay> delay = boost::dynamic_pointer_cast<Delay>(convertors->convertFromLuaUntyped(L, -1, "delay"));

+ if (!!delay) {

+ result->setDelay(delay);

+ }

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(convertors->convertFromLua(L, -1));

+ if (!!stanza) {

+ result->setStanza(stanza);

+ }

+ lua_pop(L, 1);

+ return result;

+ }

+ return result;

+ lua_createtable(L, 0, 0);

+ if (convertors->convertToLuaUntyped(L, payload->getDelay()) > 0) {

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

+ }

+ boost::shared_ptr<Stanza> stanza = payload->getStanza();

+ if (!!stanza) {

+ if (convertors->convertToLua(L, stanza) > 0) {

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

+ }

+ }

+ return Documentation(

+ "Forwarded",

+ "This table has the following fields:\n\n"

+ "- `delay`: @{Delay} (Optional)\n"

+ "- `stanza`: @{Stanza} (Optional)\n"

+ );

+ class LuaElementConvertors;

+ class ForwardedConvertor : public GenericLuaElementConvertor<Forwarded> {

+ public:

+ ForwardedConvertor(LuaElementConvertors* convertors);

+ virtual ~ForwardedConvertor();

+ virtual boost::shared_ptr<Forwarded> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Forwarded>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ private:

+ LuaElementConvertors* convertors;

+ };

+IQConvertor::IQConvertor(LuaElementConvertors* convertors) :

+ StanzaConvertor<IQ>("iq"),

+ convertors(convertors) {

+ boost::shared_ptr<IQ> result = getStanza(L, convertors);

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

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

+ result->setType(IQConvertor::convertIQTypeFromString(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ pushStanza(L, stanza, convertors);

+ const std::string type = IQConvertor::convertIQTypeToString(stanza->getType());

+ lua_pushstring(L, type.c_str());

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

+ return Documentation(

+ "IQ",

+ "This table has the following fields:\n\n"

+ "- `type`: string\n"

+ "- `id`: string\n"

+ "- `from`: string\n"

+ "- `to`: string\n"

+ "- `payloads`: array<@{Payload}>\n"

+ );

+ switch (type) {

+ case IQ::Get: return "get";

+ case IQ::Set: return "set";

+ case IQ::Result: return "result";

+ case IQ::Error: return "error";

+ }

+ assert(false);

+ return "";

+ if (type == "get") {

+ return IQ::Get;

+ }

+ else if (type == "set") {

+ return IQ::Set;

+ }

+ else {

+ throw Lua::Exception("Illegal query type: '" + type + "'");

+ }

+ class LuaElementConvertors;

+ class IQConvertor : public StanzaConvertor<IQ> {

+ public:

+ IQConvertor(LuaElementConvertors* convertors);

+ virtual ~IQConvertor();

+ virtual boost::shared_ptr<IQ> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<IQ>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ static std::string convertIQTypeToString(IQ::Type type);

+ static IQ::Type convertIQTypeFromString(const std::string& type);

+ private:

+ LuaElementConvertors* convertors;

+ };

+IsodeIQDelegationConvertor::IsodeIQDelegationConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<IsodeIQDelegation>("isode_iq_delegation"),

+ convertors(convertors) {

+ boost::shared_ptr<IsodeIQDelegation> result = boost::make_shared<IsodeIQDelegation>();

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<Forwarded> payload = boost::dynamic_pointer_cast<Forwarded>(convertors->convertFromLuaUntyped(L, -1, "forwarded"))) {

+ result->setForward(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (convertors->convertToLuaUntyped(L, payload->getForward()) > 0) {

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

+ }

+ return Documentation(

+ "IsodeIQDelegation",

+ "This table has the following fields:\n\n"

+ "- `forward`: @{Forwarded}\n"

+ );

+ class LuaElementConvertors;

+ class IsodeIQDelegationConvertor : public GenericLuaElementConvertor<IsodeIQDelegation> {

+ public:

+ IsodeIQDelegationConvertor(LuaElementConvertors* convertors);

+ virtual ~IsodeIQDelegationConvertor();

+ virtual boost::shared_ptr<IsodeIQDelegation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<IsodeIQDelegation>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+MAMFinConvertor::MAMFinConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<MAMFin>("mam_fin"),

+ convertors(convertors) {

+ boost::shared_ptr<MAMFin> result = boost::make_shared<MAMFin>();

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

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

+ result->setQueryID(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ result->setComplete(lua_toboolean(L, -1) != 0);

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ result->setStable(lua_toboolean(L, -1) != 0);

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<ResultSet> resultSet = boost::dynamic_pointer_cast<ResultSet>(convertors->convertFromLuaUntyped(L, -1, "result_set"));

+ if (!!resultSet) {

+ result->setResultSet(resultSet);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getQueryID()) {

+ lua_pushstring(L, (*payload->getQueryID()).c_str());

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

+ }

+ lua_pushboolean(L, payload->isComplete());

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

+ lua_pushboolean(L, payload->isStable());

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

+ if (convertors->convertToLuaUntyped(L, payload->getResultSet()) > 0) {

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

+ }

+ return Documentation(

+ "MAMFin",

+ "This table has the following fields:\n\n"

+ "- `query_id`: string (Optional)\n"

+ "- `complete`: boolean (Optional)\n"

+ "- `stable`: boolean (Optional)\n"

+ "- `result_set`: @{ResultSet} (Optional)\n"

+ );

+ class LuaElementConvertors;

+ class MAMFinConvertor : public GenericLuaElementConvertor<MAMFin> {

+ public:

+ MAMFinConvertor(LuaElementConvertors* convertors);

+ virtual ~MAMFinConvertor();

+ virtual boost::shared_ptr<MAMFin> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<MAMFin>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+MAMQueryConvertor::MAMQueryConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<MAMQuery>("mam"),

+ convertors(convertors) {

+ boost::shared_ptr<MAMQuery> result = boost::make_shared<MAMQuery>();

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

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

+ result->setQueryID(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<Form> form = boost::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"));

+ if (!!form) {

+ result->setForm(form);

+ }

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<ResultSet> resultSet = boost::dynamic_pointer_cast<ResultSet>(convertors->convertFromLuaUntyped(L, -1, "result_set"));

+ if (!!resultSet) {

+ result->setResultSet(resultSet);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getQueryID()) {

+ lua_pushstring(L, (*payload->getQueryID()).c_str());

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

+ }

+ if (payload->getNode()) {

+ lua_pushstring(L, (*payload->getNode()).c_str());

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

+ }

+ if (convertors->convertToLuaUntyped(L, payload->getForm()) > 0) {

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

+ }

+ if (convertors->convertToLuaUntyped(L, payload->getResultSet()) > 0) {

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

+ }

+ return Documentation(

+ "MAMQuery",

+ "This table has the following fields:\n\n"

+ "- `query_id`: string (Optional)\n"

+ "- `node`: string (Optional)\n"

+ "- `form`: string @{Form} (Optional)\n"

+ "- `result_set`: @{ResultSet} (Optional)\n"

+ );

+ class LuaElementConvertors;

+ class MAMQueryConvertor : public GenericLuaElementConvertor<MAMQuery> {

+ public:

+ MAMQueryConvertor(LuaElementConvertors* convertors);

+ virtual ~MAMQueryConvertor();

+ virtual boost::shared_ptr<MAMQuery> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<MAMQuery>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+MAMResultConvertor::MAMResultConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<MAMResult>("mam_result"),

+ convertors(convertors) {

+ boost::shared_ptr<MAMResult> result = boost::make_shared<MAMResult>();

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

+ if (!lua_isnil(L, -1)) {

+ boost::shared_ptr<Forwarded> payload = boost::dynamic_pointer_cast<Forwarded>(convertors->convertFromLuaUntyped(L, -1, "payload"));

+ if (!!payload) {

+ result->setPayload(payload);

+ }

+ }

+ lua_pop(L, 1);

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

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

+ result->setID(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ result->setQueryID(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (convertors->convertToLuaUntyped(L, payload->getPayload()) > 0) {

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

+ }

+ lua_pushstring(L, payload->getID().c_str());

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

+ if (payload->getQueryID()) {

+ lua_pushstring(L, (*payload->getQueryID()).c_str());

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

+ }

+ return Documentation(

+ "MAMResult",

+ "This table has the following fields:\n\n"

+ "- `payload`: @{Forwarded}\n"

+ "- `id`: string\n"

+ "- `query_id`: string (Optional)\n"

+ );

+ class LuaElementConvertors;

+ class MAMResultConvertor : public GenericLuaElementConvertor<MAMResult> {

+ public:

+ MAMResultConvertor(LuaElementConvertors* convertors);

+ virtual ~MAMResultConvertor();

+ virtual boost::shared_ptr<MAMResult> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<MAMResult>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+MessageConvertor::MessageConvertor(LuaElementConvertors* convertors) :

+ StanzaConvertor<Message>("message"),

+ convertors(convertors) {

+ boost::shared_ptr<Message> result = getStanza(L, convertors);

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

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

+ result->setType(convertMessageTypeFromString(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ pushStanza(L, stanza, convertors);

+ const std::string type = convertMessageTypeToString(stanza->getType());

+ lua_pushstring(L, type.c_str());

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

+ return Documentation(

+ "Message",

+ "This table has the following fields:\n\n"

+ "- `type`: string\n"

+ "- `id`: string\n"

+ "- `from`: string\n"

+ "- `to`: string\n"

+ "- `payloads`: array<@{Payload}>\n"

+ );

+ switch (type) {

+ case Message::Normal: return "normal";

+ case Message::Chat: return "chat";

+ case Message::Error: return "error";

+ case Message::Groupchat: return "groupchat";

+ case Message::Headline: return "headline";

+ }

+ assert(false);

+ return "";

+ if (type == "normal") {

+ return Message::Normal;

+ }

+ else if (type == "chat") {

+ return Message::Chat;

+ }

+ else if (type == "error") {

+ return Message::Error;

+ }

+ else if (type == "groupchat") {

+ return Message::Groupchat;

+ }

+ else if (type == "headline") {

+ return Message::Headline;

+ }

+ else {

+ throw Lua::Exception("Illegal message type: '" + type + "'");

+ }

+ class LuaElementConvertors;

+ class MessageConvertor : public StanzaConvertor<Message> {

+ public:

+ MessageConvertor(LuaElementConvertors* convertors);

+ virtual ~MessageConvertor();

+ virtual boost::shared_ptr<Message> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Message>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ static std::string convertMessageTypeToString(Message::Type type);

+ static Message::Type convertMessageTypeFromString(const std::string& type);

+ private:

+ LuaElementConvertors* convertors;

+ };

+PresenceConvertor::PresenceConvertor(LuaElementConvertors* convertors) :

+ StanzaConvertor<Presence>("presence"),

+ convertors(convertors) {

+ boost::shared_ptr<Presence> result = getStanza(L, convertors);

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

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

+ result->setType(convertPresenceTypeFromString(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ pushStanza(L, stanza, convertors);

+ const std::string type = convertPresenceTypeToString(stanza->getType());

+ lua_pushstring(L, type.c_str());

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

+ return Documentation(

+ "Presence",

+ "This table has the following fields:\n\n"

+ "- `type`: string\n"

+ "- `id`: string\n"

+ "- `from`: string\n"

+ "- `to`: string\n"

+ "- `payloads`: array<@{Payload}>\n"

+ );

+ switch (type) {

+ case Presence::Available: return "available";

+ case Presence::Error: return "error";

+ case Presence::Probe: return "probe";

+ case Presence::Subscribe: return "subscribe";

+ case Presence::Subscribed: return "subscribed";

+ case Presence::Unavailable: return "unavailable";

+ case Presence::Unsubscribe: return "unsubscribe";

+ case Presence::Unsubscribed: return "unsubscribed";

+ }

+ assert(false);

+ return "";

+ if (type == "available") {

+ return Presence::Available;

+ }

+ else if (type == "error") {

+ return Presence::Error;

+ }

+ else if (type == "probe") {

+ return Presence::Probe;

+ }

+ else if (type == "subscribe") {

+ return Presence::Subscribe;

+ }

+ else if (type == "subscribed") {

+ return Presence::Subscribed;

+ }

+ else if (type == "unavailable") {

+ return Presence::Unavailable;

+ }

+ else if (type == "unsubscribe") {

+ return Presence::Unsubscribe;

+ }

+ else if (type == "unsubscribed") {

+ return Presence::Unsubscribed;

+ }

+ else {

+ throw Lua::Exception("Illegal presence type: '" + type + "'");

+ }

+ class LuaElementConvertors;

+ class PresenceConvertor : public StanzaConvertor<Presence> {

+ public:

+ PresenceConvertor(LuaElementConvertors* convertors);

+ virtual ~PresenceConvertor();

+ virtual boost::shared_ptr<Presence> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<Presence>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ static std::string convertPresenceTypeToString(Presence::Type type);

+ static Presence::Type convertPresenceTypeFromString(const std::string& type);

+ private:

+ LuaElementConvertors* convertors;

+ };

+ GenericLuaElementConvertor<PubSubAffiliation>("pubsub_affiliation") {

+ boost::shared_ptr<PubSubAffiliation> result = boost::make_shared<PubSubAffiliation>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ if (std::string(lua_tostring(L, -1)) == "none") {

+ result->setType(PubSubAffiliation::None);

+ }

+ if (std::string(lua_tostring(L, -1)) == "member") {

+ result->setType(PubSubAffiliation::Member);

+ }

+ if (std::string(lua_tostring(L, -1)) == "outcast") {

+ result->setType(PubSubAffiliation::Outcast);

+ }

+ if (std::string(lua_tostring(L, -1)) == "owner") {

+ result->setType(PubSubAffiliation::Owner);

+ }

+ if (std::string(lua_tostring(L, -1)) == "publisher") {

+ result->setType(PubSubAffiliation::Publisher);

+ }

+ if (std::string(lua_tostring(L, -1)) == "publish_only") {

+ result->setType(PubSubAffiliation::PublishOnly);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ switch (payload->getType()) {

+ case PubSubAffiliation::None:

+ lua_pushstring(L, "none");

+ break;

+ case PubSubAffiliation::Member:

+ lua_pushstring(L, "member");

+ break;

+ case PubSubAffiliation::Outcast:

+ lua_pushstring(L, "outcast");

+ break;

+ case PubSubAffiliation::Owner:

+ lua_pushstring(L, "owner");

+ break;

+ case PubSubAffiliation::Publisher:

+ lua_pushstring(L, "publisher");

+ break;

+ case PubSubAffiliation::PublishOnly:

+ lua_pushstring(L, "publish_only");

+ break;

+ }

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

+ return Documentation(

+ "PubSubAffiliation",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ "- `type`: `\"none\"`, `\"member\"`, `\"outcast\"`, `\"owner\"`, `\"publisher\"`, or `\"publish_only\"`\n"

+ );

+ class LuaElementConvertors;

+ class PubSubAffiliationConvertor : public GenericLuaElementConvertor<PubSubAffiliation> {

+ public:

+ PubSubAffiliationConvertor();

+ virtual ~PubSubAffiliationConvertor();

+ virtual boost::shared_ptr<PubSubAffiliation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubAffiliation>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ };

+PubSubAffiliationsConvertor::PubSubAffiliationsConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubAffiliations>("pubsub_affiliations"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubAffiliations> result = boost::make_shared<PubSubAffiliations>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ if (lua_type(L, -1) == LUA_TTABLE) {

+ std::vector< boost::shared_ptr<PubSubAffiliation> > items;

+ for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

+ lua_pushnumber(L, i + 1);

+ lua_gettable(L, -2);

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubAffiliation> payload = boost::dynamic_pointer_cast<PubSubAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_affiliation"))) {

+ items.push_back(payload);

+ }

+ }

+ lua_pop(L, 1);

+ }

+ result->setAffiliations(items);

+ }

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getNode()) {

+ lua_pushstring(L, (*payload->getNode()).c_str());

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

+ }

+ if (!payload->getAffiliations().empty()) {

+ {

+ int i = 0;

+ foreach(boost::shared_ptr<PubSubAffiliation> item, payload->getAffiliations()) {

+ if (convertors->convertToLuaUntyped(L, item) > 0) {

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

+ ++i;

+ }

+ }

+ }

+ }

+ return Documentation(

+ "PubSubAffiliations",

+ "This table has the following fields:\n\n"

+ "- `node`: string (Optional)\n"

+ "- `affiliations`: array<@{PubSubAffiliation}>\n"

+ );

+ class LuaElementConvertors;

+ class PubSubAffiliationsConvertor : public GenericLuaElementConvertor<PubSubAffiliations> {

+ public:

+ PubSubAffiliationsConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubAffiliationsConvertor();

+ virtual boost::shared_ptr<PubSubAffiliations> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubAffiliations>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubConfigureConvertor::PubSubConfigureConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubConfigure>("pubsub_configure"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubConfigure> result = boost::make_shared<PubSubConfigure>();

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<Form> payload = boost::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"))) {

+ result->setData(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (convertors->convertToLuaUntyped(L, payload->getData()) > 0) {

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

+ }

+ return Documentation(

+ "PubSubConfigure",

+ "This table has the following fields:\n\n"

+ "- `data`: @{Form}\n"

+ );

+ class LuaElementConvertors;

+ class PubSubConfigureConvertor : public GenericLuaElementConvertor<PubSubConfigure> {

+ public:

+ PubSubConfigureConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubConfigureConvertor();

+ virtual boost::shared_ptr<PubSubConfigure> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubConfigure>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubCreateConvertor::PubSubCreateConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubCreate>("pubsub_create"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubCreate> result = boost::make_shared<PubSubCreate>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubConfigure> payload = boost::dynamic_pointer_cast<PubSubConfigure>(convertors->convertFromLuaUntyped(L, -1, "pubsub_configure"))) {

+ result->setConfigure(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ if (convertors->convertToLuaUntyped(L, payload->getConfigure()) > 0) {

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

+ }

+ return Documentation(

+ "PubSubCreate",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ "- `configure`: @{PubSubConfigure}\n"

+ );

+ class LuaElementConvertors;

+ class PubSubCreateConvertor : public GenericLuaElementConvertor<PubSubCreate> {

+ public:

+ PubSubCreateConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubCreateConvertor();

+ virtual boost::shared_ptr<PubSubCreate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubCreate>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+ GenericLuaElementConvertor<PubSubDefault>("pubsub_default") {

+ boost::shared_ptr<PubSubDefault> result = boost::make_shared<PubSubDefault>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ if (std::string(lua_tostring(L, -1)) == "none") {

+ result->setType(PubSubDefault::None);

+ }

+ if (std::string(lua_tostring(L, -1)) == "collection") {

+ result->setType(PubSubDefault::Collection);

+ }

+ if (std::string(lua_tostring(L, -1)) == "leaf") {

+ result->setType(PubSubDefault::Leaf);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getNode()) {

+ lua_pushstring(L, (*payload->getNode()).c_str());

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

+ }

+ switch (payload->getType()) {

+ case PubSubDefault::None:

+ lua_pushstring(L, "none");

+ break;

+ case PubSubDefault::Collection:

+ lua_pushstring(L, "collection");

+ break;

+ case PubSubDefault::Leaf:

+ lua_pushstring(L, "leaf");

+ break;

+ }

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

+ return Documentation(

+ "PubSubDefault",

+ "This table has the following fields:\n\n"

+ "- `node`: string (Optional)\n"

+ "- `type`: `\"none\"`, `\"collection\"`, or `\"leaf\"`\n"

+ );

+ class LuaElementConvertors;

+ class PubSubDefaultConvertor : public GenericLuaElementConvertor<PubSubDefault> {

+ public:

+ PubSubDefaultConvertor();

+ virtual ~PubSubDefaultConvertor();

+ virtual boost::shared_ptr<PubSubDefault> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubDefault>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ };

+ GenericLuaElementConvertor<PubSubEventAssociate>("pubsub_event_associate") {

+ boost::shared_ptr<PubSubEventAssociate> result = boost::make_shared<PubSubEventAssociate>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ return Documentation(

+ "PubSubEventAssociate",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventAssociateConvertor : public GenericLuaElementConvertor<PubSubEventAssociate> {

+ public:

+ PubSubEventAssociateConvertor();

+ virtual ~PubSubEventAssociateConvertor();

+ virtual boost::shared_ptr<PubSubEventAssociate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventAssociate>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ };

+PubSubEventCollectionConvertor::PubSubEventCollectionConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEventCollection>("pubsub_event_collection"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEventCollection> result = boost::make_shared<PubSubEventCollection>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubEventDisassociate> payload = boost::dynamic_pointer_cast<PubSubEventDisassociate>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_disassociate"))) {

+ result->setDisassociate(payload);

+ }

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubEventAssociate> payload = boost::dynamic_pointer_cast<PubSubEventAssociate>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_associate"))) {

+ result->setAssociate(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getNode()) {

+ lua_pushstring(L, (*payload->getNode()).c_str());

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

+ }

+ if (convertors->convertToLuaUntyped(L, payload->getDisassociate()) > 0) {

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

+ }

+ if (convertors->convertToLuaUntyped(L, payload->getAssociate()) > 0) {

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

+ }

+ return Documentation(

+ "PubSubEventCollection",

+ "This table has the following fields:\n\n"

+ "- `node`: string (Optional)\n"

+ "- `disassociate`: @{PubSubEventDisassociate}\n"

+ "- `associate`: @{PubSubEventAssociate}\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventCollectionConvertor : public GenericLuaElementConvertor<PubSubEventCollection> {

+ public:

+ PubSubEventCollectionConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventCollectionConvertor();

+ virtual boost::shared_ptr<PubSubEventCollection> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventCollection>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubEventConfigurationConvertor::PubSubEventConfigurationConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEventConfiguration>("pubsub_event_configuration"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEventConfiguration> result = boost::make_shared<PubSubEventConfiguration>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<Form> payload = boost::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"))) {

+ result->setData(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ if (convertors->convertToLuaUntyped(L, payload->getData()) > 0) {

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

+ }

+ return Documentation(

+ "PubSubEventConfiguration",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ "- `data`: @{Form}\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventConfigurationConvertor : public GenericLuaElementConvertor<PubSubEventConfiguration> {

+ public:

+ PubSubEventConfigurationConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventConfigurationConvertor();

+ virtual boost::shared_ptr<PubSubEventConfiguration> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventConfiguration>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubEventConvertor::PubSubEventConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEvent>("pubsub_event"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEvent> result = boost::make_shared<PubSubEvent>();

+ if (boost::shared_ptr<PubSubEventPayload> payload = boost::dynamic_pointer_cast<PubSubEventPayload>(convertors->convertFromLua(L, -1))) {

+ result->setPayload(payload);

+ }

+ return result;

+ convertors->convertToLua(L, event->getPayload());

+ class LuaElementConvertors;

+ class PubSubEventConvertor : public GenericLuaElementConvertor<PubSubEvent> {

+ public:

+ PubSubEventConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventConvertor();

+ virtual boost::shared_ptr<PubSubEvent> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEvent>) SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubEventDeleteConvertor::PubSubEventDeleteConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEventDelete>("pubsub_event_delete"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEventDelete> result = boost::make_shared<PubSubEventDelete>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubEventRedirect> payload = boost::dynamic_pointer_cast<PubSubEventRedirect>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_redirect"))) {

+ result->setRedirects(payload);

+ }

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ if (convertors->convertToLuaUntyped(L, payload->getRedirects()) > 0) {

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

+ }

+ return Documentation(

+ "PubSubEventDelete",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ "- `redirects`: @{PubSubEventRedirect}\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventDeleteConvertor : public GenericLuaElementConvertor<PubSubEventDelete> {

+ public:

+ PubSubEventDeleteConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventDeleteConvertor();

+ virtual boost::shared_ptr<PubSubEventDelete> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventDelete>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+ GenericLuaElementConvertor<PubSubEventDisassociate>("pubsub_event_disassociate") {

+ boost::shared_ptr<PubSubEventDisassociate> result = boost::make_shared<PubSubEventDisassociate>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ return Documentation(

+ "PubSubEventDisassociate",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventDisassociateConvertor : public GenericLuaElementConvertor<PubSubEventDisassociate> {

+ public:

+ PubSubEventDisassociateConvertor();

+ virtual ~PubSubEventDisassociateConvertor();

+ virtual boost::shared_ptr<PubSubEventDisassociate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventDisassociate>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ };

+PubSubEventItemConvertor::PubSubEventItemConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEventItem>("pubsub_event_item"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEventItem> result = boost::make_shared<PubSubEventItem>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

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

+ result->setPublisher(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (lua_type(L, -1) == LUA_TTABLE) {

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

+ for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

+ lua_pushnumber(L, i + 1);

+ lua_gettable(L, -2);

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<Payload> payload = boost::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {

+ items.push_back(payload);

+ }

+ }

+ lua_pop(L, 1);

+ }

+ result->setData(items);

+ }

+ lua_pop(L, 1);

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

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

+ result->setID(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ if (payload->getNode()) {

+ lua_pushstring(L, (*payload->getNode()).c_str());

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

+ }

+ if (payload->getPublisher()) {

+ lua_pushstring(L, (*payload->getPublisher()).c_str());

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

+ }

+ if (!payload->getData().empty()) {

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

+ {

+ int i = 0;

+ foreach(boost::shared_ptr<Payload> item, payload->getData()) {

+ if (convertors->convertToLua(L, item) > 0) {

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

+ ++i;

+ }

+ }

+ }

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

+ }

+ if (payload->getID()) {

+ lua_pushstring(L, (*payload->getID()).c_str());

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

+ }

+ return Documentation(

+ "PubSubEventItem",

+ "This table has the following fields:\n\n"

+ "- `node`: string (Optional)\n"

+ "- `publisher`: string (Optional)\n"

+ "- `data`: array<element (table)>\n"

+ "- `id`: string (Optional)\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventItemConvertor : public GenericLuaElementConvertor<PubSubEventItem> {

+ public:

+ PubSubEventItemConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventItemConvertor();

+ virtual boost::shared_ptr<PubSubEventItem> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventItem>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+PubSubEventItemsConvertor::PubSubEventItemsConvertor(LuaElementConvertors* convertors) :

+ GenericLuaElementConvertor<PubSubEventItems>("pubsub_event_items"),

+ convertors(convertors) {

+ boost::shared_ptr<PubSubEventItems> result = boost::make_shared<PubSubEventItems>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

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

+ if (lua_type(L, -1) == LUA_TTABLE) {

+ std::vector< boost::shared_ptr<PubSubEventItem> > items;

+ for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

+ lua_pushnumber(L, i + 1);

+ lua_gettable(L, -2);

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubEventItem> payload = boost::dynamic_pointer_cast<PubSubEventItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_item"))) {

+ items.push_back(payload);

+ }

+ }

+ lua_pop(L, 1);

+ }

+ result->setItems(items);

+ }

+ lua_pop(L, 1);

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

+ if (lua_type(L, -1) == LUA_TTABLE) {

+ std::vector< boost::shared_ptr<PubSubEventRetract> > items;

+ for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

+ lua_pushnumber(L, i + 1);

+ lua_gettable(L, -2);

+ if (!lua_isnil(L, -1)) {

+ if (boost::shared_ptr<PubSubEventRetract> payload = boost::dynamic_pointer_cast<PubSubEventRetract>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_retract"))) {

+ items.push_back(payload);

+ }

+ }

+ lua_pop(L, 1);

+ }

+ result->setRetracts(items);

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ if (!payload->getItems().empty()) {

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

+ {

+ int i = 0;

+ foreach(boost::shared_ptr<PubSubEventItem> item, payload->getItems()) {

+ if (convertors->convertToLuaUntyped(L, item) > 0) {

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

+ ++i;

+ }

+ }

+ }

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

+ }

+ if (!payload->getRetracts().empty()) {

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

+ {

+ int i = 0;

+ foreach(boost::shared_ptr<PubSubEventRetract> item, payload->getRetracts()) {

+ if (convertors->convertToLuaUntyped(L, item) > 0) {

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

+ ++i;

+ }

+ }

+ }

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

+ }

+ return Documentation(

+ "PubSubEventItems",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ "- `items`: array<@{PubSubEventItem}>\n"

+ "- `retracts`: array<@{PubSubEventRetract}>\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventItemsConvertor : public GenericLuaElementConvertor<PubSubEventItems> {

+ public:

+ PubSubEventItemsConvertor(LuaElementConvertors* convertors);

+ virtual ~PubSubEventItemsConvertor();

+ virtual boost::shared_ptr<PubSubEventItems> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

+ virtual void doConvertToLua(lua_State*, boost::shared_ptr<PubSubEventItems>) SWIFTEN_OVERRIDE;

+ virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

+ private:

+ LuaElementConvertors* convertors;

+ };

+ GenericLuaElementConvertor<PubSubEventPurge>("pubsub_event_purge") {

+ boost::shared_ptr<PubSubEventPurge> result = boost::make_shared<PubSubEventPurge>();

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

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

+ result->setNode(std::string(lua_tostring(L, -1)));

+ }

+ lua_pop(L, 1);

+ return result;

+ lua_createtable(L, 0, 0);

+ lua_pushstring(L, payload->getNode().c_str());

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

+ return Documentation(

+ "PubSubEventPurge",

+ "This table has the following fields:\n\n"

+ "- `node`: string\n"

+ );

+ class LuaElementConvertors;

+ class PubSubEventPurgeConvertor : public GenericLuaElementConvertor<PubSubEventPurge> {

+ public:

+ PubSubEventPurgeConvertor();