Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r65825 - in sandbox/itl/boost/validate: . driver laws
From: afojgo_at_[hidden]
Date: 2010-10-08 06:31:10


Author: jofaber
Date: 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
New Revision: 65825
URL: http://svn.boost.org/trac/boost/changeset/65825

Log:
Refactoring: Renaming unon, neutron etc. 2. Renaming in boost/validate. Fast test. Stable{msvc-9.0,10.0, gcc-3.4.4}
Text files modified:
   sandbox/itl/boost/validate/driver/bit_collector_driver.hpp | 52 ++++++++++++++++----------------
   sandbox/itl/boost/validate/driver/collector_driver.hpp | 58 ++++++++++++++++++------------------
   sandbox/itl/boost/validate/driver/itl_driver.hpp | 20 ++++++------
   sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp | 30 +++++++++---------
   sandbox/itl/boost/validate/driver/itl_relations_driver.hpp | 50 +++++++++++++++---------------
   sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp | 50 +++++++++++++++---------------
   sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp | 64 ++++++++++++++++++++--------------------
   sandbox/itl/boost/validate/driver/map_order_driver.hpp | 22 ++++++------
   sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp | 22 ++++++------
   sandbox/itl/boost/validate/driver/set_order_driver.hpp | 22 ++++++------
   sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp | 64 ++++++++++++++++++++--------------------
   sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp | 50 +++++++++++++++---------------
   sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp | 50 +++++++++++++++---------------
   sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp | 22 ++++++------
   sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp | 22 ++++++------
   sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 64 ++++++++++++++++++++--------------------
   sandbox/itl/boost/validate/laws/monoid.hpp | 6 +-
   sandbox/itl/boost/validate/utility.hpp | 8 ++--
   18 files changed, 338 insertions(+), 338 deletions(-)

Modified: sandbox/itl/boost/validate/driver/bit_collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/bit_collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/bit_collector_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -56,14 +56,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 50;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 50;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 0;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 0;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -83,10 +83,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
             }
 
         }
@@ -95,39 +95,39 @@
         concept_validater* chooseValidater()
         {
             int rootChoice = _rootChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             ////-----------------------------------------------------------------
             case RootType::itl_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                     return new collector_validater< itl::map<int, itl::bits8, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                     return new collector_validater< itl::map<int, itl::bits32, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
- default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case itl_map
             ////-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                     return new collector_validater<interval_map<int, itl::bits64, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                     return new collector_validater<interval_map<int, itl::bits16, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             ////-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                     return new collector_validater<split_interval_map<int, itl::bits32, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                     return new collector_validater<split_interval_map<double, itl::bits8, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/collector_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 50;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 50;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 0;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 0;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("collector_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("collector_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("collector_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,36 +96,36 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::itl_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new collector_validater<itl::map<int,std::set<int> > >;
- case NeutronHandlerType::partial_enricher: return new collector_validater<itl::map<int,std::set<int>,partial_enricher> >;
- //case NeutronHandlerType::total_absorber : return new collector_validater<itl::map<int,std::set<int>,total_absorber > >;
- default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new collector_validater<itl::map<int,std::set<int> > >;
+ case IdentityHandlerType::partial_enricher: return new collector_validater<itl::map<int,std::set<int>,partial_enricher> >;
+ //case IdentityHandlerType::total_absorber : return new collector_validater<itl::map<int,std::set<int>,total_absorber > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new collector_validater<interval_map<double,std::set<int> > >;
- case NeutronHandlerType::partial_enricher: return new collector_validater<interval_map<int,std::set<int>,partial_enricher> >;
- //case NeutronHandlerType::total_absorber : return new collector_validater<interval_map<int,std::set<int>,total_absorber > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new collector_validater<interval_map<double,std::set<int> > >;
+ case IdentityHandlerType::partial_enricher: return new collector_validater<interval_map<int,std::set<int>,partial_enricher> >;
+ //case IdentityHandlerType::total_absorber : return new collector_validater<interval_map<int,std::set<int>,total_absorber > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new collector_validater<split_interval_map<int,std::set<int> > >;
- case NeutronHandlerType::partial_enricher: return new collector_validater<split_interval_map<double,std::set<int>,partial_enricher> >;
- //case NeutronHandlerType::total_absorber : return new collector_validater<split_interval_map<int,std::set<int>,total_absorber > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new collector_validater<split_interval_map<int,std::set<int> > >;
+ case IdentityHandlerType::partial_enricher: return new collector_validater<split_interval_map<double,std::set<int>,partial_enricher> >;
+ //case IdentityHandlerType::total_absorber : return new collector_validater<split_interval_map<int,std::set<int>,total_absorber > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -44,9 +44,9 @@
         enum CodomainTypes { Nat, Int, Double, set_int, raw_bitset, CodomainTypes_size };
     }
 
- namespace NeutronHandlerType
+ namespace IdentityHandlerType
     {
- enum NeutronHandlerTypes { partial_absorber, partial_enricher, total_absorber, total_enricher, NeutronHandlerTypes_size };
+ enum IdentityHandlerTypes { partial_absorber, partial_enricher, total_absorber, total_enricher, IdentityHandlerTypes_size };
     }
 
     namespace FreeChoice
@@ -237,14 +237,14 @@
             type_names[CodomainType::raw_bitset] = "raw_bitset";
             _codomainChoice.setTypeNames(type_names);
         }
- void setNeutronHandlerTypeNames()
+ void setIdentityHandlerTypeNames()
         {
- std::vector<std::string> type_names(NeutronHandlerType::NeutronHandlerTypes_size);
- type_names[NeutronHandlerType::partial_absorber] = "partial_absorber";
- type_names[NeutronHandlerType::partial_enricher] = "partial_enricher";
- type_names[NeutronHandlerType::total_absorber] = "total_absorber";
- type_names[NeutronHandlerType::total_enricher] = "total_enricher";
- _neutronizerChoice.setTypeNames(type_names);
+ std::vector<std::string> type_names(IdentityHandlerType::IdentityHandlerTypes_size);
+ type_names[IdentityHandlerType::partial_absorber] = "partial_absorber";
+ type_names[IdentityHandlerType::partial_enricher] = "partial_enricher";
+ type_names[IdentityHandlerType::total_absorber] = "total_absorber";
+ type_names[IdentityHandlerType::total_enricher] = "total_enricher";
+ _identityHandlerChoice.setTypeNames(type_names);
         }
         void setFreeChoiceNames()
         {
@@ -281,7 +281,7 @@
         ChoiceT _rootChoice;
         ChoiceT _domainChoice;
         ChoiceT _codomainChoice;
- ChoiceT _neutronizerChoice;
+ ChoiceT _identityHandlerChoice;
         ChoiceT _freeChoice;
 
     private:

Modified: sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -53,14 +53,14 @@
         setCodomainTypeNames();
         _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
         if(!_rootChoice.is_consistent())
         {
@@ -80,10 +80,10 @@
             std::cout << _codomainChoice.inconsitencyMessage("itl_morphic_driver::setProfile()") << std::endl;
         }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
         {
             setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("itl_morphic_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("itl_morphic_driver::setProfile()") << std::endl;
         }
 
     }
@@ -93,7 +93,7 @@
         int rootChoice = _rootChoice.some();
         int domainChoice = _domainChoice.some();
         //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
         switch(rootChoice)
         {
@@ -109,10 +109,10 @@
         case RootType::split_interval_map: {
             switch(domainChoice) {
             case DomainType::Int:
- switch(neutronizerChoice) {
+ switch(identityHandlerChoice) {
                 NEURONIZER_CASES(interval_morphic_validater, split_interval_map, int, int)
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
- neutronizerChoice, _neutronizerChoice);
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"),
+ identityHandlerChoice, _identityHandlerChoice);
                 }
             default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                          domainChoice, _domainChoice);
@@ -121,7 +121,7 @@
         case RootType::interval_map: {
             switch(domainChoice) {
             case DomainType::Int:
- switch(neutronizerChoice) {
+ switch(identityHandlerChoice) {
                 NEURONIZER_CASES(interval_morphic_validater, interval_map, int, int)
                 default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                             domainChoice, _domainChoice);

Modified: sandbox/itl/boost/validate/driver/itl_relations_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_relations_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_relations_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("itl_relations_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("itl_relations_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("itl_relations_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,7 +96,7 @@
             int rootChoice = _rootChoice.some();
             int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
@@ -124,17 +124,17 @@
             case RootType::split_interval_map: {
                     switch(domainChoice) {
                         case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
+ case IdentityHandlerType::total_absorber:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
+ case IdentityHandlerType::total_enricher:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
- neutronizerChoice, _neutronizerChoice);
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"),
+ identityHandlerChoice, _identityHandlerChoice);
                             }
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                                 domainChoice, _domainChoice);
@@ -143,17 +143,17 @@
             case RootType::interval_map: {
                     switch(domainChoice) {
                         case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                                     return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                                     return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
+ case IdentityHandlerType::total_absorber:
                                     return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
+ case IdentityHandlerType::total_enricher:
                                     return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
- neutronizerChoice, _neutronizerChoice);
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"),
+ identityHandlerChoice, _identityHandlerChoice);
                             }
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                                 domainChoice, _domainChoice);

Modified: sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -58,14 +58,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -85,10 +85,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("itl_single_law_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("itl_single_law_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("itl_single_law_driver::setProfile()") << std::endl;
             }
 
         }
@@ -99,7 +99,7 @@
             int rootChoice = _rootChoice.some();
             int domainChoice = _domainChoice.some();
             int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
@@ -127,17 +127,17 @@
             case RootType::split_interval_map: {
                     switch(domainChoice) {
                         case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
+ case IdentityHandlerType::total_absorber:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
+ case IdentityHandlerType::total_enricher:
                                     return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
- neutronizerChoice, _neutronizerChoice);
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"),
+ identityHandlerChoice, _identityHandlerChoice);
                             }
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                                 domainChoice, _domainChoice);
@@ -146,17 +146,17 @@
             case RootType::interval_map: {
                     switch(domainChoice) {
                         case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber:
                                     return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
+ case IdentityHandlerType::partial_enricher:
                                     return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
+ case IdentityHandlerType::total_absorber:
                                     return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
+ case IdentityHandlerType::total_enricher:
                                     return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
- neutronizerChoice, _neutronizerChoice);
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"),
+ identityHandlerChoice, _identityHandlerChoice);
                             }
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
                                                 domainChoice, _domainChoice);

