Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 721 insertions, 719 deletions

diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 47fd5ce783..0ab7dcb99b 100644
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -1,719 +1,721 @@
-/** 
- * @file llinventorymodel.h
- * @brief LLInventoryModel class header file
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLINVENTORYMODEL_H
-#define LL_LLINVENTORYMODEL_H
-
-#include <map>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "llassettype.h"
-#include "llfoldertype.h"
-#include "llframetimer.h"
-#include "lluuid.h"
-#include "llpermissionsflags.h"
-#include "llviewerinventory.h"
-#include "llstring.h"
-#include "httpcommon.h"
-#include "httprequest.h"
-#include "httpoptions.h"
-#include "httpheaders.h"
-#include "httphandler.h"
-#include "lleventcoro.h"
-#include "llcoros.h"
-
-class LLInventoryObserver;
-class LLInventoryObject;
-class LLInventoryItem;
-class LLInventoryCategory;
-class LLMessageSystem;
-class LLInventoryCollectFunctor;
-
-///----------------------------------------------------------------------------
-/// LLInventoryValidationInfo 
-///----------------------------------------------------------------------------
-class LLInventoryValidationInfo: public LLRefCount
-{
-public:
-	LLInventoryValidationInfo();
-	void toOstream(std::ostream& os) const;
-	void asLLSD(LLSD& sd) const;
-	
-	bool mInitialized{false};
-	S32 mWarningCount{0};
-	std::map<std::string,U32> mWarnings;
-
-    S32 mLoopCount{0}; // Presence of folders whose ancestors loop onto themselves
-    S32 mOrphanedCount{0}; // Missing or orphaned items, links and folders
-
-	S32 mFatalErrorCount{0};
-	bool mFatalNoRootFolder{false};
-	S32 mFatalSystemDuplicate{0};
-	bool mFatalNoLibraryRootFolder{false};
-	bool mFatalQADebugMode{false};
-
-	std::set<LLFolderType::EType> mMissingRequiredSystemFolders;
-	std::set<LLFolderType::EType> mDuplicateRequiredSystemFolders;
-};
-std::ostream& operator<<(std::ostream& s, const LLInventoryValidationInfo& v);
-
-///----------------------------------------------------------------------------
-// LLInventoryModel
-//
-// Represents a collection of inventory, and provides efficient ways to access 
-// that information.
-//   NOTE: 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 LLInventoryModel
-{
-	LOG_CLASS(LLInventoryModel);
-
-public:
-	enum EHasChildren
-	{
-		CHILDREN_NO,
-		CHILDREN_YES,
-		CHILDREN_MAYBE
-	};
-
-	typedef std::vector<LLPointer<LLViewerInventoryCategory> > cat_array_t;
-	typedef std::vector<LLPointer<LLViewerInventoryItem> > item_array_t;
-	typedef std::set<LLUUID> changed_items_t;
-
-    // Rider: This is using the old responder patter.  It should be refactored to 
-    // take advantage of coroutines.
-
-	// HTTP handler for individual item requests (inventory or library).
-	// Background item requests are derived from this in the background
-	// inventory system.  All folder requests are also located there
-	// but have their own handler derived from HttpHandler.
-	class FetchItemHttpHandler : public LLCore::HttpHandler
-	{
-	public:
-		LOG_CLASS(FetchItemHttpHandler);
-
-		FetchItemHttpHandler(const LLSD & request_sd);
-		virtual ~FetchItemHttpHandler();
-
-	protected:
-		FetchItemHttpHandler(const FetchItemHttpHandler &);				// Not defined
-		void operator=(const FetchItemHttpHandler &);					// Not defined
-
-	public:
-		virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
-
-	private:
-		void processData(LLSD & body, LLCore::HttpResponse * response);
-		void processFailure(LLCore::HttpStatus status, LLCore::HttpResponse * response);
-		void processFailure(const char * const reason, LLCore::HttpResponse * response);
-
-	private:
-		LLSD mRequestSD;
-	};
-
-/********************************************************************************
- **                                                                            **
- **                    INITIALIZATION/SETUP
- **/
-
-	//--------------------------------------------------------------------
-	// Constructors / Destructors
-	//--------------------------------------------------------------------
-public:
-	LLInventoryModel();
-	~LLInventoryModel();
-	void cleanupInventory();
-protected:
-	void empty(); // empty the entire contents
-
-	//--------------------------------------------------------------------
-	// Initialization
-	//--------------------------------------------------------------------
-public:
-	// The inventory model usage is sensitive to the initial construction of the model
-	bool isInventoryUsable() const;
-private:
-	bool mIsAgentInvUsable; // used to handle an invalid inventory state
-
-	// One-time initialization of HTTP system.
-	void initHttpRequest();
-	
-	//--------------------------------------------------------------------
-	// Root Folders
-	//--------------------------------------------------------------------
-public:
-	// The following are set during login with data from the server
-	void setRootFolderID(const LLUUID& id);
-	void setLibraryOwnerID(const LLUUID& id);
-	void setLibraryRootFolderID(const LLUUID& id);
-
-	const LLUUID &getRootFolderID() const;
-	const LLUUID &getLibraryOwnerID() const;
-	const LLUUID &getLibraryRootFolderID() const;
-private:
-	LLUUID mRootFolderID;
-	LLUUID mLibraryRootFolderID;
-	LLUUID mLibraryOwnerID;	
-	
-	//--------------------------------------------------------------------
-	// Structure
-	//--------------------------------------------------------------------
-public:
-	// Methods to load up inventory skeleton & meat. These are used
-	// during authentication. Returns true if everything parsed.
-	bool loadSkeleton(const LLSD& options, const LLUUID& owner_id);
-	void buildParentChildMap(); // brute force method to rebuild the entire parent-child relations
-	void createCommonSystemCategories();
-
-	static std::string getInvCacheAddres(const LLUUID& owner_id);
-
-	// Call on logout to save a terse representation.
-	void cache(const LLUUID& parent_folder_id, const LLUUID& agent_id);
-private:
-	// 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;
-	cat_map_t mCategoryMap;
-	item_map_t mItemMap;
-	// This last set of indices is used to map parents to children.
-	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;
-
-	// Track links to items and categories. We do not store item or
-	// category pointers here, because broken links are also supported.
-	typedef std::multimap<LLUUID, LLUUID> backlink_mmap_t;
-	backlink_mmap_t mBacklinkMMap; // key = target_id: ID of item, values = link_ids: IDs of item or folder links referencing it.
-	// For internal use only
-	bool hasBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id) const;
-	void addBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id);
-	void removeBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id);
-	
-	//--------------------------------------------------------------------
-	// Login
-	//--------------------------------------------------------------------
-public:
-	static bool getIsFirstTimeInViewer2();
-    static bool  isSysFoldersReady() { return (sPendingSystemFolders == 0); }
-
-private:
-	static bool sFirstTimeInViewer2;
-	const static S32 sCurrentInvCacheVersion; // expected inventory cache version
-
-    static S32 sPendingSystemFolders;
-
-/**                    Initialization/Setup
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    ACCESSORS
- **/
-
-	//--------------------------------------------------------------------
-	// Descendants
-	//--------------------------------------------------------------------
-public:
-	// Make sure we have the descendants in the structure.  Returns true
-	// if a fetch was performed.
-	bool fetchDescendentsOf(const LLUUID& folder_id) const;
-
-	// Return the direct descendants of the id provided.Set passed
-	// in values to NULL if the call fails.
-	//    NOTE: 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;
-    void getDirectDescendentsOf(const LLUUID& cat_id, cat_array_t& categories, item_array_t& items, LLInventoryCollectFunctor& f) const;
-
-	typedef LLUUID digest_t; // To clarify the actual usage of this "UUID"
-	// Compute a hash of direct descendant names (for detecting child name changes)
-	digest_t hashDirectDescendentNames(const LLUUID& cat_id) const;
-	
-	// Starting with the object specified, add its descendants to the
-	// array provided, but do not add the inventory object specified
-	// by id. There is no guaranteed order. 
-	//    NOTE: 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 
-	};
-	// Simpler existence test if matches don't actually need to be collected.
-	bool hasMatchingDirectDescendent(const LLUUID& cat_id,
-									 LLInventoryCollectFunctor& filter);
-	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);
-
-	// Collect all items in inventory that are linked to item_id.
-	// Assumes item_id is itself not a linked item.
-	item_array_t collectLinksTo(const LLUUID& item_id);
-
-	// 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) const;
-    
-    enum EAncestorResult{
-        ANCESTOR_OK = 0,
-        ANCESTOR_MISSING = 1,
-        ANCESTOR_LOOP = 2,
-    };
-	// Follow parent chain to the top.
-    EAncestorResult getObjectTopmostAncestor(const LLUUID& object_id, LLUUID& result) const;
-
-	//--------------------------------------------------------------------
-	// Find
-	//--------------------------------------------------------------------
-public:
-
-    // Checks if category exists ("My Inventory" only), if it does not, creates it
-    void ensureCategoryForTypeExists(LLFolderType::EType preferred_type);
-
-	const LLUUID findCategoryUUIDForTypeInRoot(
-		LLFolderType::EType preferred_type,
-		const LLUUID& root_id) const;
-
-	// 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: If create_folder is true, this will create a new inventory category 
-	//    on the fly if one does not exist. *NOTE: if find_in_library is true it 
-	//    will search in the user's library folder instead of "My Inventory"
-	const LLUUID findCategoryUUIDForType(LLFolderType::EType preferred_type) const;
-	//    will search in the user's library folder instead of "My Inventory"
-	const LLUUID findLibraryCategoryUUIDForType(LLFolderType::EType preferred_type) const;
-	// Returns user specified category for uploads, returns default id if there are no
-	// user specified one or it does not exist, creates default category if it is missing.
-	const LLUUID findUserDefinedCategoryUUIDForType(LLFolderType::EType preferred_type) const;
-	
-	// Get whatever special folder this object is a child of, if any.
-	const LLViewerInventoryCategory *getFirstNondefaultParent(const LLUUID& obj_id) const;
-	
-	// Get first descendant of the child object under the specified parent
-	const LLViewerInventoryCategory *getFirstDescendantOf(const LLUUID& master_parent_id, const LLUUID& obj_id) const;
-
-	// Get the object by id. Returns NULL if not found.
-	//   NOTE: 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.
-	//    NOTE: 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.
-	//    NOTE: Use the pointer for read operations - use the
-	//    updateCategory() method to actually modify values.
-	LLViewerInventoryCategory* getCategory(const LLUUID& id) const;
-
-	// Get the inventoryID or item that this item points to, else just return object_id
-	const LLUUID& getLinkedItemID(const LLUUID& object_id) const;
-	LLViewerInventoryItem* getLinkedItem(const LLUUID& object_id) const;
-    
-    // Copy content of all folders of type "type" into folder "id" and delete/purge the empty folders
-    // Note : This method has been designed for FT_OUTBOX (aka Merchant Outbox) but can be used for other categories
-    void consolidateForType(const LLUUID& id, LLFolderType::EType type);
-    
-private:
-	mutable LLPointer<LLViewerInventoryItem> mLastItem; // cache recent lookups	
-
-	//--------------------------------------------------------------------
-	// Count
-	//--------------------------------------------------------------------
-public:
-	// Return the number of items or categories
-	S32 getItemCount() const;
-	S32 getCategoryCount() const;
-
-/**                    Accessors
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    MUTATORS
- **/
-
-public:
-	// Change an existing item with a matching item_id or add the item
-	// to the current inventory. Returns the change mask generated by
-	// the update. No notification 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, U32 mask = 0);
-
-	// Change an existing item with the matching id or add
-	// the category. No notification 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 accountForUpdate() or LLViewerInventoryCategory::
-	//    updateServer() before calling this method.
-	void updateCategory(const LLViewerInventoryCategory* cat, U32 mask = 0);
-
-	// Move the specified object id to the specified category and
-	// update the internal structures. No cache accounting,
-	// observer notification, or server update is performed.
-	void moveObject(const LLUUID& object_id, const LLUUID& cat_id);
-
-	// Migrated from llinventoryfunctions
-	void changeItemParent(LLViewerInventoryItem* item,
-						  const LLUUID& new_parent_id,
-						  bool restamp);
-
-	// Migrated from llinventoryfunctions
-	void changeCategoryParent(LLViewerInventoryCategory* cat,
-							  const LLUUID& new_parent_id,
-							  bool restamp);
-
-    // Marks links from a "possibly" broken list for a rebuild
-    // clears the list
-    void rebuildBrockenLinks();
-    bool hasPosiblyBrockenLinks() const { return mPossiblyBrockenLinks.size() > 0; }
-
-	//--------------------------------------------------------------------
-	// Delete
-	//--------------------------------------------------------------------
-public:
-		
-	// Update model after an item is confirmed as removed from
-	// server. Works for categories or items.
-	void onObjectDeletedFromServer(const LLUUID& item_id,
-								   bool fix_broken_links = true,
-								   bool update_parent_version = true,
-								   bool do_notify_observers = true);
-
-	// Update model after all descendants removed from server.
-	void onDescendentsPurgedFromServer(const LLUUID& object_id, bool fix_broken_links = true);
-
-	// Update model after an existing item gets updated on server.
-	void onItemUpdated(const LLUUID& item_id, const LLSD& updates, bool update_parent_version);
-
-	// Update model after an existing category gets updated on server.
-	void onCategoryUpdated(const LLUUID& cat_id, const LLSD& updates);
-
-	// Delete a particular inventory object by ID. Will purge one
-	// object from the internal data structures, maintaining a
-	// consistent internal state. No cache accounting, observer
-	// notification, or server update is performed.
-	void deleteObject(const LLUUID& id, bool fix_broken_links = true, bool do_notify_observers = true);
-	/// move Item item_id to Trash
-	void removeItem(const LLUUID& item_id);
-	/// move Category category_id to Trash
-	void removeCategory(const LLUUID& category_id);
-	/// removeItem() or removeCategory(), whichever is appropriate
-	void removeObject(const LLUUID& object_id);
-
-	// "TrashIsFull" when trash exceeds maximum capacity
-	void checkTrashOverflow();
-
-protected:
-    void rebuildLinkItems(LLInventoryModel::item_array_t& items);
-	
-	//--------------------------------------------------------------------
-	// Reorder
-	//--------------------------------------------------------------------
-public:
-	// Changes items order by insertion of the item identified by src_item_id
-	// before (or after) the item identified by dest_item_id. Both items must exist in items array.
-	// Sorting is stored after method is finished. Only src_item_id is moved before (or after) dest_item_id.
-	// The parameter "insert_before" controls on which side of dest_item_id src_item_id gets reinserted.
-	static void updateItemsOrder(LLInventoryModel::item_array_t& items, 
-								 const LLUUID& src_item_id, 
-								 const LLUUID& dest_item_id,
-								 bool insert_before = true);
-	// Gets an iterator on an item vector knowing only the item UUID.
-	// Returns end() of the vector if not found.
-	static LLInventoryModel::item_array_t::iterator findItemIterByUUID(LLInventoryModel::item_array_t& items, const LLUUID& id);
-
-
-	// Rearranges Landmarks inside Favorites folder.
-	// Moves source landmark before target one.
-	void rearrangeFavoriteLandmarks(const LLUUID& source_item_id, const LLUUID& target_item_id);
-	//void saveItemsOrder(const LLInventoryModel::item_array_t& items);
-
-	//--------------------------------------------------------------------
-	// Creation
-	//--------------------------------------------------------------------
-public:
-	// 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.
-	void createNewCategory(const LLUUID& parent_id,
-							 LLFolderType::EType preferred_type,
-							 const std::string& name,
-							 inventory_func_type callback = NULL,
-							 const LLUUID& thumbnail_id = LLUUID::null);
-protected:
-	// Internal methods that 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);
-
-    void createNewCategoryCoro(std::string url, LLSD postData, inventory_func_type callback);
-	
-/**                    Mutators
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    CATEGORY ACCOUNTING
- **/
-
-public:
-	// 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 exists 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<LLUUID, LLInitializedS32> update_map_t;
-
-	// Call when there are category updates.  Call them *before* the 
-	// actual update so the method can do descendent accounting correctly.
-	void accountForUpdate(const LLCategoryUpdate& update) const;
-	void accountForUpdate(const update_list_t& updates);
-	void accountForUpdate(const update_map_t& updates);
-
-	// Return (yes/no/maybe) child status of category children.
-	EHasChildren categoryHasChildren(const LLUUID& cat_id) const;
-
-	// Returns true if category version is known and theoretical
-	// descendents == actual descendents.
-	bool isCategoryComplete(const LLUUID& cat_id) const;
-	
-/**                    Category Accounting
- **                                                                            **
- *******************************************************************************/
-
-/********************************************************************************
- **                                                                            **
- **                    NOTIFICATIONS
- **/
-
-public:
-	// Called by the idle loop.  Only updates if new state is detected.  Call 
-	// notifyObservers() manually to update regardless of whether state change 
-	// has been indicated.
-	void idleNotifyObservers();
-
-	// Call to explicitly update everyone on a new state.
-	void notifyObservers();
-
-	// Allows outsiders to tell the inventory if something has
-	// been changed 'under the hood', but outside the control of the
-	// inventory. The next notify will include that notification.
-	void addChangedMask(U32 mask, const LLUUID& referent);
-	
-	const changed_items_t& getChangedIDs() const { return mChangedItemIDs; }
-	const changed_items_t& getAddedIDs() const { return mAddedItemIDs; }
-protected:
-	// Updates all linked items pointing to this id.
-	void addChangedMaskForLinks(const LLUUID& object_id, U32 mask);
-private:
-	// Flag set when notifyObservers is being called, to look for bugs
-	// where it's called recursively.
-	bool mIsNotifyObservers;
-	// Variables used to track what has changed since the last notify.
-	U32 mModifyMask;
-	changed_items_t mChangedItemIDs;
-	changed_items_t mAddedItemIDs;
-    // Fallback when notifyObservers is in progress
-    U32 mModifyMaskBacklog;
-    changed_items_t mChangedItemIDsBacklog;
-    changed_items_t mAddedItemIDsBacklog;
-    typedef std::map<LLUUID , changed_items_t> broken_links_t;
-    broken_links_t mPossiblyBrockenLinks; // there can be multiple links per item
-    changed_items_t mLinksRebuildList;
-    boost::signals2::connection mBulkFecthCallbackSlot;
-	
-	
-	//--------------------------------------------------------------------
-	// Observers
-	//--------------------------------------------------------------------
-public:
-	// If the observer is destroyed, be sure to remove it.
-	void addObserver(LLInventoryObserver* observer);
-	void removeObserver(LLInventoryObserver* observer);
-	bool containsObserver(LLInventoryObserver* observer) const;
-private:
-	typedef std::set<LLInventoryObserver*> observer_list_t;
-	observer_list_t mObservers;
-	
-/**                    Notifications
- **                                                                            **
- *******************************************************************************/
-
-
-/********************************************************************************
- **                                                                            **
- **                    HTTP Transport
- **/
-public:
-	// Invoke handler completion method (onCompleted) for all
-	// requests that are ready.
-	void handleResponses(bool foreground);
-
-	// Request an inventory HTTP operation to either the
-	// foreground or background processor.  These are actually
-	// the same service queue but the background requests are
-	// seviced more slowly effectively de-prioritizing new
-	// requests.
-	LLCore::HttpHandle requestPost(bool foreground,
-								   const std::string & url,
-								   const LLSD & body,
-								   const LLCore::HttpHandler::ptr_t &handler,
-								   const char * const message);
-	
-private:
-	// Usual plumbing for LLCore:: HTTP operations.
-	LLCore::HttpRequest *				mHttpRequestFG;
-	LLCore::HttpRequest *				mHttpRequestBG;
-	LLCore::HttpOptions::ptr_t			mHttpOptions;
-	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
-	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
-	
-/**                    HTTP Transport
- **                                                                            **
- *******************************************************************************/
-
-
-/********************************************************************************
- **                                                                            **
- **                    MISCELLANEOUS
- **/
-
-	//--------------------------------------------------------------------
-	// Callbacks
-	//--------------------------------------------------------------------
-public:
-	// Trigger a notification and empty the folder type (FT_TRASH or FT_LOST_AND_FOUND) if confirmed
-	void emptyFolderType(const std::string notification, LLFolderType::EType folder_type);
-	bool callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLFolderType::EType preferred_type);
-	static void registerCallbacks(LLMessageSystem* msg);
-
-	//--------------------------------------------------------------------
-	// File I/O
-	//--------------------------------------------------------------------
-protected:
-	static bool loadFromFile(const std::string& filename,
-							 cat_array_t& categories,
-							 item_array_t& items,
-							 changed_items_t& cats_to_update,
-							 bool& is_cache_obsolete); 
-	static bool saveToFile(const std::string& filename,
-						   const cat_array_t& categories,
-						   const item_array_t& items); 
-
-	//--------------------------------------------------------------------
-	// Message handling functionality
-	//--------------------------------------------------------------------
-public:
-	static void processUpdateCreateInventoryItem(LLMessageSystem* msg, void**);
-	static void removeInventoryItem(LLUUID agent_id, LLMessageSystem* msg, const char* msg_label);
-	static void processRemoveInventoryItem(LLMessageSystem* msg, void**);
-	static void removeInventoryFolder(LLUUID agent_id, LLMessageSystem* msg);
-	static void processRemoveInventoryFolder(LLMessageSystem* msg, void**);
-	static void processRemoveInventoryObjects(LLMessageSystem* msg, void**);
-	static void processSaveAssetIntoInventory(LLMessageSystem* msg, void**);
-	static void processBulkUpdateInventory(LLMessageSystem* msg, void**);
-	static void processMoveInventoryItem(LLMessageSystem* msg, void**);
-protected:
-	bool messageUpdateCore(LLMessageSystem* msg, bool do_accounting, U32 mask = 0x0);
-
-	//--------------------------------------------------------------------
-	// Locks
-	//--------------------------------------------------------------------
-public:
-	void lockDirectDescendentArrays(const LLUUID& cat_id,
-									cat_array_t*& categories,
-									item_array_t*& items);
-	void unlockDirectDescendentArrays(const LLUUID& cat_id);
-protected:
-	cat_array_t* getUnlockedCatArray(const LLUUID& id);
-	item_array_t* getUnlockedItemArray(const LLUUID& id);
-private:
-	std::map<LLUUID, bool> mCategoryLock;
-	std::map<LLUUID, bool> mItemLock;
-	
-	//--------------------------------------------------------------------
-	// Debugging
-	//--------------------------------------------------------------------
-public:
-	void dumpInventory() const;
-	LLPointer<LLInventoryValidationInfo> validate() const;
-	LLPointer<LLInventoryValidationInfo> mValidationInfo;
-	std::string getFullPath(const LLInventoryObject *obj) const;
-
-/**                    Miscellaneous
- **                                                                            **
- *******************************************************************************/
-};
-
-// a special inventory model for the agent
-extern LLInventoryModel gInventory;
-
-#endif // LL_LLINVENTORYMODEL_H
-
+/**

+ * @file llinventorymodel.h

+ * @brief LLInventoryModel class header file

+ *

+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#ifndef LL_LLINVENTORYMODEL_H

+#define LL_LLINVENTORYMODEL_H

+

+#include <map>

+#include <set>

+#include <string>

+#include <vector>

+

+#include "llassettype.h"

+#include "llfoldertype.h"

+#include "llframetimer.h"

+#include "lluuid.h"

+#include "llpermissionsflags.h"

+#include "llviewerinventory.h"

+#include "llstring.h"

+#include "httpcommon.h"

+#include "httprequest.h"

+#include "httpoptions.h"

+#include "httpheaders.h"

+#include "httphandler.h"

+#include "lleventcoro.h"

+#include "llcoros.h"

+

+class LLInventoryObserver;

+class LLInventoryObject;

+class LLInventoryItem;

+class LLInventoryCategory;

+class LLMessageSystem;

+class LLInventoryCollectFunctor;

+

+///----------------------------------------------------------------------------

+/// LLInventoryValidationInfo

+///----------------------------------------------------------------------------

+class LLInventoryValidationInfo: public LLRefCount

+{

+public:

+    LLInventoryValidationInfo();

+    void toOstream(std::ostream& os) const;

+    void asLLSD(LLSD& sd) const;

+

+    bool mInitialized{false};

+    S32 mWarningCount{0};

+    std::map<std::string,U32> mWarnings;

+

+    S32 mLoopCount{0}; // Presence of folders whose ancestors loop onto themselves

+    S32 mOrphanedCount{0}; // Missing or orphaned items, links and folders

+

+    S32 mFatalErrorCount{0};

+    bool mFatalNoRootFolder{false};

+    S32 mFatalSystemDuplicate{0};

+    bool mFatalNoLibraryRootFolder{false};

+    bool mFatalQADebugMode{false};

+

+    std::set<LLFolderType::EType> mMissingRequiredSystemFolders;

+    std::set<LLFolderType::EType> mDuplicateRequiredSystemFolders;

+};

+std::ostream& operator<<(std::ostream& s, const LLInventoryValidationInfo& v);

+

+///----------------------------------------------------------------------------

+// LLInventoryModel

+//

+// Represents a collection of inventory, and provides efficient ways to access

+// that information.

+//   NOTE: 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 LLInventoryModel

+{

+    LOG_CLASS(LLInventoryModel);

+

+public:

+    enum EHasChildren

+    {

+        CHILDREN_NO,

+        CHILDREN_YES,

+        CHILDREN_MAYBE

+    };

+

+    typedef std::vector<LLPointer<LLViewerInventoryCategory> > cat_array_t;

+    typedef std::vector<LLPointer<LLViewerInventoryItem> > item_array_t;

+    typedef std::set<LLUUID> changed_items_t;

+

+    // Rider: This is using the old responder patter.  It should be refactored to

+    // take advantage of coroutines.

+

+    // HTTP handler for individual item requests (inventory or library).

+    // Background item requests are derived from this in the background

+    // inventory system.  All folder requests are also located there

+    // but have their own handler derived from HttpHandler.

+    class FetchItemHttpHandler : public LLCore::HttpHandler

+    {

+    public:

+        LOG_CLASS(FetchItemHttpHandler);

+

+        FetchItemHttpHandler(const LLSD & request_sd);

+        virtual ~FetchItemHttpHandler();

+

+    protected:

+        FetchItemHttpHandler(const FetchItemHttpHandler &);             // Not defined

+        void operator=(const FetchItemHttpHandler &);                   // Not defined

+

+    public:

+        virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);

+

+    private:

+        void processData(LLSD & body, LLCore::HttpResponse * response);

+        void processFailure(LLCore::HttpStatus status, LLCore::HttpResponse * response);

+        void processFailure(const char * const reason, LLCore::HttpResponse * response);

+

+    private:

+        LLSD mRequestSD;

+    };

+

+/********************************************************************************

+ **                                                                            **

+ **                    INITIALIZATION/SETUP

+ **/

