Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r70757 - in trunk: boost/icl boost/icl/concept boost/icl/detail boost/icl/type_traits libs/icl/test libs/icl/test/chrono libs/icl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2011-03-30 16:20:25


Author: jofaber
Date: 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
New Revision: 70757
URL: http://svn.boost.org/trac/boost/changeset/70757

Log:
Improved mutual agnostic interoperability between boost::chrono and boost::icl. Second try, improved for gcc.
Added:
   trunk/boost/icl/type_traits/rep_type_of.hpp (contents, props changed)
   trunk/libs/icl/test/chrono/
   trunk/libs/icl/test/chrono/utility.hpp (contents, props changed)
Text files modified:
   trunk/boost/icl/concept/element_map.hpp | 6
   trunk/boost/icl/concept/interval.hpp | 4
   trunk/boost/icl/concept/interval_associator.hpp | 2
   trunk/boost/icl/concept/interval_map.hpp | 14 +-
   trunk/boost/icl/concept/joinable.hpp | 4
   trunk/boost/icl/concept/map_value.hpp | 4
   trunk/boost/icl/detail/interval_map_algo.hpp | 2
   trunk/boost/icl/detail/map_algo.hpp | 2
   trunk/boost/icl/interval_base_map.hpp | 98 ++++++++--------
   trunk/boost/icl/interval_map.hpp | 10
   trunk/boost/icl/map.hpp | 18 +-
   trunk/boost/icl/split_interval_map.hpp | 10
   trunk/boost/icl/type_traits/difference_type_of.hpp | 52 +++++++-
   trunk/boost/icl/type_traits/infinity.hpp | 186 +++++++++++++++++++++++++-----
   trunk/boost/icl/type_traits/is_container.hpp | 2
   trunk/boost/icl/type_traits/is_discrete.hpp | 25 +++
   trunk/boost/icl/type_traits/is_numeric.hpp | 30 ++++
   trunk/boost/icl/type_traits/size_type_of.hpp | 55 +++++++++
   trunk/libs/icl/test/Jamfile.v2 | 77 ++++++++++++
   trunk/libs/icl/test/fast_stat_interval_map_cases.hpp | 20 +-
   trunk/libs/icl/test/test_casual_/test_casual.cpp | 7 +
   trunk/libs/icl/test/test_type_lists.hpp | 238 +++++++++++++++++++++++++++------------
   22 files changed, 649 insertions(+), 217 deletions(-)

Modified: trunk/boost/icl/concept/element_map.hpp
==============================================================================
--- trunk/boost/icl/concept/element_map.hpp (original)
+++ trunk/boost/icl/concept/element_map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -42,7 +42,7 @@
 {
     typedef typename Type::const_iterator const_iterator;
     const_iterator found_ = super.find(value_pair.first);
- return found_ != super.end() && found_->second == value_pair.second;
+ return found_ != super.end() && (*found_).second == value_pair.second;
 }
 
 //------------------------------------------------------------------------------
@@ -109,7 +109,7 @@
         return identity_element<size_type>::value();
 
     iterator it_ = object.find(value_pair.first);
- if(it_ != object.end() && value_pair.second == it_->second)
+ if(it_ != object.end() && value_pair.second == (*it_).second)
     {
         object.erase(it_);
         return unit_element<size_type>::value();
@@ -394,7 +394,7 @@
         icl::flip(object, *it_);
 
     ICL_FORALL(typename Type, it2_, object)
- it2_->second = identity_element<typename Type::codomain_type>::value();
+ (*it2_).second = identity_element<typename Type::codomain_type>::value();
 
     return object;
 }

Modified: trunk/boost/icl/concept/interval.hpp
==============================================================================
--- trunk/boost/icl/concept/interval.hpp (original)
+++ trunk/boost/icl/concept/interval.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -923,7 +923,7 @@
             && domain_equal<Type>(lower(object), upper(object)))
         return icl::unit_element<SizeT>::value();
     else
- return infinity<SizeT>::value();
+ return icl::infinity<SizeT>::value();
 }
 
 template<class Type>
@@ -945,7 +945,7 @@
     if(icl::is_empty(object))
         return icl::identity_element<SizeT>::value();
     else
- return infinity<SizeT>::value();
+ return icl::infinity<SizeT>::value();
 }
 
 template<class Type>

Modified: trunk/boost/icl/concept/interval_associator.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_associator.hpp (original)
+++ trunk/boost/icl/concept/interval_associator.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -146,7 +146,7 @@
     ICL_const_FORALL(typename Type, it, object)
     {
         interval_size = icl::cardinality(key_value<Type>(it));
- if(interval_size == infinity<size_type>::value())
+ if(interval_size == icl::infinity<size_type>::value())
             return interval_size;
         else
             size += interval_size;

Modified: trunk/boost/icl/concept/interval_map.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_map.hpp (original)
+++ trunk/boost/icl/concept/interval_map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -44,7 +44,7 @@
 {
     typedef typename Type::const_iterator const_iterator;
     const_iterator it_ = icl::find(super, key_value_pair.key);
- return it_ != super.end() && it_->second == key_value_pair.data;
+ return it_ != super.end() && (*it_).second == key_value_pair.data;
 }
 
 template<class Type>
@@ -374,7 +374,7 @@
 
     const_iterator it_ = icl::find(object, key_value);
     if(it_ != object.end())
- add(section, segment_type(interval_type(key_value),it_->second));
+ add(section, segment_type(interval_type(key_value),(*it_).second));
 }
 
 template<class Type>
@@ -398,10 +398,10 @@
     iterator prior_ = section.end();
     for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
     {
- interval_type common_interval = it_->first & inter_val;
+ interval_type common_interval = (*it_).first & inter_val;
         if(!icl::is_empty(common_interval))
             prior_ = add(section, prior_,
- value_type(common_interval, it_->second) );
+ value_type(common_interval, (*it_).second) );
     }
 }
 
@@ -514,7 +514,7 @@
 
     object += operand;
     ICL_FORALL(typename Type, it_, object)
- it_->second = identity_element<codomain_type>::value();
+ (*it_).second = identity_element<codomain_type>::value();
 
     if(mpl::not_<is_interval_splitter<Type> >::value)
         icl::join(object);
@@ -572,7 +572,7 @@
     result.clear();
     set_iterator prior_ = result.end();
     ICL_const_FORALL(typename Type, it_, object)
- prior_ = icl::insert(result, prior_, it_->first);
+ prior_ = icl::insert(result, prior_, (*it_).first);
     
     return result;
 }
@@ -664,7 +664,7 @@
 {
     stream << "{";
     ICL_const_FORALL(typename Type, it_, object)
- stream << "(" << it_->first << "->" << it_->second << ")";
+ stream << "(" << (*it_).first << "->" << (*it_).second << ")";
 
     return stream << "}";
 }

Modified: trunk/boost/icl/concept/joinable.hpp
==============================================================================
--- trunk/boost/icl/concept/joinable.hpp (original)
+++ trunk/boost/icl/concept/joinable.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -27,8 +27,8 @@
     typename enable_if<is_interval_map<Type>, bool>::type
     is_joinable(typename Type::iterator it_, typename Type::iterator next_, Type* = 0)
     {
- return touches(it_->first, next_->first)
- && it_->second == next_->second ;
+ return touches((*it_).first, (*next_).first)
+ && (*it_).second == (*next_).second ;
     }
 }
 

Modified: trunk/boost/icl/concept/map_value.hpp
==============================================================================
--- trunk/boost/icl/concept/map_value.hpp (original)
+++ trunk/boost/icl/concept/map_value.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -22,14 +22,14 @@
 inline typename enable_if<is_map<Type>, const typename Type::key_type>::type&
 key_value(Iterator it_)
 {
- return it_->first;
+ return (*it_).first;
 }
 
 template<class Type, class Iterator>
 inline typename enable_if<is_map<Type>, const typename Type::codomain_type>::type&
 co_value(Iterator it_)
 {
- return it_->second;
+ return (*it_).second;
 }
 
 template<class Type>

Modified: trunk/boost/icl/detail/interval_map_algo.hpp
==============================================================================
--- trunk/boost/icl/detail/interval_map_algo.hpp (original)
+++ trunk/boost/icl/detail/interval_map_algo.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -130,7 +130,7 @@
               const typename IntervalMapT::element_type& key_value_pair)
 {
     typename IntervalMapT::const_iterator it_ = container.find(key_value_pair.key);
- return it_ != container.end() && it_->second == key_value_pair.data;
+ return it_ != container.end() && (*it_).second == key_value_pair.data;
 }
 
 template<class IntervalMapT>

Modified: trunk/boost/icl/detail/map_algo.hpp
==============================================================================
--- trunk/boost/icl/detail/map_algo.hpp (original)
+++ trunk/boost/icl/detail/map_algo.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -45,7 +45,7 @@
 typename MapT::const_iterator next_proton(typename MapT::const_iterator& iter_, const MapT& object)
 {
     while( iter_ != object.end()
- && iter_->second == identity_element<typename MapT::codomain_type>::value())
+ && (*iter_).second == identity_element<typename MapT::codomain_type>::value())
         ++iter_;
 
     return iter_;

Modified: trunk/boost/icl/interval_base_map.hpp
==============================================================================
--- trunk/boost/icl/interval_base_map.hpp (original)
+++ trunk/boost/icl/interval_base_map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -270,7 +270,7 @@
     {
         const_iterator it_ = icl::find(*this, key_value);
         return it_==end() ? identity_element<codomain_type>::value()
- : it_->second;
+ : (*it_).second;
     }
 
     //==========================================================================
@@ -499,10 +499,10 @@
 
         for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
         {
- interval_type common_interval = it_->first & inter_val;
+ interval_type common_interval = (*it_).first & inter_val;
             if(!icl::is_empty(common_interval))
             {
- section.template _add<codomain_combine> (value_type(common_interval, it_->second) );
+ section.template _add<codomain_combine> (value_type(common_interval, (*it_).second) );
                 section.template _add<codomain_intersect>(value_type(common_interval, operand.second));
             }
         }
@@ -537,9 +537,9 @@
         iterator inserted_
             = this->_map.insert(prior_, value_type(inter_val, Combiner::identity_element()));
 
- if(inserted_->first == inter_val && inserted_->second == Combiner::identity_element())
+ if((*inserted_).first == inter_val && (*inserted_).second == Combiner::identity_element())
         {
- Combiner()(inserted_->second, co_val);
+ Combiner()((*inserted_).second, co_val);
             return std::pair<iterator,bool>(inserted_, true);
         }
         else
@@ -555,7 +555,7 @@
 
         if(inserted_ == prior_)
             return std::pair<iterator,bool>(inserted_, false);
- else if(inserted_->first == inter_val)
+ else if((*inserted_).first == inter_val)
             return std::pair<iterator,bool>(inserted_, true);
         else
             return std::pair<iterator,bool>(inserted_, false);
@@ -694,7 +694,7 @@
         {
             object += operand;
             ICL_FORALL(typename Type, it_, object)
- it_->second = identity_element<codomain_type>::value();
+ (*it_).second = identity_element<codomain_type>::value();
 
             if(mpl::not_<is_interval_splitter<Type> >::value)
                 icl::join(object);
@@ -737,7 +737,7 @@
 
             while(it_ != end_ )
             {
- const codomain_type& co_value = it_->second;
+ const codomain_type& co_value = (*it_).second;
                 covered = (*it_++).first;
                 //[a ... : span
                 // [b ... : covered
@@ -788,16 +788,16 @@
     // The addend interval 'inter_val' covers the beginning of the collision sequence.
 
     // only for the first there can be a left_resid: a part of *first_ left of inter_val
- interval_type left_resid = right_subtract(first_->first, inter_val);
+ interval_type left_resid = right_subtract((*first_).first, inter_val);
 
     if(!icl::is_empty(left_resid))
     { // [------------ . . .
         // [left_resid---first_ --- . . .
         iterator prior_ = cyclic_prior(*this, first_);
- const_cast<interval_type&>(first_->first)
- = left_subtract(first_->first, left_resid);
+ const_cast<interval_type&>((*first_).first)
+ = left_subtract((*first_).first, left_resid);
         //NOTE: Only splitting
- this->_map.insert(prior_, segment_type(left_resid, first_->second));
+ this->_map.insert(prior_, segment_type(left_resid, (*first_).second));
     }
     //POST:
     // [----- inter_val ---- . . .
@@ -809,7 +809,7 @@
 inline void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type lead_gap = right_subtract(inter_val, it_->first);
+ interval_type lead_gap = right_subtract(inter_val, (*it_).first);
     if(!icl::is_empty(lead_gap))
     {
         // [lead_gap--- . . .
@@ -821,7 +821,7 @@
 
     // . . . --------- . . . addend interval
     // [-- it_ --) has a common part with the first overval
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
     that()->template handle_left_combined<Combiner>(it_++);
 }
 
@@ -835,7 +835,7 @@
     interval_type cur_interval;
     while(it_!=last_)
     {
- cur_interval = it_->first ;
+ cur_interval = (*it_).first ;
         add_segment<Combiner>(inter_val, co_val, it_);
         // shrink interval
         inter_val = left_subtract(inter_val, cur_interval);
@@ -848,7 +848,7 @@
     ::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
     iterator prior_ = cyclic_prior(*that(), it_);
- interval_type cur_itv = it_->first ;
+ interval_type cur_itv = (*it_).first ;
 
     interval_type lead_gap = right_subtract(inter_val, cur_itv);
     if(!icl::is_empty(lead_gap))
@@ -863,7 +863,7 @@
     {
         // [----------------end_gap)
         // . . . -- it_ --)
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
         that()->template gap_insert_at<Combiner>(it_, prior_, end_gap, co_val);
     }
     else
@@ -875,22 +875,22 @@
         {
             // [---------------)
             // [-- it_ ---)
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
             that()->template handle_preceeded_combined<Combiner>(prior_, it_);
         }
         else
         {
             // [--------------)
             // [-- it_ --right_resid)
- const_cast<interval_type&>(it_->first) = right_subtract(it_->first, right_resid);
+ const_cast<interval_type&>((*it_).first) = right_subtract((*it_).first, right_resid);
 
             //NOTE: This is NOT an insertion that has to take care for correct application of
             // the Combiner functor. It only reestablished that state after splitting the
             // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
- iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
+ iterator insertion_ = this->_map.insert(it_, value_type(right_resid, (*it_).second));
             that()->handle_reinserted(insertion_);
 
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
             that()->template handle_preceeded_combined<Combiner>(insertion_, it_);
         }
     }
@@ -983,13 +983,13 @@
 inline void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_front(const interval_type& inter_val, iterator& it_)
 {
- interval_type left_resid = right_subtract(it_->first, inter_val);
+ interval_type left_resid = right_subtract((*it_).first, inter_val);
 
     if(!icl::is_empty(left_resid)) // [--- inter_val ---)
     { //[prior_) [left_resid)[--- it_ . . .
         iterator prior_ = cyclic_prior(*this, it_);
- const_cast<interval_type&>(it_->first) = left_subtract(it_->first, left_resid);
- this->_map.insert(prior_, value_type(left_resid, it_->second));
+ const_cast<interval_type&>((*it_).first) = left_subtract((*it_).first, left_resid);
+ this->_map.insert(prior_, value_type(left_resid, (*it_).second));
         // The segemnt *it_ is split at inter_val.first(), so as an invariant
         // segment *it_ is always "under" inter_val and a left_resid is empty.
     }
@@ -1003,7 +1003,7 @@
 {
     while(it_ != last_)
     {
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
         that()->template handle_left_combined<Combiner>(it_++);
     }
 }
@@ -1013,18 +1013,18 @@
 inline void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_rear(interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type right_resid = left_subtract(it_->first, inter_val);
+ interval_type right_resid = left_subtract((*it_).first, inter_val);
 
     if(icl::is_empty(right_resid))
     {
- Combiner()(it_->second, co_val);
+ Combiner()((*it_).second, co_val);
         that()->template handle_combined<Combiner>(it_);
     }
     else
     {
- const_cast<interval_type&>(it_->first) = right_subtract(it_->first, right_resid);
- iterator next_ = this->_map.insert(it_, value_type(right_resid, it_->second));
- Combiner()(it_->second, co_val);
+ const_cast<interval_type&>((*it_).first) = right_subtract((*it_).first, right_resid);
+ iterator next_ = this->_map.insert(it_, value_type(right_resid, (*it_).second));
+ Combiner()((*it_).second, co_val);
         that()->template handle_succeeded_combined<Combiner>(it_, next_);
     }
 }
@@ -1073,7 +1073,7 @@
 
     while(it_ != end_ )
     {
- cur_itv = it_->first ;
+ cur_itv = (*it_).first ;
         left_gap = right_subtract(rest_interval, cur_itv);
 
         if(!icl::is_empty(left_gap))
@@ -1165,20 +1165,20 @@
     ::erase_rest(interval_type& inter_val, const CodomainT& co_val,
                  iterator& it_, const iterator& last_)
 {
- // For all intervals within loop: it_->first are contained_in inter_val
+ // For all intervals within loop: (*it_).first are contained_in inter_val
     while(it_ != last_)
- if(it_->second == co_val)
+ if((*it_).second == co_val)
             this->_map.erase(it_++);
         else it_++;
 
     //erase_rear:
- if(it_->second == co_val)
+ if((*it_).second == co_val)
     {
- interval_type right_resid = left_subtract(it_->first, inter_val);
+ interval_type right_resid = left_subtract((*it_).first, inter_val);
         if(icl::is_empty(right_resid))
             this->_map.erase(it_);
         else
- const_cast<interval_type&>(it_->first) = right_resid;
+ const_cast<interval_type&>((*it_).first) = right_resid;
     }
 }
 
@@ -1206,19 +1206,19 @@
     { // [----inter_val----)
         // .....first_==last_.....
         // only for the last there can be a right_resid: a part of *it_ right of minuend
- interval_type right_resid = left_subtract(first_->first, inter_val);
+ interval_type right_resid = left_subtract((*first_).first, inter_val);
 
- if(first_->second == co_val)
+ if((*first_).second == co_val)
         {
- interval_type left_resid = right_subtract(first_->first, inter_val);
+ interval_type left_resid = right_subtract((*first_).first, inter_val);
             if(!icl::is_empty(left_resid)) // [----inter_val----)
             { // [left_resid)..first_==last_......
- const_cast<interval_type&>(first_->first) = left_resid;
+ const_cast<interval_type&>((*first_).first) = left_resid;
                 if(!icl::is_empty(right_resid))
                     this->_map.insert(first_, value_type(right_resid, co_val));
             }
             else if(!icl::is_empty(right_resid))
- const_cast<interval_type&>(first_->first) = right_resid;
+ const_cast<interval_type&>((*first_).first) = right_resid;
             else
                 this->_map.erase(first_);
         }
@@ -1226,13 +1226,13 @@
     else
     {
         // first AND NOT last
- if(first_->second == co_val)
+ if((*first_).second == co_val)
         {
- interval_type left_resid = right_subtract(first_->first, inter_val);
+ interval_type left_resid = right_subtract((*first_).first, inter_val);
             if(icl::is_empty(left_resid))
                 this->_map.erase(first_);
             else
- const_cast<interval_type&>(first_->first) = left_resid;
+ const_cast<interval_type&>((*first_).first) = left_resid;
         }
 
         erase_rest(inter_val, co_val, second_, last_);
@@ -1259,18 +1259,18 @@
              end_ = exterior.second,
              last_ = prior(end_);
 
- interval_type left_resid = right_subtract(first_->first, minuend);
+ interval_type left_resid = right_subtract((*first_).first, minuend);
     interval_type right_resid = left_subtract(last_ ->first, minuend);
 
     if(first_ == last_ )
         if(!icl::is_empty(left_resid))
         {
- const_cast<interval_type&>(first_->first) = left_resid;
+ const_cast<interval_type&>((*first_).first) = left_resid;
             if(!icl::is_empty(right_resid))
- this->_map.insert(first_, value_type(right_resid, first_->second));
+ this->_map.insert(first_, value_type(right_resid, (*first_).second));
         }
         else if(!icl::is_empty(right_resid))
- const_cast<interval_type&>(first_->first) = left_subtract(first_->first, minuend);
+ const_cast<interval_type&>((*first_).first) = left_subtract((*first_).first, minuend);
         else
             this->_map.erase(first_);
     else
@@ -1283,7 +1283,7 @@
         this->_map.erase(start_, stop_); //erase [start_, stop_)
 
         if(!icl::is_empty(left_resid))
- const_cast<interval_type&>(first_->first) = left_resid;
+ const_cast<interval_type&>((*first_).first) = left_resid;
 
         if(!icl::is_empty(right_resid))
             const_cast<interval_type&>(last_ ->first) = right_resid;

Modified: trunk/boost/icl/interval_map.hpp
==============================================================================
--- trunk/boost/icl/interval_map.hpp (original)
+++ trunk/boost/icl/interval_map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -132,7 +132,7 @@
     template<class Combiner>
     void handle_left_combined(iterator it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
             this->_map.erase(it_);
         else
             segmental::join_left(*this, it_);
@@ -141,7 +141,7 @@
     template<class Combiner>
     void handle_combined(iterator it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
             this->_map.erase(it_);
         else
             segmental::join_neighbours(*this, it_);
@@ -150,7 +150,7 @@
     template<class Combiner>
     void handle_preceeded_combined(iterator prior_, iterator& it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
         {
             this->_map.erase(it_);
             it_ = prior_;
@@ -162,7 +162,7 @@
     template<class Combiner>
     void handle_succeeded_combined(iterator it_, iterator next_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
         {
             this->_map.erase(it_);
             segmental::join_right(*this, next_);
@@ -186,7 +186,7 @@
     void gap_insert_at(iterator& it_, iterator prior_,
                        const interval_type& end_gap, const codomain_type& co_val)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
         {
             this->_map.erase(it_);
             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);

Modified: trunk/boost/icl/map.hpp
==============================================================================
--- trunk/boost/icl/map.hpp (original)
+++ trunk/boost/icl/map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -431,7 +431,7 @@
     { // !codomain_is_set, !absorbs_identities
         static void subtract(Type&, typename Type::iterator it_,
                               const typename Type::codomain_type& )
- { it_->second = identity_element<typename Type::codomain_type>::value(); }
+ { (*it_).second = identity_element<typename Type::codomain_type>::value(); }
     };
 
     template<class Type>
@@ -449,7 +449,7 @@
         static void subtract(Type&, typename Type::iterator it_,
                               const typename Type::codomain_type& co_value)
         {
- inverse_codomain_intersect()(it_->second, co_value);
+ inverse_codomain_intersect()((*it_).second, co_value);
         }
     };
 
@@ -460,8 +460,8 @@
         static void subtract(Type& object, typename Type::iterator it_,
                                      const typename Type::codomain_type& co_value)
         {
- inverse_codomain_intersect()(it_->second, co_value);
- if(it_->second == identity_element<codomain_type>::value())
+ inverse_codomain_intersect()((*it_).second, co_value);
+ if((*it_).second == identity_element<codomain_type>::value())
                 object.erase(it_);
         }
     };
@@ -489,7 +489,7 @@
         {
             object.add(operand);
             ICL_FORALL(typename Type, it_, object)
- it_->second = identity_element<codomain_type>::value();
+ (*it_).second = identity_element<codomain_type>::value();
         }
     };
 
@@ -583,9 +583,9 @@
     iterator inserted_
         = base_type::insert(prior_,
                             value_type(addend.first, Combiner::identity_element()));
- Combiner()(inserted_->second, addend.second);
+ Combiner()((*inserted_).second, addend.second);
 
- if(on_absorbtion_::is_absorbable(inserted_->second))
+ if(on_absorbtion_::is_absorbable((*inserted_).second))
     {
         erase(inserted_);
         return end();
@@ -609,8 +609,8 @@
     iterator it_ = find(minuend.first);
     if(it_ != end())
     {
- Combiner()(it_->second, minuend.second);
- if(on_absorbtion_::is_absorbable(it_->second))
+ Combiner()((*it_).second, minuend.second);
+ if(on_absorbtion_::is_absorbable((*it_).second))
             erase(it_);
     }
     return *this;

Modified: trunk/boost/icl/split_interval_map.hpp
==============================================================================
--- trunk/boost/icl/split_interval_map.hpp (original)
+++ trunk/boost/icl/split_interval_map.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -105,21 +105,21 @@
     template<class Combiner>
     void handle_left_combined(iterator it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
             this->_map.erase(it_);
     }
 
     template<class Combiner>
     void handle_combined(iterator it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
             this->_map.erase(it_);
     }
 
     template<class Combiner>
     void handle_preceeded_combined(iterator prior_, iterator& it_)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
         {
             this->_map.erase(it_);
             it_ = prior_;
@@ -129,7 +129,7 @@
     template<class Combiner>
     void handle_succeeded_combined(iterator it_, iterator)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
             this->_map.erase(it_);
     }
 
@@ -139,7 +139,7 @@
     void gap_insert_at(iterator& it_, iterator prior_,
                        const interval_type& end_gap, const codomain_type& co_val)
     {
- if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
         {
             this->_map.erase(it_);
             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);

Modified: trunk/boost/icl/type_traits/difference_type_of.hpp
==============================================================================
--- trunk/boost/icl/type_traits/difference_type_of.hpp (original)
+++ trunk/boost/icl/type_traits/difference_type_of.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -11,50 +11,88 @@
 #include <boost/config.hpp> // For macro BOOST_STATIC_CONSTANT
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
 #include <boost/icl/type_traits/no_type.hpp>
 #include <boost/icl/type_traits/is_numeric.hpp>
+#include <boost/icl/type_traits/rep_type_of.hpp>
 
 namespace boost{ namespace icl
 {
+ namespace detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
+ }
+
+ //--------------------------------------------------------------------------
+ template <class Type>
+ struct has_difference_type
+ : mpl::bool_<detail::has_difference_type<Type>::value>
+ {};
+
+ //--------------------------------------------------------------------------
+ template<class Type> // type_of(T-T)==T
+ struct is_subtraction_closed
+ {
+ typedef is_subtraction_closed type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (mpl::or_< is_numeric<Type>
+ , mpl::and_< has_rep_type<Type>
+ , mpl::not_<has_difference_type<Type> >
+ >
+ >::value)
+ );
+ };
+
     //--------------------------------------------------------------------------
     template<class Type>
     struct has_difference
     {
         typedef has_difference type;
         BOOST_STATIC_CONSTANT(bool,
- value = (mpl::or_< is_numeric<Type>
- , is_pointer<Type> >::value)
+ value = (mpl::or_< is_subtraction_closed<Type>
+ , is_pointer<Type>
+ , has_difference_type<Type> >::value)
             );
     };
 
     //--------------------------------------------------------------------------
- template <class Type, bool has_difference>
+ template <class Type, bool has_difference, bool has_diff_type>
     struct get_difference_type;
 
     template <class Type>
- struct get_difference_type<Type, false>
+ struct get_difference_type<Type, false, false>
     {
         typedef no_type type;
     };
 
     template <class Type>
- struct get_difference_type<Type*, true>
+ struct get_difference_type<Type*, true, false>
     {
         typedef std::ptrdiff_t type;
     };
 
     template <class Type>
- struct get_difference_type<Type, true>
+ struct get_difference_type<Type, true, false>
     {
         typedef Type type;
     };
 
+ template <class Type>
+ struct get_difference_type<Type, true, true>
+ {
+ typedef typename Type::difference_type type;
+ };
+
     //--------------------------------------------------------------------------
     template<class Type>
     struct difference_type_of
     {
         typedef typename
- get_difference_type<Type, has_difference<Type>::value>::type type;
+ get_difference_type< Type
+ , has_difference<Type>::value
+ , has_difference_type<Type>::value
+ >::type type;
     };
 
 }} // namespace boost icl

Modified: trunk/boost/icl/type_traits/infinity.hpp
==============================================================================
--- trunk/boost/icl/type_traits/infinity.hpp (original)
+++ trunk/boost/icl/type_traits/infinity.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------------+
-Copyright (c) 2010-2010: Joachim Faulhaber
+Copyright (c) 2010-2011: Joachim Faulhaber
 +------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
@@ -10,48 +10,170 @@
 
 #include <string>
 #include <boost/static_assert.hpp>
+#include <boost/type_traits/ice.hpp>
 #include <boost/icl/type_traits/is_numeric.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/mpl/if.hpp>
 
 namespace boost{ namespace icl
 {
 
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
- template <class Type> struct numeric_infinity
- {
- typedef numeric_infinity type;
-
- static Type value()
- {
- BOOST_STATIC_ASSERT((is_numeric<Type>::value));
- if(std::numeric_limits<Type>::has_infinity)
- return std::numeric_limits<Type>::infinity();
- else
- return (std::numeric_limits<Type>::max)();
- }
- };
+template<class Type> struct has_std_infinity
+{
+ typedef has_std_infinity type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (type_traits::ice_and
+ < is_numeric<Type>::value
+ , std::numeric_limits<Type>::has_infinity
+ >::value)
+ );
+};
 
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+template<class Type> struct has_max_infinity
+{
+ typedef has_max_infinity type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (type_traits::ice_and
+ < is_numeric<Type>::value
+ , type_traits::ice_not<std::numeric_limits<Type>::has_infinity>::value
+ >::value)
+ );
+};
+
+//------------------------------------------------------------------------------
+template <class Type, bool has_std_inf=false, bool has_std_max=false>
+struct get_numeric_infinity;
 
+template <class Type, bool has_std_max>
+struct get_numeric_infinity<Type, true, has_std_max>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
+ {
+ return (std::numeric_limits<Type>::infinity)();
+ }
+};
 
- template <class Type> struct infinity
+template <class Type>
+struct get_numeric_infinity<Type, false, true>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
     {
- typedef infinity type;
+ return (std::numeric_limits<Type>::max)();
+ }
+};
 
- static Type value()
- {
- return
- mpl::if_<is_numeric<Type>,
- numeric_infinity<Type>,
- identity_element<Type> >::type::value();
- }
- };
+template <class Type>
+struct get_numeric_infinity<Type, false, false>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
+ {
+ return Type();
+ }
+};
+
+template <class Type>
+struct numeric_infinity
+{
+ typedef numeric_infinity type;
+ static Type value()
+ {
+ return get_numeric_infinity< Type
+ , has_std_infinity<Type>::value
+ , has_max_infinity<Type>::value >::value();
+ }
+};
+
+
+//------------------------------------------------------------------------------
+template<class Type, bool has_numeric_inf, bool has_repr_inf, bool has_size, bool has_diff>
+struct get_infinity;
+
+template<class Type, bool has_repr_inf, bool has_size, bool has_diff>
+struct get_infinity<Type, true, has_repr_inf, has_size, has_diff>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return numeric_infinity<Type>::value();
+ }
+};
+
+template<class Type, bool has_size, bool has_diff>
+struct get_infinity<Type, false, true, has_size, has_diff>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return Type(numeric_infinity<typename Type::rep>::value());
+ }
+};
+
+template<class Type, bool has_diff>
+struct get_infinity<Type, false, false, true, has_diff>
+{
+ typedef get_infinity type;
+ typedef typename Type::size_type size_type;
+
+ static Type value()
+ {
+ return Type(numeric_infinity<size_type>::value());
+ }
+};
+
+template<class Type>
+struct get_infinity<Type, false, false, false, true>
+{
+ typedef get_infinity type;
+ typedef typename Type::difference_type difference_type;
+
+ static Type value()
+ {
+ return identity_element<difference_type>::value();
+ }
+};
+
+template<class Type>
+struct get_infinity<Type, false, false, false, false>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return identity_element<Type>::value();
+ }
+};
+
+template <class Type> struct infinity
+{
+ typedef infinity type;
+
+ static Type value()
+ {
+ return
+ get_infinity< Type
+ , is_numeric<Type>::value
+ , has_rep_type<Type>::value
+ , has_size_type<Type>::value
+ , has_difference_type<Type>::value
+ >::value();
+ }
+};
+
+template <>
+struct infinity<std::string>
+{
+ typedef infinity type;
+
+ static std::string value()
+ {
+ return std::string();
+ }
+};
 
 }} // namespace boost icl
 

