changed: GroupItem plugin has been renamed to Group

it's nearly finished
         now we are using three levels from Space (ConfParser)
         - group set
         - group
         - values
         


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@773 e52654a7-88a9-db11-a3e9-0013d4bc506e

plugins/group/groups.cpp

@@ -0,0 +1,216 @@
+/*
+ * This file is a part of Winix
+ * and is not publicly distributed
+ * 
+ * Copyright (c) 2011, Tomasz Sowa
+ * All rights reserved.
+ * 
+ */
+
+#include <limits>
+#include "groups.h"
+#include "core/log.h"
+
+
+namespace GroupItem
+{
+
+
+
+Space * Groups::GetSpace()
+{
+	return &space;
+}
+
+
+
+void Groups::Reindex()
+{
+	set_index.clear();
+	group_index_tab.clear();
+	size_t seti = 0;
+
+	while( seti < space.spaces.size() )
+	{
+		const std::wstring & name = space.spaces[seti]->name;
+
+		if( set_index.find(name) == set_index.end() )
+		{
+			set_index[name] = seti;
+			group_index_tab.push_back(GroupIndex());
+			ReindexGroups(group_index_tab.back(), *space.spaces[seti]);
+			seti += 1;
+		}
+		else
+		{
+			slog << logerror << "set: " << name << " already defined (skipping)" << logend;
+			space.spaces.erase(space.spaces.begin() + seti);
+		}
+	}
+}
+
+
+void Groups::ReindexGroups(GroupIndex & group_index, Space & set)
+{
+size_t i, v;
+
+	// loop through all groups in the set
+	for( i=0 ; i < set.spaces.size() ; ++i )
+	{
+		Space & group = *set.spaces[i];
+		const std::wstring & key = group.Text(L"key", L"value");
+
+		// loop through all values in the group
+		for(v=0 ; v<group.spaces.size() ; )
+		{
+			Space::Table::iterator vali = group.spaces[v]->table.find(key);
+
+			if( vali != group.spaces[v]->table.end() && vali->second.size() == 1 )
+			{
+				GroupIndex::iterator g = group_index.find(vali->second[0]);
+
+				if( g == group_index.end() )
+				{
+					group_index[vali->second[0]] = i;
+					v += 1;
+				}
+				else
+				{
+					slog << logwarning << "set: " << set.name << " has a group with a duplicated value: "
+						 << vali->second[0] << " (skipping)" << logend;
+					group.spaces.erase(group.spaces.begin() + v);
+				}
+			}
+			else
+			{
+				slog << logwarning << "set: " << set.name << " has a group without a value (skipping)" << logend;
+				group.spaces.erase(group.spaces.begin() + v);
+			}
+		}
+
+		SortValues(group);
+	}
+}
+
+
+void Groups::SortValues(Space & group)
+{
+	sort_by  = group.Text(L"sort_by");
+	sort_asc = (group.Text(L"sort_asc", L"true") == L"true");
+
+	if( !sort_by.empty() )
+	{
+		group.ListText(L"sort", sort_value);
+		std::sort(group.spaces.begin(), group.spaces.end(), SortFunHelper(this));
+	}
+}
+
+
+bool Groups::SortFunHelper::operator()(Space * sp1, Space * sp2)
+{
+	const std::wstring & val1 = sp1->Text(groups->sort_by, L"");
+	const std::wstring & val2 = sp2->Text(groups->sort_by, L"");
+
+	if( groups->sort_asc )
+		return SortValue(val1) < SortValue(val2);
+	else
+		return SortValue(val1) > SortValue(val2);
+}
+
+
+size_t Groups::SortFunHelper::SortValue(const std::wstring & val)
+{
+	for(size_t i=0 ; i<groups->sort_value.size() ; ++i)
+		if( val == groups->sort_value[i] )
+			return i;
+
+return std::numeric_limits<size_t>::max();
+}
+
+
+
+bool Groups::Find(const std::wstring & set, const std::wstring & value, size_t & seti, size_t & groupi)
+{
+	SetIndex::iterator i = set_index.find(set);
+
+	if( i != set_index.end() )
+	{
+		if( i->second < group_index_tab.size() )
+		{
+			GroupIndex::iterator viter = group_index_tab[i->second].find(value);
+
+			if( viter != group_index_tab[i->second].end() )
+			{
+				seti   = i->second;
+				groupi = viter->second;
+				return true;
+			}
+		}
+	}
+
+return false;
+}
+
+
+
+const std::wstring & Groups::GetOption(size_t seti, size_t groupi, size_t valuei, const wchar_t * option)
+{
+	if( seti < space.spaces.size() )
+	{
+		Space & groups = *space.spaces[seti];
+
+		if( groupi < groups.spaces.size() )
+		{
+			Space & value = *groups.spaces[groupi];
+
+			if( valuei < value.spaces.size() )
+				return value.spaces[valuei]->Text(option);
+
+		}
+	}
+
+return empty_str;
+}
+
+
+const std::wstring & Groups::GetOption(size_t seti, size_t groupi, size_t valuei, const std::wstring & option)
+{
+	return GetOption(seti, groupi, valuei, option.c_str());
+}
+
+
+size_t Groups::Size(size_t seti, size_t groupi)
+{
+	if( seti < space.spaces.size() )
+	{
+		Space & groups = *space.spaces[seti];
+
+		if( groupi < groups.spaces.size() )
+			return groups.spaces[groupi]->spaces.size();
+	}
+
+return 0;
+}
+
+
+
+
+
+
+
+void Groups::Clear()
+{
+	space.Clear();
+	set_index.clear();
+	group_index_tab.clear();
+}
+
+
+
+
+
+
+
+}
+
+