+

+    //--------------------------------------------------------------------

+    // Constructors / Destructors

+    //--------------------------------------------------------------------

+public:

+    LLInventoryModel();

+    ~LLInventoryModel();

+    void cleanupInventory();

+protected:

+    void empty(); // empty the entire contents

+

+    //--------------------------------------------------------------------

+    // Initialization

+    //--------------------------------------------------------------------

+public:

+    // The inventory model usage is sensitive to the initial construction of the model

+    bool isInventoryUsable() const;

+private:

+    bool mIsAgentInvUsable; // used to handle an invalid inventory state

+

+    // One-time initialization of HTTP system.

+    void initHttpRequest();

+

+    //--------------------------------------------------------------------

+    // Root Folders

+    //--------------------------------------------------------------------

+public:

+    // The following are set during login with data from the server

+    void setRootFolderID(const LLUUID& id);

+    void setLibraryOwnerID(const LLUUID& id);

+    void setLibraryRootFolderID(const LLUUID& id);

+

+    const LLUUID &getRootFolderID() const;

+    const LLUUID &getLibraryOwnerID() const;

+    const LLUUID &getLibraryRootFolderID() const;

+private:

+    LLUUID mRootFolderID;

+    LLUUID mLibraryRootFolderID;

+    LLUUID mLibraryOwnerID;

