void PackageManager::onFinished(PackageKit::Transaction::Exit status, uint runtime) { #ifdef PACKAGEMANAGER_LOG qDebug() << Q_FUNC_INFO << status << runtime; #endif PackageKit::Transaction *t = qobject_cast<PackageKit::Transaction*>(sender()); if (sender() == m_getUpdatesTransaction) { // delete m_getUpdatesTransaction; m_getUpdatesTransaction = 0; } else if (sender() == m_getPackagesTransaction) { // delete m_getPackagesTransaction; m_getPackagesTransaction = 0; } if (t && t->role() == PackageKit::Transaction::RoleRemovePackages) { m_packManContext.setSelectedGroup(PackageKit::Transaction::GroupUnknown); refreshUpdate(); refreshInstalled(); } else if (t && t->role() == PackageKit::Transaction::RoleUpdatePackages) { m_packManContext.setSelectedGroup(PackageKit::Transaction::GroupUnknown); refreshUpdate(); refreshInstalled(); } else if (t && t->role() == PackageKit::Transaction::RoleInstallPackages) { uint group = m_packManContext.selectedGroup(); refreshCache(); // includes refreshUpdate(); refreshInstalled(); if (m_bSimulation == false) { refreshAvailable(group); } } }
MetaObjectPrivate& MetaObjectPrivate::operator=(const MetaObjectPrivate &rhs) { if (this == &rhs) return *this; { boost::recursive_mutex::scoped_lock sl(rhs._methodsMutex); _methodsNameToIdx = rhs._methodsNameToIdx; _methods = rhs._methods; } { boost::recursive_mutex::scoped_lock sl(rhs._eventsMutex); _eventsNameToIdx = rhs._eventsNameToIdx; _events = rhs._events; } { boost::recursive_mutex::scoped_lock sl(rhs._propertiesMutex); _properties = rhs._properties; } _index = rhs._index; _description = rhs._description; // cache data uses pointers to map entries and must be refreshed refreshCache(); return (*this); }
ULONG VorticalLayerCtrl::expand(ULONG nItem, BOOL bexpand /*= TRUE*/) { m_bCached = FALSE; ULONG nLine = m_pRoot->expand(nItem, TRUE, bexpand); if (bexpand) { WFX_CONDITION(nItem < m_rgCacheInfo.size()); m_rgCacheInfo[nItem].m_bexpanded = TRUE; for (int i = 0; i < nLine; i++) { WFX_CONDITION(nItem + i + 1 <= m_rgCacheInfo.size()); CacheInfo chinfo(getLayer(nItem + i + 1), TRUE); m_rgCacheInfo.insert(m_rgCacheInfo.begin() + nItem + 1, chinfo); } } else { m_rgCacheInfo[nItem].m_bexpanded = FALSE; for (int i = 0; i < nLine; i++) { WFX_CONDITION(nItem + i + 1 < m_rgCacheInfo.size()); m_rgCacheInfo.erase(m_rgCacheInfo.begin() + nItem + 1); } } refreshCache(); return m_rgCacheInfo.size(); }
char* meridian(time_t t) { // meridian refreshCache(t); if (isPM()) return "PM"; else return "AM"; }
int hourFormat12(time_t t) { // the hour for the given time in 12 hour format refreshCache(t); if( tm.Hour == 0 ) return 12; // 12 midnight else if( tm.Hour > 12) return tm.Hour - 12 ; else return tm.Hour ; }
/** * Store the simulated events in the given workspace. This clears the calculated * values * @param resultWS :: An output workspace that has all of its meta-data set up * and just needs to * be filled with events. */ void ResolutionConvolvedCrossSection::storeSimulatedEvents( const API::IMDEventWorkspace_sptr &resultWS) { auto outputWS = boost::dynamic_pointer_cast<MDEventWorkspace4>(resultWS); if (!outputWS) { throw std::invalid_argument( "ResolutionConvolvedCrossSection currently only supports 4 dimensions"); } auto iterEnd = m_simulatedEvents.end(); for (auto iter = m_simulatedEvents.begin(); iter != iterEnd; ++iter) { outputWS->addEvent(*iter); } m_simulatedEvents.clear(); // This splits up all the boxes according to split thresholds and sizes. auto threadScheduler = new ThreadSchedulerFIFO(); ThreadPool threadPool(threadScheduler); outputWS->splitAllIfNeeded(threadScheduler); threadPool.joinAll(); outputWS->refreshCache(); }
void KStandardItemListWidget::triggerCacheRefreshing() { if ((!m_dirtyContent && !m_dirtyLayout) || index() < 0) { return; } refreshCache(); const QHash<QByteArray, QVariant> values = data(); m_isExpandable = m_supportsItemExpanding && values["isExpandable"].toBool(); m_isHidden = isHidden(); m_customizedFont = customizedFont(styleOption().font); m_customizedFontMetrics = QFontMetrics(m_customizedFont); updateExpansionArea(); updateTextsCache(); updatePixmapCache(); m_dirtyLayout = false; m_dirtyContent = false; m_dirtyContentRoles.clear(); }
/** * Performs centre-point rebinning and produces an MDWorkspace * @param inputWs : The workspace you wish to perform centre-point rebinning on. * @param boxController : controls how the MDWorkspace will be split * @param frame: the md frame for the two MDHistoDimensions * @returns An MDWorkspace based on centre-point rebinning of the inputWS */ Mantid::API::IMDEventWorkspace_sptr ReflectometryTransform::executeMD( Mantid::API::MatrixWorkspace_const_sptr inputWs, BoxController_sptr boxController, Mantid::Geometry::MDFrame_uptr frame) const { auto dim0 = boost::make_shared<MDHistoDimension>( m_d0Label, m_d0ID, *frame, static_cast<Mantid::coord_t>(m_d0Min), static_cast<Mantid::coord_t>(m_d0Max), m_d0NumBins); auto dim1 = boost::make_shared<MDHistoDimension>( m_d1Label, m_d1ID, *frame, static_cast<Mantid::coord_t>(m_d1Min), static_cast<Mantid::coord_t>(m_d1Max), m_d1NumBins); auto ws = createMDWorkspace(dim0, dim1, boxController); auto spectraAxis = inputWs->getAxis(1); for (size_t index = 0; index < inputWs->getNumberHistograms(); ++index) { auto counts = inputWs->readY(index); auto wavelengths = inputWs->readX(index); auto errors = inputWs->readE(index); const size_t nInputBins = wavelengths.size() - 1; const double theta_final = spectraAxis->getValue(index); m_calculator->setThetaFinal(theta_final); // Loop over all bins in spectra for (size_t binIndex = 0; binIndex < nInputBins; ++binIndex) { const double &wavelength = 0.5 * (wavelengths[binIndex] + wavelengths[binIndex + 1]); double _d0 = m_calculator->calculateDim0(wavelength); double _d1 = m_calculator->calculateDim1(wavelength); double centers[2] = {_d0, _d1}; ws->addEvent(MDLeanEvent<2>(float(counts[binIndex]), float(errors[binIndex] * errors[binIndex]), centers)); } } ws->splitAllIfNeeded(nullptr); ws->refreshCache(); return ws; }
int hour(time_t t) { // the hour for the given time refreshCache(t); return tm.Hour; }
int month(time_t t) { // the month for the given time refreshCache(t); return tm.Month; }
int year(time_t t) { // the year for the given time refreshCache(t); return tmYearToCalendar(tm.Year); }
int day(time_t t) { // the day for the given time (0-6) refreshCache(t); return tm.Day; }
int weekday(time_t t) { refreshCache(t); return tm.Wday; }
int second(time_t t) { // the second for the given time refreshCache(t); return tm.Second; }
char* weekdayStr(time_t t) { refreshCache(t); return dayShortStr(tm.Wday); }
int minute(time_t t) { // the minute for the given time refreshCache(t); return tm.Minute; }
char* weekdayStrLong(time_t t) { //this returns a string refreshCache(t); return dayStr(tm.Wday); }
/** * Create an output event workspace filled with data simulated with the fitting * function. * @param baseName :: The base name for the workspace * @param inputWorkspace :: The input workspace. * @param values :: The calculated values * @param outputWorkspacePropertyName :: The property name */ boost::shared_ptr<API::Workspace> FitMD::createEventOutputWorkspace( const std::string &baseName, const API::IMDEventWorkspace &inputWorkspace, const API::FunctionValues &values, const std::string &outputWorkspacePropertyName) { auto outputWS = MDEventFactory::CreateMDWorkspace(inputWorkspace.getNumDims(), "MDEvent"); // Add events // TODO: Generalize to ND (the current framework is a bit limiting) auto mdWS = boost::dynamic_pointer_cast< DataObjects::MDEventWorkspace<DataObjects::MDEvent<4>, 4>>(outputWS); if (!mdWS) { return boost::shared_ptr<API::Workspace>(); } // Bins extents and meta data for (size_t i = 0; i < 4; ++i) { boost::shared_ptr<const Geometry::IMDDimension> inputDim = inputWorkspace.getDimension(i); Geometry::MDHistoDimensionBuilder builder; builder.setName(inputDim->getName()); builder.setId(inputDim->getDimensionId()); builder.setUnits(inputDim->getUnits()); builder.setNumBins(inputDim->getNBins()); builder.setMin(inputDim->getMinimum()); builder.setMax(inputDim->getMaximum()); builder.setFrameName(inputDim->getMDFrame().name()); outputWS->addDimension(builder.create()); } // Run information outputWS->copyExperimentInfos(inputWorkspace); // Coordinates outputWS->setCoordinateSystem(inputWorkspace.getSpecialCoordinateSystem()); // Set sensible defaults for splitting behaviour BoxController_sptr bc = outputWS->getBoxController(); bc->setSplitInto(3); bc->setSplitThreshold(3000); outputWS->initialize(); outputWS->splitBox(); auto inputIter = inputWorkspace.createIterator(); size_t resultValueIndex(0); const float errorSq = 0.0; do { const size_t numEvents = inputIter->getNumEvents(); const float signal = static_cast<float>(values.getCalculated(resultValueIndex)); for (size_t i = 0; i < numEvents; ++i) { coord_t centers[4] = { inputIter->getInnerPosition(i, 0), inputIter->getInnerPosition(i, 1), inputIter->getInnerPosition(i, 2), inputIter->getInnerPosition(i, 3)}; mdWS->addEvent(MDEvent<4>(signal, errorSq, inputIter->getInnerRunIndex(i), inputIter->getInnerDetectorID(i), centers)); } ++resultValueIndex; } while (inputIter->next()); delete inputIter; // This splits up all the boxes according to split thresholds and sizes. auto threadScheduler = new Kernel::ThreadSchedulerFIFO(); Kernel::ThreadPool threadPool(threadScheduler); outputWS->splitAllIfNeeded(threadScheduler); threadPool.joinAll(); outputWS->refreshCache(); // Store it if (!outputWorkspacePropertyName.empty()) { declareProperty( new API::WorkspaceProperty<API::IMDEventWorkspace>( outputWorkspacePropertyName, "", Direction::Output), "Name of the output Workspace holding resulting simulated spectrum"); m_manager->setPropertyValue(outputWorkspacePropertyName, baseName + "Workspace"); m_manager->setProperty(outputWorkspacePropertyName, outputWS); } return outputWS; }
void *watch_share() { int length, i = 0, wd; int fd; int rc; int access_count = 1; int r_count = 1; char *p; char buffer[BUF_LEN] __attribute__ ((aligned(8))); int counter = 0; int wds[MAX_WTD]; String dirs[MAX_WTD]; String query; sqlite3 *db; sqlite3_stmt *res; const char *tail; rc = sqlite3_open(DBNAME, &db); if (rc != SQLITE_OK){ fprintf(stderr, "Can't open database: %s.\n", sqlite3_errmsg(db)); sqlite3_close(db); exit(1); } strcpy(query, "SELECT mountpt FROM Target;"); rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail); if (rc != SQLITE_OK){ fprintf(stderr, "Failed to retrieved data.\n"); exit(1); } /*Initialize inotify*/ fd = inotify_init(); if ( fd < 0 ) { perror( "Couldn't initialize inotify" ); } list_dir(TEMP_LOC, fd, wds, dirs, counter); //printf("HELLO!!!\n"); while (sqlite3_step(res) == SQLITE_ROW){ wd = inotify_add_watch(fd, sqlite3_column_text(res,0), IN_CREATE | IN_OPEN | IN_CLOSE); wds[counter] = wd; strcpy(dirs[counter], sqlite3_column_text(res,0)); counter++; if (wd == -1){ syslog(LOG_INFO, "FileTransaction: Couldn't add watch to %s\n", sqlite3_column_text(res,0)); } else { syslog(LOG_INFO, "FileTransaction: Watching:: %s\n", sqlite3_column_text(res,0)); } //Check each target for directory String dir_to_read = ""; strcpy(dir_to_read, sqlite3_column_text(res,0)); list_dir(dir_to_read, fd, wds, dirs, counter); } wd = inotify_add_watch(fd, CACHE_LOC, IN_OPEN | IN_CLOSE); wds[counter] = wd; strcpy(dirs[counter], CACHE_LOC); counter++; if (wd != -1){ syslog(LOG_INFO, "FileTransaction: Watching:: %s\n", CACHE_LOC); } /*do it forever*/ for(;;){ create_link(); length = read(fd, buffer, BUF_LEN); if (length < 0){ perror("read"); } for(p = buffer; p < buffer + length;){ struct inotify_event *event = (struct inotify_event *) p; if (event->mask & IN_CREATE){ if (event->mask & IN_ISDIR){ int size = sizeof(wds) / sizeof(wds[0]); int i = 0; for (i = 0; i < size; i++){ if (wds[i] == event->wd){ if (strstr(dirs[i], "/mnt/Share") == NULL){ String add_watch_dir = ""; sprintf(add_watch_dir, "%s/%s", dirs[i], event->name); int wd = inotify_add_watch(fd, add_watch_dir, IN_ALL_EVENTS); if (wd == -1){ } else { printf("READ := Watching := %s\n", add_watch_dir); } wds[counter] = wd; strcpy(dirs[counter], add_watch_dir); counter++; } break; } } } else { } } if (event->mask & IN_OPEN){ if (event->mask & IN_ISDIR){ }else { //printf("Linear file %s opened.\n", event->name); if (strstr(event->name,"part1.") != NULL){ int k = 0; for (k = 0; k < counter; k++){ if (wds[k] == event->wd){ //printf("IN OPEN : %s | FILENAME : %s\n", dirs[k], event->name); break; } } //printf("FILENAME : %s opened.\n", event->name); int flag; FILE *fp = fopen("random.txt", "r"); fscanf(fp,"%d",&flag); fclose(fp); printf("IN OPEN FLAG := %d\n", flag); if (flag == 0){ //done striping continue with open event incrementFrequency(event->name); String comm = "", comm_out = ""; int inCache = 0; sprintf(comm, "ls %s", CACHE_LOC); runCommand(comm, comm_out); char *ptr = NULL; ptr = strtok(comm_out, "\n"); while (ptr != NULL){ if (strcmp(ptr, event->name) == 0){ inCache = 1; break; } ptr = strtok(NULL, "\n"); } if (!inCache){ printf("Watch Share: Should be assembling file here....\n"); FILE *fp1 = fopen("assembled.txt", "rb"); String file = ""; int check = 0; String line = ""; strcpy(file, event->name); strcat(file, "\n"); while (fgets(line, sizeof(file), fp1) != NULL){ printf("LINE := %s | FILENAME := %s\n", line, event->name); if (strcmp(line, file) == 0){ printf("SAME FILE := \n"); check = 1; break; } } fclose(fp1); if (!check){ // assemble the file by getting parts from volumes // take NOTE: assembly of file should only happen when all files are present // (or when no file striping is happening) // can this be determined with random.txt? assemble(event->name);} //String assembled_file = ""; //sprintf(assembled_file, "%s/%s", ASSEMBLY_LOC, event->name); //printf("Assembled File: %s\n", assembled_file); //assemble(event->name); //printf("Checking if assembled file exist...\n"); //FILE *fp; //fp = fopen(assembled_file, "r"); //if (fp == NULL){ //printf("Assembled file does not exist. Assembling here...\n"); //assemble(event->name); //} else { //printf("Assembled file already exist. Don't assembled anymore..\n"); //} //fclose(fp); } } } } } if (event->mask & IN_CLOSE){ if (event->mask & IN_ISDIR){ }else{ syslog(LOG_INFO, "FileTransaction: The file %s was closed.\n", event->name); //printf("File %s closed.\n", event->name); int k = 0; for (k = 0; k < counter; k++){ if (wds[k] == event->wd){ //printf("IN_CLOSE : %s | FILENAME : %s\n", dirs[k], event->name); break; } } //strcpy(COMMANDS[COUNTER], ""); //COUNTER++; //String original_file = ""; //sprintf(original_file, "%s/%s", STORAGE_LOC, event->name); //FILE *fp; // fp = fopen(original_file, "r"); // if (fp == NULL){ // printf("Original file does not exist.. Do nothing..\n"); // } else { // printf("Original file exist. File closed. Disassembling file..\n"); //} //fclose(fp); int flag; FILE *fp = fopen("random.txt", "rb"); fscanf(fp, "%d", &flag); fclose(fp); printf("IN CLOSE FLAG := %d\n", flag); if (flag == 0) { //done striping String comm = "", comm_out = ""; int inCache = 0; strcpy(comm, "ls /mnt/CVFSCache"); runCommand(comm, comm_out); char *pch = strtok(comm_out, "\n"); while (pch != NULL){ if (strcmp(pch, event->name) == 0){ inCache = 1; break; } pch = strtok(NULL, "\n"); } if (!inCache){ //check if file already assembled FILE *fp = fopen("assembled.txt", "rb"); String line = ""; String file = ""; int assembled = 0; strcpy(file, event->name); strcat(file, "\n"); while (fgets(line, sizeof(file), fp) != NULL){ printf("LINE := %s | FILE := %s\n", line, event->name); if (strcmp(line, file) == 0){ assembled = 1; break; } } fclose(fp); if (assembled){ printf("File has been closed\n"); disassemble(event->name); } } if (strstr(event->name, "part1.") != NULL){ refreshCache(); } } } } p += EVENT_SIZE + event->len; } } /* Clean up */ inotify_rm_watch(fd, wd); close(fd); sqlite3_finalize(res); sqlite3_close(db); }
repo::gui::RepoFederationDialog::RepoFederationDialog( RepoIDBCache *dbCache, QWidget *parent) : QDialog(parent) , ui(new Ui::RepoFederationDialog) , dbCache(dbCache) { ui->setupUi(this); ui->availableWidget->setExpandedUI(); ui->availableWidget->setExtendedSelection(); ui->availableWidget->setRootIsDecorated(true); ui->federatedWidget->setExpandedUI(); ui->federatedWidget->setExtendedSelection(); ui->federatedWidget->setRootIsDecorated(true); // ui->federatedWidget->getTreeView()->setDragEnabled(true); // ui->federatedWidget->getTreeView()->viewport()->setAcceptDrops(true); // ui->federatedWidget->getTreeView()->setDropIndicatorShown(true); // ui->federatedWidget->getTreeView()->setDragDropMode(QAbstractItemView::InternalMove); ui->buttonBox->button(QDialogButtonBox::StandardButton::Ok)->setText(tr("Next")); //-------------------------------------------------------------------------- dbCache->setHostsComboBox(ui->hostComboBox); dbCache->setDatabasesComboBox(ui->databaseComboBox); //-------------------------------------------------------------------------- ui->addPushButton->setIcon(RepoFontAwesome::getInstance().getIcon(RepoFontAwesome::fa_arrow_right)); ui->removePushButton->setIcon(RepoFontAwesome::getInstance().getIcon(RepoFontAwesome::fa_arrow_left)); QStandardItemModel *availableModel = ui->availableWidget->getModel(); availableModel->setColumnCount(1); availableModel->setHeaderData( 0, Qt::Horizontal, tr("Project")); QStandardItemModel *federatedModel = ui->federatedWidget->getModel(); federatedModel->setColumnCount(3); federatedModel->setHeaderData( 0, Qt::Horizontal, tr("Project")); federatedModel->setHeaderData( 1, Qt::Horizontal, tr("Branch")); federatedModel->setHeaderData( 2, Qt::Horizontal, tr("Revision")); QObject::connect(ui->refreshPushButton, SIGNAL(pressed()), this, SLOT(refresh())); QObject::connect(ui->refreshPushButton, SIGNAL(pressed()), this, SLOT(refreshCache())); QObject::connect(ui->databaseComboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(refresh())); QObject::connect(ui->addPushButton, SIGNAL(pressed()), this, SLOT(addProjectsToFederation())); QObject::connect(ui->removePushButton, SIGNAL(pressed()), this, SLOT(removeProjectsFromFederation())); QObject::connect(ui->federatedWidget->getTreeView(), SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showFederationMenu(QPoint))); }