Index: src/libchcore/TTaskInfo.cpp
===================================================================
diff -u -N -r95a466ca0a4f95851dcacf2b80e2084e0168b7e4 -re96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3
--- src/libchcore/TTaskInfo.cpp	(.../TTaskInfo.cpp)	(revision 95a466ca0a4f95851dcacf2b80e2084e0168b7e4)
+++ src/libchcore/TTaskInfo.cpp	(.../TTaskInfo.cpp)	(revision e96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3)
@@ -22,247 +22,246 @@
 #include "ISerializerRowData.h"
 #include "ISerializerRowReader.h"
 
-BEGIN_CHCORE_NAMESPACE
-
-TTaskInfoEntry::TTaskInfoEntry() :
-	m_iOrder(m_setModifications, 0),
-	m_pathSerializeLocation(m_setModifications),
-	m_oidObjectID(0)
+namespace chcore
 {
-	m_setModifications[eMod_Added] = true;
-}
+	TTaskInfoEntry::TTaskInfoEntry() :
+		m_iOrder(m_setModifications, 0),
+		m_pathSerializeLocation(m_setModifications),
+		m_oidObjectID(0)
+	{
+		m_setModifications[eMod_Added] = true;
+	}
 
-TTaskInfoEntry::TTaskInfoEntry(object_id_t oidTaskID, const TSmartPath& pathTask, int iOrder, const TTaskPtr& spTask) :
-	m_oidObjectID(oidTaskID),
-	m_pathSerializeLocation(m_setModifications, pathTask),
-	m_iOrder(m_setModifications, iOrder),
-	m_spTask(spTask)
-{
-	m_setModifications[eMod_Added] = true;
-}
+	TTaskInfoEntry::TTaskInfoEntry(object_id_t oidTaskID, const TSmartPath& pathTask, int iOrder, const TTaskPtr& spTask) :
+		m_oidObjectID(oidTaskID),
+		m_pathSerializeLocation(m_setModifications, pathTask),
+		m_iOrder(m_setModifications, iOrder),
+		m_spTask(spTask)
+	{
+		m_setModifications[eMod_Added] = true;
+	}
 
-TTaskInfoEntry::TTaskInfoEntry(const TTaskInfoEntry& rSrc) :
-	m_oidObjectID(rSrc.m_oidObjectID),
-	m_pathSerializeLocation(m_setModifications, rSrc.m_pathSerializeLocation),
-	m_iOrder(m_setModifications, rSrc.m_iOrder),
-	m_spTask(rSrc.m_spTask)
-{
-	m_setModifications = rSrc.m_setModifications;
-}
-
-TTaskInfoEntry& TTaskInfoEntry::operator=(const TTaskInfoEntry& rSrc)
-{
-	if(this != &rSrc)
+	TTaskInfoEntry::TTaskInfoEntry(const TTaskInfoEntry& rSrc) :
+		m_oidObjectID(rSrc.m_oidObjectID),
+		m_pathSerializeLocation(m_setModifications, rSrc.m_pathSerializeLocation),
+		m_iOrder(m_setModifications, rSrc.m_iOrder),
+		m_spTask(rSrc.m_spTask)
 	{
-		m_oidObjectID = rSrc.m_oidObjectID;
-		m_pathSerializeLocation = rSrc.m_pathSerializeLocation;
-		m_iOrder = rSrc.m_iOrder;
-		m_spTask = rSrc.m_spTask;
 		m_setModifications = rSrc.m_setModifications;
 	}
 
-	return *this;
-}
+	TTaskInfoEntry& TTaskInfoEntry::operator=(const TTaskInfoEntry& rSrc)
+	{
+		if (this != &rSrc)
+		{
+			m_oidObjectID = rSrc.m_oidObjectID;
+			m_pathSerializeLocation = rSrc.m_pathSerializeLocation;
+			m_iOrder = rSrc.m_iOrder;
+			m_spTask = rSrc.m_spTask;
+			m_setModifications = rSrc.m_setModifications;
+		}
 
-TSmartPath TTaskInfoEntry::GetTaskSerializeLocation() const
-{
-	return m_pathSerializeLocation;
-}
+		return *this;
+	}
 
-void TTaskInfoEntry::SetTaskSerializeLocation(const TSmartPath& strTaskPath)
-{
-	m_pathSerializeLocation = strTaskPath;
-}
+	TSmartPath TTaskInfoEntry::GetTaskSerializeLocation() const
+	{
+		return m_pathSerializeLocation;
+	}
 