+

+    //--------------------------------------------------------------------

+    // Structure

+    //--------------------------------------------------------------------

+public:

+    // Methods to load up inventory skeleton & meat. These are used

+    // during authentication. Returns true if everything parsed.

+    bool loadSkeleton(const LLSD& options, const LLUUID& owner_id);

+    void buildParentChildMap(); // brute force method to rebuild the entire parent-child relations

+    void createCommonSystemCategories();

+

+    static std::string getInvCacheAddres(const LLUUID& owner_id);

+

+    // Call on logout to save a terse representation.

+    void cache(const LLUUID& parent_folder_id, const LLUUID& agent_id);

+private:

+    // 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;

+    cat_map_t mCategoryMap;

+    item_map_t mItemMap;

+    // This last set of indices is used to map parents to children.

+    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;

+

+    // Track links to items and categories. We do not store item or

+    // category pointers here, because broken links are also supported.

+    typedef std::multimap<LLUUID, LLUUID> backlink_mmap_t;

+    backlink_mmap_t mBacklinkMMap; // key = target_id: ID of item, values = link_ids: IDs of item or folder links referencing it.

+    // For internal use only

+    bool hasBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id) const;

+    void addBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id);

+    void removeBacklinkInfo(const LLUUID& link_id, const LLUUID& target_id);