Modified: trunk/boost/icl/type_traits/is_container.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_container.hpp (original)
+++ trunk/boost/icl/type_traits/is_container.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -15,6 +15,7 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/icl/type_traits/element_type_of.hpp>
 #include <boost/icl/type_traits/segment_type_of.hpp>
+#include <boost/icl/type_traits/size_type_of.hpp>
 #include <boost/icl/type_traits/is_map.hpp>
 
 namespace boost{ namespace icl
@@ -22,7 +23,6 @@
     namespace detail
     {
         BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
         BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
     }
 

Modified: trunk/boost/icl/type_traits/is_discrete.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_discrete.hpp (original)
+++ trunk/boost/icl/type_traits/is_discrete.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -26,6 +26,8 @@
 
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_floating_point.hpp>
+#include <boost/icl/type_traits/rep_type_of.hpp>
+#include <boost/icl/type_traits/is_numeric.hpp>
 
 namespace boost{ namespace icl
 {
@@ -33,9 +35,26 @@
     {
         typedef is_discrete type;
         BOOST_STATIC_CONSTANT(bool,
- value = (mpl::and_< boost::detail::is_incrementable<Type>
- , mpl::not_<is_floating_point<Type> >
- >::value)
+ value =
+ (mpl::and_
+ <
+ boost::detail::is_incrementable<Type>
+ , mpl::or_
+ <
+ mpl::and_
+ <
+ mpl::not_<has_rep_type<Type> >
+ , is_non_floating_point<Type>
+ >
+ , mpl::and_
+ <
+ has_rep_type<Type>
+ , is_discrete<typename rep_type_of<Type>::type>
+ //CL , is_non_floating_point<typename rep_type_of<Type>::type>
+ >
+ >
+ >::value
+ )
             );
     };
 

Modified: trunk/boost/icl/type_traits/is_numeric.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_numeric.hpp (original)
+++ trunk/boost/icl/type_traits/is_numeric.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -10,6 +10,9 @@
 
 #include <limits>
 #include <complex>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_integral.hpp>
 
 namespace boost{ namespace icl
 {
@@ -20,11 +23,27 @@
     BOOST_STATIC_CONSTANT(bool, value = (0 < std::numeric_limits<Type>::digits));
 };
 
+template <class Type> struct is_std_numeric
+{
+ typedef is_std_numeric type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (std::numeric_limits<Type>::is_specialized));
+};
+
+template <class Type> struct is_std_integral
+{
+ typedef is_std_integral type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (std::numeric_limits<Type>::is_integer));
+};
+
 template <class Type> struct is_numeric
 {
     typedef is_numeric type;
     BOOST_STATIC_CONSTANT(bool, value =
- (mpl::or_<is_fixed_numeric<Type>, is_integral<Type> >::value) );
+ (mpl::or_< is_std_numeric<Type>
+ , boost::is_integral<Type>
+ , is_std_integral<Type> >::value) );
 };
 
 template <class Type>
@@ -54,6 +73,15 @@
     { return cond || is_less_than(value); }
 };
 