-TTaskPtr TTaskInfoEntry::GetTask() const
-{
-	return m_spTask;
-}
+	void TTaskInfoEntry::SetTaskSerializeLocation(const TSmartPath& strTaskPath)
+	{
+		m_pathSerializeLocation = strTaskPath;
+	}
 
-void TTaskInfoEntry::SetTask(const TTaskPtr& spTask)
-{
-	m_spTask = spTask;
-}
+	TTaskPtr TTaskInfoEntry::GetTask() const
+	{
+		return m_spTask;
+	}
 
-int TTaskInfoEntry::GetOrder() const
-{
-	return m_iOrder;
-}
+	void TTaskInfoEntry::SetTask(const TTaskPtr& spTask)
+	{
+		m_spTask = spTask;
+	}
 
-void TTaskInfoEntry::SetOrder(int iOrder)
-{
-	m_iOrder = iOrder;
-}
+	int TTaskInfoEntry::GetOrder() const
+	{
+		return m_iOrder;
+	}
 
-void TTaskInfoEntry::Store(const ISerializerContainerPtr& spContainer) const
-{
-	if(!m_setModifications.any())
-		return;
+	void TTaskInfoEntry::SetOrder(int iOrder)
+	{
+		m_iOrder = iOrder;
+	}
 
-	bool bAdded = m_setModifications[eMod_Added];
-	ISerializerRowData& rRow = spContainer->GetRow(m_oidObjectID, bAdded);
+	void TTaskInfoEntry::Store(const ISerializerContainerPtr& spContainer) const
+	{
+		if (!m_setModifications.any())
+			return;
 
-	if(bAdded || m_setModifications[eMod_TaskPath])
-		rRow.SetValue(_T("path"), m_pathSerializeLocation);
-	if(bAdded || m_setModifications[eMod_Order])
-		rRow.SetValue(_T("task_order"), m_iOrder);
+		bool bAdded = m_setModifications[eMod_Added];
+		ISerializerRowData& rRow = spContainer->GetRow(m_oidObjectID, bAdded);
 
-	m_setModifications.reset();
-}
+		if (bAdded || m_setModifications[eMod_TaskPath])
+			rRow.SetValue(_T("path"), m_pathSerializeLocation);
+		if (bAdded || m_setModifications[eMod_Order])
+			rRow.SetValue(_T("task_order"), m_iOrder);
 
-void TTaskInfoEntry::Load(const ISerializerRowReaderPtr& spRowReader)
-{
-	spRowReader->GetValue(_T("id"), m_oidObjectID);
-	spRowReader->GetValue(_T("path"), m_pathSerializeLocation.Modify());
-	spRowReader->GetValue(_T("task_order"), m_iOrder.Modify());
+		m_setModifications.reset();
+	}
 
-	m_setModifications.reset();
-}
+	void TTaskInfoEntry::Load(const ISerializerRowReaderPtr& spRowReader)
+	{
+		spRowReader->GetValue(_T("id"), m_oidObjectID);
+		spRowReader->GetValue(_T("path"), m_pathSerializeLocation.Modify());
+		spRowReader->GetValue(_T("task_order"), m_iOrder.Modify());
 
-void TTaskInfoEntry::InitColumns(IColumnsDefinition& rColumnDefs)
-{
-	rColumnDefs.AddColumn(_T("id"), ColumnType<object_id_t>::value);
-	rColumnDefs.AddColumn(_T("path"), IColumnsDefinition::eType_path);
-	rColumnDefs.AddColumn(_T("task_order"), IColumnsDefinition::eType_int);
-}
+		m_setModifications.reset();
+	}
 
-object_id_t TTaskInfoEntry::GetObjectID() const
-{
-	return m_oidObjectID;
-}
+	void TTaskInfoEntry::InitColumns(IColumnsDefinition& rColumnDefs)
+	{
+		rColumnDefs.AddColumn(_T("id"), ColumnType<object_id_t>::value);
+		rColumnDefs.AddColumn(_T("path"), IColumnsDefinition::eType_path);
+		rColumnDefs.AddColumn(_T("task_order"), IColumnsDefinition::eType_int);
+	}
 
-void TTaskInfoEntry::ResetModifications()
-{
-	m_setModifications.reset();
-}
+	object_id_t TTaskInfoEntry::GetObjectID() const
+	{
+		return m_oidObjectID;
+	}
 