+

+    //--------------------------------------------------------------------

+    // Login

+    //--------------------------------------------------------------------

+public:

+    static bool getIsFirstTimeInViewer2();

+    static bool  isSysFoldersReady() { return (sPendingSystemFolders == 0); }

+

+private:

+    static bool sFirstTimeInViewer2;

+    const static S32 sCurrentInvCacheVersion; // expected inventory cache version

+

+    static S32 sPendingSystemFolders;

+

+/**                    Initialization/Setup

+ **                                                                            **

+ *******************************************************************************/

+

+/********************************************************************************

+ **                                                                            **

+ **                    ACCESSORS

+ **/

+

+    //--------------------------------------------------------------------

+    // Descendants

+    //--------------------------------------------------------------------

+public:

+    // Make sure we have the descendants in the structure.  Returns true

+    // if a fetch was performed.

+    bool fetchDescendentsOf(const LLUUID& folder_id) const;

+

+    // Return the direct descendants of the id provided.Set passed

+    // in values to NULL if the call fails.

+    //    NOTE: 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;

+    void getDirectDescendentsOf(const LLUUID& cat_id, cat_array_t& categories, item_array_t& items, LLInventoryCollectFunctor& f) const;

+

+    typedef LLUUID digest_t; // To clarify the actual usage of this "UUID"

