diff options
Diffstat (limited to 'indra/newview/llinventorymodel.h')
| -rw-r--r-- | indra/newview/llinventorymodel.h | 757 |
1 files changed, 757 insertions, 0 deletions
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h new file mode 100644 index 0000000000..25f08322be --- /dev/null +++ b/indra/newview/llinventorymodel.h @@ -0,0 +1,757 @@ +/** + * @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 "llassetstorage.h" +#include "lldarray.h" +//#include "llskiplist.h" +//#include "llptrskipmap.h" +#include "lluuid.h" +#include "llpermissionsflags.h" +#include "llstring.h" + +#include <map> +#include <set> +#include <string> +#include <vector> + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// 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<LLPointer<LLViewerInventoryCategory> > cat_array_t; + typedef LLDynamicArray<LLPointer<LLViewerInventoryItem> > 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<LLUUID>& category_ids, + LLDynamicArray<LLUUID>& 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<LLUUID>& 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<std::string, std::string> response_t; + typedef std::vector<response_t> 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<LLCategoryUpdate> update_list_t; + + // This structure eixts to make it easier to account for deltas in + // a map. + struct LLInitializedS32 + { + LLInitializedS32() : mValue(0) {} + S32 mValue; + LLInitializedS32& operator++() { ++mValue; return *this; } + LLInitializedS32& operator--() { --mValue; return *this; } + }; + typedef std::map<LLUUID, LLInitializedS32> 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, bool highlight_new); + +protected: + // Varaibles used to track what has changed since the last notify. + U32 mModifyMask; + typedef std::set<LLUUID> 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<LLUUID, LLPointer<LLViewerInventoryCategory> > cat_map_t; + typedef std::map<LLUUID, LLPointer<LLViewerInventoryItem> > item_map_t; + //inv_map_t mInventory; + cat_map_t mCategoryMap; + item_map_t mItemMap; + + // cache recent lookups + mutable LLPointer<LLViewerInventoryItem> mLastItem; + + // This last set of indices is used to map parents to children. + //LLPtrSkipMap<const LLUUID, cat_array_t*> mParentChildCategoryTree; + //LLPtrSkipMap<const LLUUID, item_array_t*> mParentChildItemTree; + typedef std::map<LLUUID, cat_array_t*> parent_cat_map_t; + typedef std::map<LLUUID, item_array_t*> parent_item_map_t; + parent_cat_map_t mParentChildCategoryTree; + parent_item_map_t mParentChildItemTree; + + typedef std::set<LLInventoryObserver*> 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<LLViewerInventoryItem> 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<LLUUID> 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<LLUUID> 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<LLUUID> 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<LLUUID> 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<LLUUID> folder_ref_t; + typedef std::vector<LLUUID> 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<LLUUID> item_ref_t; + item_ref_t mExist; + item_ref_t mMIA; +}; + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// 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<LLUUID> folder_ref_t; + typedef std::vector<LLUUID> item_ref_t; + virtual void done(const folder_ref_t& folders, const item_ref_t& items) = 0; + + LLTransactionID mTransactionID; +}; + + +#endif // LL_LLINVENTORYMODEL_H |