void Simulator::onStart() { QMutexLocker locker(&lock); QThread* mainThread = QThread::currentThread(); qDebug() << "Simulator Thread: "<< mainThread; // Get required UAVObjects ExtensionSystem::PluginManager* pm = ExtensionSystem::PluginManager::instance(); UAVObjectManager* objManager = pm->getObject<UAVObjectManager>(); actDesired = ActuatorDesired::GetInstance(objManager); actCommand = ActuatorCommand::GetInstance(objManager); manCtrlCommand = ManualControlCommand::GetInstance(objManager); gcsReceiver = GCSReceiver::GetInstance(objManager); flightStatus = FlightStatus::GetInstance(objManager); posHome = HomeLocation::GetInstance(objManager); velActual = VelocityActual::GetInstance(objManager); posActual = PositionActual::GetInstance(objManager); baroAlt = BaroAltitude::GetInstance(objManager); airspeedActual = AirspeedActual::GetInstance(objManager); attActual = AttitudeActual::GetInstance(objManager); attitudeSettings = AttitudeSettings::GetInstance(objManager); accels = Accels::GetInstance(objManager); gyros = Gyros::GetInstance(objManager); gpsPos = GPSPosition::GetInstance(objManager); gpsVel = GPSVelocity::GetInstance(objManager); telStats = GCSTelemetryStats::GetInstance(objManager); groundTruth = GroundTruth::GetInstance(objManager); // Listen to autopilot connection events TelemetryManager* telMngr = pm->getObject<TelemetryManager>(); connect(telMngr, SIGNAL(connected()), this, SLOT(onAutopilotConnect())); connect(telMngr, SIGNAL(disconnected()), this, SLOT(onAutopilotDisconnect())); //connect(telStats, SIGNAL(objectUpdated(UAVObject*)), this, SLOT(telStatsUpdated(UAVObject*))); // If already connect setup autopilot GCSTelemetryStats::DataFields stats = telStats->getData(); if ( stats.Status == GCSTelemetryStats::STATUS_CONNECTED ) onAutopilotConnect(); inSocket = new QUdpSocket(); outSocket = new QUdpSocket(); setupUdpPorts(settings.hostAddress,settings.inPort,settings.outPort); emit processOutput("\nLocal interface: " + settings.hostAddress + "\n" + \ "Remote interface: " + settings.remoteAddress + "\n" + \ "inputPort: " + QString::number(settings.inPort) + "\n" + \ "outputPort: " + QString::number(settings.outPort) + "\n"); qxtLog->info("\nLocal interface: " + settings.hostAddress + "\n" + \ "Remote interface: " + settings.remoteAddress + "\n" + \ "inputPort: " + QString::number(settings.inPort) + "\n" + \ "outputPort: " + QString::number(settings.outPort) + "\n"); connect(inSocket, SIGNAL(readyRead()), this, SLOT(receiveUpdate()),Qt::DirectConnection); // Setup transmit timer txTimer = new QTimer(); connect(txTimer, SIGNAL(timeout()), this, SLOT(transmitUpdate()),Qt::DirectConnection); txTimer->setInterval(updatePeriod); txTimer->start(); // Setup simulator connection timer simTimer = new QTimer(); connect(simTimer, SIGNAL(timeout()), this, SLOT(onSimulatorConnectionTimeout()),Qt::DirectConnection); simTimer->setInterval(simTimeout); simTimer->start(); // setup time time = new QTime(); time->start(); current.T=0; current.i=0; }
IDBServer::IDBServer() { Locker<Lock> locker(m_databaseThreadCreationLock); m_threadID = createThread(IDBServer::databaseThreadEntry, this, "IndexedDatabase Server"); }
status_t TeamDebugInfo::AddImageDebugInfo(ImageDebugInfo* imageDebugInfo) { AutoLocker<BLocker> locker(fLock); // We have both locks now, so that for read-only access either lock // suffices. if (!fImages.AddItem(imageDebugInfo)) return B_NO_MEMORY; // Match all of the image debug info's functions instances with functions. BObjectList<SourceFileEntry> sourceFileEntries; for (int32 i = 0; FunctionInstance* instance = imageDebugInfo->FunctionAt(i); i++) { // lookup the function or create it, if it doesn't exist yet Function* function = fFunctions->Lookup(instance); if (function != NULL) { // TODO: Also update possible user breakpoints in this function! function->AddInstance(instance); instance->SetFunction(function); // The new image debug info might have additional information about // the source file of the function, so remember the source file // entry. if (LocatableFile* sourceFile = function->SourceFile()) { SourceFileEntry* entry = fSourceFiles->Lookup(sourceFile); if (entry != NULL && entry->GetSourceCode() != NULL) sourceFileEntries.AddItem(entry); } } else { function = new(std::nothrow) Function; if (function == NULL) { RemoveImageDebugInfo(imageDebugInfo); return B_NO_MEMORY; } function->AddInstance(instance); instance->SetFunction(function); status_t error = _AddFunction(function); // Insert after adding the instance. Otherwise the function // wouldn't be hashable/comparable. if (error != B_OK) { function->RemoveInstance(instance); instance->SetFunction(NULL); RemoveImageDebugInfo(imageDebugInfo); return error; } } } // update the source files the image debug info knows about for (int32 i = 0; SourceFileEntry* entry = sourceFileEntries.ItemAt(i); i++) { FileSourceCode* sourceCode = entry->GetSourceCode(); sourceCode->Lock(); if (imageDebugInfo->AddSourceCodeInfo(entry->SourceFile(), sourceCode) == B_OK) { // TODO: Notify interesting parties! Iterate through all functions // for this source file? } sourceCode->Unlock(); } return B_OK; }
int mytable::get_recno() const { tu_autolock locker(s_mysql_plugin_mutex); return m_index; }
int mytable::fld_count() { tu_autolock locker(s_mysql_plugin_mutex); return m_title.size(); }
void CmaEvent::stop() { QMutexLocker locker(&active); is_active = false; sema.release(); }
void CmaEvent::vitaEventOperateObject(vita_event_t *event, int eventId) { qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); operate_object_t operateobject; if(VitaMTP_OperateObject(device, eventId, &operateobject) != PTP_RC_OK) { qWarning("Cannot get information on object to operate"); return; } QMutexLocker locker(&m_db->mutex); QString fullpath = m_db->getAbsolutePath(operateobject.ohfi); // end for renaming only if(fullpath.isNull()) { VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Not_Exist_Object); return; } switch(operateobject.cmd) { case VITA_OPERATE_CREATE_FOLDER: { qDebug("Operate command %d: Create folder %s", operateobject.cmd, operateobject.title); QDir dir(fullpath); if(!dir.mkdir(operateobject.title)) { qWarning("Unable to create temporary folder: %s", operateobject.title); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); } else { int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi); qDebug("Created folder %s with OHFI %d", operateobject.title, new_ohfi); VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, new_ohfi); } break; } case VITA_OPERATE_CREATE_FILE: { qDebug("Operate command %d: Create file %s", operateobject.cmd, operateobject.title); QFile file(fullpath + QDir::separator() + operateobject.title); if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) { qWarning("Unable to create temporary file: %s", operateobject.title); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); } else { int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi); //qDebug("Created file %s with OHFI %d under parent %s", newobj->metadata.path, new_ohfi, root->metadata.path); VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, new_ohfi); } break; } case VITA_OPERATE_RENAME: { //qDebug("Operate command %d: Rename %s to %s", operateobject.cmd, root->metadata.name, operateobject.title); m_db->renameObject(operateobject.ohfi, operateobject.title); QString newpath = m_db->getAbsolutePath(operateobject.ohfi); // rename in filesystem if(!QFile(fullpath).rename(newpath)) { qWarning("Unable to rename %s to %s", fullpath.toLocal8Bit().constData(), operateobject.title); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); break; } qDebug("Renamed OHFI %d from %s to %s", operateobject.ohfi, fullpath.toLocal8Bit().constData(), newpath.toLocal8Bit().constData()); VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, operateobject.ohfi); break; } default: qWarning("Operate command %d: Not implemented", operateobject.cmd); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Failed_Operate_Object); break; } free(operateobject.title); }
void ValueGenerator::setMinValue(uint16_t minValue) { QMutexLocker locker(&mutex); _minValue = minValue; }
void ValueGenerator::setMaxValue(uint16_t maxValue) { QMutexLocker locker(&mutex); _maxValue = maxValue; }
bool PlayerCreationManager::createCharacter(ClientCreateCharacterCallback* callback) { TemplateManager* templateManager = TemplateManager::instance(); ZoneClientSession* client = callback->getClient(); if (client->getCharacterCount(zoneServer.get()->getGalaxyID()) >= 10) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are limited to 10 characters per galaxy.", 0x0); client->sendMessage(errMsg); return false; } PlayerManager* playerManager = zoneServer.get()->getPlayerManager(); SkillManager* skillManager = SkillManager::instance(); //Get all the data and validate it. UnicodeString characterName; callback->getCharacterName(characterName); //TODO: Replace this at some point? if (!playerManager->checkPlayerName(callback)) return false; String raceFile; callback->getRaceFile(raceFile); uint32 serverObjectCRC = raceFile.hashCode(); PlayerCreatureTemplate* playerTemplate = dynamic_cast<PlayerCreatureTemplate*>(templateManager->getTemplate( serverObjectCRC)); if (playerTemplate == NULL) { error("Unknown player template selected: " + raceFile); return false; } String fileName = playerTemplate->getTemplateFileName(); String clientTemplate = templateManager->getTemplateFile( playerTemplate->getClientObjectCRC()); RacialCreationData* raceData = racialCreationData.get(fileName); if (raceData == NULL) raceData = racialCreationData.get(0); //Just get the first race, since they tried to create a race that doesn't exist. String profession, customization, hairTemplate, hairCustomization; callback->getSkill(profession); if (profession.contains("jedi")) profession = "crafting_artisan"; callback->getCustomizationString(customization); callback->getHairObject(hairTemplate); callback->getHairCustomization(hairCustomization); float height = callback->getHeight(); height = MAX(MIN(height, playerTemplate->getMaxScale()), playerTemplate->getMinScale()); //validate biography UnicodeString bio; callback->getBiography(bio); bool doTutorial = callback->getTutorialFlag(); //bool doTutorial = false; ManagedReference<CreatureObject*> playerCreature = zoneServer.get()->createObject( serverObjectCRC, 2).castTo<CreatureObject*>(); if (playerCreature == NULL) { error("Could not create player with template: " + raceFile); return false; } Locker playerLocker(playerCreature); playerCreature->createChildObjects(); playerCreature->setHeight(height); playerCreature->setCustomObjectName(characterName, false); //TODO: Validate with Name Manager. client->setPlayer(playerCreature); playerCreature->setClient(client); // Set starting cash and starting bank playerCreature->setCashCredits(startingCash, false); playerCreature->setBankCredits(startingBank, false); ManagedReference<PlayerObject*> ghost = playerCreature->getPlayerObject(); if (ghost != NULL) { //Set skillpoints before adding any skills. ghost->setSkillPoints(skillPoints); ghost->setStarterProfession(profession); } addCustomization(playerCreature, customization, playerTemplate->getAppearanceFilename()); addHair(playerCreature, hairTemplate, hairCustomization); if (!doTutorial) { addProfessionStartingItems(playerCreature, profession, clientTemplate, false); addStartingItems(playerCreature, clientTemplate, false); addRacialMods(playerCreature, fileName, playerTemplate->getStartingSkills(), playerTemplate->getStartingItems(), false); } else { addProfessionStartingItems(playerCreature, profession, clientTemplate, true); addStartingItems(playerCreature, clientTemplate, true); addRacialMods(playerCreature, fileName, playerTemplate->getStartingSkills(), playerTemplate->getStartingItems(), true); } // Set starting cash and starting bank playerCreature->setCashCredits(startingCash, false); playerCreature->setBankCredits(startingBank, false); if (ghost != NULL) { ghost->setAccountID(client->getAccountID()); if (!freeGodMode) { try { uint32 accID = client->getAccountID(); ManagedReference<Account*> playerAccount = playerManager->getAccount(accID); if (playerAccount == NULL) { playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } int accountPermissionLevel = playerAccount->getAdminLevel(); String accountName = playerAccount->getUsername(); if(accountPermissionLevel > 0 && (accountPermissionLevel == 9 || accountPermissionLevel == 10 || accountPermissionLevel == 12 || accountPermissionLevel == 15)) { playerManager->updatePermissionLevel(playerCreature, accountPermissionLevel); /* Reference<ShipControlDevice*> shipControlDevice = zoneServer->createObject(STRING_HASHCODE("object/intangible/ship/sorosuub_space_yacht_pcd.iff"), 1).castTo<ShipControlDevice*>(); //ShipObject* ship = (ShipObject*) server->createObject(STRING_HASHCODE("object/ship/player/player_sorosuub_space_yacht.iff"), 1); Reference<ShipObject*> ship = zoneServer->createObject(STRING_HASHCODE("object/ship/player/player_basic_tiefighter.iff"), 1).castTo<ShipObject*>(); shipControlDevice->setControlledObject(ship); if (!shipControlDevice->transferObject(ship, 4)) info("Adding of ship to device failed"); ManagedReference<SceneObject*> datapad = playerCreature->getSlottedObject("datapad"); if (datapad != NULL) { if (!datapad->transferObject(shipControlDevice, -1)) { shipControlDevice->destroyObjectFromDatabase(true); } } else { shipControlDevice->destroyObjectFromDatabase(true); error("could not get datapad from player"); } */ } if (accountPermissionLevel < 9) { try { StringBuffer query; //query << "SELECT UNIX_TIMESTAMP(creation_date) FROM characters c WHERE galaxy_id = " << zoneServer.get()->getGalaxyID() << " AND account_id = " << client->getAccountID() << " ORDER BY creation_date desc;"; uint32 galaxyId = zoneServer.get()->getGalaxyID(); uint32 accountId = client->getAccountID(); query << "(SELECT UNIX_TIMESTAMP(c.creation_date) as t FROM characters as c WHERE c.account_id = " << accountId << " AND c.galaxy_id = " << galaxyId << " ORDER BY c.creation_date DESC) UNION (SELECT UNIX_TIMESTAMP(d.creation_date) FROM deleted_characters as d WHERE d.account_id = " << accountId << " AND d.galaxy_id = " << galaxyId << " ORDER BY d.creation_date DESC) ORDER BY t DESC LIMIT 1"; Reference<ResultSet*> res = ServerDatabase::instance()->executeQuery(query); if (res != NULL && res->next()) { uint32 sec = res->getUnsignedInt(0); Time timeVal(sec); if (timeVal.miliDifference() < 3600000) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0); client->sendMessage(errMsg); playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } //timeVal.se } } catch (DatabaseException& e) { error(e.getMessage()); } Locker locker(&charCountMutex); if (lastCreatedCharacter.containsKey(accID)) { Time lastCreatedTime = lastCreatedCharacter.get(accID); if (lastCreatedTime.miliDifference() < 3600000) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0); client->sendMessage(errMsg); playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } else { lastCreatedTime.updateToCurrentTime(); lastCreatedCharacter.put(accID, lastCreatedTime); } } else { lastCreatedCharacter.put(accID, Time()); } } } catch (Exception& e) { error(e.getMessage()); } } else { playerManager->updatePermissionLevel(playerCreature, PermissionLevelList::instance()->getLevelNumber("admin")); } if (doTutorial) playerManager->createTutorialBuilding(playerCreature); else playerManager->createSkippedTutorialBuilding(playerCreature); ValidatedPosition* lastValidatedPosition = ghost->getLastValidatedPosition(); lastValidatedPosition->update(playerCreature); ghost->setBiography(bio); ghost->setLanguageID(playerTemplate->getDefaultLanguage()); } ClientCreateCharacterSuccess* msg = new ClientCreateCharacterSuccess( playerCreature->getObjectID()); playerCreature->sendMessage(msg); ChatManager* chatManager = zoneServer.get()->getChatManager(); chatManager->addPlayer(playerCreature); String firstName = playerCreature->getFirstName(); String lastName = playerCreature->getLastName(); int raceID = playerTemplate->getRace(); try { StringBuffer query; query << "INSERT INTO `characters_dirty` (`character_oid`, `account_id`, `galaxy_id`, `firstname`, `surname`, `race`, `gender`, `template`)" << " VALUES (" << playerCreature->getObjectID() << "," << client->getAccountID() << "," << zoneServer.get()->getGalaxyID() << "," << "'" << firstName.escapeString() << "','" << lastName.escapeString() << "'," << raceID << "," << 0 << ",'" << raceFile.escapeString() << "')"; ServerDatabase::instance()->executeStatement(query); } catch (DatabaseException& e) { error(e.getMessage()); } playerManager->addPlayer(playerCreature); // Copy claimed veteran rewards from player's alt character uint32 accID = client->getAccountID(); ManagedReference<Account*> playerAccount = playerManager->getAccount(accID); if (playerAccount != NULL && ghost != NULL) { // Find the first alt character ManagedReference<CreatureObject*> altPlayer = NULL; CharacterList* characters = playerAccount->getCharacterList(); for(int i = 0; i < characters->size(); ++i) { CharacterListEntry* entry = &characters->get(i); if(entry->getGalaxyID() == zoneServer.get()->getGalaxyID() && entry->getFirstName() != playerCreature->getFirstName() ) { altPlayer = playerManager->getPlayer(entry->getFirstName()); if( altPlayer != NULL ){ break; } } } // Record the rewards if alt player was found if( altPlayer != NULL && altPlayer->getPlayerObject() != NULL){ Locker alocker( altPlayer ); for( int i = 0; i < playerManager->getNumVeteranRewardMilestones(); i++ ){ int milestone = playerManager->getVeteranRewardMilestone(i); String claimedReward = altPlayer->getPlayerObject()->getChosenVeteranReward(milestone); if( !claimedReward.isEmpty() ){ ghost->addChosenVeteranReward(milestone,claimedReward); } } } } client->addCharacter(playerCreature->getObjectID(), zoneServer.get()->getGalaxyID()); JediManager::instance()->onPlayerCreated(playerCreature); chatManager->sendMail("system", "@newbie_tutorial/newbie_mail:welcome_subject", "@newbie_tutorial/newbie_mail:welcome_body", playerCreature->getFirstName()); //Join auction chat room ghost->addChatRoom(chatManager->getAuctionRoom()->getRoomID()); ManagedReference<SuiMessageBox*> box = new SuiMessageBox(playerCreature, SuiWindowType::NONE); box->setPromptTitle("PLEASE NOTE"); box->setPromptText("You are limited to creating one character per hour. Attempting to create another character or deleting your character before the 1 hour timer expires will reset the timer."); ghost->addSuiBox(box); playerCreature->sendMessage(box->generateMessage()); return true; }
void PlayerCreationManager::addHair(CreatureObject* creature, const String& hairTemplate, const String& hairCustomization) { if (hairTemplate.isEmpty()) return; HairStyleInfo* hairInfo = hairStyleInfo.get(hairTemplate); if (hairInfo == NULL) hairInfo = hairStyleInfo.get(0); HairAssetData* hairAssetData = CustomizationIdManager::instance()->getHairAssetData(hairTemplate); if (hairAssetData == NULL) { error("no hair asset data detected for " + hairTemplate); return; } if (hairAssetData->getServerPlayerTemplate() != creature->getObjectTemplate()->getFullTemplateString()) { error( "hair " + hairTemplate + " is not compatible with this creature player " + creature->getObjectTemplate()->getFullTemplateString()); return; } if (!hairAssetData->isAvailableAtCreation()) { error("hair " + hairTemplate + " not available at creation"); return; } ManagedReference<SceneObject*> hair = zoneServer->createObject( hairTemplate.hashCode(), 1); //TODO: Validate hairCustomization if (hair == NULL) { return; } Locker locker(hair); if (!hair->isTangibleObject()) { hair->destroyObjectFromDatabase(true); return; } TangibleObject* tanoHair = cast<TangibleObject*>(hair.get()); tanoHair->setContainerDenyPermission("owner", ContainerPermissions::MOVECONTAINER); tanoHair->setContainerDefaultDenyPermission( ContainerPermissions::MOVECONTAINER); String appearanceFilename = tanoHair->getObjectTemplate()->getAppearanceFilename(); CustomizationVariables data; data.parseFromClientString(hairCustomization); if (ImageDesignManager::validateCustomizationString(&data, appearanceFilename, -1)) tanoHair->setCustomizationString(hairCustomization); creature->transferObject(tanoHair, 4); }
void CommitThread::enqueueChunk(const QByteArray *data, bool last) { QMutexLocker locker(&queueMutex); this->last = last; queue.enqueue(data); }
QgsAuthPkiPathsMethod::~QgsAuthPkiPathsMethod() { QMutexLocker locker( &mConfigMutex ); qDeleteAll( sPkiConfigBundleCache ); sPkiConfigBundleCache.clear(); }
void ThreadState::attach(intptr_t* startOfStack) { MutexLocker locker(threadAttachMutex()); ThreadState* state = new ThreadState(startOfStack); attachedThreads().add(state); }
void CmaEvent::vitaEventSendObject(vita_event_t *event, int eventId) { qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); int ohfi = event->Param2; QMutexLocker locker(&m_db->mutex); qDebug("Searching object with OHFI %d", ohfi); metadata_t *metadata = NULL; if(!m_db->getObjectList(ohfi, &metadata)) { qWarning("Failed to find OHFI %d", ohfi); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_OHFI); return; } metadata_t *start = metadata; quint32 parentHandle = event->Param3; bool send_folder = metadata->dataType & Folder; quint32 handle; do { quint64 len = metadata->size; m_file = new QFile(m_db->getAbsolutePath(metadata->ohfi)); // read the file to send if it's not a directory // if it is a directory, data and len are not used by VitaMTP if(metadata->dataType & File) { if(!m_file->open(QIODevice::ReadOnly)) { qWarning() << "Failed to read" << m_file->fileName(); delete m_file; VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Not_Exist_Object); return; } } // get the PTP object ID for the parent to put the object // we know the parent has to be before the current node // the first time this is called, parentHandle is left untouched if(start != metadata) { metadata_t parent_metadata; m_db->getObjectMetadata(metadata->ohfiParent, parent_metadata); parentHandle = parent_metadata.handle; } // send the data over qDebug("Sending %s of %llu bytes to device", metadata->name, len); qDebug("OHFI %d with handle 0x%08X", metadata->ohfi, parentHandle); VitaMTP_RegisterCancelEventId(eventId); quint16 ret = VitaMTP_SendObject_Callback(device, &parentHandle, &handle, metadata, &CmaEvent::readCallback); if(ret != PTP_RC_OK) { qWarning("Sending of %s failed. Code: %04X", metadata->name, ret); if(ret == PTP_ERROR_CANCEL) { VitaMTP_ReportResult(device, eventId, PTP_RC_GeneralError); } m_file->close(); delete m_file; return; } metadata->handle = handle; if(metadata->dataType & File) { m_file->close(); delete m_file; } // break early if only a file needs to be sent if(!send_folder) { break; } metadata = metadata->next_metadata; } while(metadata && metadata->ohfiParent >= OHFI_BASE_VALUE); // get everything under this "folder" m_db->freeMetadata(start); VitaMTP_ReportResultWithParam(device, eventId, PTP_RC_OK, handle); VitaMTP_ReportResult(device, eventId, PTP_RC_VITA_Invalid_Data); // TODO: Send thumbnail }
uint16_t ValueGenerator::getMaxValue() { QMutexLocker locker(&mutex); return _maxValue; }
bool CmaEvent::isActive() { QMutexLocker locker(&active); return is_active; }
void ValueGenerator::setAlarmValue(uint16_t alarmValue) { QMutexLocker locker(&mutex); _alarmValue = alarmValue; }
void CmaEvent::setDevice(vita_device_t *device) { QMutexLocker locker(&mutex); this->device = device; }
uint16_t ValueGenerator::getAlarmValue() { QMutexLocker locker(&mutex); return _alarmValue; }
int mytable::size() const { tu_autolock locker(s_mysql_plugin_mutex); return m_data.size(); }
void ValueGenerator::setValueType(SensorValueType valueType) { QMutexLocker locker(&mutex); _valueType = valueType; }
void mytable::first() { tu_autolock locker(s_mysql_plugin_mutex); m_index = 0; }
void ValueGenerator::setValue(uint16_t value) { QMutexLocker locker(&mutex); _value = value; }
void mytable::retrieve_data(MYSQL_RES* result) { tu_autolock locker(s_mysql_plugin_mutex); MYSQL_FIELD* fld = mysql_fetch_fields(result); int num_fields = mysql_num_fields(result); int num_rows = (int) mysql_num_rows(result); m_title.resize(num_fields); for (int i = 0; i < num_fields; i++) { m_title[i] = fld[i].name; } m_data.resize(num_rows); for (int i = 0; i < num_rows; i++) { MYSQL_ROW row = mysql_fetch_row(result); m_data[i] = new as_object(get_player()); for (int j = 0; j < num_fields; j++) { as_value val; if (row[j] == NULL) { // val.set_undefined(); val.set_string(""); } else { switch (fld[j].type) { default: break; case MYSQL_TYPE_TINY: case MYSQL_TYPE_SHORT: case MYSQL_TYPE_INT24: val.set_int(atoi(row[j])); break; case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_LONG: case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_DOUBLE: case MYSQL_TYPE_LONGLONG: val.set_double(atof(row[j])); break; case MYSQL_TYPE_NULL: case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_DATE: case MYSQL_TYPE_TIME: case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_YEAR: case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_BIT: case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_ENUM: case MYSQL_TYPE_SET: case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_STRING: case MYSQL_TYPE_GEOMETRY: val.set_string(row[j]); break; } } m_data[i]->set_member(fld[j].name, val); } } }
SensorValueType ValueGenerator::getValueType() { QMutexLocker locker(&mutex); return _valueType; }
status_t TeamDebugInfo::LoadSourceCode(LocatableFile* file, FileSourceCode*& _sourceCode) { AutoLocker<BLocker> locker(fLock); // If we don't know the source file, there's nothing we can do. SourceFileEntry* entry = fSourceFiles->Lookup(file); if (entry == NULL) return B_ENTRY_NOT_FOUND; // the source might already be loaded FileSourceCode* sourceCode = entry->GetSourceCode(); if (sourceCode != NULL) { sourceCode->AcquireReference(); _sourceCode = sourceCode; return B_OK; } // get the source language from some function's image debug info Function* function = entry->FunctionAt(0); if (function == NULL) return B_ENTRY_NOT_FOUND; FunctionDebugInfo* functionDebugInfo = function->FirstInstance()->GetFunctionDebugInfo(); SourceLanguage* language; status_t error = functionDebugInfo->GetSpecificImageDebugInfo() ->GetSourceLanguage(functionDebugInfo, language); if (error != B_OK) return error; BReference<SourceLanguage> languageReference(language, true); // no source code yet // locker.Unlock(); // TODO: It would be nice to unlock here, but we need to iterate through // the images below. We could clone the list, acquire references, and // unlock. Then we have to compare the list with the then current list when // we're done loading. // load the source file SourceFile* sourceFile; error = fFileManager->LoadSourceFile(file, sourceFile); if (error != B_OK) return error; // create the source code sourceCode = new(std::nothrow) FileSourceCode(file, sourceFile, language); sourceFile->ReleaseReference(); if (sourceCode == NULL) return B_NO_MEMORY; BReference<FileSourceCode> sourceCodeReference(sourceCode, true); error = sourceCode->Init(); if (error != B_OK) return error; // Iterate through all images that know the source file and ask them to add // information. bool anyInfo = false; for (int32 i = 0; ImageDebugInfo* imageDebugInfo = fImages.ItemAt(i); i++) anyInfo |= imageDebugInfo->AddSourceCodeInfo(file, sourceCode) == B_OK; if (!anyInfo) return B_ENTRY_NOT_FOUND; entry->SetSourceCode(sourceCode); _sourceCode = sourceCodeReference.Detach(); return B_OK; }
void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *event, int eventId) { qDebug("Event recieved in %s, code: 0x%x, id: %d", Q_FUNC_INFO, event->Code, eventId); copy_confirmation_info_t *info; if(VitaMTP_SendCopyConfirmationInfoInit(device, eventId, &info) != PTP_RC_OK) { qWarning("Error recieving initial information."); return; } QMutexLocker locker(&m_db->mutex); qint64 total_size = 0; // check if the item is a single folder if(info->count == 1) { metadata_t meta; if(m_db->getObjectMetadata(info->ohfi[0], meta)) { // got a folder if(meta.dataType & Folder) { metadata_t *meta_list = NULL; if(m_db->getObjectList(info->ohfi[0], &meta_list)) { int count = 0; metadata_t *meta = meta_list; // count files while(meta) { if(meta->dataType & File) { count++; } meta = meta->next_metadata; } // create struct to hold all the file identifiers info = (copy_confirmation_info_t *)malloc(sizeof(uint32_t) * count + sizeof(copy_confirmation_info_t)); meta = meta_list; info->count = 0; // copy all the file ohfi while(meta) { if(meta->dataType & File) { info->ohfi[info->count] = meta->ohfi; total_size += meta->size; info->count++; } meta = meta->next_metadata; } } m_db->freeMetadata(meta_list); } } } else { qint64 size; for(quint32 i = 0; i < info->count; i++) { if((size = m_db->getObjectSize(info->ohfi[i])) < 0) { qWarning("Cannot find OHFI %d", info->ohfi[i]); free(info); return; } total_size += size; } } if(VitaMTP_SendCopyConfirmationInfo(device, eventId, info, total_size) != PTP_RC_OK) { qWarning("Error sending copy confirmation"); } else { VitaMTP_ReportResult(device, eventId, PTP_RC_OK); } free(info); }
SSDP* SSDP::Instance() { QMutexLocker locker(&g_pSSDPCreationLock); return g_pSSDP ? g_pSSDP : (g_pSSDP = new SSDP()); }
void ErrorHandler::clear() { QMutexLocker locker(&mutex); m_errorQueue.clear(); m_worstError = Debug; }