Subject: [Boost-commit] svn:boost r69401 - in trunk: boost/icl boost/icl/concept libs/icl/test libs/icl/test/fastest_icl_interval_ libs/icl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2011-02-28 16:54:07
Author: jofaber
Date: 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
New Revision: 69401
URL: http://svn.boost.org/trac/boost/changeset/69401
Log:
Added function icl::unit_closure. Enabled functions find, contains and intersects for element-types-arguments on icl containers. Added some tests.
Text files modified:
trunk/boost/icl/concept/interval.hpp | 76 ++++++++++++++++++++++++++++++
trunk/boost/icl/concept/interval_associator.hpp | 52 ++++++++++++++++++++
trunk/boost/icl/concept/interval_map.hpp | 2
trunk/boost/icl/concept/interval_set.hpp | 4
trunk/boost/icl/interval_base_map.hpp | 15 +++--
trunk/boost/icl/interval_base_set.hpp | 12 ++--
trunk/libs/icl/test/Jamfile.v2 | 6 ++
trunk/libs/icl/test/fastest_icl_interval_/fastest_icl_interval.cpp | 25 +++++++--
trunk/libs/icl/test/fastest_interval_map_cases.hpp | 1
trunk/libs/icl/test/test_casual_/test_casual.cpp | 98 ---------------------------------------
trunk/libs/icl/test/test_icl_interval.hpp | 18 +++++++
trunk/libs/icl/test/vc9_icl_fast_tests.sln | 12 ++++
12 files changed, 203 insertions(+), 118 deletions(-)
Modified: trunk/boost/icl/concept/interval.hpp
==============================================================================
--- trunk/boost/icl/concept/interval.hpp (original)
+++ trunk/boost/icl/concept/interval.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -120,6 +120,81 @@
}
//==============================================================================
+//= Construct<Interval> unit_closure == generalized singleton
+// The smallest interval on an incrementable (and decrementable) type that can
+// be constructed using ++ and -- and such that it contains a given value.
+// If 'Type' is discrete, 'unit_closure' and 'singleton' are identical. So we
+// can view 'unit_closure' as a generalized singleton for static intervals of
+// continuous types.
+//==============================================================================
+template<class Type>
+typename enable_if
+<
+ mpl::and_< is_static_right_open<Type>
+ , boost::detail::is_incrementable<typename interval_traits<Type>::domain_type> >
+ , Type
+>::type
+unit_closure(const typename interval_traits<Type>::domain_type& value)
+{
+ return interval_traits<Type>::construct(value, icl::succ(value));
+}
+
+template<class Type>
+typename enable_if
+<
+ mpl::and_< is_static_left_open<Type>
+ , boost::detail::is_incrementable<typename interval_traits<Type>::domain_type> >
+ , Type
+>::type
+unit_closure(const typename interval_traits<Type>::domain_type& value)
+{
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value) ));
+
+ return interval_traits<Type>::construct(icl::pred(value), value);
+}
+
+template<class Type>
+typename enable_if
+<
+ mpl::and_< is_static_open<Type>
+ , is_discrete<typename interval_traits<Type>::domain_type> >
+ , Type
+>::type
+unit_closure(const typename interval_traits<Type>::domain_type& value)
+{
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value)));
+
+ return interval_traits<Type>::construct(icl::pred(value), icl::succ(value));
+}
+
+template<class Type>
+typename enable_if
+<
+ mpl::and_< is_static_closed<Type>
+ , is_discrete<typename interval_traits<Type>::domain_type> >
+ , Type
+>::type
+unit_closure(const typename interval_traits<Type>::domain_type& value)
+{
+ return interval_traits<Type>::construct(value, value);
+}
+
+//NOTE: statically bounded closed or open intervals of continuous domain types
+// are NOT supported by ICL. They can not be used with interval containers
+// consistently.
+
+
+template<class Type>
+typename enable_if<has_dynamic_bounds<Type>, Type>::type
+unit_closure(const typename interval_traits<Type>::domain_type& value)
+{
+ return dynamic_interval_traits<Type>::construct(value, value, interval_bounds::closed());
+}
+
+
+//==============================================================================
//= Construct<Interval> multon
//==============================================================================
template<class Type>
@@ -1341,7 +1416,6 @@
<< right_bracket<Type>(object) ;
}
-
}} // namespace icl boost
#endif
Modified: trunk/boost/icl/concept/interval_associator.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_associator.hpp (original)
+++ trunk/boost/icl/concept/interval_associator.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -202,6 +202,56 @@
return dist;
}
+//==============================================================================
+//= Selection<IntervalSet|IntervalMap>
+//==============================================================================
+template<class Type>
+typename enable_if<mpl::and_< is_interval_container<Type>
+ , is_discrete<typename domain_type_of<Type>::type>
+ >
+ , typename Type::const_iterator>::type
+find(const Type& object, const typename domain_type_of<Type>::type& key_val)
+{
+ typedef typename Type::const_iterator const_iterator;
+ typedef typename Type::interval_type interval_type;
+ return object.find(icl::unit_closure<interval_type>(key_val));
+}
+
+template<class Type>
+typename enable_if<mpl::and_< is_interval_container<Type>
+ , is_continuous<typename domain_type_of<Type>::type>
+ , has_dynamic_bounds<typename interval_type_of<Type>::type>
+ >
+ , typename Type::const_iterator>::type
+find(const Type& object, const typename domain_type_of<Type>::type& key_val)
+{
+ typedef typename Type::const_iterator const_iterator;
+ typedef typename Type::interval_type interval_type;
+ return object.find(icl::singleton<interval_type>(key_val));
+}
+
+template<class Type>
+typename enable_if<mpl::and_< is_interval_container<Type>
+ , is_continuous<typename domain_type_of<Type>::type>
+ , has_static_bounds<typename interval_type_of<Type>::type>
+ , boost::detail::is_incrementable<typename domain_type_of<Type>::type>
+ >
+ , typename Type::const_iterator>::type
+find(const Type& object, const typename domain_type_of<Type>::type& key_val)
+{
+ typedef typename Type::const_iterator const_iterator;
+ typedef typename Type::interval_type interval_type;
+ const_iterator collision = object.find(icl::unit_closure<interval_type>(key_val));
+ // A part of the cover(key_value)-interval may be found in the container, that
+ // does not contain key_value. Therefore we have to check for its existence:
+ return ( collision == object.end()
+ || icl::contains(key_value<Type>(collision), key_val) )
+ ? collision
+ : object.end();
+}
+
+// NOTE: find(object, key) won't compile if key is of continuous type that does
+// not implement in(de)crementation (e.g. std::string).
//==============================================================================
//= Range<IntervalSet|IntervalMap>
@@ -663,7 +713,7 @@
bool>::type
intersects(const Type& left, const CoType& right)
{
- return left.find(right) != left.end();
+ return left.find(right) != left.end();
}
Modified: trunk/boost/icl/concept/interval_map.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_map.hpp (original)
+++ trunk/boost/icl/concept/interval_map.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -47,7 +47,7 @@
contains(const Type& super, const typename Type::element_type& key_value_pair)
{
typedef typename Type::const_iterator const_iterator;
- const_iterator it_ = super.find(key_value_pair.key);
+ const_iterator it_ = icl::find(super, key_value_pair.key);
return it_ != super.end() && it_->second == key_value_pair.data;
}
Modified: trunk/boost/icl/concept/interval_set.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_set.hpp (original)
+++ trunk/boost/icl/concept/interval_set.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -26,7 +26,7 @@
typename enable_if<is_interval_set<Type>, bool>::type
contains(const Type& super, const typename Type::element_type& element)
{
- return !(super.find(element) == super.end());
+ return !(icl::find(super, element) == super.end());
}
template<class Type>
@@ -173,7 +173,7 @@
const typename Type::element_type& operand)
{
typedef typename Type::const_iterator const_iterator;
- const_iterator found = object.find(operand);
+ const_iterator found = icl::find(object, operand);
if(found != object.end())
icl::add(section, operand);
}
Modified: trunk/boost/icl/interval_base_map.hpp
==============================================================================
--- trunk/boost/icl/interval_base_map.hpp (original)
+++ trunk/boost/icl/interval_base_map.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -253,20 +253,23 @@
//==========================================================================
/** Find the interval value pair, that contains \c key */
- const_iterator find(const domain_type& key)const
+ const_iterator find(const domain_type& key_value)const
{
- return _map.find(interval_type(key));
+ return icl::find(*this, key_value);
+ //CL return _map.find(interval_type(key_value));
}
- const_iterator find(const interval_type& key)const
+ /** Find the first interval value pair, that collides with interval
+ \c key_interval */
+ const_iterator find(const interval_type& key_interval)const
{
- return _map.find(key);
+ return _map.find(key_interval);
}
/** Total select function. */
- codomain_type operator()(const domain_type& key)const
+ codomain_type operator()(const domain_type& key_value)const
{
- const_iterator it_ = _map.find(interval_type(key));
+ const_iterator it_ = icl::find(*this, key_value);
return it_==end() ? identity_element<codomain_type>::value()
: it_->second;
}
Modified: trunk/boost/icl/interval_base_set.hpp
==============================================================================
--- trunk/boost/icl/interval_base_set.hpp (original)
+++ trunk/boost/icl/interval_base_set.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -201,15 +201,17 @@
//= Selection
//==========================================================================
- /** Find the interval value pair, that contains element \c key */
- const_iterator find(const element_type& key)const
+ /** Find the interval, that contains element \c key_value */
+ const_iterator find(const element_type& key_value)const
{
- return this->_set.find(icl::singleton<segment_type>(key));
+ return icl::find(*this, key_value);
+ //CL return this->_set.find(icl::singleton<segment_type>(key));
}
- const_iterator find(const segment_type& segment)const
+ /** Find the first interval, that collides with interval \c key_interval */
+ const_iterator find(const interval_type& key_interval)const
{
- return this->_set.find(segment);
+ return this->_set.find(key_interval);
}
//==========================================================================
Modified: trunk/libs/icl/test/Jamfile.v2
==============================================================================
--- trunk/libs/icl/test/Jamfile.v2 (original)
+++ trunk/libs/icl/test/Jamfile.v2 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -33,6 +33,12 @@
# maps
[ run fastest_interval_map_/fastest_interval_map.cpp ]
+ #[ run fast_stat_interval_map_/fast_stat_interval_map.cpp
+ # : : : <define>BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS : interval_map_right_open ]
+ #[ run fast_stat_interval_map_/fast_stat_interval_map.cpp
+ # : : : <define>BOOST_ICL_DISCRETE_STATIC_INTERVAL_DEFAULT=left_open_interval
+ # <define>BOOST_ICL_CONTINUOUS_STATIC_INTERVAL_DEFAULT=left_open_interval
+ # : interval_map_left_open ]
[ run fastest_interval_map_infix_/fastest_interval_map_infix.cpp ]
[ run fastest_split_interval_map_/fastest_split_interval_map.cpp ]
[ run fastest_split_interval_map_infix_/fastest_split_interval_map_infix.cpp ]
Modified: trunk/libs/icl/test/fastest_icl_interval_/fastest_icl_interval.cpp
==============================================================================
--- trunk/libs/icl/test/fastest_icl_interval_/fastest_icl_interval.cpp (original)
+++ trunk/libs/icl/test/fastest_icl_interval_/fastest_icl_interval.cpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -50,27 +50,40 @@
//- sta.asy.{dis|con} ----------------------------------------------------------
BOOST_AUTO_TEST_CASE
(fastest_itl_right_open_interval_ctor_4_ordered_types)
-{ interval_ctor_4_ordered_types<right_open_interval<ordered_type_1> >(); }
+{ interval_ctor_4_ordered_types<right_open_interval<ordered_type_1> >(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_right_open_interval_4_ordered_types)
-{ singelizable_interval_4_ordered_types<right_open_interval<discrete_type_1> >(); }
+{ singelizable_interval_4_ordered_types<right_open_interval<discrete_type_1> >(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_right_open_interval_4_bicremental_types)
-{ singelizable_interval_4_bicremental_types<right_open_interval<discrete_type_2> >(); }
+{ singelizable_interval_4_bicremental_types<right_open_interval<discrete_type_2> >(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_left_open_interval_ctor_4_ordered_types)
-{ interval_ctor_4_ordered_types<left_open_interval<ordered_type_2> >(); }
+{ interval_ctor_4_ordered_types<left_open_interval<ordered_type_2> >(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_left_open_interval_4_ordered_types_singelizable)
-{ singelizable_interval_4_ordered_types<left_open_interval<signed_discrete_type_1> >(); }
+{ singelizable_interval_4_ordered_types<left_open_interval<signed_discrete_type_1> >(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_left_open_interval_4_bicremental_types)
-{ singelizable_interval_4_bicremental_types<left_open_interval<discrete_type_4> >(); }
+{ singelizable_interval_4_bicremental_types<left_open_interval<discrete_type_4> >(); }
+
+//- coverables -----------------------------------------------------------------
+BOOST_AUTO_TEST_CASE
+(fastest_cover_right_open_interval_4_bicremental_types)
+{ coverable_asymmetric_interval_4_bicremental_types<right_open_interval<numeric_continuous_type_1> >(); }
+
+BOOST_AUTO_TEST_CASE
+(fastest_cover_left_open_interval_4_bicremental_types)
+{ coverable_asymmetric_interval_4_bicremental_types<left_open_interval<numeric_continuous_type_3> >(); }
+
+//BOOST_AUTO_TEST_CASE
+//(fastest_cover_closed_interval_4_bicremental_types)
+//{ coverable_closed_interval_4_bicremental_types<closed_interval<numeric_continuous_type_2> >(); }
//- dyn.dis --------------------------------------------------------------------
Modified: trunk/libs/icl/test/fastest_interval_map_cases.hpp
==============================================================================
--- trunk/libs/icl/test/fastest_interval_map_cases.hpp (original)
+++ trunk/libs/icl/test/fastest_interval_map_cases.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -59,6 +59,7 @@
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_flip_4_bicremental_types)
{ interval_map_flip_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, int>();}
+
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_find_4_bicremental_types)
{ interval_map_find_4_bicremental_types<INTERVAL_MAP, bicremental_type_2, int>();}
Modified: trunk/libs/icl/test/test_casual_/test_casual.cpp
==============================================================================
--- trunk/libs/icl/test/test_casual_/test_casual.cpp (original)
+++ trunk/libs/icl/test/test_casual_/test_casual.cpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -35,78 +35,6 @@
using namespace boost::icl;
-
-BOOST_AUTO_TEST_CASE(ticket_5207)
-{
- icl::interval< int >::type int_interval;
- icl::interval_set< int > int_set;
- icl::interval_map< int, int > int_map;
- icl::interval_map< int, int >::element_type int_element;
- icl::interval_map< int, int >::segment_type int_segment;
-
- /// AFAICT none of the following lines compiles and they all should:
- icl::lower( int_interval );
- icl::upper( int_interval );
- icl::first( int_interval );
- icl::last( int_interval );
- //icl::add( int_set, int_set );
- //icl::add( int_map, int_map );
- //icl::subtract( int_set, int_set );
- //icl::subtract( int_map, int_map );
- int_set += int_interval;
- icl::disjoint( int_map, int_element );
- icl::disjoint( int_map, int_segment );
- icl::intersects( int_map, int_segment );
- icl::intersects( int_map, int_element );
-}
-
-BOOST_AUTO_TEST_CASE(generalized_find)
-{
- typedef icl::interval_set<int>::const_iterator int_set_iterator;
- icl::interval_set<int> int_set;
-
- icl::interval<int>::type to_be_found(1,5);
- int_set += icl::interval<int>::type(0,2);
- int_set += icl::interval<int>::type(4,7);
- int_set += icl::interval<int>::type(8,9);
-
- int_set_iterator found;
- found = int_set.lower_bound(to_be_found);
- cout << *found << endl; // [0,2)
- found = int_set.find(to_be_found);
- cout << *found << endl; // [0,2)
- found = int_set.upper_bound(to_be_found);
- cout << *found << endl; // [8,9)
- std::pair<int_set_iterator,int_set_iterator> exterior;
- exterior = int_set.equal_range(to_be_found);
- cout << "[" << *exterior.first
- << "," << *exterior.second << ")" << endl;
- // [[0,2),[8,9))
-}
-
-BOOST_AUTO_TEST_CASE(using_vaious_interval_types)
-{
- interval_set<int, std::less, discrete_interval<int,std::less> > dyn_int_set;
- interval_set<int, std::less, right_open_interval<int,std::less> > stat_int_set;
- interval_set<float, std::less, continuous_interval<float,std::less> > dyn_float_set;
-
- dyn_int_set += discrete_interval<int>(1);
- BOOST_CHECK(( contains(dyn_int_set,1) ));
-
- stat_int_set += right_open_interval<int>(1);
- BOOST_CHECK(( contains(stat_int_set,1) ));
-
- dyn_float_set += continuous_interval<float>(1.0);
- BOOST_CHECK(( contains(dyn_float_set, 1.0) ));
-}
-
- template <class IncrementableT>
- inline static IncrementableT succ_(IncrementableT x) { return ++x; }
-
- template <class DecrementableT>
- inline static DecrementableT pred_(DecrementableT x) { return --x; }
-
-
BOOST_AUTO_TEST_CASE(casual)
{
//typedef int T;
@@ -115,6 +43,7 @@
//typedef interval_set<T> IntervalSetT;
//typedef IntervalMapT::interval_type IntervalT;
+ /*
int i;
int j = int();
chrono::duration<int> cd1 = chrono::duration<int>();
@@ -131,30 +60,7 @@
cout << (cd1==cd2 ? "eq" : "!eq") << endl;
cout << "chrono::duration cd1() = " << cd1 << endl;
cout << "chrono::duration cd2(0) = " << cd2 << endl;
-
- (dur2++)--;
- (dur3--)++;
- dur4++;
- dur4--;
- cout << dur1 << ", " << dur2 << ", " << dur3 << ", " << dur4 << endl;
- //---------
- dur2 = dur3 = dur4 = dur1;
- cout << icl::pred(icl::succ(dur2)) << endl;
- //---------
- //(itg2++)--;
- //(itg3--)++;
- //itg4++;
- //itg4--;
- //cout << itg1 << ", " << itg2 << ", " << itg3 << ", " << itg4 << endl;
-
-
- dur2 = dur3 = dur4 = dur1;
- --(++dur2);
- ++(--dur3);
- --dur4;
- ++dur4;
- cout << dur1 << ", " << dur2 << ", " << dur3 << ", " << dur4 << endl;
-
+ */
BOOST_CHECK_EQUAL(true, true);
}
Modified: trunk/libs/icl/test/test_icl_interval.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_interval.hpp (original)
+++ trunk/libs/icl/test/test_icl_interval.hpp 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -84,6 +84,24 @@
BOOST_CHECK_EQUAL( icl::contains(IntervalT(MK_v(1)), MK_v(1)), true );
}
+template <class IntervalT>
+void coverable_asymmetric_interval_4_bicremental_types()
+{
+ typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
+ typedef typename icl::size_type_of<T>::type SizeT;
+ typedef typename icl::difference_type_of<T>::type DiffT;
+ //T t_0 = icl::identity_element<T>::value();
+ SizeT s_1 = icl::unit_element<SizeT>::value();
+ DiffT d_1 = icl::unit_element<DiffT>::value();
+
+ //JODO BOOST_CHECK( is_incremental_coverable<IntervalT>::value );
+ BOOST_CHECK( has_difference<T>::value );
+
+ BOOST_CHECK_EQUAL( icl::contains(icl::unit_closure<IntervalT>(MK_v(4)), MK_v(4)), true );
+ BOOST_CHECK_EQUAL( icl::length (icl::unit_closure<IntervalT>(MK_v(3))), d_1 );
+ BOOST_CHECK ( icl::touches (icl::unit_closure<IntervalT>(MK_v(2)), icl::unit_closure<IntervalT>(MK_v(3))) );
+}
+
#endif // BOOST_ICL_TEST_ICL_INTERVAL_HPP_JOFA_100930
Modified: trunk/libs/icl/test/vc9_icl_fast_tests.sln
==============================================================================
--- trunk/libs/icl/test/vc9_icl_fast_tests.sln (original)
+++ trunk/libs/icl/test/vc9_icl_fast_tests.sln 2011-02-28 16:54:04 EST (Mon, 28 Feb 2011)
@@ -63,6 +63,10 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_cmp_clang_ttp_passing2", "cmp_clang_ttp_passing2_\vc9_cmp_clang_ttp_passing2.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8D7A9FA3}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_use_case", "use_case_\vc9_use_case.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8DAA9FA0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fast_stat_interval_map", "fast_stat_interval_map_\vc9_fast_stat_interval_map.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B7D3A900D}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -193,6 +197,14 @@
{EE61B7EF-EC45-4165-8B49-FD5B8D7A9FA3}.Debug|Win32.Build.0 = Debug|Win32
{EE61B7EF-EC45-4165-8B49-FD5B8D7A9FA3}.Release|Win32.ActiveCfg = Release|Win32
{EE61B7EF-EC45-4165-8B49-FD5B8D7A9FA3}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8DAA9FA0}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8DAA9FA0}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8DAA9FA0}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8DAA9FA0}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D3A900D}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D3A900D}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D3A900D}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D3A900D}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE