Index: src/libchcore/TTaskConfigTracker.cpp
===================================================================
diff -u -N -r73d92717b7ba780c7aea1489a5eaa87404afa408 -re96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3
--- src/libchcore/TTaskConfigTracker.cpp	(.../TTaskConfigTracker.cpp)	(revision 73d92717b7ba780c7aea1489a5eaa87404afa408)
+++ src/libchcore/TTaskConfigTracker.cpp	(.../TTaskConfigTracker.cpp)	(revision e96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3)
@@ -26,229 +26,228 @@
 #include "ErrorCodes.h"
 #include "TStringSet.h"
 
-BEGIN_CHCORE_NAMESPACE
-
-TOptionsSet& TOptionsSet::operator%(ETaskOptions eOption)
+namespace chcore
 {
-	m_setOptions.insert(eOption);
+	TOptionsSet& TOptionsSet::operator%(ETaskOptions eOption)
+	{
+		m_setOptions.insert(eOption);
 
-	return *this;
-}
+		return *this;
+	}
 
-std::set<ETaskOptions>& TOptionsSet::Get()
-{
-	return m_setOptions;
-}
+	std::set<ETaskOptions>& TOptionsSet::Get()
+	{
+		return m_setOptions;
+	}
 
-TTaskConfigTracker::TTaskConfigTracker()
-{
-}
+	TTaskConfigTracker::TTaskConfigTracker()
+	{
+	}
 
-TTaskConfigTracker::~TTaskConfigTracker()
-{
-}
+	TTaskConfigTracker::~TTaskConfigTracker()
+	{
+	}
 
-bool TTaskConfigTracker::IsModified() const
-{
-	boost::shared_lock<boost::shared_mutex> lock(m_lock);
-	return !m_setModified.empty();
-}
+	bool TTaskConfigTracker::IsModified() const
+	{
+		boost::shared_lock<boost::shared_mutex> lock(m_lock);
+		return !m_setModified.empty();
+	}
 
-bool TTaskConfigTracker::IsModified(ETaskOptions eOption) const
-{
-	boost::shared_lock<boost::shared_mutex> lock(m_lock);
-	return m_setModified.find(eOption) != m_setModified.end();
-}
-
-bool TTaskConfigTracker::IsModified(TOptionsSet setOptions) const
-{
-	boost::shared_lock<boost::shared_mutex> lock(m_lock);
-
-	std::set<ETaskOptions> setCommon;
-	std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
-
-	return !setCommon.empty();
-}
-
-bool TTaskConfigTracker::IsModified(ETaskOptions eOption, bool bResetModificationState)
-{
-	boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
-
-	std::set<ETaskOptions>::iterator iterOption = m_setModified.find(eOption);
-	bool bModified = (iterOption != m_setModified.end());
-	if(bModified && bResetModificationState)
+	bool TTaskConfigTracker::IsModified(ETaskOptions eOption) const
 	{
-		boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
-		m_setModified.erase(iterOption);
+		boost::shared_lock<boost::shared_mutex> lock(m_lock);
+		return m_setModified.find(eOption) != m_setModified.end();
 	}
 
-	return bModified;
-}
+	bool TTaskConfigTracker::IsModified(TOptionsSet setOptions) const
+	{
+		boost::shared_lock<boost::shared_mutex> lock(m_lock);
 
-bool TTaskConfigTracker::IsModified(TOptionsSet setOptions, bool bResetModificationState)
-{
-	boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
+		std::set<ETaskOptions> setCommon;
+		std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
 
-	std::set<ETaskOptions> setCommon;
-	std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
+		return !setCommon.empty();
+	}
 
-	bool bModified = !setCommon.empty();
-	if(bModified && bResetModificationState)
+	bool TTaskConfigTracker::IsModified(ETaskOptions eOption, bool bResetModificationState)
 	{
-		boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
-		std::set<ETaskOptions>::iterator iterOption;
-		BOOST_FOREACH(ETaskOptions eOption, setCommon)
+		boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
+
+		std::set<ETaskOptions>::iterator iterOption = m_setModified.find(eOption);
+		bool bModified = (iterOption != m_setModified.end());
+		if (bModified && bResetModificationState)
 		{
-			iterOption = m_setModified.find(eOption);
-			if(iterOption != m_setModified.end())
-				m_setModified.erase(iterOption);
+			boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
+			m_setModified.erase(iterOption);
 		}
+
+		return bModified;
 	}
 
-	return bModified;
-}
+	bool TTaskConfigTracker::IsModified(TOptionsSet setOptions, bool bResetModificationState)
+	{
+		boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
 
-void TTaskConfigTracker::AddModified(const TString& strModified)
-{
-	ETaskOptions eOption = TTaskConfigTracker::GetOptionFromString(strModified);
+		std::set<ETaskOptions> setCommon;
+		std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
 
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
+		bool bModified = !setCommon.empty();
+		if (bModified && bResetModificationState)
+		{
+			boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
+			std::set<ETaskOptions>::iterator iterOption;
+			BOOST_FOREACH(ETaskOptions eOption, setCommon)
+			{
+				iterOption = m_setModified.find(eOption);
+				if (iterOption != m_setModified.end())
+					m_setModified.erase(iterOption);
+			}
+		}
 
-	m_setModified.insert(eOption);
-}
+		return bModified;
+	}
 
-void TTaskConfigTracker::AddModified(ETaskOptions eModified)
-{
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
-	m_setModified.insert(eModified);
-}
+	void TTaskConfigTracker::AddModified(const TString& strModified)
+	{
+		ETaskOptions eOption = TTaskConfigTracker::GetOptionFromString(strModified);
 
-void TTaskConfigTracker::AddModified(TOptionsSet setOptions)
-{
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
-	m_setModified.insert(setOptions.Get().begin(), setOptions.Get().end());
-}
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
 
-void TTaskConfigTracker::AddModified(const TStringSet& setModified)
-{
-	TStringSet::const_iterator iterBegin = setModified.Begin();
-	TStringSet::const_iterator iterEnd = setModified.End();
+		m_setModified.insert(eOption);
+	}
 
-	for(; iterBegin != iterEnd; ++iterBegin)
+	void TTaskConfigTracker::AddModified(ETaskOptions eModified)
 	{
-		AddModified(*iterBegin);
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
+		m_setModified.insert(eModified);
 	}
-}
 
-void TTaskConfigTracker::AddModified(const std::set<ETaskOptions>& setModified)
-{
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
+	void TTaskConfigTracker::AddModified(TOptionsSet setOptions)
+	{
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
+		m_setModified.insert(setOptions.Get().begin(), setOptions.Get().end());
+	}
 
-	m_setModified.insert(setModified.begin(), setModified.end());
-}
-
-void TTaskConfigTracker::RemoveModification(ETaskOptions eModified)
-{
-	boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
-	std::set<ETaskOptions>::iterator iterOption = m_setModified.find(eModified);
-	if(iterOption != m_setModified.end())
+	void TTaskConfigTracker::AddModified(const TStringSet& setModified)
 	{
-		boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
-		m_setModified.erase(iterOption);
+		TStringSet::const_iterator iterBegin = setModified.Begin();
+		TStringSet::const_iterator iterEnd = setModified.End();
+
+		for (; iterBegin != iterEnd; ++iterBegin)
+		{
+			AddModified(*iterBegin);
+		}
 	}
-}
 
-void TTaskConfigTracker::RemoveModificationSet(TOptionsSet setOptions)
-{
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
+	void TTaskConfigTracker::AddModified(const std::set<ETaskOptions>& setModified)
+	{
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
 
-	std::set<ETaskOptions> setCommon;
-	std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
+		m_setModified.insert(setModified.begin(), setModified.end());
+	}
 
-	std::set<ETaskOptions>::iterator iterOption;
-	BOOST_FOREACH(ETaskOptions eOption, setCommon)
+	void TTaskConfigTracker::RemoveModification(ETaskOptions eModified)
 	{
-		iterOption = m_setModified.find(eOption);
-		if(iterOption != m_setModified.end())
+		boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
+		std::set<ETaskOptions>::iterator iterOption = m_setModified.find(eModified);
+		if (iterOption != m_setModified.end())
+		{
+			boost::upgrade_to_unique_lock<boost::shared_mutex> upgraded_lock(lock);
 			m_setModified.erase(iterOption);
+		}
 	}
-}
 
