|
|
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