+//--------------------------------------------------------------------------
+template<class Type>
+struct is_non_floating_point
+{
+ typedef is_non_floating_point type;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::not_< is_floating_point<Type> >::value));
+};
+
 }} // namespace boost icl
 
 #endif

Added: trunk/boost/icl/type_traits/rep_type_of.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/icl/type_traits/rep_type_of.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -0,0 +1,69 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ICL_TYPE_TRAITS_REP_TYPE_OF_HPP_JOFA_110329
+#define BOOST_ICL_TYPE_TRAITS_REP_TYPE_OF_HPP_JOFA_110329
+
+#include <boost/config.hpp> // For macro BOOST_STATIC_CONSTANT
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/icl/type_traits/no_type.hpp>
+
+namespace boost{ namespace icl
+{
+ namespace detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(rep)
+ }
+
+ //--------------------------------------------------------------------------
+ template <class Type>
+ struct has_rep_type
+ : mpl::bool_<detail::has_rep<Type>::value>
+ {};
+
+ template <class Rep, class Type>
+ struct represents // Rep represents Type; Type is_wrapper_of Rep
+ : mpl::bool_<detail::has_rep<Type>::value>
+ {
+ typedef represents type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (mpl::and_< has_rep_type<Type>
+ , is_same<typename Type::rep, Rep> >::value)
+ );
+ };
+
+ //--------------------------------------------------------------------------
+ template <class Type, bool has_rep>
+ struct get_rep_type;
+
+ template <class Type>
+ struct get_rep_type<Type, false>
+ {
+ typedef no_type type;
+ };
+
+ template <class Type>
+ struct get_rep_type<Type, true>
+ {
+ typedef typename Type::rep type;
+ };
+
+ //--------------------------------------------------------------------------
+ template<class Type>
+ struct rep_type_of
+ {
+ typedef typename
+ get_rep_type<Type, has_rep_type<Type>::value>::type type;
+ };
+
+}} // namespace boost icl
+
+#endif
+
+

Modified: trunk/boost/icl/type_traits/size_type_of.hpp
==============================================================================
--- trunk/boost/icl/type_traits/size_type_of.hpp (original)
+++ trunk/boost/icl/type_traits/size_type_of.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -8,9 +8,62 @@
 #ifndef BOOST_ICL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
 #define BOOST_ICL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
 
+#include <boost/icl/type_traits/difference_type_of.hpp>
+
 namespace boost{ namespace icl
 {
- template <class Type> struct size_type_of{ typedef std::size_t type; };
+
+ namespace detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
+ }
+
+ //--------------------------------------------------------------------------
+ template <class Type>
+ struct has_size_type
+ : mpl::bool_<detail::has_size_type<Type>::value>
+ {};
+
+ //--------------------------------------------------------------------------
+ template <class Type, bool has_size, bool has_diff, bool has_rep>
+ struct get_size_type;
+
+ template <class Type>
+ struct get_size_type<Type, false, false, false>
+ {
+ typedef std::size_t type;
+ };
+
+ template <class Type, bool has_diff, bool has_rep>
+ struct get_size_type<Type, true, has_diff, has_rep>
+ {
+ typedef typename Type::size_type type;
+ };
+
+ template <class Type, bool has_rep>
+ struct get_size_type<Type, false, true, has_rep>
+ {
+ typedef typename Type::difference_type type;
+ };
+
+ template <class Type>
+ struct get_size_type<Type, false, false, true>
+ {
+ typedef Type type;
+ };
+
+ //--------------------------------------------------------------------------
+ template<class Type>
+ struct size_type_of
+ {
+ typedef typename
+ get_size_type< Type
+ , has_size_type<Type>::value
+ , has_difference_type<Type>::value
+ , has_rep_type<Type>::value
+ >::type type;
+ };
+
 }} // namespace boost icl
 
 #endif

Modified: trunk/libs/icl/test/Jamfile.v2
==============================================================================
--- trunk/libs/icl/test/Jamfile.v2 (original)
+++ trunk/libs/icl/test/Jamfile.v2 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -10,6 +10,7 @@
     : requirements
       <library>/boost/test//boost_unit_test_framework
       <library>/boost/date_time//boost_date_time
+ <library>/boost/chrono//boost_chrono
       <link>static
       <include>../../..
     ;
@@ -78,5 +79,79 @@
       
       # Ad hoc -----------------------------------------------------------------
       #[ run test_casual_/test_casual.cpp ]
-
+
+
+ # ------------------------------------------------------------------------
+ # Chrono -----------------------------------------------------------------
+ # interval
+ [ run fastest_icl_interval_/fastest_icl_interval.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_icl_interval ]
+
+ # sets
+ [ run fastest_interval_set_/fastest_interval_set.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_set ]
+
+ [ run fastest_interval_set_infix_/fastest_interval_set_infix.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_set_infix ]
+
+ [ run fastest_interval_set_mixed_/fastest_interval_set_mixed.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_set_mixed ]
+
+ # maps
+ [ run fastest_interval_map_/fastest_interval_map.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_map ]
+
+ [ run fastest_interval_map_infix_/fastest_interval_map_infix.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_map_infix ]
+
+ [ run fastest_interval_map_mixed_/fastest_interval_map_mixed.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_map_mixed ]
+
+ [ run fastest_interval_map_mixed2_/fastest_interval_map_mixed2.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_map_mixed2 ]
+
+ [ run fastest_interval_map_infix_mixed_/fastest_interval_map_infix_mixed.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_interval_map_infix_mixed ]
+
+ [ run fastest_icl_map_/fastest_icl_map.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_icl_map ]
+
+
+ # handcoded tests using laws (not LaBatea) -------------------------------
+ # Concept Set
+ [ run fastest_set_interval_set_/fastest_set_interval_set.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_set_interval_set ]
+
+ [ run fastest_set_icl_set_/fastest_set_icl_set.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_set_icl_set ]
+
+ # Concept Map
+ [ run fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_partial_interval_quantifier ]
+
+ [ run fastest_total_interval_quantifier_/fastest_total_interval_quantifier.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_total_interval_quantifier ]
+
+ [ run fastest_partial_icl_quantifier_/fastest_partial_icl_quantifier.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_partial_icl_quantifier ]
+
+ [ run fastest_total_icl_quantifier_/fastest_total_icl_quantifier.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_total_icl_quantifier ]
+
     ;

Added: trunk/libs/icl/test/chrono/utility.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/icl/test/chrono/utility.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -0,0 +1,49 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2011-2011: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_LIBS_ICL_TEST_CHRONO_UTILITY_HPP_JOFA_20110314
+#define BOOST_LIBS_ICL_TEST_CHRONO_UTILITY_HPP_JOFA_20110314
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/chrono/chrono_io.hpp>
+
+// In order to perform simple testing with chrono::time_point
+// we need to provide a dummy test clock
+
+class Now // A trivial test clock
+{
+public:
+ typedef boost::chrono::duration<int> duration;
+ typedef duration::rep rep;
+ typedef duration::period periond;
+ typedef boost::chrono::time_point<Now> time_point;
+
+ static time_point now(){ return time_point(); }
+};
+
+namespace boost{ namespace chrono {
+
+template <class CharT>
+struct clock_string<Now, CharT>
+{
+ static std::basic_string<CharT> name()
+ {
+ static const CharT u[] = {'n', 'o', 'w', '_', 'c', 'l','o', 'c', 'k'};
+ static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
+ return str;
+ }
+ static std::basic_string<CharT> since()
+ {
+ const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'n', 'o', 'w'};
+ const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
+ return str;
+ }
+};
+
+}} //namespace boost chrono
+
+#endif BOOST_LIBS_ICL_TEST_CHRONO_UTILITY_HPP_JOFA_20110314

Modified: trunk/libs/icl/test/fast_stat_interval_map_cases.hpp
==============================================================================
--- trunk/libs/icl/test/fast_stat_interval_map_cases.hpp (original)
+++ trunk/libs/icl/test/fast_stat_interval_map_cases.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -10,31 +10,31 @@
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_fundamentals_4_ordered_types)
-{ interval_map_fundamentals_4_ordered_types<INTERVAL_MAP, ordered_type_1, int>();}
+{ interval_map_fundamentals_4_ordered_types<INTERVAL_MAP, discrete_type_1, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_ctor_4_bicremental_types)
-{ interval_map_ctor_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, int>();}
+{ interval_map_ctor_4_bicremental_types<INTERVAL_MAP, discrete_type_2, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_add_sub_4_bicremental_types)
-{ interval_map_add_sub_4_bicremental_types<INTERVAL_MAP, bicremental_type_2, int>();}
+{ interval_map_add_sub_4_bicremental_types<INTERVAL_MAP, discrete_type_3, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_contains_4_bicremental_types)
-{ interval_map_contains_4_bicremental_types<INTERVAL_MAP, discrete_type_5, int>();}
+{ interval_map_contains_4_bicremental_types<INTERVAL_MAP, discrete_type_4, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_contains_key_objects_4_bicremental_types)
-{ interval_map_contains_key_objects_4_bicremental_types<INTERVAL_MAP, discrete_type_4, int>();}
+{ interval_map_contains_key_objects_4_bicremental_types<INTERVAL_MAP, discrete_type_5, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_operators_4_bicremental_types)
-{ interval_map_operators_4_bicremental_types<INTERVAL_MAP, bicremental_type_5, int>();}
+{ interval_map_operators_4_bicremental_types<INTERVAL_MAP, discrete_type_6, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_base_intersect_4_bicremental_types)
-{ interval_map_base_intersect_4_bicremental_types<INTERVAL_MAP, bicremental_type_6, int>();}
+{ interval_map_base_intersect_4_bicremental_types<INTERVAL_MAP, discrete_type_1, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_base_erase_4_bicremental_types)
@@ -42,11 +42,11 @@
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_base_is_disjoint_4_bicremental_types)
-{ interval_map_base_is_disjoint_4_bicremental_types<INTERVAL_MAP, bicremental_type_8, int>();}
+{ interval_map_base_is_disjoint_4_bicremental_types<INTERVAL_MAP, discrete_type_8, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_flip_4_bicremental_types)
-{ interval_map_flip_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, int>();}
+{ interval_map_flip_4_bicremental_types<INTERVAL_MAP, discrete_type_1, int>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_find_4_bicremental_types)
@@ -70,7 +70,7 @@
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_std_copy_via_inserter_4_bicremental_types)
-{ interval_map_std_copy_via_inserter_4_bicremental_types<signed_bicremental_type_1, int, partial_absorber, INTERVAL_MAP>();}
+{ interval_map_std_copy_via_inserter_4_bicremental_types<signed_discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
 
 BOOST_AUTO_TEST_CASE
 (fastest_icl_interval_map_element_iter_4_discrete_types)

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-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -7,6 +7,8 @@
 +-----------------------------------------------------------------------------*/
 #define BOOST_TEST_MODULE icl::casual unit test
 
+#define BOOST_ICL_TEST_CHRONO
+
 #include <libs/icl/test/disable_test_warnings.hpp>
 
 #include <string>
@@ -21,7 +23,6 @@
 #include "../test_value_maker.hpp"
 
 #include <boost/rational.hpp>
-#include <boost/icl/chrono.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 
@@ -53,6 +54,8 @@
 */
 }} //namespace boost scalars
 
