void NTPClient::query(const boost::asio::ip::udp::resolver::query &query) { m_response.reset(); shared_ptr<ConnectionScope> scope(OS_NEW ConnectionScope(m_service, get_this_ptr())); scope->extendTimeout(boost::posix_time::milliseconds(m_timeout)); m_resolver->async_resolve(query, boost::bind(&NTPClient::resolveCallback, get_this_ptr(), boost::asio::placeholders::error, boost::asio::placeholders::iterator, scope)); }
shared_ptr<IRCRoom::UserDetails> IRCRoom::ensureUser(shared_ptr<IRCUser> user) { if(user == nullptr) { OS_ASSERTFALSE(); return nullptr; } OS_LOCK(*m_cs); shared_ptr<IRCRoom::UserDetails> userDetails; Users::iterator i = m_users.find(user->getID()); if(i != m_users.end()) { userDetails = i->second.second; } else { userDetails.reset(OS_NEW UserDetails(get_this_ptr(), m_cs)); m_users[user->getID()] = std::make_pair(user, userDetails); m_modified = true; } OS_ASSERT(userDetails != nullptr); return userDetails; }
shared_ptr<IRCConnection> IRCSession::openConnection(shared_ptr<TCPSocket> socket) { if(socket == nullptr) { OS_ASSERTFALSE(); return nullptr; } OS_LOCK(m_dataCS); shared_ptr<IRCConnection> connection = m_connection.lock(); if(connection != nullptr) return connection; shared_ptr<ConnectionsManager> connectionsManager = m_connectionsManager.lock(); if(connectionsManager == nullptr) return nullptr; clear(); initLoginRequest(); connection.reset(OS_NEW IRCConnection(get_this_ptr(), socket, connectionsManager)); connectionsManager->addConnection(connection, true); m_connection = connection; return connection; }
bool IRCSession::requestChannelsList() { std::string command; command.append("LIST"); command.append(OS_IRC_COMMANDS_TERMINATOR); return addRequest(shared_ptr<IIRCCommand>(OS_NEW IRCCommandRaw(get_this_ptr(), command)), true); }
void IRCSession::notifyCommand(shared_ptr<IIRCCommand> command) { OS_ASSERT(command != nullptr); OS_ASSERT(command->getSession() == get_this_ptr()); OS_LOCK(m_signalsCS); m_commandsSignal(command); }
void IRCRoom::notifyModified(const boost::signal<void (shared_ptr<IRCRoom>)> &callback, bool force) { OS_LOCK(*m_cs); if(m_modified || force) { m_modified = false; callback(get_this_ptr()); } }
shared_ptr<LanguageCulture> LanguageCulture::addCulture(const String &id) { Cultures::const_iterator i = m_cultures.find(String(id).to_lower()); if(i != m_cultures.end()) return i->second; shared_ptr<LanguageCulture> culture(OS_NEW LanguageCulture(get_this_ptr())); m_cultures[String(id).to_lower()] = culture; return culture; }
bool IHttpDirectory::addDirectory(shared_ptr<IHttpDirectory> directory) { OS_LOCK(m_cs); if(directory == nullptr) return false; OS_EXCEPT_IF(hasDirectory(directory->getName()), "Duplicated directory"); directory->m_parent = get_this_ptr(); m_directories.push_back(directory->getName(), directory); return true; }
bool IRCSession::leaveChannel(const std::string &channel) { if(channel.empty()) { OS_ASSERTFALSE(); return false; } std::string command; command.append("PART " + channel); command.append(OS_IRC_COMMANDS_TERMINATOR); return addRequest(shared_ptr<IIRCCommand>(OS_NEW IRCCommandRaw(get_this_ptr(), command)), true); }
bool LanguageCulture::getTranslationDerivedAvaible() { shared_ptr<LanguageCulture> current = get_this_ptr(); for(;;) { if( (current == nullptr) || (current->getID() == _S("inv")) ) return false; if(current->getTranslationAvaible()) return true; current = current->getParent(); } return false; }
void OMLItem::add(shared_ptr<OMLItem> i) { // Qui compatto + tag "text" consecutivi. Soprattutto per fare che un // http://www.alfa[beta]gamma.com venga rappresentato in un'unico 'item', per far s che le regex lo individuino. if(i->getTagName() == OMLItem::ITEM_TAG_TEXT) { if( (m_lastAdded) && (m_lastAdded->getTagName() == OMLItem::ITEM_TAG_TEXT) ) { m_lastAdded->setParam(OMLItem::ITEM_PARAM_TEXT, m_lastAdded->getParam(OMLItem::ITEM_PARAM_TEXT) + i->getParam(OMLItem::ITEM_PARAM_TEXT)); return; } } i->m_parent = get_this_ptr(); m_childs.push_back(i); m_lastAdded = i; }
bool IRCSession::handleResponse(const std::string &command) { IRCParser parser; shared_ptr<IIRCCommand> response = parser.parse(get_this_ptr(), command); if(response != nullptr) { processResponse(response); notifyCommand(response); shared_ptr<IIRCCommand> reply = response->getReply(); if(reply != nullptr) addRequest(reply, false); } else { OS_LOG_DEBUG(_S("Unknown IRC command '") + command + _S("'")); } return parser.getAlive(); }
HttpPath IHttpDirectory::getPath() const { OS_LOCK(m_cs); String path; shared_ptr<const IHttpDirectory> directory = get_this_ptr(); while(directory != nullptr) { String name = directory->getName(); OS_ASSERT((name.empty() == false) || (directory->getParent() == nullptr)); if(name.empty() == false) path.insert(0, (OS_HTTP_PATH_SEPARATOR + name).c_str()); directory = directory->getParent(); } return path; }
shared_ptr<IRCChannel> IRCSession::ensureChannel(const std::string &name) { OS_LOCK(m_dataCS); shared_ptr<IRCChannel> channel; Channels::const_iterator i = m_channels.find(name); if(i != m_channels.end()) { channel = i->second; } else { channel.reset(OS_NEW IRCChannel(get_this_ptr(), name)); m_channels[name] = channel; } OS_ASSERT(channel != nullptr); return channel; }
shared_ptr<IRCUser> IRCSession::ensureUser(const std::string &name) { OS_LOCK(m_dataCS); shared_ptr<IRCUser> user; Users::const_iterator i = m_users.find(name); if(i != m_users.end()) { user = i->second; } else { user.reset(OS_NEW IRCUser(get_this_ptr(), m_usersID)); m_users[name] = user; m_usersID++; } OS_ASSERT(user != nullptr); return user; }
bool IRCSession::initLoginRequest() { std::string nick = getNick(); std::string user = getUser(); if(user.empty()) user = nick; std::string clientName = getClientName(); OS_ASSERT(nick.empty() == false); OS_ASSERT(user.empty() == false); OS_ASSERT(clientName.empty() == false); std::string command; command.append("PASS NOPASS"); command.append(OS_IRC_COMMANDS_TERMINATOR); command.append("NICK " + nick); command.append(OS_IRC_COMMANDS_TERMINATOR); command.append("USER " + user + " USING " + clientName + " :" + nick); command.append(OS_IRC_COMMANDS_TERMINATOR); return addRequest(shared_ptr<IIRCCommand>(OS_NEW IRCCommandRaw(get_this_ptr(), command)), false); }
void NTPClient::requestCallback(const boost::system::error_code &e, size_t transferredBytes, shared_ptr<ConnectionScope> scope) { scope->cancelTimeout(); if(e) throw boost::system::system_error(e); if(transferredBytes != sizeof(Packet)) OS_EXCEPTION("request error"); OS_ZEROMEMORY(&m_responsePacket, sizeof(FullPacket)); boost::asio::ip::udp::endpoint localEndpoint; m_socket->async_receive_from(boost::asio::buffer(&m_responsePacket, sizeof(FullPacket)), localEndpoint, boost::bind(&NTPClient::responseCallback, get_this_ptr(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, NTPTime::GetCurrentTime(), scope->extendTimeout())); }
void NTPClient::resolveCallback(const boost::system::error_code &e, boost::asio::ip::udp::resolver::iterator endpoint, shared_ptr<ConnectionScope> scope) { scope->cancelTimeout(); if(e) throw boost::system::system_error(e); OS_ZEROMEMORY(&m_requestPacket, sizeof(Packet)); m_requestPacket.liVnMode = 27; //Encoded representation which represents NTP Client Request & NTP version 3.0 (i.e. LI=0, VN=3, Mode=3) m_requestPacket.transmit_time = NTPTime::GetCurrentTime(); m_socket->async_send_to(boost::asio::buffer(&m_requestPacket, sizeof(Packet)), *endpoint, boost::bind(&NTPClient::requestCallback, get_this_ptr(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, scope->extendTimeout())); }
void LanguageCulture::parse(shared_ptr<XMLNode> node) { if(node->getName() == _S("culture")) { m_id = node->getAttributeString(_S("id")); m_englishName = node->getAttributeString(_S("englishName")); m_nativeName = node->getAttributeString(_S("nativeName")); m_isNeutralCulture = conversions::from_utf16<bool>(node->getAttributeString(_S("isNeutralCulture"))); m_defaultNotNeutral = node->getAttributeString(_S("defaultNotNeutral")); m_isoName = node->getAttributeString(_S("isoName")); m_lcid = conversions::from_utf16<uint32>(node->getAttributeString(_S("LCID"))); m_defaultTimeOffset = conversions::from_utf16<int32>(node->getAttributeString(_S("defaultTimeOffset"))); LanguageManager::instance()->getCultures()[String(getID()).to_lower()] = get_this_ptr(); shared_ptr<XMLNode> nodeCultures = node->getNode(_S("cultures")); if(nodeCultures != nullptr) { shared_ptr<XMLNodes> childs = nodeCultures->getNodes(); for(XMLNodes::const_iterator i = childs->begin(); i != childs->end(); ++i) { shared_ptr<XMLNode> subNode = *i; OS_ASSERT(subNode->getName() == _S("culture")); shared_ptr<LanguageCulture> subCulture(OS_NEW LanguageCulture(get_this_ptr())); subCulture->parse(subNode); m_cultures[String(subCulture->getID()).to_lower()] = subCulture; } } shared_ptr<XMLNode> nodeDataTimeFormatInfo = node->getNode(_S("dateTimeFormatInfo")); if(nodeDataTimeFormatInfo != nullptr) { //m_calendarWeekRule = nodeDataTimeFormatInfo->getAttributeString(_S("calendarWeekRule")); //m_dateSeparator = nodeDataTimeFormatInfo->getAttributeString(_S("dateSeparator")); //m_timeSeparator = nodeDataTimeFormatInfo->getAttributeString(_S("timeSeparator")); m_amDesignator = nodeDataTimeFormatInfo->getAttributeString(_S("amDesignator")); m_pmDesignator = nodeDataTimeFormatInfo->getAttributeString(_S("pmDesignator")); m_longDatePattern = nodeDataTimeFormatInfo->getAttributeString(_S("longDatePattern")); m_shortDatePattern = nodeDataTimeFormatInfo->getAttributeString(_S("shortDatePattern")); m_longTimePattern = nodeDataTimeFormatInfo->getAttributeString(_S("longTimePattern")); m_shortTimePattern = nodeDataTimeFormatInfo->getAttributeString(_S("shortTimePattern")); shared_ptr<XMLNode> nodeDayNames = nodeDataTimeFormatInfo->getNode(_S("dayNames")); if(nodeDayNames != nullptr) { shared_ptr<XMLNodes> childs = nodeDayNames->getNodes(); for(XMLNodes::const_iterator i = childs->begin(); i != childs->end(); ++i) { shared_ptr<XMLNode> nodeDayName = *i; uint32 index = conversions::from_utf16<uint32>(nodeDayName->getAttributeString(_S("index"))); String name = nodeDayName->getAttributeString(_S("name")); String abbreviated = nodeDayName->getAttributeString(_S("abbreviated")); OS_ASSERT(index < 7); m_dayNamesLong[index] = name; m_dayNamesShort[index] = abbreviated; } } shared_ptr<XMLNode> nodeMonthNames = nodeDataTimeFormatInfo->getNode(_S("monthNames")); { shared_ptr<XMLNodes> childs = nodeMonthNames->getNodes(); for(XMLNodes::const_iterator i = childs->begin(); i != childs->end(); ++i) { shared_ptr<XMLNode> nodeMonthName = *i; uint32 index = conversions::from_utf16<uint32>(nodeMonthName->getAttributeString(_S("index"))); String name = nodeMonthName->getAttributeString(_S("name")); String abbreviated = nodeMonthName->getAttributeString(_S("abbreviated")); OS_ASSERT(index < 12); m_monthNamesLong[index] = name; m_monthNamesShort[index] = abbreviated; } } } } }
void ExtensionsExtension::executeContexts(bool loaded) { for(CodeContexts::const_iterator i = m_contexts.begin(); i != m_contexts.end(); (*i)->execute(get_this_ptr(), loaded), ++i); }
bool ExtensionsExtension::init(const ExtensionID &id, const Path &path) { OS_ASSERT(path.empty() == false); OS_ASSERT(m_path.empty()); m_path = path; //String filename = utils::makeFilePath(path, id.toUTF16() + ".xml"); // 0.13 String filename = utils::makeFilePath(path, OS_MANIFESTXML); // 0.14 if(FileSystem::instance()->fileExists(filename) == false) return false; shared_ptr<XMLDocument> document(OS_NEW XMLDocument(XMLSchema::fromFile(utils::makeFilePath(utils::makeFolderPath(Options::instance()->getSharePath(), OS_SCHEMAS_PATH), OS_EXTENSIONS_EXTENSION_SCHEMA)))); if(document->parseFile(filename) == false) return false; String languagesPath = utils::makeFolderPath(path.path(), OS_LANGUAGES_PATH); if(FileSystem::instance()->directoryExists(languagesPath)) { m_languageFolder.reset(OS_NEW LanguageFolder()); m_languageFolder->addPath(languagesPath); } String htdocsPath = utils::makeFolderPath(path.path(), OS_HTDOCS_PATH); if(FileSystem::instance()->directoryExists(htdocsPath)) { // TODO: Qui dovrei fare un'opzione a livello di xml extension, che stabilisce il nome della virtual-directory. Se omesso, è l'ID. // Per ora, forzo l'unico caso in cui mi servirebbe. String virtualName = id.toUTF16(); if(id.toUTF16() == OS_EXTENSIONS_CORE) virtualName = OS_HTDOCS_PATH; m_httpDirectory.reset(OS_NEW HttpPhysicalDirectory(virtualName, htdocsPath)); } // Auto-discovery IdeSkinSimple String skinsPath = utils::makeFolderPath(path.path(), "skins"); { if(FileSystem::instance()->directoryExists(skinsPath)) { StringList skins; FileSystem::instance()->getFiles(skinsPath, skins, false); for(StringList::const_iterator i = skins.begin(); i != skins.end(); ++i) { String config = "/skins/" + *i; String title = FileSystem::instance()->getFileTitle(*i); shared_ptr<IdeSkinSimple> skin(OS_NEW IdeSkinSimple()); if(skin->init(get_this_ptr(), config, title)) m_skins.push_back(skin); } } } shared_ptr<XMLNode> root = document->getRoot(); if(root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_ID) != id.getString()) // Ensure that the directory name is equal to ID. return false; m_id = id; m_name = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_NAME); m_description = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_DESCRIPTION); m_content = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_CONTENT); m_category = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_CATEGORY); m_tags = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_TAGS); m_trust = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_TRUST); m_author = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_AUTHOR); m_versionCode = root->getAttributeInt32(OS_EXTENSION_XML_NODE_ROOT_VERSION_CODE); m_versionName = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_VERSION_NAME); m_compatibility = root->getAttributeInt32(OS_EXTENSION_XML_NODE_ROOT_COMPATIBILITY); /* if(m_version.fromString(root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_VERSION).to_ascii()) == false) return false; String compatibility = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_COMPATIBILITY); if( (compatibility.empty() == false) && (m_compatibility.fromString(compatibility.to_ascii()) == false) ) return false; */ m_homepage = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_HOMEPAGE); m_icon = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_ICON); m_logo = root->getAttributeString(OS_EXTENSION_XML_NODE_ROOT_LOGO); NotificationsManager::instance()->notify(_S("Loading extension: ") + m_name); shared_ptr<XMLNode> nodeFiles = document->getRoot()->getNode(OS_EXTENSION_XML_NODE_SCRIPTS); if(nodeFiles != nullptr) { shared_ptr<XMLNodes> files = nodeFiles->getNodes(); for(XMLNodes::const_iterator i = files->begin(); i != files->end(); ++i) { String scriptPath = utils::makeFilePath(path, (*i)->getAttributeString(OS_EXTENSION_XML_NODE_SCRIPT_PATH)); String scriptLanguage = (*i)->getAttributeString(OS_EXTENSION_XML_NODE_SCRIPT_LANGUAGE); shared_ptr<IExtensionsCodeProvider> codeProvider = ExtensionsSystem::instance()->getCodeProvider(scriptLanguage); if(codeProvider == nullptr) { OS_LOG_ERROR(_S("Invalid script language '") + scriptLanguage + _S("'")); return false; } shared_ptr<IExtensionsCodeContext> context = codeProvider->createContext(); if(context == nullptr) { OS_LOG_ERROR(_S("Cannot create context for script language '") + scriptLanguage + _S("'")); return false; } if(context->parseFile(scriptPath)) m_contexts.push_back(context); else OS_LOG_ERROR(_S("Cannot parse extension file '") + scriptPath + _S("'")); } } return true; }
String OMLItem::getOsml(shared_ptr<OMLContext> context) { return OMLManager::instance()->processItemForOsml(get_this_ptr(), context); }
String OMLItem::getHtml(shared_ptr<OMLContext> context) { // Chiedo al Manager di convertilo. return OMLManager::instance()->processItemForHtml(get_this_ptr(), context); }