/* Function : onLeaderVersion * Arguments : stream - socket, through which the data is received and sent * Description: handler of REPLICATION_LEADER_VERSION command; comparing the * received version to the local one and downloading the replica * from the remote replication daemon when the received version is * better than the local one and there is no downloading * 'condor_transferer' running at the same time */ void ReplicatorStateMachine::onLeaderVersion( Stream* stream ) { dprintf( D_ALWAYS, "ReplicatorStateMachine::onLeaderVersion started\n" ); if( m_state != BACKUP ) { return ; } checkVersionSynchronization( ); Version* newVersion = decodeVersionAndState( stream ); // comparing the received version to the local one bool downloadNeeded = replicaSelectionHandler( *newVersion ); // downloading the replica from the remote replication daemon, when the // received version is better and there is no running downloading // 'condor_transferers' if( downloadTransferersNumber( ) == 0 && newVersion && downloadNeeded ) { dprintf( D_FULLDEBUG, "ReplicatorStateMachine::onLeaderVersion " "downloading from %s\n", newVersion->getSinfulString( ).Value( ) ); download( newVersion->getSinfulString( ).Value( ) ); } // replication leader must not send a version which hasn't been updated //assert(downloadNeeded); //REPLICATION_ASSERT(downloadNeeded); delete newVersion; }
/* Function : decodeVersionAndState * Arguments : stream - socket, through which the data is received * Description: receives remote replication daemon version and state from the * given socket */ Version* ReplicatorStateMachine::decodeVersionAndState( Stream* stream ) { Version* newVersion = new Version; // decode remote replication daemon version if( ! newVersion->decode( stream ) ) { dprintf( D_ALWAYS, "ReplicatorStateMachine::decodeVersionAndState " "cannot read remote daemon version\n" ); delete newVersion; return 0; } int remoteReplicatorState; stream->decode( ); // decode remore replication daemon state if( ! stream->code( remoteReplicatorState ) ) { dprintf( D_ALWAYS, "ReplicatorStateMachine::decodeVersionAndState " "unable to decode the state\n" ); delete newVersion; return 0; } newVersion->setState( ReplicatorState( remoteReplicatorState ) ); return newVersion; //updateVersionsList( *newVersion ); }
/* Function : versionRequestingTimer * Description: timer, expiration of which means stopping collecting the pool * versions in VERSION_REQUESTING state, passing to * VERSION_DOWNLOADING state and starting downloading from the * machine with the best version */ void ReplicatorStateMachine::versionRequestingTimer( ) { dprintf( D_ALWAYS, "ReplicatorStateMachine::versionRequestingTimer started\n" ); utilCancelTimer(m_versionRequestingTimerId); dprintf( D_FULLDEBUG, "ReplicatorStateMachine::versionRequestingTimer " "cancelling version requesting timer\n" ); m_state = VERSION_DOWNLOADING; // selecting the best version amongst all the versions that have been sent // by other replication daemons Version updatedVersion; if( replicaSelectionHandler( updatedVersion ) ) { download( updatedVersion.getSinfulString( ).Value( ) ); dprintf( D_FULLDEBUG, "ReplicatorStateMachine::versionRequestingTimer " "registering version downloading timer\n" ); m_versionDownloadingTimerId = daemonCore->Register_Timer( m_maxTransfererLifeTime, (TimerHandlercpp) &ReplicatorStateMachine::versionDownloadingTimer, "Time to pass to BACKUP state", this ); } else { versionDownloadingTimer( ); } }
// ============================================================================= Common::Result Client::handle_command(Protocol::Packet &packet, Common::ByteArray &payload, uint16_t offset) { Common::Result result = Common::Result::OK; CMD cmd = static_cast<CMD>(packet.message.itf.member); switch (cmd) { case NEW_VERSION_AVAILABLE_CMD /* CHECK_VERSION_CMD */: { if (packet.message.isCommand()) { Version version; uint16_t size = version.unpack(payload, offset); /* *INDENT-OFF* */ HF_ASSERT(size != 0, {result = Common::Result::FAIL_ARG;}); /* *INDENT-ON* */ auto code = new_version_available(packet.source, version); Protocol::Response response; response.code = static_cast<Common::Result>(code); Protocol::Message message(packet.message, response.size()); response.pack(message.payload); send(packet.source, message); }
void LoadVersionV1(TiXmlElement *verNode, Package *pkg) { const char *name = verNode->Attribute("name"); if(!name) name = ""; Version *ver = new Version(name, pkg); unique_ptr<Version> ptr(ver); const char *author = verNode->Attribute("author"); if(author) ver->setAuthor(author); const char *time = verNode->Attribute("time"); if(time) ver->setTime(time); TiXmlElement *node = verNode->FirstChildElement("source"); while(node) { LoadSourceV1(node, ver); node = node->NextSiblingElement("source"); } node = verNode->FirstChildElement("changelog"); if(node) { if(const char *changelog = node->GetText()) ver->setChangelog(changelog); } if(pkg->addVersion(ver)) ptr.release(); }
UpdateCheckerDlg::UpdateCheckerDlg(Update_Status updateStatus, const Version& latestVersion, CWnd* pParent /*=nullptr*/) : CDialog(UpdateCheckerDlg::IDD, pParent) , m_updateStatus(updateStatus) { switch (updateStatus) { case UPDATER_UPDATE_AVAILABLE: case UPDATER_UPDATE_AVAILABLE_IGNORED: m_text.Format(IDS_NEW_UPDATE_AVAILABLE, latestVersion.ToString(), UpdateChecker::MPC_HC_VERSION.ToString()); break; case UPDATER_LATEST_STABLE: m_text.LoadString(IDS_USING_LATEST_STABLE); break; case UPDATER_NEWER_VERSION: m_text.Format(IDS_USING_NEWER_VERSION, UpdateChecker::MPC_HC_VERSION.ToString(), latestVersion.ToString()); break; case UPDATER_ERROR: m_text.LoadString(IDS_UPDATE_ERROR); break; default: ASSERT(0); // should never happen } }
Version::Version(const Version &other) { m_major = other.getMajor(); m_minor = other.getMinor(); m_mini = other.getMini(); m_build = other.getBuild(); }
void UpdateChecker::finished(QNetworkReply* reply_){ if(reply_->error() != QNetworkReply::NoError){ emit error(reply_->errorString()); }else{ Version last = RaptorVersion; QDomDocument document; if(document.setContent(reply_->readAll())){ const QDomNodeList entries = document.elementsByTagName("entry"); for(int i = 0; i < entries.count(); i++) { const QDomElement element = entries.at(i).toElement(); QDomNodeList nodes = element.elementsByTagName("title"); for (int i = 0; i < nodes.count(); i++) { const QDomElement elem = nodes.at(i).toElement(); QString filename = elem.firstChild().toText().data().trimmed(); QRegExp rx("raptor-.*([\\d\\.\\d\\.\\d]{1,}).*"); if(rx.exactMatch(filename)){ Version found(rx.cap(1)); if(last < found) last = found; } } } } emit lastVersion(last.getVersion()); } }
bool XmlConfigurationConverter::updateDocument(XmlDocument* document, std::string dtd, const Version& version, std::string rootElementName) { // update root element name XmlElement* root = document->getRootElement(); if (!root) { return false; } // if root->setName(rootElementName); // update version entry in root element if (root->hasAttribute("version")) { root->getAttribute("version")->setValue(version.toString()); } // if else { XmlAttribute* versionAttribute = new XmlAttribute("version", version.toString()); root->addAttribute(versionAttribute); } // else // update dtd reference XmlDtdReference* dtdRef = document->getDtd(); if (!dtdRef) { dtdRef = new XmlDtdReference(rootElementName, dtd); document->setDtd(dtdRef); } else { dtdRef->setName(rootElementName); dtdRef->setDtd(dtd); } // else return true; } // updateRootElement
Bool Version::operator>(const Version& other) const { const auto shortes = __min(m_parts.size(), other.GetPartsCount()); for (SizeT i = 0; i < shortes; i++) { if (m_parts[i] > other[i]) { return True; } if (m_parts[i] < other[i]) { return False; } } if (other.GetPartsCount() > m_parts.size()) { return False; } for (SizeT i = shortes; i < m_parts.size(); i++) { if (m_parts[i] != 0) { return True; } } return False; }
QList<Update *> AppcastMinSysUpdateFilter::filter(const QList<Update *> candidates) { QList<Update *> filtered; foreach (Update *candidate, candidates) { AppcastUpdate *update = qobject_cast<AppcastUpdate *>(candidate); if (update) { Version systemVersion = d_ptr->sysVersion; Version minSystemVersion(update->minSysVersion()); if (!systemVersion.isValid()) { // An unknown system is typically a newer version of the OS than // what was available at the time the application was built. // Assume compatiblity until proven otherwise. filtered.append(candidate); continue; } if (!minSystemVersion.isValid()) { // The minimum version was not specified, which means any // version is acceptable. filtered.append(candidate); continue; } if (systemVersion >= minSystemVersion) { filtered.append(candidate); continue; } } else { // This is not a type understood by this filter. Let it through so // other filters in the chain get a chance to handle it. filtered.append(candidate); continue; } }
Version Popt::getVersion(const Package &p, VersionFlag vf, bool versionMustExist) { if(_args.empty()) { switch(vf) { case NO_DEFAULT: // No default, skip to the popArg call below which // will trigger the appropriate error. break; case INSTALLED: if(p.isInstalled()) { return p.getInstalledVersion(); // exists per definition } break; // Fall through to popArg case INSTALLED_OR_CURRENT: if(p.isInstalled()) { return p.getInstalledVersion(); // exists per definition } // fall through to next case case CURRENT: if(p.hasVersions()) { return p.getRecentVersion(); // Exists per definition } break; // Fall through to popArg case NONE_NEEDED: // Ignores versionMustExist, caller has to handle this, // but at least we do not return an invalid version just an empty // one, the caller can easily distinct them. return Version::EMPTY_VERSION; } } const Version v(popArg("missing version")); if(v.isEmptyVersion() || versionMustExist) { p.checkVersionExists(v); } return v; }
void VersionManager::addVersion_Click(){ if (askSaveChangeds()){ currentVersionChanged_ = false; } else { return; } bool ok; QString name; Version *vers = new Version(); name = QInputDialog::getText(this, tr("Add version"), tr("Version name:"), QLineEdit::Normal, "", &ok); if (ok && !name.isEmpty()){ vers->name_ = name; while (vers->load()){ name = QInputDialog::getText(this, tr("Add version"), tr("Sorry. It seems that the version name already exists.<br>Please choose another version name."), QLineEdit::Normal, name, &ok); if (!ok || name.isEmpty()) break; vers->clear(); vers->name_ = name; } if (vers->save()){ getVersions(); setVersionFocus(vers->name_); currentVersionChanged_ = true; } } }
bool Version::TryParse(const StringRef& versionString, Version& outVersion) { outVersion = Version::Zero; List<HeapString> parts; StringParser::Split(versionString, StringRef("."), parts); uint length = (uint)parts.Count(); RETURN_FALSE_IF(length < 2 || length>4); long outMajor; if (parts[0].TryParseInt(outMajor)) { outVersion.SetMajor((uint)outMajor); } else { return false; } long outMinor; if (parts[1].TryParseInt(outMinor)) { outVersion.SetMinor((uint)outMinor); } else { return false; } length -= 2; if (length > 0) { long outBuild; if (parts[2].TryParseInt(outBuild)) { outVersion.SetBuild((uint)outBuild); } else { return false; } --length; if (length > 0) { long outRevision; if (parts[3].TryParseInt(outRevision)) { outVersion.SetRevision((uint)outRevision); } else { return false; } } } return true; }
void PrefixSettings::txtRunString_Changed(){ QString run_string = txtRunString->toPlainText().replace("\"", "\\\""); QString console_bin = CoreLib->getSetting("console", "bin").toString(); QString console_args = CoreLib->getSetting("console", "args", false).toString(); if (console_bin.split("/").last() == "konsole"){ console_args.append(" /bin/sh -c "); } run_string.replace("%CONSOLE_BIN%", console_bin); run_string.replace("%CONSOLE_ARGS%", QString("%1 \"").arg(console_args)); Version ver; if (!txtWineBin->text().isEmpty()){ ver.wine_exec_ = txtWineBin->text(); ver.wine_loader_ = txtWineLoaderBin->text(); ver.wine_server_ = txtWineServerBin->text(); ver.wine_dllpath32_ = txtWineLibs->text(); ver.wine_dllpath64_ = txtWineLibs->text(); } else { ver.clear(); ver.name_ = comboVersionList->currentText(); if (!ver.load()){ QMessageBox::critical(this, tr("Error"), tr("Unable to load version by name: %1").arg(ver.name_)); return; } } QString env; env.append(QString(" WINE='%1' ").arg(ver.wine_exec_)); env.append(QString(" WINEPREFIX='%1' ").arg(txtPrefixPath->text())); env.append(QString(" WINESERVER='%1' ").arg(ver.wine_server_)); env.append(QString(" WINELOADER='%1' ").arg(ver.wine_loader_)); if (comboArchList->currentText()=="win64"){ env.append(QString(" WINEDLLPATH='%1' ").arg(ver.wine_dllpath64_)); } else if (comboArchList->currentText()=="win32"){ env.append(QString(" WINEDLLPATH='%1' ").arg(ver.wine_dllpath32_)); } env.append(QString(" WINEARCH='%1' ").arg(comboArchList->currentText())); env.append(QString(" WINEDEBUG='%1' ").arg("-all")); env.append(QString(" WINEDLLOVERRIDES='' ")); env.append(QString(" LANG='' ")); run_string.replace("%ENV_BIN%", CoreLib->getWhichOut("env")); run_string.replace("%ENV_ARGS%", env); run_string.replace("%WORK_DIR%", QString("cd \'%1\' &&").arg(QDir::homePath())); run_string.replace("%SET_NICE%", QString("%1 -n 10").arg(CoreLib->getSetting("system", "nice", false).toString())); run_string.replace("%WINE_BIN%", ver.wine_exec_); run_string.replace("%VIRTUAL_DESKTOP%", " explorer.exe /desktop=winecfg,800x600 "); run_string.replace("%PROGRAM_BIN%", "\'winecfg\'"); run_string.replace("%PROGRAM_ARGS%", "-h"); run_string.append(" \""); lblTemalate->setText(run_string); }
Ref<DetectorResult> Detector::processFinderPatternInfo(Ref<FinderPatternInfo> info){ Ref<FinderPattern> topLeft(info->getTopLeft()); Ref<FinderPattern> topRight(info->getTopRight()); Ref<FinderPattern> bottomLeft(info->getBottomLeft()); float moduleSize = calculateModuleSize(topLeft, topRight, bottomLeft); if (moduleSize < 1.0f) { throw zxing::ReaderException("bad module size"); } int dimension = computeDimension(topLeft, topRight, bottomLeft, moduleSize); Version *provisionalVersion = Version::getProvisionalVersionForDimension(dimension); int modulesBetweenFPCenters = provisionalVersion->getDimensionForVersion() - 7; Ref<AlignmentPattern> alignmentPattern; // Anything above version 1 has an alignment pattern if (provisionalVersion->getAlignmentPatternCenters().size() > 0) { // Guess where a "bottom right" finder pattern would have been float bottomRightX = topRight->getX() - topLeft->getX() + bottomLeft->getX(); float bottomRightY = topRight->getY() - topLeft->getY() + bottomLeft->getY(); // Estimate that alignment pattern is closer by 3 modules // from "bottom right" to known top left location float correctionToTopLeft = 1.0f - 3.0f / (float)modulesBetweenFPCenters; int estAlignmentX = (int)(topLeft->getX() + correctionToTopLeft * (bottomRightX - topLeft->getX())); int estAlignmentY = (int)(topLeft->getY() + correctionToTopLeft * (bottomRightY - topLeft->getY())); // Kind of arbitrary -- expand search radius before giving up for (int i = 4; i <= 16; i <<= 1) { try { alignmentPattern = findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, (float)i); break; } catch (zxing::ReaderException const& re) { (void)re; // try next round } } if (alignmentPattern == 0) { // Try anyway } } Ref<PerspectiveTransform> transform = createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension); Ref<BitMatrix> bits(sampleGrid(image_, dimension, transform)); ArrayRef< Ref<ResultPoint> > points(new Array< Ref<ResultPoint> >(alignmentPattern == 0 ? 3 : 4)); points[0].reset(bottomLeft); points[1].reset(topLeft); points[2].reset(topRight); if (alignmentPattern != 0) { points[3].reset(alignmentPattern); } Ref<DetectorResult> result(new DetectorResult(bits, points)); return result; }
Version::Version(const Version& val) :mMajor(val.Major()), mMinor(val.Minor()), mBuild(val.Build()), mRevision(val.Revision()) { }
int main() { // Default pins to low status for (int i = 0; i < 5; i++){ leds[i].output(); leds[i] = (i & 1) ^ 1; } //bool sdok= (sd.disk_initialize() == 0); sd.disk_initialize(); Kernel* kernel = new Kernel(); kernel->streams->printf("Smoothie ( grbl port ) version 0.8.0-rc1 with new accel @%ldMHz\r\n", SystemCoreClock / 1000000); Version version; kernel->streams->printf(" Build version %s, Build date %s\r\n", version.get_build(), version.get_build_date()); // Create and add main modules kernel->add_module( new Laser() ); kernel->add_module( new Extruder() ); kernel->add_module( new SimpleShell() ); kernel->add_module( new Configurator() ); kernel->add_module( new CurrentControl() ); kernel->add_module( new TemperatureControlPool() ); kernel->add_module( new SwitchPool() ); kernel->add_module( new PauseButton() ); kernel->add_module( new PlayLed() ); kernel->add_module( new Endstops() ); kernel->add_module( new Player() ); kernel->add_module( new Panel() ); kernel->add_module( new Touchprobe() ); // Create and initialize USB stuff u.init(); //if(sdok) { // only do this if there is an sd disk // msc= new USBMSD(&u, &sd); // kernel->add_module( msc ); //} kernel->add_module( &msc ); kernel->add_module( &usbserial ); if( kernel->config->value( second_usb_serial_enable_checksum )->by_default(false)->as_bool() ){ kernel->add_module( new USBSerial(&u) ); } kernel->add_module( &dfu ); kernel->add_module( &u ); // clear up the config cache to save some memory kernel->config->config_cache_clear(); // Main loop while(1){ kernel->call_event(ON_MAIN_LOOP); kernel->call_event(ON_IDLE); } }
void PrefixSettings::getVersionsList(){ comboVersionList->clear(); Version ver; QList<Version> list = ver.load_all(); for (int i = 0; i < list.size(); ++i) comboVersionList->addItem(list.at(i).name_); comboVersionList->setCurrentIndex(comboVersionList->findText(version_name)); }
// P. 150 core::ResultCode BlockHeader::restoreFull(ISchema& schema, DWGBuffer& buffer, const Handle& handle, const Version& version) const { // LOG_WARNING(handle.getValue()); UnicodeString strName = buffer.readText(version); bool flag = buffer.readBit(); int xref = buffer.readBit16() - 1; bool xdep = buffer.readBit(); bool anonymous = buffer.readBit(); bool hasattr = buffer.readBit(); bool isxref = buffer.readBit(); bool isoverlaidxref = buffer.readBit(); if (version.isAtLeast(Version::R2000)) bool loadedbit = buffer.readBit(); if (version.isAtLeast(Version::R2004)) { size_t owned = buffer.readBit32(); } const double baseX = buffer.readBitDouble(); const double baseY = buffer.readBitDouble(); const double baseZ = buffer.readBitDouble(); UnicodeString strPathName = buffer.readText(version); // LOG_DEBUG(strName << " - " << strPathName << " [" << baseX << ", " << baseY << ", " << baseZ << "]"); if (version.isAtLeast(Version::R2000)) { int tot = 0; while (true) { size_t insertcount = buffer.readRaw8(); // TODO: Read until insertcount == 0??? if (insertcount == 0) break; ++tot; } UnicodeString strDescription = buffer.readText(version); const uint32_t previewSize = buffer.readBit32(); buffer.skipBytes(previewSize); if (version.isAtLeast(Version::R2007)) { const int16_t insertUnits = buffer.readBit16(); const bool isExplodable = buffer.readBit(); const char blockScaling = buffer.readRaw8(); LOG_WARNING(insertUnits << ".. " << isExplodable << " " << blockScaling); } Handle handleRefs = buffer.readHandle(); // LOG_WARNING(tot << " " << strDescription << ": " << previewSize); // LOG_WARNING(handleRefs.getCode() << ": " << handleRefs.getValue()); } return core::rcSuccess; }
void VersionsConverterManager::displayTooOldSaveError(Version const &saveVersion) { bool const showVersionDetails = saveVersion.isValid(); QString const reason = showVersionDetails ? QObject::tr("This project was created by version %1 of the editor.").arg(saveVersion.toString()) : QObject::tr("This project was created by too old version of the editor."); QString const errorMessage = reason + QObject::tr(" It is now considered outdated and cannot be opened."); showError(errorMessage); }
TEST(VersionTest, Interface) { Version V; ASSERT_TRUE(V.isNull()); ASSERT_TRUE(Version(1) < Version(1, 1)); ASSERT_TRUE(Version(1) < Version(2)); ASSERT_TRUE(Version(1, 1) < Version(2)); ASSERT_TRUE(Version(1, 1) == Version(1, 1)); ASSERT_EQ(Version(1).getMajor(), unsigned(1)); ASSERT_EQ(Version(1).getMinor(), unsigned(0)); ASSERT_EQ(Version(1, 2).getMinor(), unsigned(2)); }
static std::vector<MSVC> installedCompilers() { std::vector<MSVC> msvcs; std::vector<MSVCInstallInfo> installInfos = installedMSVCsFromVsWhere(); if (installInfos.empty()) installInfos = installedMSVCsFromRegistry(); for (const MSVCInstallInfo &installInfo : installInfos) { MSVC msvc; msvc.internalVsVersion = Version::fromString(installInfo.version, true); if (!msvc.internalVsVersion.isValid()) continue; QDir vsInstallDir(installInfo.installDir); msvc.vsInstallPath = vsInstallDir.absolutePath(); if (vsInstallDir.dirName() != QStringLiteral("VC") && !vsInstallDir.cd(QStringLiteral("VC"))) { continue; } msvc.version = QString::number(Internal::VisualStudioVersionInfo( msvc.internalVsVersion).marketingVersion()); if (msvc.version.isEmpty()) { qbsWarning() << Tr::tr("Unknown MSVC version %1 found.").arg(installInfo.version); continue; } if (msvc.internalVsVersion.majorVersion() < 15) { QDir vcInstallDir = vsInstallDir; if (!vcInstallDir.cd(QStringLiteral("bin"))) continue; msvc.vcInstallPath = vcInstallDir.absolutePath(); msvcs.push_back(msvc); } else { QDir vcInstallDir = vsInstallDir; vcInstallDir.cd(QStringLiteral("Tools/MSVC")); const auto vcVersionStrs = vcInstallDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot); for (const QString &vcVersionStr : vcVersionStrs) { const Version vcVersion = Version::fromString(vcVersionStr); if (!vcVersion.isValid()) continue; QDir specificVcInstallDir = vcInstallDir; if (!specificVcInstallDir.cd(vcVersionStr) || !specificVcInstallDir.cd(QStringLiteral("bin"))) { continue; } msvc.vcInstallPath = specificVcInstallDir.absolutePath(); msvcs.push_back(msvc); } } } return msvcs; }
int main(int, char * []) { // enlist all versions std::cout << std::endl << std::endl << "[VERSIONS]" << std::endl << std::endl; std::cout << "# Versions: " << Meta::versions().size() << std::endl << std::endl; for (Version v : Meta::versions()) std::cout << v.toString() << std::endl; // enlist all enums std::cout << std::endl << std::endl << "[ENUMS]" << std::endl << std::endl; if (Meta::stringsByGL()) { std::cout << "# Enums: " << Meta::enums().size() << std::endl << std::endl; for (GLenum e : Meta::enums()) // c++ 14 ... std::cout << " (" << std::hex << std::showbase << std::internal << std::setfill('0') << std::setw(8) << static_cast<std::underlying_type<GLenum>::type>(e) << ") " << Meta::getString(e) << std::dec << std::endl; std::cout << std::dec; } else std::cout << std::endl << "warning: Enums cannot be enlisted since the glbinding used was compiled without GL_BY_STRINGS support." << std::endl; // enlist all extensions std::cout << std::endl << std::endl << "[EXTENSIONS]" << std::endl << std::endl; if (Meta::stringsByGL()) { std::cout << " # Extensions: " << Meta::extensions().size() << std::endl << std::endl; for (GLextension e : Meta::extensions()) { const Version v = Meta::getRequiringVersion(e); std::cout << " " << Meta::getString(e) << " " << (v.isNull() ? "" : v.toString()) << std::endl; } } else std::cout << std::endl << "warning: EXTENSIONS cannot be enlisted since the glbinding used was compiled without GL_BY_STRINGS support." << std::endl; // print some gl infos (query) std::cout << std::endl << "OpenGL Revision: " << Meta::glRevision() << " (gl.xml)" << std::endl << std::endl; return 0; }
StlExport::StlExport(const QUrl &baseUrl, const Version &version, QObject *parent) : QObject(parent), _manager(new QNetworkAccessManager()), _manager2(new QNetworkAccessManager()), _messageName("finfoil"), _versionSuffix("_v" + QString::number(version.Major()) + "." + QString::number(version.Minor()) + "." + QString::number(version.Revision())), _baseUrl(baseUrl) { _messageName.append(_versionSuffix); _messageName.append(".html"); }
void AbstractReplicatorStateMachine::cancelVersionsListLeader( ) { Version* version; m_versionsList.Rewind( ); while( m_versionsList.Next( version ) ) { version->setState( BACKUP ); } m_versionsList.Rewind( ); }
bool CheckVersionDiff() { bool diff = false; if(HasConnection()) { std::string js = RetrieveContent("https://api.github.com/repos/xortroll/goldleaf/releases", "application/json"); json j = json::parse(js); std::string latestid = j[0]["tag_name"].get<std::string>(); Version latestv = Version::FromString(latestid); Version currentv = Version::FromString("0.3"); diff = latestv.IsLower(currentv); } return diff; }
UpdateDialog::UpdateDialog(QWidget *parent, const Version &local, const Version &remote) : QDialog(parent), ui(new Ui::UpdateDialog) { ui->setupUi(this); m_remoteVersion = remote.toString().c_str(); ui->versionLabel->setText(QApplication::translate("UpdateDialog", "Version %1 has been released (you are using %2). Would you like to visit the download page?", 0, QApplication::UnicodeUTF8).arg(m_remoteVersion).arg(local.toString().c_str())); ui->changeView->setHtml("Loading change log .."); m_networkManager = new QNetworkAccessManager(this); connect(m_networkManager, SIGNAL(finished(QNetworkReply *)), this, SLOT(onNetworkFinished(QNetworkReply *))); m_networkReply = m_networkManager->get(QNetworkRequest(QUrl("http://www.mitsuba-renderer.org/changelog.html"))); }
Version Application::lastVersion() { if (m_versions.size() < 1) throw NoVersions(); std::map<std::string, Version>::iterator itr = m_versions.begin(); Version lastVer = itr->second; while (itr != m_versions.end()) { if (itr->second.version() > lastVer.version()) lastVer = itr->second; itr++; } return lastVer; }
// print out build version void SimpleShell::version_command( string parameters, StreamOutput *stream) { Version vers; uint32_t dev = getDeviceType(); const char *mcu = (dev & 0x00100000) ? "LPC1769" : "LPC1768"; stream->printf("Build version: %s, Build date: %s, MCU: %s, System Clock: %ldMHz\r\n", vers.get_build(), vers.get_build_date(), mcu, SystemCoreClock / 1000000); }