+    // Compute a hash of direct descendant names (for detecting child name changes)

+    digest_t hashDirectDescendentNames(const LLUUID& cat_id) const;

+

+    // Starting with the object specified, add its descendants to the

+    // array provided, but do not add the inventory object specified

+    // by id. There is no guaranteed order.

+    //    NOTE: 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

+    };

+    // Simpler existence test if matches don't actually need to be collected.

+    bool hasMatchingDirectDescendent(const LLUUID& cat_id,

+                                     LLInventoryCollectFunctor& filter);

+    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);

+

+    // Collect all items in inventory that are linked to item_id.

+    // Assumes item_id is itself not a linked item.

+    item_array_t collectLinksTo(const LLUUID& item_id);

+

+    // 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) const;

+

+    enum EAncestorResult{

+        ANCESTOR_OK = 0,

+        ANCESTOR_MISSING = 1,

+        ANCESTOR_LOOP = 2,

+    };

+    // Follow parent chain to the top.

+    EAncestorResult getObjectTopmostAncestor(const LLUUID& object_id, LLUUID& result) const;

+

+    //--------------------------------------------------------------------

+    // Find

+    //--------------------------------------------------------------------

+public:

+

+    // Checks if category exists ("My Inventory" only), if it does not, creates it

+    void ensureCategoryForTypeExists(LLFolderType::EType preferred_type);

