llinventorymodel.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:29k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llinventorymodel.h
  3.  * @brief LLInventoryModel class header file
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_LLINVENTORYMODEL_H
  33. #define LL_LLINVENTORYMODEL_H
  34. #include "llassettype.h"
  35. #include "llfoldertype.h"
  36. #include "lldarray.h"
  37. #include "llframetimer.h"
  38. #include "llhttpclient.h"
  39. #include "lluuid.h"
  40. #include "llpermissionsflags.h"
  41. #include "llstring.h"
  42. #include <map>
  43. #include <set>
  44. #include <string>
  45. #include <vector>
  46. class LLInventoryObserver;
  47. class LLInventoryObject;
  48. class LLInventoryItem;
  49. class LLInventoryCategory;
  50. class LLViewerInventoryItem;
  51. class LLViewerInventoryCategory;
  52. class LLViewerInventoryItem;
  53. class LLViewerInventoryCategory;
  54. class LLMessageSystem;
  55. class LLInventoryCollectFunctor;
  56. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  57. // Class LLInventoryModel
  58. //
  59. // This class represents a collection of inventory, and provides
  60. // efficient ways to access that information. This class could in
  61. // theory be used for any place where you need inventory, though it
  62. // optimizes for time efficiency - not space efficiency, probably
  63. // making it inappropriate for use on tasks.
  64. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  65. class LLInventoryModel
  66. {
  67. public:
  68. friend class LLInventoryModelFetchDescendentsResponder;
  69. enum EHasChildren
  70. {
  71. CHILDREN_NO,
  72. CHILDREN_YES,
  73. CHILDREN_MAYBE
  74. };
  75. // These are used a lot...
  76. typedef LLDynamicArray<LLPointer<LLViewerInventoryCategory> > cat_array_t;
  77. typedef LLDynamicArray<LLPointer<LLViewerInventoryItem> > item_array_t;
  78. typedef std::set<LLUUID> changed_items_t;
  79. // construction & destruction
  80. LLInventoryModel();
  81. ~LLInventoryModel();
  82. void cleanupInventory();
  83. class fetchInventoryResponder : public LLHTTPClient::Responder
  84. {
  85. public:
  86. fetchInventoryResponder(const LLSD& request_sd) : mRequestSD(request_sd) {};
  87. void result(const LLSD& content);
  88. void error(U32 status, const std::string& reason);
  89. public:
  90. typedef std::vector<LLViewerInventoryCategory*> folder_ref_t;
  91. protected:
  92. LLSD mRequestSD;
  93. };
  94. //
  95. // Accessors
  96. //
  97. // Check if one object has a parent chain up to the category specified by UUID.
  98. BOOL isObjectDescendentOf(const LLUUID& obj_id, const LLUUID& cat_id) const;
  99. // Get whatever special folder this object is a child of, if any.
  100. const LLViewerInventoryCategory *getFirstNondefaultParent(const LLUUID& obj_id) const;
  101. // Get the object by id. Returns NULL if not found.
  102. // * WARNING: use the pointer returned for read operations - do
  103. // not modify the object values in place or you will break stuff.
  104. LLInventoryObject* getObject(const LLUUID& id) const;
  105. // Get the item by id. Returns NULL if not found.
  106. // * WARNING: use the pointer for read operations - use the
  107. // updateItem() method to actually modify values.
  108. LLViewerInventoryItem* getItem(const LLUUID& id) const;
  109. // Get the category by id. Returns NULL if not found.
  110. // * WARNING: use the pointer for read operations - use the
  111. // updateCategory() method to actually modify values.
  112. LLViewerInventoryCategory* getCategory(const LLUUID& id) const;
  113. // Return the number of items or categories
  114. S32 getItemCount() const;
  115. S32 getCategoryCount() const;
  116. // Return the direct descendents of the id provided.Set passed
  117. // in values to NULL if the call fails.
  118. // *WARNING: The array provided points straight into the guts of
  119. // this object, and should only be used for read operations, since
  120. // modifications may invalidate the internal state of the
  121. // inventory.
  122. void getDirectDescendentsOf(const LLUUID& cat_id,
  123. cat_array_t*& categories,
  124. item_array_t*& items) const;
  125. // SJB: Added version to lock the arrays to catch potential logic bugs
  126. void lockDirectDescendentArrays(const LLUUID& cat_id,
  127. cat_array_t*& categories,
  128. item_array_t*& items);
  129. void unlockDirectDescendentArrays(const LLUUID& cat_id);
  130. // Starting with the object specified, add its descendents to the
  131. // array provided, but do not add the inventory object specified
  132. // by id. There is no guaranteed order. Neither array will be
  133. // erased before adding objects to it. Do not store a copy of the
  134. // pointers collected - use them, and collect them again later if
  135. // you need to reference the same objects.
  136. enum { EXCLUDE_TRASH = FALSE, INCLUDE_TRASH = TRUE };
  137. void collectDescendents(const LLUUID& id,
  138. cat_array_t& categories,
  139. item_array_t& items,
  140. BOOL include_trash);
  141. void collectDescendentsIf(const LLUUID& id,
  142.   cat_array_t& categories,
  143.   item_array_t& items,
  144.   BOOL include_trash,
  145.   LLInventoryCollectFunctor& add,
  146.   BOOL follow_folder_links = FALSE);
  147. // Collect all items in inventory that are linked to item_id.
  148. // Assumes item_id is itself not a linked item.
  149. item_array_t collectLinkedItems(const LLUUID& item_id,
  150. const LLUUID& start_folder_id = LLUUID::null);
  151. // Get the inventoryID that this item points to, else just return item_id
  152. const LLUUID& getLinkedItemID(const LLUUID& object_id) const;
  153. // The inventory model usage is sensitive to the initial construction of the 
  154. // model. 
  155. bool isInventoryUsable() const;
  156. //
  157. // Mutators
  158. //
  159. // Calling this method with an inventory item will either change
  160. // an existing item with a matching item_id, or will add the item
  161. // to the current inventory. Returns the change mask generated by
  162. // the update. No notification will be sent to observers. This
  163. // method will only generate network traffic if the item had to be
  164. // reparented.
  165. // *NOTE: In usage, you will want to perform cache accounting
  166. // operations in LLInventoryModel::accountForUpdate() or
  167. // LLViewerInventoryItem::updateServer() before calling this
  168. // method.
  169. U32 updateItem(const LLViewerInventoryItem* item);
  170. // Calling this method with an inventory category will either
  171. // change an existing item with the matching id, or it will add
  172. // the category. No notifcation will be sent to observers. This
  173. // method will only generate network traffic if the item had to be
  174. // reparented.
  175. // *NOTE: In usage, you will want to perform cache accounting
  176. // operations in LLInventoryModel::accountForUpdate() or
  177. // LLViewerInventoryCategory::updateServer() before calling this
  178. // method.
  179. void updateCategory(const LLViewerInventoryCategory* cat);
  180. // This method will move the specified object id to the specified
  181. // category, update the internal structures. No cache accounting,
  182. // observer notification, or server update is performed.
  183. void moveObject(const LLUUID& object_id, const LLUUID& cat_id);
  184. // delete a particular inventory object by ID. This will purge one
  185. // object from the internal data structures maintaining a
  186. // consistent internal state. No cache accounting, observer
  187. // notification, or server update is performed.  Purges linked items.
  188. void deleteObject(const LLUUID& id);
  189. // delete a particular inventory object by ID, and delete it from
  190. // the server.  Also updates linked items.
  191. void purgeObject(const LLUUID& id);
  192. void updateLinkedObjectsFromPurge(const LLUUID& baseobj_id);
  193. // This is a method which collects the descendants of the id
  194. // provided. If the category is not found, no action is
  195. // taken. This method goes through the long winded process of
  196. // removing server representation of folders and items while doing
  197. // cache accounting in a fairly efficient manner. This method does
  198. // not notify observers (though maybe it should...)
  199. void purgeDescendentsOf(const LLUUID& id);
  200. // This method optimally removes the referenced categories and
  201. // items from the current agent's inventory in the database. It
  202. // performs all of the during deletion. The local representation
  203. // is not removed.
  204. void deleteFromServer(LLDynamicArray<LLUUID>& category_ids,
  205.   LLDynamicArray<LLUUID>& item_ids);
  206. // Add/remove an observer. If the observer is destroyed, be sure
  207. // to remove it.
  208. void addObserver(LLInventoryObserver* observer);
  209. void removeObserver(LLInventoryObserver* observer);
  210. BOOL containsObserver(LLInventoryObserver* observer) const;
  211. //
  212. // Misc Methods 
  213. //
  214. // findCategoryUUIDForType() returns the uuid of the category that
  215. // specifies 'type' as what it defaults to containing. The
  216. // category is not necessarily only for that type. *NOTE: If create_folder is true, this
  217. // will create a new inventory category on the fly if one does not exist. *NOTE: if find_in_library is
  218. // true it will search in the user's library folder instead of "My Inventory"
  219. // SDK: Added flag to specify whether the folder should be created if not found.  This fixes the horrible
  220. // multiple trash can bug.
  221. const LLUUID findCategoryUUIDForType(LLFolderType::EType preferred_type, bool create_folder = true, bool find_in_library = false);
  222. // This gets called by the idle loop.  It only updates if new
  223. // state is detected.  Call notifyObservers() manually to update
  224. // regardless of whether state change has been indicated.
  225. void idleNotifyObservers();
  226. // Call this method to explicitly update everyone on a new state.
  227. // The optional argument 'service_name' is used by Agent Inventory Service [DEV-20328]
  228. void notifyObservers(const std::string service_name="");
  229. // This allows outsiders to tell the inventory if something has
  230. // been changed 'under the hood', but outside the control of the
  231. // inventory. For example, if we grant someone modify permissions,
  232. // then that changes the data structures for LLAvatarTracker, but
  233. // potentially affects inventory observers. This API makes sure
  234. // that the next notify will include that notification.
  235. void addChangedMask(U32 mask, const LLUUID& referent);
  236. const changed_items_t& getChangedIDs() const { return mChangedItemIDs; }
  237. // This method to prepares a set of mock inventory which provides
  238. // minimal functionality before the actual arrival of inventory.
  239. //void mock(const LLUUID& root_id);
  240. // Make sure we have the descendents in the structure.  Returns true
  241. // if a fetch was performed.
  242. bool fetchDescendentsOf(const LLUUID& folder_id);
  243. // call this method to request the inventory.
  244. //void requestFromServer(const LLUUID& agent_id);
  245. // call this method on logout to save a terse representation
  246. void cache(const LLUUID& parent_folder_id, const LLUUID& agent_id);
  247. // Generates a string containing the path to the item specified by
  248. // item_id.
  249. void appendPath(const LLUUID& id, std::string& path) const;
  250. // message handling functionality
  251. static void registerCallbacks(LLMessageSystem* msg);
  252. // Convenience function to create a new category. You could call
  253. // updateCatgory() with a newly generated UUID category, but this
  254. // version will take care of details like what the name should be
  255. // based on preferred type. Returns the UUID of the new
  256. // category. If you want to use the default name based on type,
  257. // pass in a NULL to the 'name parameter.
  258. LLUUID createNewCategory(const LLUUID& parent_id,
  259.  LLFolderType::EType preferred_type,
  260.  const std::string& name);
  261. // methods to load up inventory skeleton & meat. These are used
  262. // during authentication. return true if everything parsed.
  263. bool loadSkeleton(const LLSD& options, const LLUUID& owner_id);
  264. bool loadMeat(const LLSD& options, const LLUUID& owner_id);
  265. // This is a brute force method to rebuild the entire parent-child
  266. // relations.
  267. void buildParentChildMap();
  268. //
  269. // Category accounting.
  270. //
  271. // This structure represents the number of items added or removed
  272. // from a category.
  273. struct LLCategoryUpdate
  274. {
  275. LLCategoryUpdate() : mDescendentDelta(0) {}
  276. LLCategoryUpdate(const LLUUID& category_id, S32 delta) :
  277. mCategoryID(category_id),
  278. mDescendentDelta(delta) {}
  279. LLUUID mCategoryID;
  280. S32 mDescendentDelta;
  281. };
  282. typedef std::vector<LLCategoryUpdate> update_list_t;
  283. // This structure eixts to make it easier to account for deltas in
  284. // a map.
  285. struct LLInitializedS32
  286. {
  287. LLInitializedS32() : mValue(0) {}
  288. LLInitializedS32(S32 value) : mValue(value) {}
  289. S32 mValue;
  290. LLInitializedS32& operator++() { ++mValue; return *this; }
  291. LLInitializedS32& operator--() { --mValue; return *this; }
  292. };
  293. typedef std::map<LLUUID, LLInitializedS32> update_map_t;
  294. // Call these methods when there are category updates, but call
  295. // them *before* the actual update so the method can do descendent
  296. // accounting correctly.
  297. void accountForUpdate(const LLCategoryUpdate& update) const;
  298. void accountForUpdate(const update_list_t& updates);
  299. void accountForUpdate(const update_map_t& updates);
  300. // Return child status of category children. yes/no/maybe
  301. EHasChildren categoryHasChildren(const LLUUID& cat_id) const;
  302. // returns true iff category version is known and theoretical
  303. // descendents == actual descendents.
  304. bool isCategoryComplete(const LLUUID& cat_id) const;
  305. // callbacks
  306. // Trigger a notification and empty the folder type (FT_TRASH or FT_LOST_AND_FOUND) if confirmed
  307. void emptyFolderType(const std::string notification, LLFolderType::EType folder_type);
  308. bool callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLFolderType::EType preferred_type);
  309. // Utility Functions
  310. void removeItem(const LLUUID& item_id);
  311.     static void findLostItems();
  312. // Data about the agent's root folder and root library folder
  313. // are stored here, rather than in LLAgent where it used to be, because
  314. // gInventory is a singleton and represents the agent's inventory.
  315. // The "library" is actually the inventory of a special agent,
  316. // usually Alexandria Linden.
  317. const LLUUID &getRootFolderID() const;
  318. const LLUUID &getLibraryOwnerID() const;
  319. const LLUUID &getLibraryRootFolderID() const;
  320. // These are set during login with data from the server
  321. void setRootFolderID(const LLUUID& id);
  322. void setLibraryOwnerID(const LLUUID& id);
  323. void setLibraryRootFolderID(const LLUUID& id);
  324. /**
  325.  * Changes items order by insertion of the item identified by src_item_id
  326.  * BEFORE the item identified by dest_item_id. Both items must exist in items array.
  327.  *
  328.  * Sorting is stored after method is finished. Only src_item_id is moved before dest_item_id.
  329.  *
  330.  * @param[in, out] items - vector with items to be updated. It should be sorted in a right way
  331.  * before calling this method.
  332.  * @param src_item_id - LLUUID of inventory item to be moved in new position
  333.  * @param dest_item_id - LLUUID of inventory item before which source item should be placed.
  334.  */
  335. static void updateItemsOrder(LLInventoryModel::item_array_t& items, const LLUUID& src_item_id, const LLUUID& dest_item_id);
  336. /**
  337.  * Saves current order of the passed items using inventory item sort field.
  338.  *
  339.  * It reset items' sort fields and saves them on server.
  340.  * Is used to save order for Favorites folder.
  341.  *
  342.  * @param[in] items vector of items in order to be saved.
  343.  */
  344. void saveItemsOrder(const LLInventoryModel::item_array_t& items);
  345. /**
  346.  * Rearranges Landmarks inside Favorites folder.
  347.  * Moves source landmark before target one.
  348.  *
  349.  * @param source_item_id - LLUUID of the source item to be moved into new position
  350.  * @param target_item_id - LLUUID of the target item before which source item should be placed.
  351.  */
  352. void rearrangeFavoriteLandmarks(const LLUUID& source_item_id, const LLUUID& target_item_id);
  353. protected:
  354. // Internal methods which add inventory and make sure that all of
  355. // the internal data structures are consistent. These methods
  356. // should be passed pointers of newly created objects, and the
  357. // instance will take over the memory management from there.
  358. void addCategory(LLViewerInventoryCategory* category);
  359. void addItem(LLViewerInventoryItem* item);
  360. // ! DEPRECRATE ! Remove this and add it into findCategoryUUIDForType,
  361. // since that's the only function that uses this.  It's too confusing 
  362. // having both methods.
  363. // 
  364. // Internal method which looks for a category with the specified
  365. // preferred type. Returns LLUUID::null if not found
  366.   const LLUUID &findCatUUID(LLFolderType::EType preferred_type, bool find_in_library = false) const;
  367. // Empty the entire contents
  368. void empty();
  369. // Given the current state of the inventory items, figure out the
  370. // clone information. *FIX: This is sub-optimal, since we can
  371. // insert this information snurgically, but this makes sure the
  372. // implementation works before we worry about optimization.
  373. //void recalculateCloneInformation();
  374. // file import/export.
  375. static bool loadFromFile(const std::string& filename,
  376.  cat_array_t& categories,
  377.  item_array_t& items,
  378.  bool& is_cache_obsolete); 
  379. static bool saveToFile(const std::string& filename,
  380.    const cat_array_t& categories,
  381.    const item_array_t& items); 
  382. // message handling functionality
  383. //static void processUseCachedInventory(LLMessageSystem* msg, void**);
  384. static void processUpdateCreateInventoryItem(LLMessageSystem* msg, void**);
  385. static void processRemoveInventoryItem(LLMessageSystem* msg, void**);
  386. static void processUpdateInventoryFolder(LLMessageSystem* msg, void**);
  387. static void processRemoveInventoryFolder(LLMessageSystem* msg, void**);
  388. //static void processExchangeCallingcard(LLMessageSystem* msg, void**);
  389. //static void processAddCallingcard(LLMessageSystem* msg, void**);
  390. //static void processDeclineCallingcard(LLMessageSystem* msg, void**);
  391. static void processSaveAssetIntoInventory(LLMessageSystem* msg, void**);
  392. static void processBulkUpdateInventory(LLMessageSystem* msg, void**);
  393. static void processInventoryDescendents(LLMessageSystem* msg, void**);
  394. static void processMoveInventoryItem(LLMessageSystem* msg, void**);
  395. static void processFetchInventoryReply(LLMessageSystem* msg, void**);
  396. bool messageUpdateCore(LLMessageSystem* msg, bool do_accounting);
  397. // Updates all linked items pointing to this id.
  398. void addChangedMaskForLinks(const LLUUID& object_id, U32 mask);
  399. protected:
  400. cat_array_t* getUnlockedCatArray(const LLUUID& id);
  401. item_array_t* getUnlockedItemArray(const LLUUID& id);
  402. private:
  403. // Variables used to track what has changed since the last notify.
  404. U32 mModifyMask;
  405. changed_items_t mChangedItemIDs;
  406. std::map<LLUUID, bool> mCategoryLock;
  407. std::map<LLUUID, bool> mItemLock;
  408. // cache recent lookups
  409. mutable LLPointer<LLViewerInventoryItem> mLastItem;
  410. // This last set of indices is used to map parents to children.
  411. typedef std::map<LLUUID, cat_array_t*> parent_cat_map_t;
  412. typedef std::map<LLUUID, item_array_t*> parent_item_map_t;
  413. parent_cat_map_t mParentChildCategoryTree;
  414. parent_item_map_t mParentChildItemTree;
  415. typedef std::set<LLInventoryObserver*> observer_list_t;
  416. observer_list_t mObservers;
  417. // Agent inventory folder information.
  418. LLUUID mRootFolderID;
  419. LLUUID mLibraryRootFolderID;
  420. LLUUID mLibraryOwnerID;
  421. static BOOL sTimelyFetchPending;
  422. static S32  sNumFetchRetries;
  423. static LLFrameTimer sFetchTimer;
  424. static F32 sMinTimeBetweenFetches;
  425. static F32 sMaxTimeBetweenFetches;
  426. // Expected inventory cache version
  427. const static S32 sCurrentInvCacheVersion;
  428. // This flag is used to handle an invalid inventory state.
  429. bool mIsAgentInvUsable;
  430. private:
  431. // Information for tracking the actual inventory. We index this
  432. // information in a lot of different ways so we can access
  433. // the inventory using several different identifiers.
  434. // mInventory member data is the 'master' list of inventory, and
  435. // mCategoryMap and mItemMap store uuid->object mappings. 
  436. typedef std::map<LLUUID, LLPointer<LLViewerInventoryCategory> > cat_map_t;
  437. typedef std::map<LLUUID, LLPointer<LLViewerInventoryItem> > item_map_t;
  438. //inv_map_t mInventory;
  439. cat_map_t mCategoryMap;
  440. item_map_t mItemMap;
  441. // Flag set when notifyObservers is being called, to look for bugs
  442. // where it's called recursively.
  443. BOOL mIsNotifyObservers;
  444. public:
  445. // *NOTE: DEBUG functionality
  446. void dumpInventory() const;
  447. ////////////////////////////////////////////////////////////////////////////////
  448. // Bulk fetch
  449. public:
  450. // Start and stop background breadth-first fetching of inventory contents.
  451. // This gets triggered when performing a filter-search
  452. void startBackgroundFetch(const LLUUID& cat_id = LLUUID::null);
  453. static BOOL backgroundFetchActive();
  454. static bool isEverythingFetched();
  455. static void backgroundFetch(void*); // background fetch idle function
  456. static void incrBulkFetch(S16 fetching) {  sBulkFetchCount+=fetching; if (sBulkFetchCount<0) sBulkFetchCount=0; }
  457. static void stopBackgroundFetch(); // stop fetch process
  458. static bool isBulkFetchProcessingComplete();
  459. // Add categories to a list to be fetched in bulk.
  460. static void bulkFetch(std::string url);
  461. static bool libraryFetchStarted();
  462. static bool libraryFetchCompleted();
  463. static bool libraryFetchInProgress();
  464. static bool myInventoryFetchStarted();
  465. static bool myInventoryFetchCompleted();
  466. static bool myInventoryFetchInProgress();
  467. private:
  468.   static BOOL sMyInventoryFetchStarted;
  469. static BOOL sLibraryFetchStarted;
  470. static BOOL sAllFoldersFetched; 
  471. static void setAllFoldersFetched();
  472. // completing the fetch once per session should be sufficient
  473. static BOOL sBackgroundFetchActive;
  474. static S16 sBulkFetchCount;
  475. ////////////////////////////////////////////////////////////////////////////////
  476. // Login status
  477. public:
  478. static BOOL getIsFirstTimeInViewer2();
  479. private:
  480. static BOOL sFirstTimeInViewer2;
  481. };
  482. // a special inventory model for the agent
  483. extern LLInventoryModel gInventory;
  484. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  485. // Class LLInventoryCollectFunctor
  486. //
  487. // Base class for LLInventoryModel::collectDescendentsIf() method
  488. // which accepts an instance of one of these objects to use as the
  489. // function to determine if it should be added. Derive from this class
  490. // and override the () operator to return TRUE if you want to collect
  491. // the category or item passed in.
  492. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  493. class LLInventoryCollectFunctor
  494. {
  495. public:
  496. virtual ~LLInventoryCollectFunctor(){};
  497. virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item) = 0;
  498. static bool itemTransferCommonlyAllowed(LLInventoryItem* item);
  499. };
  500. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  501. // Class LLAssetIDMatches
  502. //
  503. // This functor finds inventory items pointing to the specified asset
  504. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  505. class LLViewerInventoryItem;
  506. class LLAssetIDMatches : public LLInventoryCollectFunctor
  507. {
  508. public:
  509. LLAssetIDMatches(const LLUUID& asset_id) : mAssetID(asset_id) {}
  510. virtual ~LLAssetIDMatches() {}
  511. bool operator()(LLInventoryCategory* cat, LLInventoryItem* item);
  512. protected:
  513. LLUUID mAssetID;
  514. };
  515. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  516. // Class LLLinkedItemIDMatches
  517. //
  518. // This functor finds inventory items linked to the specific inventory id.
  519. // Assumes the inventory id is itself not a linked item.
  520. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  521. class LLLinkedItemIDMatches : public LLInventoryCollectFunctor
  522. {
  523. public:
  524. LLLinkedItemIDMatches(const LLUUID& item_id) : mBaseItemID(item_id) {}
  525. virtual ~LLLinkedItemIDMatches() {}
  526. bool operator()(LLInventoryCategory* cat, LLInventoryItem* item);
  527. protected:
  528. LLUUID mBaseItemID;
  529. };
  530. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  531. // Class LLIsType
  532. //
  533. // Implementation of a LLInventoryCollectFunctor which returns TRUE if
  534. // the type is the type passed in during construction.
  535. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  536. class LLIsType : public LLInventoryCollectFunctor
  537. {
  538. public:
  539. LLIsType(LLAssetType::EType type) : mType(type) {}
  540. virtual ~LLIsType() {}
  541. virtual bool operator()(LLInventoryCategory* cat,
  542. LLInventoryItem* item);
  543. protected:
  544. LLAssetType::EType mType;
  545. };
  546. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  547. // Class LLIsNotType
  548. //
  549. // Implementation of a LLInventoryCollectFunctor which returns FALSE if the
  550. // type is the type passed in during construction, otherwise false.
  551. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  552. class LLIsNotType : public LLInventoryCollectFunctor
  553. {
  554. public:
  555. LLIsNotType(LLAssetType::EType type) : mType(type) {}
  556. virtual ~LLIsNotType() {}
  557. virtual bool operator()(LLInventoryCategory* cat,
  558. LLInventoryItem* item);
  559. protected:
  560. LLAssetType::EType mType;
  561. };
  562. class LLIsTypeWithPermissions : public LLInventoryCollectFunctor
  563. {
  564. public:
  565. LLIsTypeWithPermissions(LLAssetType::EType type, const PermissionBit perms, const LLUUID &agent_id, const LLUUID &group_id) 
  566. : mType(type), mPerm(perms), mAgentID(agent_id), mGroupID(group_id) {}
  567. virtual ~LLIsTypeWithPermissions() {}
  568. virtual bool operator()(LLInventoryCategory* cat,
  569. LLInventoryItem* item);
  570. protected:
  571. LLAssetType::EType mType;
  572. PermissionBit mPerm;
  573. LLUUID mAgentID;
  574. LLUUID mGroupID;
  575. };
  576. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  577. // Class LLIsClone
  578. //
  579. // Implementation of a LLInventoryCollectFunctor which returns TRUE if
  580. // the object is a clone of the item passed in during
  581. // construction.
  582. //
  583. // *NOTE: Since clone information is determined based off of asset id
  584. // (or creator with calling cards), if the id is NULL, it has no
  585. // clones - even itself.
  586. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  587. //class LLIsClone : public LLInventoryCollectFunctor
  588. //{
  589. //public:
  590. // LLIsClone(LLViewerInventoryItem* item) : mItem(item) {}
  591. // virtual ~LLIsClone() {}
  592. // virtual bool operator()(LLViewerInventoryCategory* cat,
  593. // LLViewerInventoryItem* item);
  594. //protected:
  595. // LLPointer<LLViewerInventoryItem> mItem;
  596. //};
  597. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  598. // Class LLBuddyCollector
  599. //
  600. // Simple class that collects calling cards that are not null, and not
  601. // the agent. Duplicates are possible.
  602. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  603. class LLBuddyCollector : public LLInventoryCollectFunctor
  604. {
  605. public:
  606. LLBuddyCollector() {}
  607. virtual ~LLBuddyCollector() {}
  608. virtual bool operator()(LLInventoryCategory* cat,
  609. LLInventoryItem* item);
  610. };
  611. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  612. // Class LLUniqueBuddyCollector
  613. //
  614. // Simple class that collects calling cards that are not null, and not
  615. // the agent. Duplicates are discarded.
  616. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  617. class LLUniqueBuddyCollector : public LLInventoryCollectFunctor
  618. {
  619. public:
  620. LLUniqueBuddyCollector() {}
  621. virtual ~LLUniqueBuddyCollector() {}
  622. virtual bool operator()(LLInventoryCategory* cat,
  623. LLInventoryItem* item);
  624. protected:
  625. std::set<LLUUID> mSeen;
  626. };
  627. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  628. // Class LLParticularBuddyCollector
  629. //
  630. // Simple class that collects calling cards that match a particular uuid
  631. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  632. class LLParticularBuddyCollector : public LLInventoryCollectFunctor
  633. {
  634. public:
  635. LLParticularBuddyCollector(const LLUUID& id) : mBuddyID(id) {}
  636. virtual ~LLParticularBuddyCollector() {}
  637. virtual bool operator()(LLInventoryCategory* cat,
  638. LLInventoryItem* item);
  639. protected:
  640. LLUUID mBuddyID;
  641. };
  642. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  643. // Class LLNameCategoryCollector
  644. //
  645. // Collects categories based on case-insensitive match of prefix
  646. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  647. class LLNameCategoryCollector : public LLInventoryCollectFunctor
  648. {
  649. public:
  650. LLNameCategoryCollector(const std::string& name) : mName(name) {}
  651. virtual ~LLNameCategoryCollector() {}
  652. virtual bool operator()(LLInventoryCategory* cat,
  653. LLInventoryItem* item);
  654. protected:
  655. std::string mName;
  656. };
  657. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  658. // Class LLFindCOFValidItems
  659. //
  660. // Collects items that can be legitimately linked to in the COF.
  661. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  662. class LLFindCOFValidItems : public LLInventoryCollectFunctor
  663. {
  664. public:
  665. LLFindCOFValidItems() {}
  666. virtual ~LLFindCOFValidItems() {}
  667. virtual bool operator()(LLInventoryCategory* cat,
  668. LLInventoryItem* item);
  669. };
  670. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  671. // Class LLFindWearables
  672. //
  673. // Collects wearables based on item type.
  674. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  675. class LLFindWearables : public LLInventoryCollectFunctor
  676. {
  677. public:
  678. LLFindWearables() {}
  679. virtual ~LLFindWearables() {}
  680. virtual bool operator()(LLInventoryCategory* cat,
  681. LLInventoryItem* item);
  682. };
  683. #endif // LL_LLINVENTORYMODEL_H