-void TTaskConfigTracker::RemoveModification(const TString& strModified)
-{
-	ETaskOptions eOption = TTaskConfigTracker::GetOptionFromString(strModified);
-	RemoveModification(eOption);
-}
+	void TTaskConfigTracker::RemoveModificationSet(TOptionsSet setOptions)
+	{
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
 
-void TTaskConfigTracker::Clear()
-{
-	boost::unique_lock<boost::shared_mutex> lock(m_lock);
-	m_setModified.clear();
-}
+		std::set<ETaskOptions> setCommon;
+		std::set_intersection(setOptions.Get().begin(), setOptions.Get().end(), m_setModified.begin(), m_setModified.end(), std::inserter(setCommon, setCommon.begin()));
 
-void TTaskConfigTracker::NotificationProc(const TStringSet& setModifications, void* pParam)
-{
-	if(!pParam)
-		THROW_CORE_EXCEPTION(eErr_InvalidArgument);
+		std::set<ETaskOptions>::iterator iterOption;
+		BOOST_FOREACH(ETaskOptions eOption, setCommon)
+		{
+			iterOption = m_setModified.find(eOption);
+			if (iterOption != m_setModified.end())
+				m_setModified.erase(iterOption);
+		}
+	}
 
-	TTaskConfigTracker* pTracker = (TTaskConfigTracker*)pParam;
-	pTracker->AddModified(setModifications);
-}
+	void TTaskConfigTracker::RemoveModification(const TString& strModified)
+	{
+		ETaskOptions eOption = TTaskConfigTracker::GetOptionFromString(strModified);
+		RemoveModification(eOption);
+	}
 