+

+    const LLUUID findCategoryUUIDForTypeInRoot(

+        LLFolderType::EType preferred_type,

+        const LLUUID& root_id) const;

+

+    // 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: If create_folder is true, this will create a new inventory category

+    //    on the fly if one does not exist. *NOTE: if find_in_library is true it

+    //    will search in the user's library folder instead of "My Inventory"

+    const LLUUID findCategoryUUIDForType(LLFolderType::EType preferred_type) const;

+    //    will search in the user's library folder instead of "My Inventory"

+    const LLUUID findLibraryCategoryUUIDForType(LLFolderType::EType preferred_type) const;

+    // Returns user specified category for uploads, returns default id if there are no

+    // user specified one or it does not exist, creates default category if it is missing.

+    const LLUUID findUserDefinedCategoryUUIDForType(LLFolderType::EType preferred_type) const;

+

+    // Get whatever special folder this object is a child of, if any.

+    const LLViewerInventoryCategory *getFirstNondefaultParent(const LLUUID& obj_id) const;

+

+    // Get first descendant of the child object under the specified parent

+    const LLViewerInventoryCategory *getFirstDescendantOf(const LLUUID& master_parent_id, const LLUUID& obj_id) const;

+

+    // Get the object by id. Returns NULL if not found.

+    //   NOTE: 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.

+    //    NOTE: 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.

+    //    NOTE: Use the pointer for read operations - use the

+    //    updateCategory() method to actually modify values.

+    LLViewerInventoryCategory* getCategory(const LLUUID& id) const;

+

+    // Get the inventoryID or item that this item points to, else just return object_id

+    const LLUUID& getLinkedItemID(const LLUUID& object_id) const;

+    LLViewerInventoryItem* getLinkedItem(const LLUUID& object_id) const;

+

+    // Copy content of all folders of type "type" into folder "id" and delete/purge the empty folders

+    // Note : This method has been designed for FT_OUTBOX (aka Merchant Outbox) but can be used for other categories

+    void consolidateForType(const LLUUID& id, LLFolderType::EType type);

+

+private:

+    mutable LLPointer<LLViewerInventoryItem> mLastItem; // cache recent lookups

+

+    //--------------------------------------------------------------------

+    // Count

+    //--------------------------------------------------------------------

+public:

+    // Return the number of items or categories

+    S32 getItemCount() const;

+    S32 getCategoryCount() const;

+

+/**                    Accessors

+ **                                                                            **

+ *******************************************************************************/

+

+/********************************************************************************

+ **                                                                            **

+ **                    MUTATORS

+ **/

+

+public:

+    // Change an existing item with a matching item_id or add the item

+    // to the current inventory. Returns the change mask generated by

+    // the update. No notification 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, U32 mask = 0);

+

+    // Change an existing item with the matching id or add

+    // the category. No notification 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 accountForUpdate() or LLViewerInventoryCategory::

+    //    updateServer() before calling this method.

+    void updateCategory(const LLViewerInventoryCategory* cat, U32 mask = 0);

+

+    // Move the specified object id to the specified category and

+    // update the internal structures. No cache accounting,

+    // observer notification, or server update is performed.

+    void moveObject(const LLUUID& object_id, const LLUUID& cat_id);

+

+    // Migrated from llinventoryfunctions

+    void changeItemParent(LLViewerInventoryItem* item,

+                          const LLUUID& new_parent_id,

+                          bool restamp);

+

+    // Migrated from llinventoryfunctions

+    void changeCategoryParent(LLViewerInventoryCategory* cat,

+                              const LLUUID& new_parent_id,

+                              bool restamp);

+

+    // Marks links from a "possibly" broken list for a rebuild

+    // clears the list

+    void rebuildBrockenLinks();

+    bool hasPosiblyBrockenLinks() const { return mPossiblyBrockenLinks.size() > 0; }

+

+    //--------------------------------------------------------------------

+    // Delete

+    //--------------------------------------------------------------------

+public:

+

+    // Update model after an item is confirmed as removed from

+    // server. Works for categories or items.

+    void onObjectDeletedFromServer(const LLUUID& item_id,

+                                   bool fix_broken_links = true,

+                                   bool update_parent_version = true,

+                                   bool do_notify_observers = true);

+

+    // Update model after all descendants removed from server.

+    void onDescendentsPurgedFromServer(const LLUUID& object_id, bool fix_broken_links = true);

+

+    // Update model after an existing item gets updated on server.

+    void onItemUpdated(const LLUUID& item_id, const LLSD& updates, bool update_parent_version);

+

+    // Update model after an existing category gets updated on server.

+    void onCategoryUpdated(const LLUUID& cat_id, const LLSD& updates);

+

+    // Delete a particular inventory object by ID. Will purge one

+    // object from the internal data structures, maintaining a

+    // consistent internal state. No cache accounting, observer

+    // notification, or server update is performed.

+    void deleteObject(const LLUUID& id, bool fix_broken_links = true, bool do_notify_observers = true);

+    /// move Item item_id to Trash

+    void removeItem(const LLUUID& item_id);

+    /// move Category category_id to Trash

+    void removeCategory(const LLUUID& category_id);

+    /// removeItem() or removeCategory(), whichever is appropriate

+    void removeObject(const LLUUID& object_id);

+

+    // "TrashIsFull" when trash exceeds maximum capacity

+    void checkTrashOverflow();

+

+protected:

+    void rebuildLinkItems(LLInventoryModel::item_array_t& items);

+

+    //--------------------------------------------------------------------

+    // Reorder

+    //--------------------------------------------------------------------

+public:

+    // Changes items order by insertion of the item identified by src_item_id

+    // before (or after) the item identified by dest_item_id. Both items must exist in items array.

+    // Sorting is stored after method is finished. Only src_item_id is moved before (or after) dest_item_id.

+    // The parameter "insert_before" controls on which side of dest_item_id src_item_id gets reinserted.

+    static void updateItemsOrder(LLInventoryModel::item_array_t& items,

+                                 const LLUUID& src_item_id,

+                                 const LLUUID& dest_item_id,

+                                 bool insert_before = true);

+    // Gets an iterator on an item vector knowing only the item UUID.

+    // Returns end() of the vector if not found.

+    static LLInventoryModel::item_array_t::iterator findItemIterByUUID(LLInventoryModel::item_array_t& items, const LLUUID& id);

+

+

+    // Rearranges Landmarks inside Favorites folder.

+    // Moves source landmark before target one.

+    void rearrangeFavoriteLandmarks(const LLUUID& source_item_id, const LLUUID& target_item_id);

+    //void saveItemsOrder(const LLInventoryModel::item_array_t& items);

+

+    //--------------------------------------------------------------------

+    // Creation

+    //--------------------------------------------------------------------

+public:

+    // 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.

+    void createNewCategory(const LLUUID& parent_id,

+                             LLFolderType::EType preferred_type,

+                             const std::string& name,

+                             inventory_func_type callback = NULL,

+                             const LLUUID& thumbnail_id = LLUUID::null);

+protected:

+    // Internal methods that 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);

+

+    void createNewCategoryCoro(std::string url, LLSD postData, inventory_func_type callback);

+

+/**                    Mutators

+ **                                                                            **

+ *******************************************************************************/

+

+/********************************************************************************

+ **                                                                            **

+ **                    CATEGORY ACCOUNTING

+ **/

+

+public:

+    // Represents the number of items added or removed from a category.

+    struct LLCategoryUpdate

+    {

+        LLCategoryUpdate() : mDescendentDelta(0), mChangeVersion(true) {}

+        LLCategoryUpdate(const LLUUID& category_id, S32 delta, bool change_version = true) :

+            mCategoryID(category_id),

+            mDescendentDelta(delta),

+            mChangeVersion(change_version) {}

+        LLUUID mCategoryID;

+        S32 mDescendentDelta;

+        bool mChangeVersion;

+    };

+    typedef std::vector<LLCategoryUpdate> update_list_t;

+

+    // This exists 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<LLUUID, LLInitializedS32> update_map_t;

+

+    // Call when there are category updates.  Call them *before* the

+    // actual update so the method can do descendent accounting correctly.

+    void accountForUpdate(const LLCategoryUpdate& update) const;

+    void accountForUpdate(const update_list_t& updates) const;

+    void accountForUpdate(const update_map_t& updates) const;

+

+    // Return (yes/no/maybe) child status of category children.

+    EHasChildren categoryHasChildren(const LLUUID& cat_id) const;

+

+    // Returns true if category version is known and theoretical

+    // descendents == actual descendents.

+    bool isCategoryComplete(const LLUUID& cat_id) const;

+

+/**                    Category Accounting

+ **                                                                            **

+ *******************************************************************************/

+

+/********************************************************************************

+ **                                                                            **

+ **                    NOTIFICATIONS

+ **/

+

+public:

+    // Called by the idle loop.  Only updates if new state is detected.  Call

+    // notifyObservers() manually to update regardless of whether state change

+    // has been indicated.

+    void idleNotifyObservers();

+

+    // Call to explicitly update everyone on a new state.

+    void notifyObservers();

+

+    // Allows outsiders to tell the inventory if something has

+    // been changed 'under the hood', but outside the control of the

+    // inventory. The next notify will include that notification.

+    void addChangedMask(U32 mask, const LLUUID& referent);

+

+    const changed_items_t& getChangedIDs() const { return mChangedItemIDs; }

+    const changed_items_t& getAddedIDs() const { return mAddedItemIDs; }

+protected:

+    // Updates all linked items pointing to this id.

+    void addChangedMaskForLinks(const LLUUID& object_id, U32 mask);

+private:

+    // Flag set when notifyObservers is being called, to look for bugs

+    // where it's called recursively.

+    bool mIsNotifyObservers;

+    // Variables used to track what has changed since the last notify.

+    U32 mModifyMask;

+    changed_items_t mChangedItemIDs;

+    changed_items_t mAddedItemIDs;

+    // Fallback when notifyObservers is in progress

+    U32 mModifyMaskBacklog;

+    changed_items_t mChangedItemIDsBacklog;

+    changed_items_t mAddedItemIDsBacklog;

+    typedef std::map<LLUUID , changed_items_t> broken_links_t;

+    broken_links_t mPossiblyBrockenLinks; // there can be multiple links per item

+    changed_items_t mLinksRebuildList;

+    boost::signals2::connection mBulkFecthCallbackSlot;

+

+

+    //--------------------------------------------------------------------

+    // Observers

+    //--------------------------------------------------------------------

+public:

+    // If the observer is destroyed, be sure to remove it.

+    void addObserver(LLInventoryObserver* observer);

+    void removeObserver(LLInventoryObserver* observer);

+    bool containsObserver(LLInventoryObserver* observer) const;

+private:

+    typedef std::set<LLInventoryObserver*> observer_list_t;

+    observer_list_t mObservers;

+

+/**                    Notifications

+ **                                                                            **

+ *******************************************************************************/

+

+

+/********************************************************************************

+ **                                                                            **

+ **                    HTTP Transport

+ **/

+public:

+    // Invoke handler completion method (onCompleted) for all

+    // requests that are ready.

+    void handleResponses(bool foreground);

+

+    // Request an inventory HTTP operation to either the

+    // foreground or background processor.  These are actually

+    // the same service queue but the background requests are

+    // seviced more slowly effectively de-prioritizing new

+    // requests.

+    LLCore::HttpHandle requestPost(bool foreground,

+                                   const std::string & url,

+                                   const LLSD & body,

+                                   const LLCore::HttpHandler::ptr_t &handler,

+                                   const char * const message);

+

+private:

+    // Usual plumbing for LLCore:: HTTP operations.

+    LLCore::HttpRequest *               mHttpRequestFG;

+    LLCore::HttpRequest *               mHttpRequestBG;

+    LLCore::HttpOptions::ptr_t          mHttpOptions;

+    LLCore::HttpHeaders::ptr_t          mHttpHeaders;

+    LLCore::HttpRequest::policy_t       mHttpPolicyClass;

+

+/**                    HTTP Transport

+ **                                                                            **

+ *******************************************************************************/

+

+

+/********************************************************************************

+ **                                                                            **

+ **                    MISCELLANEOUS

+ **/

+

+    //--------------------------------------------------------------------

+    // Callbacks

+    //--------------------------------------------------------------------

+public:

+    // Trigger a notification and empty the folder type (FT_TRASH or FT_LOST_AND_FOUND) if confirmed

+    void emptyFolderType(const std::string notification, LLFolderType::EType folder_type);

+    bool callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLFolderType::EType preferred_type);

+    static void registerCallbacks(LLMessageSystem* msg);

+

+    //--------------------------------------------------------------------

+    // File I/O

+    //--------------------------------------------------------------------

+protected:

+    static bool loadFromFile(const std::string& filename,

+                             cat_array_t& categories,

+                             item_array_t& items,

+                             changed_items_t& cats_to_update,

+                             bool& is_cache_obsolete);

+    static bool saveToFile(const std::string& filename,

+                           const cat_array_t& categories,

+                           const item_array_t& items);

+

+    //--------------------------------------------------------------------

+    // Message handling functionality

+    //--------------------------------------------------------------------

+public:

+    static void processUpdateCreateInventoryItem(LLMessageSystem* msg, void**);

+    static void removeInventoryItem(LLUUID agent_id, LLMessageSystem* msg, const char* msg_label);

+    static void processRemoveInventoryItem(LLMessageSystem* msg, void**);

+    static void removeInventoryFolder(LLUUID agent_id, LLMessageSystem* msg);

+    static void processRemoveInventoryFolder(LLMessageSystem* msg, void**);

+    static void processRemoveInventoryObjects(LLMessageSystem* msg, void**);

+    static void processSaveAssetIntoInventory(LLMessageSystem* msg, void**);

+    static void processBulkUpdateInventory(LLMessageSystem* msg, void**);

+    static void processMoveInventoryItem(LLMessageSystem* msg, void**);

+protected:

+    bool messageUpdateCore(LLMessageSystem* msg, bool do_accounting, U32 mask = 0x0);

+

+    //--------------------------------------------------------------------

+    // Locks

+    //--------------------------------------------------------------------

+public:

+    void lockDirectDescendentArrays(const LLUUID& cat_id,

+                                    cat_array_t*& categories,

+                                    item_array_t*& items);

+    void unlockDirectDescendentArrays(const LLUUID& cat_id);

+protected:

+    cat_array_t* getUnlockedCatArray(const LLUUID& id);

+    item_array_t* getUnlockedItemArray(const LLUUID& id);

+private:

+    std::map<LLUUID, bool> mCategoryLock;

+    std::map<LLUUID, bool> mItemLock;

+

+    //--------------------------------------------------------------------

+    // Debugging

+    //--------------------------------------------------------------------

+public:

+    void dumpInventory() const;

+    LLPointer<LLInventoryValidationInfo> validate() const;

+    LLPointer<LLInventoryValidationInfo> mValidationInfo;

+    std::string getFullPath(const LLInventoryObject *obj) const;

+

+/**                    Miscellaneous

+ **                                                                            **

+ *******************************************************************************/

+};

+

+// a special inventory model for the agent

+extern LLInventoryModel gInventory;

+

+#endif // LL_LLINVENTORYMODEL_H

+