-///////////////////////////////////////////////////////////////////////////
-TTaskInfoContainer::TTaskInfoContainer() :
-	m_oidLastObjectID(0)
-{
-}
+	void TTaskInfoEntry::ResetModifications()
+	{
+		m_setModifications.reset();
+	}
 
-void TTaskInfoContainer::Add(const TSmartPath& pathTask, int iOrder, const TTaskPtr& spTask)
-{
-	m_vTaskInfos.push_back(TTaskInfoEntry(++m_oidLastObjectID, pathTask, iOrder, spTask));
-}
+	///////////////////////////////////////////////////////////////////////////
+	TTaskInfoContainer::TTaskInfoContainer() :
+		m_oidLastObjectID(0)
+	{
+	}
 
-void TTaskInfoContainer::RemoveAt(size_t stIndex)
-{
-	if(stIndex >= m_vTaskInfos.size())
-		THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
+	void TTaskInfoContainer::Add(const TSmartPath& pathTask, int iOrder, const TTaskPtr& spTask)
+	{
+		m_vTaskInfos.push_back(TTaskInfoEntry(++m_oidLastObjectID, pathTask, iOrder, spTask));
+	}
 
-	std::vector<TTaskInfoEntry>::iterator iter = m_vTaskInfos.begin() + stIndex;
-	object_id_t oidTaskID = (*iter).GetObjectID();
-	m_vTaskInfos.erase(m_vTaskInfos.begin() + stIndex);
-	m_setRemovedTasks.Add(oidTaskID);
-}
+	void TTaskInfoContainer::RemoveAt(size_t stIndex)
+	{
+		if (stIndex >= m_vTaskInfos.size())
+			THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
 
-void TTaskInfoContainer::Clear()
-{
-	BOOST_FOREACH(TTaskInfoEntry& rEntry, m_vTaskInfos)
+		std::vector<TTaskInfoEntry>::iterator iter = m_vTaskInfos.begin() + stIndex;
+		object_id_t oidTaskID = (*iter).GetObjectID();
+		m_vTaskInfos.erase(m_vTaskInfos.begin() + stIndex);
+		m_setRemovedTasks.Add(oidTaskID);
+	}
+
+	void TTaskInfoContainer::Clear()
 	{
-		m_setRemovedTasks.Add(rEntry.GetObjectID());
+		BOOST_FOREACH(TTaskInfoEntry& rEntry, m_vTaskInfos)
+		{
+			m_setRemovedTasks.Add(rEntry.GetObjectID());
+		}
+		m_vTaskInfos.clear();
 	}
-	m_vTaskInfos.clear();
-}
 
-TTaskInfoEntry& TTaskInfoContainer::GetAt(size_t stIndex)
-{
-	if(stIndex >= m_vTaskInfos.size())
-		THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
+	TTaskInfoEntry& TTaskInfoContainer::GetAt(size_t stIndex)
+	{
+		if (stIndex >= m_vTaskInfos.size())
+			THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
 
-	return m_vTaskInfos[stIndex];
-}
+		return m_vTaskInfos[stIndex];
+	}
 
-const TTaskInfoEntry& TTaskInfoContainer::GetAt(size_t stIndex) const
-{
-	if(stIndex >= m_vTaskInfos.size())
-		THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
+	const TTaskInfoEntry& TTaskInfoContainer::GetAt(size_t stIndex) const
+	{
+		if (stIndex >= m_vTaskInfos.size())
+			THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
 
-	return m_vTaskInfos[stIndex];
-}
+		return m_vTaskInfos[stIndex];
+	}
 
-size_t TTaskInfoContainer::GetCount() const
-{
-	return m_vTaskInfos.size();
-}
+	size_t TTaskInfoContainer::GetCount() const
+	{
+		return m_vTaskInfos.size();
+	}
 
-bool TTaskInfoContainer::GetByTaskID(taskid_t tTaskID, TTaskInfoEntry& rInfo) const
-{
-	for(std::vector<TTaskInfoEntry>::const_iterator iter = m_vTaskInfos.begin(); iter != m_vTaskInfos.end(); ++iter)
+	bool TTaskInfoContainer::GetByTaskID(taskid_t tTaskID, TTaskInfoEntry& rInfo) const
 	{
-		if((*iter).GetObjectID() == tTaskID)
+		for (std::vector<TTaskInfoEntry>::const_iterator iter = m_vTaskInfos.begin(); iter != m_vTaskInfos.end(); ++iter)
 		{
-			rInfo = *iter;
-			return true;
+			if ((*iter).GetObjectID() == tTaskID)
+			{
+				rInfo = *iter;
+				return true;
+			}
 		}
+
+		return false;
 	}
 
-	return false;
-}
+	bool TTaskInfoContainer::IsEmpty() const
+	{
+		return m_vTaskInfos.empty();
+	}
 