Modified: sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -57,14 +57,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -84,10 +84,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("map_copy_conformity_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("map_copy_conformity_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("map_copy_conformity_driver::setProfile()") << std::endl;
             }
 
         }
@@ -95,39 +95,39 @@
         concept_validater* chooseValidater()
         {
             int rootChoice = _rootChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::itl_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/map_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/map_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/map_order_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -54,14 +54,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 50;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 50;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 0;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 0;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -81,10 +81,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("map_order_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("map_order_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("map_order_driver::setProfile()") << std::endl;
             }
 
         }
@@ -94,7 +94,7 @@
             int rootChoice = _rootChoice.some();
             int domainChoice = _domainChoice.some();
             int codomainChoice = _codomainChoice.some();
- //int neutronizerChoice = _neutronizerChoice.some();
+ //int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {

Modified: sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -57,14 +57,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -84,10 +84,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("set_copy_conformity_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("set_copy_conformity_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("set_copy_conformity_driver::setProfile()") << std::endl;
             }
 
         }
@@ -95,7 +95,7 @@
         concept_validater* chooseValidater()
         {
             int rootChoice = _rootChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {

Modified: sandbox/itl/boost/validate/driver/set_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/set_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/set_order_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -54,14 +54,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 50;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 50;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 0;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 0;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -81,10 +81,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("set_order_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("set_order_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("set_order_driver::setProfile()") << std::endl;
             }
 
         }
@@ -94,7 +94,7 @@
             int rootChoice = _rootChoice.some();
             int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- //int neutronizerChoice = _neutronizerChoice.some();
+ //int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {

Modified: sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -56,14 +56,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -83,10 +83,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("signed_quantifier_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("signed_quantifier_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("signed_quantifier_driver::setProfile()") << std::endl;
             }
 
         }
@@ -97,39 +97,39 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::itl_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int, partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, double, partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double, int, total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double, double, total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, double, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double, int, total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double, double, total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<interval_map<double, double, partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<interval_map<double, int, partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<int, double, total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<int, int, total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new signed_quantifier_validater<interval_map<double, double, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new signed_quantifier_validater<interval_map<double, int, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<int, double, total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<int, int, total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<split_interval_map<double, int, partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<int, double, partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<split_interval_map<double, int, total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<int, double, total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new signed_quantifier_validater<split_interval_map<double, int, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<int, double, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new signed_quantifier_validater<split_interval_map<double, int, total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<int, double, total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("sorted_associative_map_back_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("sorted_associative_map_back_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("sorted_associative_map_back_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,29 +96,29 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new sorted_associative_back_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::partial_enricher: return new sorted_associative_back_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_absorber: return new sorted_associative_back_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_enricher: return new sorted_associative_back_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::partial_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("sorted_associative_map_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("sorted_associative_map_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("sorted_associative_map_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,29 +96,29 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::partial_enricher: return new sorted_associative_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_absorber: return new sorted_associative_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_enricher: return new sorted_associative_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new sorted_associative_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::partial_enricher: return new sorted_associative_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_absorber: return new sorted_associative_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case NeutronHandlerType::total_enricher: return new sorted_associative_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("sorted_associative_set_back_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("sorted_associative_set_back_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("sorted_associative_set_back_driver::setProfile()") << std::endl;
             }
 
         }
@@ -95,7 +95,7 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- //int neutronizerChoice = _neutronizerChoice.some();
+ //int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {

Modified: sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("sorted_associative_set_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("sorted_associative_set_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("sorted_associative_set_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,7 +96,7 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- //int neutronizerChoice = _neutronizerChoice.some();
+ //int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {

Modified: sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -55,14 +55,14 @@
             setCodomainTypeNames();
             _codomainChoice.init();
 
- _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
- _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
- setNeutronHandlerTypeNames();
- _neutronizerChoice.init();
+ _identityHandlerChoice.setSize(IdentityHandlerType::IdentityHandlerTypes_size);
+ _identityHandlerChoice.setMaxWeights(100);
+ _identityHandlerChoice[IdentityHandlerType::partial_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::partial_enricher] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_absorber] = 25;
+ _identityHandlerChoice[IdentityHandlerType::total_enricher] = 25;
+ setIdentityHandlerTypeNames();
+ _identityHandlerChoice.init();
 
             if(!_rootChoice.is_consistent())
             {
@@ -82,10 +82,10 @@
                 std::cout << _codomainChoice.inconsitencyMessage("unsigned_quantifier_driver::setProfile()") << std::endl;
             }
 
- if(!_neutronizerChoice.is_consistent())
+ if(!_identityHandlerChoice.is_consistent())
             {
                 setValid(false);
- std::cout << _neutronizerChoice.inconsitencyMessage("unsigned_quantifier_driver::setProfile()") << std::endl;
+ std::cout << _identityHandlerChoice.inconsitencyMessage("unsigned_quantifier_driver::setProfile()") << std::endl;
             }
 
         }
@@ -96,39 +96,39 @@
             int rootChoice = _rootChoice.some();
             //int domainChoice = _domainChoice.some();
             //int codomainChoice = _codomainChoice.some();
- int neutronizerChoice = _neutronizerChoice.some();
+ int identityHandlerChoice = _identityHandlerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
             case RootType::itl_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,double,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat, partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int, double,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int, nat, total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,double,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int, double,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int, nat, total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<interval_map<int, nat, partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<interval_map<int, double,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<double,nat, total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<double,double,total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new unsigned_quantifier_validater<interval_map<int, nat, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new unsigned_quantifier_validater<interval_map<int, double,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<double,nat, total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<double,double,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat, partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat, partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int, double,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<double,double,total_enricher > >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- }//switch neutronizerChoice
+ switch(identityHandlerChoice) {
+ case IdentityHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int, double,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<double,double,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
+ }//switch identityHandlerChoice
             }//case split_interval_map
             //-----------------------------------------------------------------
 

Modified: sandbox/itl/boost/validate/laws/monoid.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.hpp (original)
+++ sandbox/itl/boost/validate/laws/monoid.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -159,9 +159,9 @@
     // ---------------------------------------------------------------------------
     // Inplace variant of laws for operator o=
     // ---------------------------------------------------------------------------
- template <typename Type, template<class>class Accumulator = inplace_plus, template<class>class NeutronT = neutron>
+ template <typename Type, template<class>class Accumulator = inplace_plus, template<class>class IdentityElement = neutron>
     class InplaceNeutrality
- : public Law<InplaceNeutrality<Type,Accumulator,NeutronT>,
+ : public Law<InplaceNeutrality<Type,Accumulator,IdentityElement>,
                      LOKI_TYPELIST_1(Type), LOKI_TYPELIST_1(Type)>
     {
         /** a o 0 == a computed as
@@ -177,7 +177,7 @@
         {
             return "Neutrality<"+type_to_string<Type>::apply()+","
                                 +unary_template_to_string<Accumulator>::apply()+","
- +unary_template_to_string<NeutronT>::apply()+">";
+ +unary_template_to_string<IdentityElement>::apply()+">";
         }
 
     public:

Modified: sandbox/itl/boost/validate/utility.hpp
==============================================================================
--- sandbox/itl/boost/validate/utility.hpp (original)
+++ sandbox/itl/boost/validate/utility.hpp 2010-10-08 06:31:05 EDT (Fri, 08 Oct 2010)
@@ -16,10 +16,10 @@
 #define ITL_LOCATION(message) location(__FILE__,__LINE__,message)
 
 #define NEURONIZER_CASES(validater_Template, itl_Map, domain_Type, codomain_Type) \
-case NeutronHandlerType::partial_absorber: return new validater_Template<itl_Map<domain_Type,codomain_Type,partial_absorber> >; \
-case NeutronHandlerType::partial_enricher: return new validater_Template<itl_Map<domain_Type,codomain_Type,partial_enricher> >; \
-case NeutronHandlerType::total_absorber: return new validater_Template<itl_Map<domain_Type,codomain_Type,total_absorber> >; \
-case NeutronHandlerType::total_enricher: return new validater_Template<itl_Map<domain_Type,codomain_Type,total_enricher> >;
+case IdentityHandlerType::partial_absorber: return new validater_Template<itl_Map<domain_Type,codomain_Type,partial_absorber> >; \
+case IdentityHandlerType::partial_enricher: return new validater_Template<itl_Map<domain_Type,codomain_Type,partial_enricher> >; \
+case IdentityHandlerType::total_absorber: return new validater_Template<itl_Map<domain_Type,codomain_Type,total_absorber> >; \
+case IdentityHandlerType::total_enricher: return new validater_Template<itl_Map<domain_Type,codomain_Type,total_enricher> >;
 
 
 namespace boost{namespace itl


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