+
+
 class MyInt
 {
 public:
@@ -93,6 +96,7 @@
 */
 }
 
+
 BOOST_AUTO_TEST_CASE(test_difference_types)
 {
     BOOST_CHECK(( boost::is_same< int, difference_type_of<int>::type >::value ));
@@ -209,3 +213,4 @@
     BOOST_CHECK_EQUAL(true, true);
 }
 
+

Modified: trunk/libs/icl/test/test_type_lists.hpp
==============================================================================
--- trunk/libs/icl/test/test_type_lists.hpp (original)
+++ trunk/libs/icl/test/test_type_lists.hpp 2011-03-30 16:20:23 EDT (Wed, 30 Mar 2011)
@@ -18,27 +18,29 @@
 #include <boost/icl/ptime.hpp>
 
 #ifdef BOOST_ICL_TEST_XINT
-#include <boost/icl/xint.hpp>
+# include <boost/icl/xint.hpp>
 #endif
 
 #ifdef BOOST_ICL_TEST_CHRONO
-//JODO not working: #define BOOST_CHRONO_INLINED
-#include <boost/icl/chrono.hpp>
+# define BOOST_CHRONO_EXTENSIONS
+# include <libs/icl/test/chrono/utility.hpp>
+
+ namespace boch = boost::chrono;
 #endif
 
 #include <boost/icl/rational.hpp>
 
 
 #if(_MSC_VER < 1500 && defined(_DEBUG) ) // 1500 = MSVC-9.0
-typedef int boost_posix_time_ptime;
-typedef int boost_posix_time_duration;
-typedef int boost_gregorian_date;
-typedef int boost_gregorian_date_duration;
-#else
-typedef boost::posix_time::ptime boost_posix_time_ptime;
-typedef boost::posix_time::time_duration boost_posix_time_duration;
-typedef boost::gregorian::date boost_gregorian_date;
-typedef boost::gregorian::date_duration boost_gregorian_date_duration;
+ typedef int boost_posix_time_ptime;
+ typedef int boost_posix_time_duration;
+ typedef int boost_gregorian_date;
+ typedef int boost_gregorian_date_duration;
+#else
+ typedef boost::posix_time::ptime boost_posix_time_ptime;
+ typedef boost::posix_time::time_duration boost_posix_time_duration;
+ typedef boost::gregorian::date boost_gregorian_date;
+ typedef boost::gregorian::date_duration boost_gregorian_date_duration;
 #endif
 
 typedef ::boost::mpl::list<
@@ -51,8 +53,10 @@
     ,boost::rational<boost::xint::integer>
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<int>
- ,boost::chrono::duration<double>
+ ,boch::duration<int>
+ ,boch::duration<double>
+ ,Now::time_point
+ ,boch::time_point<Now, boch::duration<double> >
 #endif
     ,boost_posix_time_ptime
     ,boost_posix_time_duration
@@ -61,15 +65,33 @@
     ,int*
> bicremental_types;
 
-typedef unsigned int bicremental_type_1;
-typedef int bicremental_type_2;
-typedef double bicremental_type_3;
-typedef boost::rational<int> bicremental_type_4;
-typedef boost_posix_time_ptime bicremental_type_5;
-typedef short bicremental_type_6;
-typedef float bicremental_type_7;
-typedef int* bicremental_type_8;
-
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<long long, boost::ratio<1,113> > duration_long2_113s;
+ typedef boch::duration<int, boost::ratio<11,113> > duration_int_11_113s;
+ typedef boch::duration<boost::rational<int>, boost::ratio<101,997> > duration_rational_101_997s;
+ typedef boch::time_point<Now, duration_int_11_113s > Now_time_int_11_113s;
+ typedef boch::time_point<Now, boch::duration<double> > Now_time_double;
+ typedef boch::time_point<Now, boch::duration<boost::rational<int> > > Now_time_rational;
+ typedef boch::time_point<Now, duration_rational_101_997s > Now_time_rational_101_997s;
+
+ typedef boch::duration<int> bicremental_type_1;
+ typedef boch::duration<double> bicremental_type_2;
+ typedef Now::time_point bicremental_type_3;
+ typedef Now_time_double bicremental_type_4;
+ typedef Now_time_rational bicremental_type_5;
+ typedef duration_long2_113s bicremental_type_6;
+ typedef duration_rational_101_997s bicremental_type_7;
+ typedef Now_time_rational_101_997s bicremental_type_8;
+#else
+ typedef unsigned int bicremental_type_1;
+ typedef int bicremental_type_2;
+ typedef double bicremental_type_3;
+ typedef boost::rational<int> bicremental_type_4;
+ typedef boost_posix_time_ptime bicremental_type_5;
+ typedef short bicremental_type_6;
+ typedef float bicremental_type_7;
+ typedef int* bicremental_type_8;
+#endif //BOOST_ICL_TEST_CHRONO
 
 typedef ::boost::mpl::list<
      short, int, long, long long
@@ -80,16 +102,25 @@
     ,boost::rational<boost::xint::integer>
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<int>
- ,boost::chrono::duration<float>
+ ,boch::duration<int>
+ ,boch::duration<float>
+ ,Now::time_point
 #endif
> signed_bicremental_types;
 
-typedef int signed_bicremental_type_1;
-typedef double signed_bicremental_type_2;
-typedef boost::rational<int> signed_bicremental_type_3;
-typedef short signed_bicremental_type_4;
-typedef float signed_bicremental_type_5;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> signed_bicremental_type_1;
+ typedef boch::duration<double> signed_bicremental_type_2;
+ typedef Now::time_point signed_bicremental_type_3;
+ typedef Now_time_double signed_bicremental_type_4;
+ typedef Now_time_rational signed_bicremental_type_5;
+#else
+ typedef int signed_bicremental_type_1;
+ typedef double signed_bicremental_type_2;
+ typedef boost::rational<int> signed_bicremental_type_3;
+ typedef short signed_bicremental_type_4;
+ typedef float signed_bicremental_type_5;
+#endif //BOOST_ICL_TEST_CHRONO
 
 //DBG short list for debugging
 typedef ::boost::mpl::list<