-ETaskOptions TTaskConfigTracker::GetOptionFromString(const TString& strOption)
-{
-	if(strOption == TaskPropData<eTO_UseOnlyDefaultBuffer>::GetPropertyName())
-		return eTO_UseOnlyDefaultBuffer;
-	else if(strOption == TaskPropData<eTO_DefaultBufferSize>::GetPropertyName())
-		return eTO_DefaultBufferSize;
-	else if(strOption == TaskPropData<eTO_OneDiskBufferSize>::GetPropertyName())
-		return eTO_OneDiskBufferSize;
-	else if(strOption == TaskPropData<eTO_TwoDisksBufferSize>::GetPropertyName())
-		return eTO_TwoDisksBufferSize;
-	else if(strOption == TaskPropData<eTO_CDBufferSize>::GetPropertyName())
-		return eTO_CDBufferSize;
-	else if(strOption == TaskPropData<eTO_LANBufferSize>::GetPropertyName())
-		return eTO_LANBufferSize;
-	else if(strOption == TaskPropData<eTO_DisableBuffering>::GetPropertyName())
-		return eTO_DisableBuffering;
-	else if (strOption == TaskPropData<eTO_DisableBufferingMinSize>::GetPropertyName())
-		return eTO_DisableBufferingMinSize;
-	else if (strOption == TaskPropData<eTO_BufferQueueDepth>::GetPropertyName())
-		return eTO_BufferQueueDepth;
+	void TTaskConfigTracker::Clear()
+	{
+		boost::unique_lock<boost::shared_mutex> lock(m_lock);
+		m_setModified.clear();
+	}
 
-	else if(strOption == TaskPropData<eTO_SetDestinationAttributes>::GetPropertyName())
-		return eTO_SetDestinationAttributes;
-	else if(strOption == TaskPropData<eTO_SetDestinationDateTime>::GetPropertyName())
-		return eTO_SetDestinationDateTime;
-	else if(strOption == TaskPropData<eTO_ProtectReadOnlyFiles>::GetPropertyName())
-		return eTO_ProtectReadOnlyFiles;
-	else if(strOption == TaskPropData<eTO_ScanDirectoriesBeforeBlocking>::GetPropertyName())
-		return eTO_ScanDirectoriesBeforeBlocking;
-	else if(strOption == TaskPropData<eTO_ThreadPriority>::GetPropertyName())
-		return eTO_ThreadPriority;
-	else if(strOption == TaskPropData<eTO_DisablePriorityBoost>::GetPropertyName())
-		return eTO_DisablePriorityBoost;
-	else if(strOption == TaskPropData<eTO_DeleteInSeparateSubTask>::GetPropertyName())
-		return eTO_DeleteInSeparateSubTask;
-
-	else if(strOption == TaskPropData<eTO_CreateEmptyFiles>::GetPropertyName())
-		return eTO_CreateEmptyFiles;
-	else if(strOption == TaskPropData<eTO_CreateDirectoriesRelativeToRoot>::GetPropertyName())
-		return eTO_CreateDirectoriesRelativeToRoot;
-	else if(strOption == TaskPropData<eTO_IgnoreDirectories>::GetPropertyName())
-		return eTO_IgnoreDirectories;
-	else if(strOption == TaskPropData<eTO_AlternateFilenameFormatString_First>::GetPropertyName())
-		return eTO_AlternateFilenameFormatString_AfterFirst;
-	else if(strOption == TaskPropData<eTO_AlternateFilenameFormatString_AfterFirst>::GetPropertyName())
-		return eTO_AlternateFilenameFormatString_First;
-	else
+	void TTaskConfigTracker::NotificationProc(const TStringSet& setModifications, void* pParam)
 	{
-		BOOST_ASSERT(false);		// unhandled case
-		THROW_CORE_EXCEPTION(eErr_UnhandledCase);
+		if (!pParam)
+			THROW_CORE_EXCEPTION(eErr_InvalidArgument);
+
+		TTaskConfigTracker* pTracker = (TTaskConfigTracker*)pParam;
+		pTracker->AddModified(setModifications);
 	}
 
-	// add new elements before this one
-	BOOST_STATIC_ASSERT(eTO_Last == eTO_AlternateFilenameFormatString_AfterFirst + 1);
-}
+	ETaskOptions TTaskConfigTracker::GetOptionFromString(const TString& strOption)
+	{
+		if (strOption == TaskPropData<eTO_UseOnlyDefaultBuffer>::GetPropertyName())
+			return eTO_UseOnlyDefaultBuffer;
+		else if (strOption == TaskPropData<eTO_DefaultBufferSize>::GetPropertyName())
+			return eTO_DefaultBufferSize;
+		else if (strOption == TaskPropData<eTO_OneDiskBufferSize>::GetPropertyName())
+			return eTO_OneDiskBufferSize;
+		else if (strOption == TaskPropData<eTO_TwoDisksBufferSize>::GetPropertyName())
+			return eTO_TwoDisksBufferSize;
+		else if (strOption == TaskPropData<eTO_CDBufferSize>::GetPropertyName())
+			return eTO_CDBufferSize;
+		else if (strOption == TaskPropData<eTO_LANBufferSize>::GetPropertyName())
+			return eTO_LANBufferSize;
+		else if (strOption == TaskPropData<eTO_DisableBuffering>::GetPropertyName())
+			return eTO_DisableBuffering;
+		else if (strOption == TaskPropData<eTO_DisableBufferingMinSize>::GetPropertyName())
+			return eTO_DisableBufferingMinSize;
+		else if (strOption == TaskPropData<eTO_BufferQueueDepth>::GetPropertyName())
+			return eTO_BufferQueueDepth;
 
-END_CHCORE_NAMESPACE
+		else if (strOption == TaskPropData<eTO_SetDestinationAttributes>::GetPropertyName())
+			return eTO_SetDestinationAttributes;
+		else if (strOption == TaskPropData<eTO_SetDestinationDateTime>::GetPropertyName())
+			return eTO_SetDestinationDateTime;
+		else if (strOption == TaskPropData<eTO_ProtectReadOnlyFiles>::GetPropertyName())
+			return eTO_ProtectReadOnlyFiles;
+		else if (strOption == TaskPropData<eTO_ScanDirectoriesBeforeBlocking>::GetPropertyName())
+			return eTO_ScanDirectoriesBeforeBlocking;
+		else if (strOption == TaskPropData<eTO_ThreadPriority>::GetPropertyName())
+			return eTO_ThreadPriority;
+		else if (strOption == TaskPropData<eTO_DisablePriorityBoost>::GetPropertyName())
+			return eTO_DisablePriorityBoost;
+		else if (strOption == TaskPropData<eTO_DeleteInSeparateSubTask>::GetPropertyName())
+			return eTO_DeleteInSeparateSubTask;
+
+		else if (strOption == TaskPropData<eTO_CreateEmptyFiles>::GetPropertyName())
+			return eTO_CreateEmptyFiles;
+		else if (strOption == TaskPropData<eTO_CreateDirectoriesRelativeToRoot>::GetPropertyName())
+			return eTO_CreateDirectoriesRelativeToRoot;
+		else if (strOption == TaskPropData<eTO_IgnoreDirectories>::GetPropertyName())
+			return eTO_IgnoreDirectories;
+		else if (strOption == TaskPropData<eTO_AlternateFilenameFormatString_First>::GetPropertyName())
+			return eTO_AlternateFilenameFormatString_AfterFirst;
+		else if (strOption == TaskPropData<eTO_AlternateFilenameFormatString_AfterFirst>::GetPropertyName())
+			return eTO_AlternateFilenameFormatString_First;
+		else
+		{
+			BOOST_ASSERT(false);		// unhandled case
+			THROW_CORE_EXCEPTION(eErr_UnhandledCase);
+		}
+
+		// add new elements before this one
+		BOOST_STATIC_ASSERT(eTO_Last == eTO_AlternateFilenameFormatString_AfterFirst + 1);
+	}
+}