-bool TTaskInfoContainer::IsEmpty() const
-{
-	return m_vTaskInfos.empty();
-}
+	void TTaskInfoContainer::ClearModifications()
+	{
+		m_setRemovedTasks.Clear();
 
-void TTaskInfoContainer::ClearModifications()
-{
-	m_setRemovedTasks.Clear();
+		BOOST_FOREACH(TTaskInfoEntry& rEntry, m_vTaskInfos)
+		{
+			// if marked as added, we don't consider it modified anymore
+			rEntry.ResetModifications();
+		}
+	}
 
-	BOOST_FOREACH(TTaskInfoEntry& rEntry, m_vTaskInfos)
+	void TTaskInfoContainer::Store(const ISerializerContainerPtr& spContainer) const
 	{
-		// if marked as added, we don't consider it modified anymore
-		rEntry.ResetModifications();
-	}
-}
+		InitColumns(spContainer);
 
-void TTaskInfoContainer::Store(const ISerializerContainerPtr& spContainer) const
-{
-	InitColumns(spContainer);
+		spContainer->DeleteRows(m_setRemovedTasks);
+		m_setRemovedTasks.Clear();
 
-	spContainer->DeleteRows(m_setRemovedTasks);
-	m_setRemovedTasks.Clear();
+		BOOST_FOREACH(const TTaskInfoEntry& rEntry, m_vTaskInfos)
+		{
+			rEntry.Store(spContainer);
+		}
+	}
 
-	BOOST_FOREACH(const TTaskInfoEntry& rEntry, m_vTaskInfos)
+	void TTaskInfoContainer::Load(const ISerializerContainerPtr& spContainer)
 	{
-		rEntry.Store(spContainer);
-	}
-}
+		InitColumns(spContainer);
 
-void TTaskInfoContainer::Load(const ISerializerContainerPtr& spContainer)
-{
-	InitColumns(spContainer);
+		ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader();
 
-	ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader();
+		TTaskInfoEntry tEntry;
+		while (spRowReader->Next())
+		{
+			tEntry.Load(spRowReader);
 
-	TTaskInfoEntry tEntry;
-	while(spRowReader->Next())
+			m_vTaskInfos.push_back(tEntry);
+			m_oidLastObjectID = std::max(m_oidLastObjectID, tEntry.GetObjectID());
+		}
+	}
+
+	TTaskInfoEntry& TTaskInfoContainer::GetAtOid(object_id_t oidObjectID)
 	{
-		tEntry.Load(spRowReader);
+		for (std::vector<TTaskInfoEntry>::iterator iter = m_vTaskInfos.begin(); iter != m_vTaskInfos.end(); ++iter)
+		{
+			if ((*iter).GetObjectID() == oidObjectID)
+				return *iter;
+		}
 
-		m_vTaskInfos.push_back(tEntry);
-		m_oidLastObjectID = std::max(m_oidLastObjectID, tEntry.GetObjectID());
+		THROW_CORE_EXCEPTION(eErr_InvalidArgument);
 	}
-}
 
-TTaskInfoEntry& TTaskInfoContainer::GetAtOid(object_id_t oidObjectID)
-{
-	for(std::vector<TTaskInfoEntry>::iterator iter = m_vTaskInfos.begin(); iter != m_vTaskInfos.end(); ++iter)
+	void TTaskInfoContainer::InitColumns(const ISerializerContainerPtr& spContainer) const
 	{
-		if((*iter).GetObjectID() == oidObjectID)
-			return *iter;
+		IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition();
+		if (rColumns.IsEmpty())
+			TTaskInfoEntry::InitColumns(rColumns);
 	}
-
-	THROW_CORE_EXCEPTION(eErr_InvalidArgument);
 }
-
-void TTaskInfoContainer::InitColumns(const ISerializerContainerPtr& spContainer) const
-{
-	IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition();
-	if(rColumns.IsEmpty())
-		TTaskInfoEntry::InitColumns(rColumns);
-}
-
-END_CHCORE_NAMESPACE