// Checked: 2011-10-06 (RLVa-1.4.2a) | Added: RLVa-1.4.2a S32 RlvInventory::getDirectDescendentsFolderCount(const LLInventoryCategory* pFolder) { LLInventoryModel::cat_array_t* pFolders = NULL; LLInventoryModel::item_array_t* pItems = NULL; if (pFolder) gInventory.getDirectDescendentsOf(pFolder->getUUID(), pFolders, pItems); return (pFolders) ? pFolders->size() : 0; }
// Checked: 2011-10-06 (RLVa-1.4.2a) | Modified: RLVa-1.4.2a const LLUUID& RlvInventory::getSharedRootID() const { if ( (m_idRlvRoot.isNull()) && (gInventory.isInventoryUsable()) ) { LLInventoryModel::cat_array_t* pFolders; LLInventoryModel::item_array_t* pItems; gInventory.getDirectDescendentsOf(gInventory.getRootFolderID(), pFolders, pItems); if (pFolders) { // NOTE: we might have multiple #RLV folders (pick the first one with sub-folders; otherwise the last one with no sub-folders) const LLViewerInventoryCategory* pFolder; for (S32 idxFolder = 0, cntFolder = pFolders->count(); idxFolder < cntFolder; idxFolder++) { if ( ((pFolder = pFolders->get(idxFolder)) != NULL) && (cstrSharedRoot == pFolder->getName()) ) { m_idRlvRoot = pFolder->getUUID(); if (getDirectDescendentsFolderCount(pFolder) > 0) break; } } if ( (m_idRlvRoot.notNull()) && (!gInventory.containsObserver((RlvInventory*)this)) ) gInventory.addObserver((RlvInventory*)this); } } return m_idRlvRoot; }
void LLFriendCardsManager::findMatchedFriendCards(const LLUUID& avatarID, LLInventoryModel::item_array_t& items) const { LLInventoryModel::cat_array_t cats; LLUUID friendFolderUUID = findFriendFolderUUIDImpl(); LLViewerInventoryCategory* friendFolder = gInventory.getCategory(friendFolderUUID); if (NULL == friendFolder) return; LLParticularBuddyCollector matchFunctor(avatarID); LLInventoryModel::cat_array_t subFolders; subFolders.push_back(friendFolder); while (subFolders.count() > 0) { LLViewerInventoryCategory* cat = subFolders.get(0); subFolders.remove(0); gInventory.collectDescendentsIf(cat->getUUID(), cats, items, LLInventoryModel::EXCLUDE_TRASH, matchFunctor); move_from_to_arrays(cats, subFolders); } }
// Checked: 2010-02-28 (RLVa-1.2.0a) | Modified: RLVa-1.0.1a LLViewerInventoryCategory* RlvInventory::getSharedFolder(const LLUUID& idParent, const std::string& strFolderName) const { LLInventoryModel::cat_array_t* pFolders; LLInventoryModel::item_array_t* pItems; gInventory.getDirectDescendentsOf(idParent, pFolders, pItems); if ( (!pFolders) || (strFolderName.empty()) ) return NULL; // If we can't find an exact match then we'll settle for a "contains" match LLViewerInventoryCategory* pPartial = NULL; //LLStringUtil::toLower(strFolderName); <- everything was already converted to lower case before std::string strName; for (S32 idxFolder = 0, cntFolder = pFolders->count(); idxFolder < cntFolder; idxFolder++) { LLViewerInventoryCategory* pFolder = pFolders->get(idxFolder); strName = pFolder->getName(); if (strName.empty()) continue; LLStringUtil::toLower(strName); if (strFolderName == strName) return pFolder; // Found an exact match, no need to keep on going else if ( (!pPartial) && (RLV_FOLDER_PREFIX_HIDDEN != strName[0]) && (std::string::npos != strName.find(strFolderName)) ) pPartial = pFolder; // Found a partial (non-hidden) match, but we might still find an exact one (first partial match wins) } return pPartial; }
// Checked: 2010-02-28 (RLVa-1.1.3a) | Modified: RLVa-1.0.0h void RlvInventory::fetchSharedInventory() { // Sanity check - don't fetch if we're already fetching, or if we don't have a shared root const LLViewerInventoryCategory* pRlvRoot = getSharedRoot(); if ( (m_fFetchStarted) || (!pRlvRoot) ) return; // Grab all the folders under the shared root LLInventoryModel::cat_array_t folders; LLInventoryModel::item_array_t items; gInventory.collectDescendents(pRlvRoot->getUUID(), folders, items, FALSE); // Add them to the "to fetch" list uuid_vec_t fetchFolders; fetchFolders.push_back(pRlvRoot->getUUID()); for (S32 idxFolder = 0, cntFolder = folders.count(); idxFolder < cntFolder; idxFolder++) fetchFolders.push_back(folders.get(idxFolder)->getUUID()); // Now fetch them all in one go RlvSharedInventoryFetcher* pFetcher = new RlvSharedInventoryFetcher(fetchFolders); RLV_INFOS << "Starting fetch of " << fetchFolders.size() << " shared folders" << RLV_ENDL; pFetcher->startFetch(); m_fFetchStarted = true; if (pFetcher->isFinished()) pFetcher->done(); else gInventory.addObserver(pFetcher); }
// Tell if a listing has one only version folder bool hasUniqueVersionFolder(const LLUUID& folder_id) { LLInventoryModel::cat_array_t* categories; LLInventoryModel::item_array_t* items; gInventory.getDirectDescendentsOf(folder_id, categories, items); return (categories->size() == 1); }
void LLFloaterOutbox::updateFolderCount() { if (mOutboxInventoryPanel.get() && mOutboxId.notNull()) { S32 item_count = 0; if (mOutboxId.notNull()) { LLInventoryModel::cat_array_t * cats; LLInventoryModel::item_array_t * items; gInventory.getDirectDescendentsOf(mOutboxId, cats, items); item_count = cats->count() + items->count(); } mOutboxItemCount = item_count; } else { // If there's no outbox, the number of items in it should be set to 0 for consistency mOutboxItemCount = 0; } if (!mImportBusy) { updateFolderCountStatus(); } }
////////////////////////////////////////////////////////////////////////// // Private methods ////////////////////////////////////////////////////////////////////////// void LLOutfitsList::computeDifference( const LLInventoryModel::cat_array_t& vcats, uuid_vec_t& vadded, uuid_vec_t& vremoved) { uuid_vec_t vnew; // Creating a vector of newly collected sub-categories UUIDs. for (LLInventoryModel::cat_array_t::const_iterator iter = vcats.begin(); iter != vcats.end(); iter++) { vnew.push_back((*iter)->getUUID()); } uuid_vec_t vcur; // Creating a vector of currently displayed sub-categories UUIDs. for (outfits_map_t::const_iterator iter = mOutfitsMap.begin(); iter != mOutfitsMap.end(); iter++) { vcur.push_back((*iter).first); } LLCommonUtils::computeDifference(vnew, vcur, vadded, vremoved); }
void move_from_to_arrays(LLInventoryModel::cat_array_t& from, LLInventoryModel::cat_array_t& to) { while (from.count() > 0) { to.put(from.get(0)); from.remove(0); } }
LLUUID FSLSLBridge::findFSBridgeContainerCategory() { llinfos << "Retrieving FSBridge container category (" << FS_BRIDGE_CONTAINER_FOLDER << ")" << llendl; if (mBridgeContainerFolderID.notNull()) { llinfos << "Returning FSBridge container category UUID from instance: " << mBridgeContainerFolderID << llendl; return mBridgeContainerFolderID; } LLUUID LibRootID = gInventory.getLibraryRootFolderID(); if (LibRootID.notNull()) { LLInventoryModel::item_array_t* items; LLInventoryModel::cat_array_t* cats; gInventory.getDirectDescendentsOf(LibRootID, cats, items); if (cats) { S32 count = cats->count(); for (S32 i = 0; i < count; ++i) { if (cats->get(i)->getName() == "Objects") { LLUUID LibObjectsCatID = cats->get(i)->getUUID(); if (LibObjectsCatID.notNull()) { LLInventoryModel::item_array_t* objects_items; LLInventoryModel::cat_array_t* objects_cats; gInventory.getDirectDescendentsOf(LibObjectsCatID, objects_cats, objects_items); if (objects_cats) { S32 objects_count = objects_cats->count(); for (S32 j = 0; j < objects_count; ++j) { if (objects_cats->get(j)->getName() == FS_BRIDGE_CONTAINER_FOLDER) { mBridgeContainerFolderID = objects_cats->get(j)->getUUID(); llinfos << "FSBridge container category found in library. UUID: " << mBridgeContainerFolderID << llendl; gInventory.fetchDescendentsOf(mBridgeContainerFolderID); return mBridgeContainerFolderID; } } } } } } } } llwarns << "FSBridge container category not found in library!" << llendl; return LLUUID(); }
// Checked: 2010-04-07 (RLVa-1.2.0a) | Modified: RLVa-1.0.0h bool RlvInventory::findSharedFolders(const std::string& strCriteria, LLInventoryModel::cat_array_t& folders) const { // Sanity check - can't do anything without a shared root const LLViewerInventoryCategory* pRlvRoot = RlvInventory::instance().getSharedRoot(); if (!pRlvRoot) return false; folders.clear(); LLInventoryModel::item_array_t items; RlvCriteriaCategoryCollector f(strCriteria); gInventory.collectDescendentsIf(pRlvRoot->getUUID(), folders, items, FALSE, f); return (folders.count() != 0); }
S32 LLFloaterMarketplaceListings::getFolderCount() { if (mPanelListings && mRootFolderId.notNull()) { LLInventoryModel::cat_array_t * cats; LLInventoryModel::item_array_t * items; gInventory.getDirectDescendentsOf(mRootFolderId, cats, items); return (cats->size() + items->size()); } else { return 0; } }
static void collectLandmarkFolders(LLInventoryModel::cat_array_t& cats) { LLUUID landmarks_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK); // Add descendent folders of the "Landmarks" category. LLInventoryModel::item_array_t items; // unused LLIsType is_category(LLAssetType::AT_CATEGORY); gInventory.collectDescendentsIf( landmarks_id, cats, items, LLInventoryModel::EXCLUDE_TRASH, is_category); // Add the "My Favorites" category. LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE); LLViewerInventoryCategory* favorites_cat = gInventory.getCategory(favorites_id); if (!favorites_cat) { LL_WARNS() << "Cannot find the favorites folder" << LL_ENDL; } else { cats.push_back(favorites_cat); } }
// static void LLLocalInventory::climb(LLInventoryCategory* cat, LLInventoryModel::cat_array_t& cats, LLInventoryModel::item_array_t& items) { LLInventoryModel* model = &gInventory; // Add this category cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)cat)); LLInventoryModel::cat_array_t *direct_cats; LLInventoryModel::item_array_t *direct_items; model->getDirectDescendentsOf(cat->getUUID(), direct_cats, direct_items); // Add items LLInventoryModel::item_array_t::iterator item_iter = direct_items->begin(); LLInventoryModel::item_array_t::iterator item_end = direct_items->end(); for( ; item_iter != item_end; ++item_iter) { items.push_back(*item_iter); } // Do subcategories LLInventoryModel::cat_array_t::iterator cat_iter = direct_cats->begin(); LLInventoryModel::cat_array_t::iterator cat_end = direct_cats->end(); for( ; cat_iter != cat_end; ++cat_iter) { climb(*cat_iter, cats, items); } }
void LLFloaterGesture::done() { //this method can be called twice: for GestureFolder and once after loading all sudir of GestureFolder if (gInventory.isCategoryComplete(mGestureFolderID)) { LL_DEBUGS("Gesture")<< "mGestureFolderID loaded" << LL_ENDL; // we load only gesture folder without childred. LLInventoryModel::cat_array_t* categories; LLInventoryModel::item_array_t* items; uuid_vec_t unloaded_folders; LL_DEBUGS("Gesture")<< "Get subdirs of Gesture Folder...." << LL_ENDL; gInventory.getDirectDescendentsOf(mGestureFolderID, categories, items); if (categories->empty()) { gInventory.removeObserver(this); LL_INFOS("Gesture")<< "Gesture dos NOT contains sub-directories."<< LL_ENDL; return; } LL_DEBUGS("Gesture")<< "There are " << categories->size() << " Folders "<< LL_ENDL; for (LLInventoryModel::cat_array_t::iterator it = categories->begin(); it != categories->end(); it++) { if (!gInventory.isCategoryComplete(it->get()->getUUID())) { unloaded_folders.push_back(it->get()->getUUID()); LL_DEBUGS("Gesture")<< it->get()->getName()<< " Folder added to fetchlist"<< LL_ENDL; } } if (!unloaded_folders.empty()) { LL_DEBUGS("Gesture")<< "Fetching subdirectories....." << LL_ENDL; setFetchIDs(unloaded_folders); startFetch(); } else { LL_DEBUGS("Gesture")<< "All Gesture subdirectories have been loaded."<< LL_ENDL; gInventory.removeObserver(this); buildGestureList(); } } else { LL_WARNS("Gesture")<< "Gesture list was NOT loaded"<< LL_ENDL; } }
bool LLInventoryCategoriesObserver::addCategory(const LLUUID& cat_id, callback_t cb) { S32 version = LLViewerInventoryCategory::VERSION_UNKNOWN; S32 current_num_known_descendents = LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN; bool can_be_added = true; LLViewerInventoryCategory* category = gInventory.getCategory(cat_id); // If category could not be retrieved it might mean that // inventory is unusable at the moment so the category is // stored with VERSION_UNKNOWN and DESCENDENT_COUNT_UNKNOWN, // it may be updated later. if (category) { // Inventory category version is used to find out if some changes // to a category have been made. version = category->getVersion(); LLInventoryModel::cat_array_t* cats; LLInventoryModel::item_array_t* items; gInventory.getDirectDescendentsOf(cat_id, cats, items); if (!cats || !items) { LL_WARNS() << "Category '" << category->getName() << "' descendents corrupted, fetch failed." << LL_ENDL; // NULL means the call failed -- cats/items map doesn't exist (note: this does NOT mean // that the cat just doesn't have any items or subfolders). // Unrecoverable, so just return "false" meaning that the category can't be observed. can_be_added = false; llassert(cats != NULL && items != NULL); } else { current_num_known_descendents = cats->size() + items->size(); } } if (can_be_added) { mCategoryMap.insert(category_map_value_t( cat_id,LLCategoryData(cat_id, cb, version, current_num_known_descendents))); } return can_be_added; }
// Checked: 2010-02-28 (RLVa-1.1.3a) | Modified: RLVa-1.0.0h LLViewerInventoryCategory* RlvInventory::getSharedRoot() const { if (gInventory.isInventoryUsable()) { LLInventoryModel::cat_array_t* pFolders; LLInventoryModel::item_array_t* pItems; gInventory.getDirectDescendentsOf(gInventory.getRootFolderID(), pFolders, pItems); if (pFolders) { // NOTE: we might have multiple #RLV folders so we'll just go with the first one we come across LLViewerInventoryCategory* pFolder; for (S32 idxFolder = 0, cntFolder = pFolders->count(); idxFolder < cntFolder; idxFolder++) { if ( ((pFolder = pFolders->get(idxFolder)) != NULL) && (RlvInventory::cstrSharedRoot == pFolder->getName()) ) return pFolder; } } } return NULL; }
//static void LLLocalInventory::saveInvCache(std::string filename, LLFolderView* folder) { LLInventoryModel* model = &gInventory; std::set<LLUUID> selected_items; folder->getSelectionList(selected_items); if(selected_items.size() < 1) { // No items selected? Wtfboom return; } LLInventoryModel::cat_array_t cats; LLInventoryModel::item_array_t items; // Make complete lists of child categories and items std::set<LLUUID>::iterator sel_iter = selected_items.begin(); std::set<LLUUID>::iterator sel_end = selected_items.end(); for( ; sel_iter != sel_end; ++sel_iter) { LLInventoryCategory* cat = model->getCategory(*sel_iter); if(cat) { climb(cat, cats, items); } } // And what about items inside a folder that wasn't selected? // I guess I will just add selected items, so long as they aren't already added for(sel_iter = selected_items.begin(); sel_iter != sel_end; ++sel_iter) { LLInventoryItem* item = model->getItem(*sel_iter); if(item) { if(std::find(items.begin(), items.end(), item) == items.end()) { items.push_back(LLPointer<LLViewerInventoryItem>((LLViewerInventoryItem*)item)); LLInventoryCategory* parent = model->getCategory(item->getParentUUID()); if(std::find(cats.begin(), cats.end(), parent) == cats.end()) { cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)parent)); } } } } LLInventoryModel::saveToFile(filename, cats, items); }
BOOL LLInventoryFetchDescendentsObserver::isCategoryComplete(const LLViewerInventoryCategory* cat) const { const S32 version = cat->getVersion(); const S32 expected_num_descendents = cat->getDescendentCount(); if ((version == LLViewerInventoryCategory::VERSION_UNKNOWN) || (expected_num_descendents == LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)) { return FALSE; } // it might be complete - check known descendents against // currently available. LLInventoryModel::cat_array_t* cats; LLInventoryModel::item_array_t* items; gInventory.getDirectDescendentsOf(cat->getUUID(), cats, items); if (!cats || !items) { LL_WARNS() << "Category '" << cat->getName() << "' descendents corrupted, fetch failed." << LL_ENDL; // NULL means the call failed -- cats/items map doesn't exist (note: this does NOT mean // that the cat just doesn't have any items or subfolders). // Unrecoverable, so just return done so that this observer can be cleared // from memory. return TRUE; } const S32 current_num_known_descendents = cats->size() + items->size(); // Got the number of descendents that we were expecting, so we're done. if (current_num_known_descendents == expected_num_descendents) { return TRUE; } // Error condition, but recoverable. This happens if something was added to the // category before it was initialized, so accountForUpdate didn't update descendent // count and thus the category thinks it has fewer descendents than it actually has. if (current_num_known_descendents >= expected_num_descendents) { LL_WARNS() << "Category '" << cat->getName() << "' expected descendentcount:" << expected_num_descendents << " descendents but got descendentcount:" << current_num_known_descendents << LL_ENDL; const_cast<LLViewerInventoryCategory *>(cat)->setDescendentCount(current_num_known_descendents); return TRUE; } return FALSE; }
LLUUID FSLSLBridge::findFSCategory() { if (!mBridgeFolderID.isNull()) { return mBridgeFolderID; } LLUUID fsCatID; LLUUID bridgeCatID; fsCatID = gInventory.findCategoryByName(ROOT_FIRESTORM_FOLDER); if (!fsCatID.isNull()) { LLInventoryModel::item_array_t* items; LLInventoryModel::cat_array_t* cats; gInventory.getDirectDescendentsOf(fsCatID, cats, items); if (cats) { S32 count = cats->count(); for (S32 i = 0; i < count; ++i) { if (cats->get(i)->getName() == FS_BRIDGE_FOLDER) { bridgeCatID = cats->get(i)->getUUID(); } } } } else { fsCatID = gInventory.createNewCategory(gInventory.getRootFolderID(), LLFolderType::FT_NONE, ROOT_FIRESTORM_FOLDER); } if (bridgeCatID.isNull()) { bridgeCatID = gInventory.createNewCategory(fsCatID, LLFolderType::FT_NONE, FS_BRIDGE_FOLDER); } mBridgeFolderID = bridgeCatID; return mBridgeFolderID; }
const LLUUID& get_folder_uuid(const LLUUID& parentFolderUUID, LLInventoryCollectFunctor& matchFunctor) { LLInventoryModel::cat_array_t cats; LLInventoryModel::item_array_t items; gInventory.collectDescendentsIf(parentFolderUUID, cats, items, LLInventoryModel::EXCLUDE_TRASH, matchFunctor); S32 cats_count = cats.count(); if (cats_count > 1) { LL_WARNS("LLFriendCardsManager") << "There is more than one Friend card folder." << "The first folder will be used." << LL_ENDL; } return (cats_count >= 1) ? cats.get(0)->getUUID() : LLUUID::null; }
void LLFloaterOutbox::updateFolderCount() { S32 item_count = 0; if (mOutboxId.notNull()) { LLInventoryModel::cat_array_t * cats; LLInventoryModel::item_array_t * items; gInventory.getDirectDescendentsOf(mOutboxId, cats, items); item_count = cats->count() + items->count(); } mOutboxItemCount = item_count; if (!mImportBusy) { updateFolderCountStatus(); } }
void LLFriendCardsManager::collectFriendsLists(folderid_buddies_map_t& folderBuddiesMap) const { folderBuddiesMap.clear(); LLInventoryModel::cat_array_t* listFolders; LLInventoryModel::item_array_t* items; // get folders in the Friend folder. Items should be NULL due to Cards should be in lists. gInventory.getDirectDescendentsOf(findFriendFolderUUIDImpl(), listFolders, items); if (NULL == listFolders) return; LLInventoryModel::cat_array_t::const_iterator itCats; // to iterate Friend Lists (categories) LLInventoryModel::item_array_t::const_iterator itBuddy; // to iterate Buddies in each List LLInventoryModel::cat_array_t* fakeCatsArg; for (itCats = listFolders->begin(); itCats != listFolders->end(); ++itCats) { if (items) items->clear(); // *HACK: Only Friends/All content will be shown for now // *TODO: Remove this hack, implement sorting if it will be needded by spec. if ((*itCats)->getUUID() != findFriendAllSubfolderUUIDImpl()) continue; gInventory.getDirectDescendentsOf((*itCats)->getUUID(), fakeCatsArg, items); if (NULL == items) continue; uuid_vec_t buddyUUIDs; for (itBuddy = items->begin(); itBuddy != items->end(); ++itBuddy) { buddyUUIDs.push_back((*itBuddy)->getCreatorUUID()); } folderBuddiesMap.insert(make_pair((*itCats)->getUUID(), buddyUUIDs)); } }
void LLCOFMgr::checkCOF() { const LLUUID idCOF = getCOF(); const LLUUID idLAF = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND); // Check COF for non-links and move them to Lost&Found LLInventoryModel::cat_array_t* pFolders; LLInventoryModel::item_array_t* pItems; gInventory.getDirectDescendentsOf(idCOF, pFolders, pItems); for (S32 idxFolder = 0, cntFolder = pFolders->count(); idxFolder < cntFolder; idxFolder++) { LLViewerInventoryCategory* pFolder = pFolders->get(idxFolder).get(); if ( (pFolder) && (idLAF.notNull()) ) change_category_parent(&gInventory, pFolder, idLAF, false); } for (S32 idxItem = 0, cntItem = pItems->count(); idxItem < cntItem; idxItem++) { LLViewerInventoryItem* pItem = pItems->get(idxItem).get(); if ( (pItem) && (!pItem->getIsLinkType()) && (idLAF.notNull()) ) change_item_parent(&gInventory, pItem, idLAF, false); } }
virtual ~LLOrderMyOutfitsOnDestroy() { if (!LLApp::isRunning()) { llwarns << "called during shutdown, skipping" << llendl; return; } const LLUUID& my_outfits_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS); if (my_outfits_id.isNull()) return; LLInventoryModel::cat_array_t* cats; LLInventoryModel::item_array_t* items; gInventory.getDirectDescendentsOf(my_outfits_id, cats, items); if (!cats) return; //My Outfits should at least contain saved initial outfit and one another outfit if (cats->size() < 2) { llwarning("My Outfits category was not populated properly", 0); return; } llinfos << "Starting updating My Outfits with wearables ordering information" << llendl; for (LLInventoryModel::cat_array_t::iterator outfit_iter = cats->begin(); outfit_iter != cats->end(); ++outfit_iter) { const LLUUID& cat_id = (*outfit_iter)->getUUID(); if (cat_id.isNull()) continue; // saved initial outfit already contains wearables ordering information if (cat_id == LLAppearanceMgr::getInstance()->getBaseOutfitUUID()) continue; LLAppearanceMgr::getInstance()->updateClothingOrderingInfo(cat_id); } llinfos << "Finished updating My Outfits with wearables ordering information" << llendl; }
// LLUUID catID=TraverseCategories("/My Inventory/#Luna/Durp") LLUUID TraverseCategories(const std::string& target_cat, LLViewerInventoryCategory *ccat, int i) { // Split the path into an array. boost::char_separator<char> sep("/"); boost::tokenizer<boost::char_separator<char> > tok(target_cat,sep); std::vector<std::string> vec; vec.assign(tok.begin(),tok.end()); std::string cat = vec[i]; LLUUID id; if(i==0) { id=gAgent.getInventoryRootID(); } else { id = ccat->getUUID(); } LLInventoryModel::cat_array_t *cats; LLInventoryModel::item_array_t *items; gInventory.getDirectDescendentsOf(id,cats,items); LLInventoryModel::cat_array_t::iterator cat_iter = cats->begin(); LLInventoryModel::cat_array_t::iterator cat_end = cats->end(); for( ; cat_iter != cat_end; ++cat_iter) { LLViewerInventoryCategory *c_cat=(*cat_iter); if(c_cat->getName() == cat) { if(vec.size() == i+1) { return c_cat->getUUID(); } else { ++i; return TraverseCategories(target_cat,*cat_iter,i); } } } return LLUUID::null; }
// Checked: 2010-08-30 (RLVa-1.2.1c) | Modified: RLVa-1.2.1c bool RlvInventory::getPath(const uuid_vec_t& idItems, LLInventoryModel::cat_array_t& folders) const { // Sanity check - can't do anything without a shared root const LLViewerInventoryCategory* pRlvRoot = RlvInventory::instance().getSharedRoot(); if (!pRlvRoot) return false; folders.clear(); for (uuid_vec_t::const_iterator itItem = idItems.begin(); itItem != idItems.end(); ++itItem) { const LLInventoryItem* pItem = gInventory.getItem(*itItem); if ( (pItem) && (gInventory.isObjectDescendentOf(pItem->getUUID(), pRlvRoot->getUUID())) ) { // If the containing folder is a folded folder we need its parent LLViewerInventoryCategory* pFolder = gInventory.getCategory(pItem->getParentUUID()); if (RlvInventory::instance().isFoldedFolder(pFolder, true)) pFolder = gInventory.getCategory(pFolder->getParentUUID()); folders.push_back(pFolder); } } return (folders.count() != 0); }
void LLPanelLandmarkInfo::populateFoldersList() { // Collect all folders that can contain landmarks. LLInventoryModel::cat_array_t cats; collectLandmarkFolders(cats); mFolderCombo->removeall(); // Put the "Landmarks" folder first in list. LLUUID landmarks_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK); const LLViewerInventoryCategory* lmcat = gInventory.getCategory(landmarks_id); if (!lmcat) { LL_WARNS() << "Cannot find the landmarks folder" << LL_ENDL; } else { std::string cat_full_name = getFullFolderName(lmcat); mFolderCombo->add(cat_full_name, lmcat->getUUID()); } typedef std::vector<folder_pair_t> folder_vec_t; folder_vec_t folders; // Sort the folders by their full name. for (S32 i = 0; i < cats.size(); i++) { const LLViewerInventoryCategory* cat = cats.at(i); std::string cat_full_name = getFullFolderName(cat); folders.push_back(folder_pair_t(cat->getUUID(), cat_full_name)); } sort(folders.begin(), folders.end(), cmp_folders); // Finally, populate the combobox. for (folder_vec_t::const_iterator it = folders.begin(); it != folders.end(); it++) mFolderCombo->add(it->second, LLSD(it->first)); }
void LLInventoryCategoriesObserver::changed(U32 mask) { if (!mCategoryMap.size()) return; std::vector<LLUUID> deleted_categories_ids; for (category_map_t::iterator iter = mCategoryMap.begin(); iter != mCategoryMap.end(); ++iter) { const LLUUID& cat_id = (*iter).first; LLCategoryData& cat_data = (*iter).second; LLViewerInventoryCategory* category = gInventory.getCategory(cat_id); if (!category) { LL_WARNS() << "Category : Category id = " << cat_id << " disappeared" << LL_ENDL; cat_data.mCallback(); // Keep track of those deleted categories so we can remove them deleted_categories_ids.push_back(cat_id); continue; } const S32 version = category->getVersion(); const S32 expected_num_descendents = category->getDescendentCount(); if ((version == LLViewerInventoryCategory::VERSION_UNKNOWN) || (expected_num_descendents == LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)) { continue; } // Check number of known descendents to find out whether it has changed. LLInventoryModel::cat_array_t* cats; LLInventoryModel::item_array_t* items; gInventory.getDirectDescendentsOf(cat_id, cats, items); if (!cats || !items) { LL_WARNS() << "Category '" << category->getName() << "' descendents corrupted, fetch failed." << LL_ENDL; // NULL means the call failed -- cats/items map doesn't exist (note: this does NOT mean // that the cat just doesn't have any items or subfolders). // Unrecoverable, so just skip this category. llassert(cats != NULL && items != NULL); continue; } const S32 current_num_known_descendents = cats->size() + items->size(); bool cat_changed = false; // If category version or descendents count has changed // update category data in mCategoryMap if (version != cat_data.mVersion || current_num_known_descendents != cat_data.mDescendentsCount) { cat_data.mVersion = version; cat_data.mDescendentsCount = current_num_known_descendents; cat_changed = true; } // If any item names have changed, update the name hash // Only need to check if (a) name hash has not previously been // computed, or (b) a name has changed. if (!cat_data.mIsNameHashInitialized || (mask & LLInventoryObserver::LABEL)) { LLMD5 item_name_hash = gInventory.hashDirectDescendentNames(cat_id); if (cat_data.mItemNameHash != item_name_hash) { cat_data.mIsNameHashInitialized = true; cat_data.mItemNameHash = item_name_hash; cat_changed = true; } } // If anything has changed above, fire the callback. if (cat_changed) cat_data.mCallback(); } // Remove deleted categories from the list for (std::vector<LLUUID>::iterator deleted_id = deleted_categories_ids.begin(); deleted_id != deleted_categories_ids.end(); ++deleted_id) { removeCategory(*deleted_id); } }
void AIFetchInventoryFolder::multiplex_impl(void) { switch (mRunState) { case AIFetchInventoryFolder_checkFolderExists: { // If LLInventoryModel_mIsAgentInvUsable_true then this should be and stay true forever. llassert(gInventory.isInventoryUsable()); if (mParentFolder.isNull()) mParentFolder = gAgent.getInventoryRootID(); if (mFolderUUID.isNull() || !gInventory.getCategory(mFolderUUID)) // Is the UUID unknown, or doesn't exist? { // Set this to null here in case we abort. mFolderUUID.setNull(); if (mFolderName.empty()) { // We can only find a folder by name, or create it, if we know it's name. llwarns << "Unknown folder ID " << mFolderUUID << llendl; abort(); break; } // Check if the parent exists. if (mParentFolder != gAgent.getInventoryRootID() && !gInventory.getCategory(mParentFolder)) { llwarns << "Unknown parent folder ID " << mParentFolder << llendl; abort(); break; } // Look up UUID by name. LLInventoryModel::cat_array_t* categories; gInventory.getDirectDescendentsOf(mParentFolder, categories); for (S32 i = 0; i < categories->getLength(); ++i) { LLPointer<LLViewerInventoryCategory> const& category(categories->get(i)); if (category->getName() == mFolderName) { mFolderUUID = category->getUUID(); break; } } if (mFolderUUID.isNull()) // Does the folder exist? { if (!mCreate) { // We're done. finish(); break; } // Create the folder. mFolderUUID = gInventory.createNewCategory(mParentFolder, LLAssetType::AT_NONE, mFolderName); llassert_always(!mFolderUUID.isNull()); Dout(dc::statemachine, "Created folder \"" << mFolderName << "\"."); mNeedNotifyObservers = true; } mCreated = true; } // mFolderUUID is now valid. mExists = true; if (!mFetchContents || // No request to fetch contents. LLInventoryModel::isEverythingFetched()) // No need to fetch contents. { // We're done. finish(); break; } set_state(AIFetchInventoryFolder_fetchDescendents); /*Fall-through*/ } case AIFetchInventoryFolder_fetchDescendents: { // This sets the state to AIFetchInventoryFolder_folderCompleted once the folder is complete. new AIInventoryFetchDescendentsObserver(this, mFolderUUID); break; } case AIFetchInventoryFolder_folderCompleted: { // Does it still exist? if (!gInventory.getCategory(mFolderUUID)) { // Assume the folder was deleted in the meantime. abort(); break; } llassert(gInventory.isCategoryComplete(mFolderUUID)); // The folder is complete! finish(); break; } } }