@@ -103,13 +134,21 @@
     ,boost::rational<boost::xint::integer>
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<double>
+ ,boch::duration<double>
+ ,boch::time_point<Now, boch::duration<double> >
 #endif
> bicremental_continuous_types;
 
-typedef float bicremental_continuous_type_1;
-typedef double bicremental_continuous_type_2;
-typedef boost::rational<int> bicremental_continuous_type_3;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> bicremental_continuous_type_1;
+ typedef Now_time_double bicremental_continuous_type_2;
+ typedef Now_time_rational bicremental_continuous_type_3;
+#else
+ typedef float bicremental_continuous_type_1;
+ typedef double bicremental_continuous_type_2;
+ typedef boost::rational<int> bicremental_continuous_type_3;
+#endif // BOOST_ICL_TEST_CHRONO
 
 
 typedef ::boost::mpl::list<
@@ -121,12 +160,10 @@
 #endif
> integral_types;
 
-typedef int integral_type_1;
-typedef unsigned int integral_type_2;
-typedef short integral_type_3;
-typedef unsigned short integral_type_4;
-typedef long long integral_type_5;
-typedef unsigned long long integral_type_6;
+typedef int integral_type_1;
+typedef unsigned int integral_type_2;
+typedef short integral_type_3;
+typedef unsigned int integral_type_4;
 
 typedef ::boost::mpl::list<
     unsigned short, unsigned int
@@ -136,29 +173,50 @@
     ,boost::xint::integer
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<unsigned short>
+ ,boch::duration<unsigned short>
+ ,Now::time_point
 #endif
     ,boost_posix_time_ptime
- ,boost_posix_time_ptime
     ,boost_posix_time_duration
     ,boost_gregorian_date
     ,boost_gregorian_date_duration
     ,int*
> discrete_types;
 
-typedef int discrete_type_1;
-typedef boost_posix_time_ptime discrete_type_2;
-typedef unsigned int discrete_type_3;
-typedef short discrete_type_4;
-typedef unsigned int discrete_type_5;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> discrete_type_1;
+ typedef duration_int_11_113s discrete_type_2;
+ typedef Now::time_point discrete_type_3;
+ typedef duration_long2_113s discrete_type_4;
+ typedef Now_time_int_11_113s discrete_type_5;
+ typedef short discrete_type_6;
+ typedef int* discrete_type_7;
+ typedef boost_posix_time_duration discrete_type_8;
+#else
+ typedef int discrete_type_1;
+ typedef boost_posix_time_ptime discrete_type_2;
+ typedef unsigned int discrete_type_3;
+ typedef short discrete_type_4;
+ typedef int* discrete_type_5;
+ typedef boost_posix_time_duration discrete_type_6;
+ typedef boost_gregorian_date discrete_type_7;
+ typedef boost_gregorian_date_duration discrete_type_8;
+#endif //BOOST_ICL_TEST_CHRONO
 
 typedef ::boost::mpl::list<
      short, int, long
> signed_discrete_types;
 
-typedef int signed_discrete_type_1;
-typedef short signed_discrete_type_2;
-typedef long signed_discrete_type_3;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef Now::time_point signed_discrete_type_1;
+ typedef duration_long2_113s signed_discrete_type_2;
+ typedef Now_time_int_11_113s signed_discrete_type_3;
+#else
+ typedef int signed_discrete_type_1;
+ typedef short signed_discrete_type_2;
+ typedef long signed_discrete_type_3;
+#endif //BOOST_ICL_TEST_CHRONO
 
 typedef ::boost::mpl::list<
     float, double, long double
@@ -166,15 +224,26 @@
 #ifdef BOOST_ICL_TEST_XINT
     ,boost::rational<boost::xint::integer>
 #endif
-#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<long double>
-#endif
+//JODO
+//test_interval_map_shared.hpp(1190) : error C2440: 'initializing' : cannot convert from 'long double' to 'boost::chrono::duration<Rep>'
+//#ifdef BOOST_ICL_TEST_CHRONO
+// ,boost::chrono::duration<long double>
+//#endif
> numeric_continuous_types;
 
-typedef double numeric_continuous_type_1;
-typedef float numeric_continuous_type_2;
-typedef boost::rational<int> numeric_continuous_type_3;
-typedef long double numeric_continuous_type_4;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> numeric_continuous_type_1;
+ typedef Now_time_double numeric_continuous_type_2;
+ typedef Now_time_rational numeric_continuous_type_3;
+ typedef duration_rational_101_997s numeric_continuous_type_4;
+#else
+ typedef double numeric_continuous_type_1;
+ typedef float numeric_continuous_type_2;
+ typedef boost::rational<int> numeric_continuous_type_3;
+ typedef long double numeric_continuous_type_4;
+#endif //BOOST_ICL_TEST_CHRONO
+
 
 typedef ::boost::mpl::list<
     float, double, long double
@@ -183,28 +252,43 @@
     ,boost::rational<boost::xint::integer>
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<double>
+ ,boch::duration<double>
+ ,boch::time_point<Now, boch::duration<double> >
 #endif
     ,std::string
> continuous_types;
 
-typedef double continuous_type_1;
-typedef float continuous_type_2;
-typedef boost::rational<int> continuous_type_3;
-typedef std::string continuous_type_4;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> continuous_type_1;
+ typedef Now_time_double continuous_type_2;
+ typedef Now_time_rational continuous_type_3;
+ typedef std::string continuous_type_4;
+#else
+ typedef double continuous_type_1;
+ typedef float continuous_type_2;
+ typedef boost::rational<int> continuous_type_3;
+ typedef std::string continuous_type_4;
+#endif //BOOST_ICL_TEST_CHRONO
 
 typedef ::boost::mpl::list<
- unsigned short, unsigned int
- ,unsigned long, unsigned long long
- ,short, int, long, long long
- ,float, double, long double
+ unsigned short
+ ,unsigned long
+ ,unsigned long long
+ ,short
+ ,int
+ ,long
+ ,long long
+ ,float
+ ,double
+ ,long double
     ,boost::rational<int>
 #ifdef BOOST_ICL_TEST_XINT
     ,boost::xint::integer
 #endif
 #ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<short>
- ,boost::chrono::duration<long double>
+ ,boch::duration<short>
+ ,boch::duration<long double>
+ ,Now::time_point
 #endif
     ,boost_posix_time_ptime
     ,boost_posix_time_duration
@@ -214,11 +298,19 @@
     ,std::string
> ordered_types;
 
-typedef int ordered_type_1;
-typedef std::string ordered_type_2;
-typedef boost_posix_time_ptime ordered_type_3;
-typedef boost::rational<int> ordered_type_4;
-typedef double ordered_type_5;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> ordered_type_1;
+ typedef boch::duration<double> ordered_type_2;
+ typedef Now::time_point ordered_type_3;
+ typedef Now_time_double ordered_type_4;
+ typedef Now_time_rational ordered_type_5;
+#else
+ typedef int ordered_type_1;
+ typedef std::string ordered_type_2;
+ typedef boost_posix_time_ptime ordered_type_3;
+ typedef boost::rational<int> ordered_type_4;
+ typedef double ordered_type_5;
+#endif //BOOST_ICL_TEST_CHRONO
 
 #endif
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk