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)));
}
