/** * @file llinventorymodel.h * @brief LLInventoryModel class header file * * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc. * $License$ */ #ifndef LL_LLINVENTORYMODEL_H #define LL_LLINVENTORYMODEL_H #include "llassettype.h" #include "lldarray.h" #include "lluuid.h" #include "llpermissionsflags.h" #include "llstring.h" #include #include #include #include //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryObserver // // This class is designed to be a simple abstract base class which can // relay messages when the inventory changes. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryObserver { public: // This enumeration is a way to refer to what changed in a more // human readable format. You can mask the value provided by // chaged() to see if the observer is interested in the change. enum { NONE = 0, LABEL = 1, // name changed INTERNAL = 2, // internal change, eg, asset uuid different ADD = 4, // something added REMOVE = 8, // something deleted STRUCTURE = 16, // structural change, eg, item or folder moved CALLING_CARD = 32, // online, grant status, cancel, etc change ALL = 0xffffffff }; virtual ~LLInventoryObserver() {}; virtual void changed(U32 mask) = 0; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryModel // // This class represents a collection of inventory, and provides // efficient ways to access that information. This class could in // theory be used for any place where you need inventory, though it // optimizes for time efficiency - not space efficiency, probably // making it inappropriate for use on tasks. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryObject; class LLInventoryItem; class LLInventoryCategory; class LLViewerInventoryItem; class LLViewerInventoryCategory; class LLViewerInventoryItem; class LLViewerInventoryCategory; class LLMessageSystem; class LLInventoryCollectFunctor; class LLInventoryModel { public: typedef enum e_has_children { CHILDREN_NO, CHILDREN_YES, CHILDREN_MAYBE }EHasChildren; // These are used a lot... typedef LLDynamicArray > cat_array_t; typedef LLDynamicArray > item_array_t; // construction & destruction LLInventoryModel(); ~LLInventoryModel(); // // Accessors // // This is a convenience function to check if one object has a // parent chain up to the category specified by UUID. BOOL isObjectDescendentOf(const LLUUID& obj_id, const LLUUID& cat_id); // Get the object by id. Returns NULL if not found. // * WARNING: use the pointer returned for read operations - do // not modify the object values in place or you will break stuff. LLInventoryObject* getObject(const LLUUID& id) const; // Get the item by id. Returns NULL if not found. // * WARNING: use the pointer for read operations - use the // updateItem() method to actually modify values. LLViewerInventoryItem* getItem(const LLUUID& id) const; // Get the category by id. Returns NULL if not found. // * WARNING: use the pointer for read operations - use the // updateCategory() method to actually modify values. LLViewerInventoryCategory* getCategory(const LLUUID& id) const; // Return the number of items or categories S32 getItemCount() const; S32 getCategoryCount() const; // Return the direct descendents of the id provided.Set passed // in values to NULL if the call fails. // *WARNING: The array provided points straight into the guts of // this object, and should only be used for read operations, since // modifications may invalidate the internal state of the // inventory. void getDirectDescendentsOf(const LLUUID& cat_id, cat_array_t*& categories, item_array_t*& items) const; // Starting with the object specified, add it's descendents to the // array provided, but do not add the inventory object specified // by id. There is no guaranteed order. Neither array will be // erased before adding objects to it. Do not store a copy of the // pointers collected - use them, and collect them again later if // you need to reference the same objects. enum { EXCLUDE_TRASH = FALSE, INCLUDE_TRASH = TRUE }; void collectDescendents(const LLUUID& id, cat_array_t& categories, item_array_t& items, BOOL include_trash); void collectDescendentsIf(const LLUUID& id, cat_array_t& categories, item_array_t& items, BOOL include_trash, LLInventoryCollectFunctor& add); // // Mutators // // Calling this method with an inventory item will either change // an existing item with a matching item_id, or will add the item // to the current inventory. Returns the change mask generated by // the update. No notifcation will be sent to observers. This // method will only generate network traffic if the item had to be // reparented. // *NOTE: In usage, you will want to perform cache accounting // operations in LLInventoryModel::accountForUpdate() or // LLViewerInventoryItem::updateServer() before calling this // method. U32 updateItem(const LLViewerInventoryItem* item); // Calling this method with an inventory category will either // change an existing item with the matching id, or it will add // the category. No notifcation will be sent to observers. This // method will only generate network traffic if the item had to be // reparented. // *NOTE: In usage, you will want to perform cache accounting // operations in LLInventoryModel::accountForUpdate() or // LLViewerInventoryCategory::updateServer() before calling this // method. void updateCategory(const LLViewerInventoryCategory* cat); // This method will move the specified object id to the specified // category, update the internal structures. No cache accounting, // observer notification, or server update is performed. void moveObject(const LLUUID& object_id, const LLUUID& cat_id); // delete a particular inventory object by ID. This will purge one // object from the internal data structures maintaining a // cosistent internal state. No cache accounting, observer // notification, or server update is performed. void deleteObject(const LLUUID& id); // This is a method which collects the descendents of the id // provided. If the category is not found, no action is // taken. This method goes through the long winded process of // removing server representation of folders and items while doing // cache accounting in a fairly efficient manner. This method does // not notify observers (though maybe it shouldd...) void purgeDescendentsOf(const LLUUID& id); // This method optimally removes the referenced categories and // items from the current agent's inventory in the database. It // performs all of the during deletion. The local representation // is not removed. void deleteFromServer(LLDynamicArray& category_ids, LLDynamicArray& item_ids); // Add/remove an observer. If the observer is destroyed, be sure // to remove it. void addObserver(LLInventoryObserver* observer); void removeObserver(LLInventoryObserver* observer); // // Misc Methods // // findCategoryUUIDForType() returns the uuid of the category that // specifies 'type' as what it defaults to containing. The // category is not necessarily only for that type. *NOTE: This // will create a new inventory category on the fly if one does not // exist. LLUUID findCategoryUUIDForType(LLAssetType::EType preferred_type); // Call this method when it's time to update everyone on a new // state, by default, the inventory model will not update // observers automatically. void notifyObservers(); // This allows outsiders to tell the inventory if something has // been changed 'under the hood', but outside the control of the // inventory. For example, if we grant someone modify permissions, // then that changes the data structures for LLAvatarTracker, but // potentially affects inventory observers. This API makes sure // that the next notify will include that notification. void addChangedMask(U32 mask, const LLUUID& referent); const std::set& getChangedIDs() { return mChangedItemIDs; } // This method to prepares a set of mock inventory which provides // minimal functionality before the actual arrival of inventory. //void mock(const LLUUID& root_id); // make sure we have the descendents in the structure. void fetchDescendentsOf(const LLUUID& folder_id); // call this method to request the inventory. //void requestFromServer(const LLUUID& agent_id); // call this method on logout to save a terse representation void cache(const LLUUID& parent_folder_id, const LLUUID& agent_id); // Generates a string containing the path to the item specified by // item_id. void appendPath(const LLUUID& id, LLString& path); // message handling functionality static void registerCallbacks(LLMessageSystem* msg); // Convenience function to create a new category. You could call // updateCatgory() with a newly generated UUID category, but this // version will take care of details like what the name should be // based on preferred type. Returns the UUID of the new // category. If you want to use the default name based on type, // pass in a NULL to the 'name parameter. LLUUID createNewCategory(const LLUUID& parent_id, LLAssetType::EType preferred_type, const LLString& name); // methods to load up inventory skeleton & meat. These are used // during authentication. return true if everything parsed. typedef std::map response_t; typedef std::vector options_t; bool loadSkeleton(const options_t& options, const LLUUID& owner_id); bool loadMeat(const options_t& options, const LLUUID& owner_id); // This is a brute force method to rebuild the entire parent-child // relations. void buildParentChildMap(); // // Category accounting. // // This structure represents the number of items added or removed // from a category. struct LLCategoryUpdate { LLCategoryUpdate() : mDescendentDelta(0) {} LLCategoryUpdate(const LLUUID& category_id, S32 delta) : mCategoryID(category_id), mDescendentDelta(delta) {} LLUUID mCategoryID; S32 mDescendentDelta; }; typedef std::vector update_list_t; // This structure eixts to make it easier to account for deltas in // a map. struct LLInitializedS32 { LLInitializedS32() : mValue(0) {} LLInitializedS32(S32 value) : mValue(value) {} S32 mValue; LLInitializedS32& operator++() { ++mValue; return *this; } LLInitializedS32& operator--() { --mValue; return *this; } }; typedef std::map update_map_t; // Call these methods when there are category updates, but call // them *before* the actual update so the method can do descendent // accounting correctly. void accountForUpdate(const LLCategoryUpdate& update); void accountForUpdate(const update_list_t& updates); void accountForUpdate(const update_map_t& updates); // Return child status of category children. yes/no/maybe EHasChildren categoryHasChildren(const LLUUID& cat_id) const; // returns true iff category version is known and theoretical // descendents == actual descendents. bool isCategoryComplete(const LLUUID& cat_id) const; // start and stop background breadth-first fetching of inventory contents // this gets triggered when performing a filter-search static void startBackgroundFetch(const LLUUID& cat_id = LLUUID::null); // start fetch process static void stopBackgroundFetch(); // stop fetch process static BOOL backgroundFetchActive(); static bool isEverythingFetched(); static void backgroundFetch(void*); // background fetch idle function protected: // Internal methods which add inventory and make sure that all of // the internal data structures are consistent. These methods // should be passed pointers of newly created objects, and the // instance will take over the memory management from there. void addCategory(LLViewerInventoryCategory* category); void addItem(LLViewerInventoryItem* item); // Internal method which looks for a category with the specified // preferred type. Returns LLUUID::null if not found LLUUID findCatUUID(LLAssetType::EType preferred_type); // Empty the entire contents void empty(); // Given the current state of the inventory items, figure out the // clone information. *FIX: This is sub-optimal, since we can // insert this information snurgically, but this makes sure the // implementation works before we worry about optimization. //void recalculateCloneInformation(); // file import/export. static bool loadFromFile( const char* filename, cat_array_t& categories, item_array_t& items); static bool saveToFile( const char* filename, const cat_array_t& categories, const item_array_t& items); // message handling functionality //static void processUseCachedInventory(LLMessageSystem* msg, void**); static void processUpdateCreateInventoryItem(LLMessageSystem* msg, void**); static void processRemoveInventoryItem(LLMessageSystem* msg, void**); static void processUpdateInventoryFolder(LLMessageSystem* msg, void**); static void processRemoveInventoryFolder(LLMessageSystem* msg, void**); //static void processExchangeCallingcard(LLMessageSystem* msg, void**); //static void processAddCallingcard(LLMessageSystem* msg, void**); //static void processDeclineCallingcard(LLMessageSystem* msg, void**); static void processSaveAssetIntoInventory(LLMessageSystem* msg, void**); static void processBulkUpdateInventory(LLMessageSystem* msg, void**); static void processInventoryDescendents(LLMessageSystem* msg, void**); static void processMoveInventoryItem(LLMessageSystem* msg, void**); static void processFetchInventoryReply(LLMessageSystem* msg, void**); bool messageUpdateCore(LLMessageSystem* msg, bool do_accounting); protected: // Varaibles used to track what has changed since the last notify. U32 mModifyMask; typedef std::set changed_items_t; changed_items_t mChangedItemIDs; // Information for tracking the actual inventory. We index this // information in a lot of different ways so we can access // the inventory using several different identifiers. // mInventory member data is the 'master' list of inventory, and // mCategoryMap and mItemMap store uuid->object mappings. typedef std::map > cat_map_t; typedef std::map > item_map_t; //inv_map_t mInventory; cat_map_t mCategoryMap; item_map_t mItemMap; // cache recent lookups mutable LLPointer mLastItem; // This last set of indices is used to map parents to children. //LLPtrSkipMap mParentChildCategoryTree; //LLPtrSkipMap mParentChildItemTree; typedef std::map parent_cat_map_t; typedef std::map parent_item_map_t; parent_cat_map_t mParentChildCategoryTree; parent_item_map_t mParentChildItemTree; typedef std::set observer_list_t; observer_list_t mObservers; // completing the fetch once per session should be sufficient static BOOL sBackgroundFetchActive; static BOOL sTimelyFetchPending; static BOOL sAllFoldersFetched; static BOOL sFullFetchStarted; static S32 sNumFetchRetries; static LLFrameTimer sFetchTimer; static F32 sMinTimeBetweenFetches; static F32 sMaxTimeBetweenFetches; public: // *NOTE: DEBUG functionality void dumpInventory(); }; // a special inventory model for the agent extern LLInventoryModel gInventory; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryCollectFunctor // // Base class for LLInventoryModel::collectDescendentsIf() method // which accepts an instance of one of these objects to use as the // function to determine if it should be added. Derive from this class // and override the () operator to return TRUE if you want to collect // the category or item passed in. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryCollectFunctor { public: virtual ~LLInventoryCollectFunctor(){}; virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item) = 0; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLAssetIDMatches // // This functor finds inventory items pointing to the specified asset //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLViewerInventoryItem; class LLAssetIDMatches : public LLInventoryCollectFunctor { public: LLAssetIDMatches(const LLUUID& asset_id) : mAssetID(asset_id) {} virtual ~LLAssetIDMatches() {} bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: LLUUID mAssetID; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLIsType // // Implementation of a LLInventoryCollectFunctor which returns TRUE if // the type is the type passed in during construction. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLIsType : public LLInventoryCollectFunctor { public: LLIsType(LLAssetType::EType type) : mType(type) {} virtual ~LLIsType() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: LLAssetType::EType mType; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLIsNotType // // Implementation of a LLInventoryCollectFunctor which returns FALSE if the // type is the type passed in during construction, otherwise false. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLIsNotType : public LLInventoryCollectFunctor { public: LLIsNotType(LLAssetType::EType type) : mType(type) {} virtual ~LLIsNotType() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: LLAssetType::EType mType; }; class LLIsTypeWithPermissions : public LLInventoryCollectFunctor { public: LLIsTypeWithPermissions(LLAssetType::EType type, const PermissionBit perms, const LLUUID &agent_id, const LLUUID &group_id) : mType(type), mPerm(perms), mAgentID(agent_id), mGroupID(group_id) {} virtual ~LLIsTypeWithPermissions() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: LLAssetType::EType mType; PermissionBit mPerm; LLUUID mAgentID; LLUUID mGroupID; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLIsClone // // Implementation of a LLInventoryCollectFunctor which returns TRUE if // the object is a clone of the item passed in during // construction. // // *NOTE: Since clone information is determined based off of asset id // (or creator with calling cards), if the id is NULL, it has no // clones - even itself. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //class LLIsClone : public LLInventoryCollectFunctor //{ //public: // LLIsClone(LLViewerInventoryItem* item) : mItem(item) {} // virtual ~LLIsClone() {} // virtual bool operator()(LLViewerInventoryCategory* cat, // LLViewerInventoryItem* item); //protected: // LLPointer mItem; //}; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLBuddyCollector // // Simple class that collects calling cards that are not null, and not // the agent. Duplicates are possible. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLBuddyCollector : public LLInventoryCollectFunctor { public: LLBuddyCollector() {} virtual ~LLBuddyCollector() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLUniqueBuddyCollector // // Simple class that collects calling cards that are not null, and not // the agent. Duplicates are discarded. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLUniqueBuddyCollector : public LLInventoryCollectFunctor { public: LLUniqueBuddyCollector() {} virtual ~LLUniqueBuddyCollector() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: std::set mSeen; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLParticularBuddyCollector // // Simple class that collects calling cards that match a particular uuid //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLParticularBuddyCollector : public LLInventoryCollectFunctor { public: LLParticularBuddyCollector(const LLUUID& id) : mBuddyID(id) {} virtual ~LLParticularBuddyCollector() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: LLUUID mBuddyID; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLNameCategoryCollector // // Collects categories based on case-insensitive match of prefix //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLNameCategoryCollector : public LLInventoryCollectFunctor { public: LLNameCategoryCollector(const char* name) : mName(name) {} virtual ~LLNameCategoryCollector() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); protected: std::string mName; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryCompletionObserver // // Class which can be used as a base class for doing something when // when all observed items are locally complete. This class implements // the changed() method of LLInventoryObserver and declares a new // method named done() which is called when all watched items have // complete information in the inventory model. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryCompletionObserver : public LLInventoryObserver { public: LLInventoryCompletionObserver() {} virtual void changed(U32 mask); void watchItem(const LLUUID& id); protected: virtual void done() = 0; typedef std::vector item_ref_t; item_ref_t mComplete; item_ref_t mIncomplete; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryFetchObserver // // This class is much like the LLInventoryCompletionObserver, except // that it handles all the the fetching necessary. Override the done() // method to do the thing you want. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryFetchObserver : public LLInventoryObserver { public: LLInventoryFetchObserver() {} virtual void changed(U32 mask); typedef std::vector item_ref_t; bool isEverythingComplete() const; void fetchItems(const item_ref_t& ids); virtual void done() = 0; protected: item_ref_t mComplete; item_ref_t mIncomplete; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryFetchDescendentsObserver // // This class is much like the LLInventoryCompletionObserver, except // that it handles fetching based on category. Override the done() // method to do the thing you want. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryFetchDescendentsObserver : public LLInventoryObserver { public: LLInventoryFetchDescendentsObserver() {} virtual void changed(U32 mask); typedef std::vector folder_ref_t; void fetchDescendents(const folder_ref_t& ids); bool isEverythingComplete() const; virtual void done() = 0; protected: bool isComplete(LLViewerInventoryCategory* cat); folder_ref_t mIncompleteFolders; folder_ref_t mCompleteFolders; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryFetchComboObserver // // This class does an appropriate combination of fetch descendents and // item fetches based on completion of categories and items. Much like // the fetch and fetch descendents, this will call done() when everything // has arrived. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryFetchComboObserver : public LLInventoryObserver { public: LLInventoryFetchComboObserver() : mDone(false) {} virtual void changed(U32 mask); typedef std::vector folder_ref_t; typedef std::vector item_ref_t; void fetch(const folder_ref_t& folder_ids, const item_ref_t& item_ids); virtual void done() = 0; protected: bool mDone; folder_ref_t mCompleteFolders; folder_ref_t mIncompleteFolders; item_ref_t mCompleteItems; item_ref_t mIncompleteItems; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryExistenceObserver // // This class is used as a base class for doing somethign when all the // observed item ids exist in the inventory somewhere. You can derive // a class from this class and implement the done() method to do // something useful. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryExistenceObserver : public LLInventoryObserver { public: LLInventoryExistenceObserver() {} virtual void changed(U32 mask); void watchItem(const LLUUID& id); protected: virtual void done() = 0; typedef std::vector item_ref_t; item_ref_t mExist; item_ref_t mMIA; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryAddedObserver // // This class is used as a base class for doing something when // a new item arrives in inventory. // It does not watch for a certain UUID, rather it acts when anything is added // Derive a class from this class and implement the done() method to do // something useful. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryAddedObserver : public LLInventoryObserver { public: LLInventoryAddedObserver() : mAdded() {} virtual void changed(U32 mask); protected: virtual void done() = 0; typedef std::vector item_ref_t; item_ref_t mAdded; }; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Class LLInventoryTransactionObserver // // Class which can be used as a base class for doing something when an // inventory transaction completes. // // *NOTE: This class is not quite complete. Avoid using unless you fix up it's // functionality gaps. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class LLInventoryTransactionObserver : public LLInventoryObserver { public: LLInventoryTransactionObserver(const LLTransactionID& transaction_id); virtual void changed(U32 mask); protected: typedef std::vector folder_ref_t; typedef std::vector item_ref_t; virtual void done(const folder_ref_t& folders, const item_ref_t& items) = 0; LLTransactionID mTransactionID; }; #endif // LL_LLINVENTORYMODEL_H