Line data    Source code

       1             : #if     !defined(_ENUM_H)
       2             : 
       3             : #include <vector>
       4             : #include <map>
       5             : #include <set>
       6             : #include <iostream>
       7             : #include <sstream>
       8             : #include <limits>
       9             : 
      10             : #include <alma/Enumtcl/enum_set.hpp>
      11             : #include <alma/Enumtcl/enum_map.hpp>
      12             : 
      13             : template< typename enum_type, 
      14             :           typename val_type,
      15             :           typename set_traits=enum_set_traits<enum_type>,
      16             :           typename map_traits=enum_map_traits<enum_type,val_type> >
      17             : class EnumSetVal
      18             : {
      19             : public:
      20             :   EnumSetVal()
      21             :   {
      22             :     reset();
      23             :   }
      24             :   EnumSetVal(enum_type setting)
      25             :   {
      26             :     setOnly(setting);
      27             :   }
      28             :   EnumSetVal &operator&=(const EnumSetVal &rhs)
      29             :   {
      30             :     bits &= rhs.bits;
      31             :     return *this;
      32             :   }
      33             :   EnumSetVal &operator|=(const EnumSetVal &rhs)
      34             :   {
      35             :     bits |= rhs.bits;
      36             :     return *this;
      37             :   }
      38             :   bool less (const EnumSetVal &rhs){
      39             :     if(bits.to_ulong()<rhs.bits.to_ulong())return true;
      40             :     return false;
      41             :   }
      42             :   bool operator!= (const EnumSetVal &rhs)
      43             :   {
      44             :     if(bits.to_ulong()==rhs.bits.to_ulong())return false;
      45             :     return true;
      46             :   }
      47             :   bool operator== (const EnumSetVal &rhs)
      48             :   {
      49             :     if(bits.to_ulong()==rhs.bits.to_ulong())return true;
      50             :     return false;
      51             :   }
      52             :   EnumSetVal &operator^=(const EnumSetVal &rhs)
      53             :   {
      54             :     bits ^= rhs.bits;
      55             :     return *this;
      56             :   }
      57             :   std::size_t count() const
      58             :   {
      59             :     return bits.count();
      60             :   }
      61             :   std::size_t size() const
      62             :   {
      63             :     return bits.size();
      64             :   }
      65             :   bool operator[](enum_type testing) const
      66             :   {
      67             :     return bits.test(to_bit(testing));
      68             :   }
      69             :   bool only(enum_type testing) const
      70             :   {
      71             :     if(count()!=1)return false;
      72             :     return bits.test(to_bit(testing));
      73             :   }
      74             :   bool operator^(enum_type testing) const   // xor operator (^ Python bitwise operator) 
      75             :   {
      76             :     if(only(testing))return true;
      77             :     if(bits.test(to_bit(testing)))return false;
      78             :     return true;
      79             :   }
      80             : 
      81             :   EnumSetVal &set()
      82             :   {
      83             :     bits.set();
      84             :     return *this;
      85             :   }
      86             :   EnumSetVal &setOnly(enum_type setting)
      87             :   {
      88             :     bits.reset();
      89             :     bits.set(to_bit(setting), true);
      90             :     return *this;
      91             :   }
      92             :   EnumSetVal &set(enum_type setting, bool value = true)
      93             :   {
      94             :     if(set_traits::maxset<set_traits::count)bits.reset();
      95             :     bits.set(to_bit(setting), value);
      96             :     return *this;
      97             :   }
      98             :   EnumSetVal &set(std::vector<enum_type> setting, bool value = true)
      99             :   {
     100             :     if(set_traits::maxset<set_traits::count)bits.reset();
     101             :     unsigned int nmax=setting.size();
     102             :     if(nmax>set_traits::maxset)nmax=set_traits::maxset;
     103             :     for(unsigned int n=0; n<nmax; n++)
     104             :       bits.set(to_bit(setting[n]), value);
     105             :     return *this;
     106             :   }
     107             :   EnumSetVal &set(std::vector<std::string> names, bool /* value = true */)
     108             :   {
     109             :     // value is not used here, commented out above to silence a compiler warning
     110             :     bits.reset();
     111             :     typename std::map<enum_type,EnumPar<val_type> >::iterator 
     112             :       it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     113             :     std::vector<std::string>::iterator iv, ivb=names.begin(), ive=names.end();
     114             :     for(iv=ivb; iv!=ive; ++iv)
     115             :       for(it=itb; it!=ite; ++it)if(it->second.str()==*iv)
     116             :         bits.set(to_bit(it->first));
     117             :     return *this;
     118             :   }
     119             : 
     120             : 
     121             :   EnumSetVal &reset()
     122             :   {
     123             :     bits.reset();
     124             :     return *this;
     125             :   }
     126             :   EnumSetVal &reset(enum_type resetting)
     127             :   {
     128             :     bits.reset(to_bit(resetting));
     129             :     return *this;
     130             :   }
     131             :   EnumSetVal &flip()
     132             :   {
     133             :     bits.flip();
     134             :     return *this;
     135             :   }
     136             :   EnumSetVal &flip(enum_type flipping)
     137             :   {
     138             :     bits.flip(to_bit(flipping));
     139             :     return *this;
     140             :   }
     141             :   EnumSetVal operator~() const
     142             :   {
     143             :     return EnumSetVal(*this).flip();
     144             :   }
     145             :   bool any() const
     146             :   {
     147             :     return bits.any();
     148             :   }
     149             :   bool none() const
     150             :   {
     151             :     return bits.none();
     152             :   }
     153             :   static std::vector<enum_type> enumEnumerators()
     154             :   {
     155             :     typename std::vector<enum_type> e;
     156             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     157             :     for(it=itb; it!=ite; ++it)e.push_back(it->first);
     158             :     return e;
     159             :   }
     160             :   static std::set<std::string> enumMemberSet()
     161             :   {
     162             :     std::set<std::string> s;
     163             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     164             :     for(it=itb; it!=ite; ++it)s.insert(it->second.str());
     165             :     return s;
     166             :   }
     167             :   static std::vector<std::string> enumMemberList(){
     168             :     std::vector<std::string> v;
     169             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     170             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.str());
     171             :     return v;
     172             :   }
     173             : 
     174             :   static std::vector<val_type> enumValues(){
     175             :     std::vector<val_type> v;
     176             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     177             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.val());
     178             :     return v;
     179             :   }
     180             : 
     181             :   static unsigned int enumNum(){
     182             :     return map_traits::m_.size();
     183             :   }
     184             : 
     185             :   static std::string doc(enum_type t){
     186             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     187             :     return itf->second.desc();
     188             :   }
     189             : 
     190             :   static val_type val(enum_type t){
     191             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     192             :     return itf->second.val();
     193             :   }
     194             : 
     195             :   /** Methods using bits and associated with enum_map */
     196             :   std::vector<int> id(){
     197             :     std::vector<int> v_id;
     198             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     199             :     for(it=itb; it!=ite; ++it)
     200             :       if(bits[it->first])v_id.push_back(it->second.id());
     201             :     return v_id;
     202             :   }
     203             : 
     204             :   std::string str(){
     205             :     return toString();
     206             :   }
     207             : 
     208             :   std::string toString(){
     209             :     std::ostringstream os;
     210             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     211             :     for(it=itb; it!=ite; ++it)
     212             :       if(bits[it->first])os<<it->second.str()<<" ";
     213             :     if(os.str().length())
     214             :       return os.str().substr(0,os.str().length()-1);
     215             :     else
     216             :       return os.str();
     217             :   }
     218             :   std::vector<enum_type> toEnumType(){
     219             :     std::vector<enum_type> v;
     220             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     221             :     for(it=itb; it!=ite; ++it)
     222             :       if(bits[it->first])v.push_back(it->first);
     223             :     return v;
     224             :   }
     225             :   // Method to define only when traits::maxset > 1
     226             :    EnumSetVal<enum_type,val_type>& fromString(std::vector<std::string> s){
     227             : //   EnumSetVal<enum_type,val_type>& fromString(std::vector<std::string> s, bool reset){
     228             : //     int id;
     229             : //     int nmax=s.size();
     230             : //     if(reset)bits.reset();
     231             : //     if(nmax>set_traits::maxset)nmax=set_traits::maxset;
     232             : //     int k=0;
     233             : //     for(int n=0; n<nmax; n++){
     234             : //       id = map_traits::fromStringToInt(s[n]);
     235             : //       if(id!=numeric_limits<int>::max())
     236             : //      bits.set(enum_type(id));
     237             : //     }
     238             : //     return *this;
     239             :     unsigned int nmax=s.size(); std::cout<<"nmax="<<nmax<<std::endl; 
     240             :     bits.reset();
     241             :     if(nmax>set_traits::maxset)
     242             :       std::cout<<"WARNING: the input number of enumerators, "<<nmax<<",exceeds the maximum number, "
     243             :                <<set_traits::maxset<<",  allowed for a compound with this EnumSet<"
     244             :                <<map_traits::typeName_<<"> type."<<std::endl;
     245             :     bool ok;
     246             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     247             :     unsigned int numSet=0;
     248             :     for(unsigned int n=0; n<nmax; n++){
     249             :       ok=false;
     250             :       for(it=itb;it!=ite;++it)
     251             :         if(s[n]==it->second.str()){ok=true; break;}
     252             :       if(ok){
     253             :         bits.set(it->first);
     254             :         numSet++;
     255             :       }else{
     256             :         std::cout<<"WARNING: "<<s[n]<<" is not a valid enumerator name for this enumeration "
     257             :                  <<map_traits::typeName_<<std::endl;
     258             :       }
     259             :       if(numSet==set_traits::maxset)break;
     260             :     }
     261             :     std::cout<<"numSet="<<numSet<<std::endl;
     262             :     return *this;
     263             :   }
     264             :   // Method useful when maxset>1.
     265             :   EnumSetVal<enum_type,val_type>& fromString(std::string s, bool reset){
     266             :     if(reset)bits.reset();
     267             :     int id = map_traits::fromStringToInt(s);
     268             :     if(id==std::numeric_limits<int>::max())
     269             :       bits.reset();
     270             :     else
     271             :       bits.set(enum_type(id));
     272             :     return *this;
     273             :   }
     274             :   // Method to define only when traits::maxset > 1
     275             :   EnumSetVal<enum_type,val_type>& fromString(std::string setting)
     276             :   {
     277             :     // TODO traiter le cas de 2 enumerators comme CORRECTED and UNCORRECTED  car ==> blancs avt ou apres 
     278             :     unsigned int nmax=set_traits::maxset;
     279             :     if(nmax<set_traits::count)bits.reset();
     280             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     281             :     for(it=itb;it!=ite;++it)
     282             :       if(setting.find(it->second.str())!=std::string::npos)bits.set(it->first);
     283             :     return *this;
     284             :   }
     285             :   // Method to get a vector of the names of the enumerators set on.
     286             :   std::vector<std::string> names()
     287             :   {
     288             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     289             :     std::vector<std::string> v_s;
     290             :     unsigned int numset=0; 
     291             :     for(it=itb;it!=ite;++it){
     292             :       if(bits.test(to_bit(it->first))){
     293             :         v_s.push_back(it->second.str());
     294             :         numset++; 
     295             :       }
     296             :       if(set_traits::maxset==numset)break;
     297             :       if(set_traits::last==it->first)break;
     298             :     }
     299             :     return v_s;
     300             :   }
     301             : 
     302             :   // Method to get the set of enumerators
     303             :   std::set<enum_type> enumSet()
     304             :   {
     305             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     306             :     std::set<enum_type> s_et;
     307             :     for(it=itb;it!=ite;++it)
     308             :       if(bits.test(to_bit(it->first)))s_et.insert(it->first);
     309             :     return s_et;
     310             :   }    
     311             :   // Method to get the set of enumerator values
     312             :   std::vector<val_type> enumVal()
     313             :   {
     314             :     std::vector<val_type> v_s;
     315             :     std::set<enum_type> s_et=enumSet();
     316             :     typename std::set<enum_type>::iterator its, itsb(s_et.begin()), itse(s_et.end());
     317             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf;
     318             :     for(its=itsb; its!=itse; ++its){
     319             :       itf=map_traits::m_.find(*its);
     320             :       v_s.push_back(itf->second.val());
     321             :     }
     322             :     return v_s;
     323             :   }    
     324             : 
     325             : 
     326             : protected:
     327             :   static std::size_t to_bit(enum_type value)
     328             :   {
     329             :     return (value - set_traits::first) / set_traits::step;
     330             :   }
     331             :   std::bitset<set_traits::count> bits;
     332             : };
     333             : 
     334             : 
     335             : template<typename enum_type,
     336             :          typename val_type=void, 
     337             :          typename set_traits=enum_set_traits<enum_type>,
     338             :          typename map_traits=enum_map_traits<enum_type,val_type> >
     339             : class EnumSet
     340             : {
     341             : public:
     342           0 :   EnumSet()
     343           0 :   {
     344           0 :     reset();
     345           0 :   }
     346             :   EnumSet(enum_type setting)
     347             :   {
     348             :     setOnly(setting);
     349             :   }
     350             :   EnumSet &operator&=(const EnumSet &rhs)
     351             :   {
     352             :     bits &= rhs.bits;
     353             :     return *this;
     354             :   }
     355             :   EnumSet &operator|=(const EnumSet &rhs)
     356             :   {
     357             :     bits |= rhs.bits;
     358             :     return *this;
     359             :   }
     360             :   bool less (const EnumSet &rhs){
     361             :     if(bits.to_ulong()<rhs.bits.to_ulong())return true;
     362             :     return false;
     363             :   }
     364             :   bool operator!= (const EnumSet &rhs){
     365             :     if(bits.to_ulong()==rhs.bits.to_ulong())return false;
     366             :     return true;
     367             :   }
     368             :   bool operator== (const EnumSet &rhs){
     369             :     if(bits.to_ulong()==rhs.bits.to_ulong())return true;
     370             :     return false;
     371             :   }
     372             :   EnumSet &operator^=(const EnumSet &rhs)
     373             :   {
     374             :     bits ^= rhs.bits;
     375             :     return *this;
     376             :   }
     377           0 :   std::size_t count() const
     378             :   {
     379           0 :     return bits.count();
     380             :   }
     381             :   std::size_t size() const
     382             :   {
     383             :     return bits.size();
     384             :   }
     385           0 :   bool operator[](enum_type testing) const
     386             :   {
     387           0 :     return bits.test(to_bit(testing));
     388             :   }
     389             :   bool only(enum_type testing) const
     390             :   {
     391             :     if(count()!=1)return false;
     392             :     return bits.test(to_bit(testing));
     393             :   }
     394             :   bool operator^(enum_type testing) const   // xor operator (^ Python bitwise operator) 
     395             :   {
     396             :     if(only(testing))return true;
     397             :     if(bits.test(to_bit(testing)))return false;
     398             :     return true;
     399             :   }
     400             : 
     401             :   EnumSet &set()
     402             :   {
     403             :     bits.set();
     404             :     return *this;
     405             :   }
     406             :   EnumSet &setOnly(enum_type setting)
     407             :   {
     408             :     bits.reset();
     409             :     bits.set(to_bit(setting), true);
     410             :     return *this;
     411             :   }
     412             : //   error: call of overloaded `set(StokesParameter)'
     413             : //   EnumSet &set(enum_type setting)
     414             : //   {
     415             : //     bits.set(to_bit(setting), true);
     416             : //     return *this;
     417             : //   }
     418           0 :   EnumSet &set(enum_type setting, bool value = true)
     419             :   {
     420             :     if(set_traits::maxset<set_traits::count)bits.reset();
     421           0 :     bits.set(to_bit(setting), value);
     422           0 :     return *this;
     423             :   }
     424           0 :   EnumSet &set(std::vector<enum_type> setting, bool value = true)
     425             :   {
     426             : //     if(set_traits::maxset<set_traits::count)bits.reset();
     427           0 :     bits.reset();
     428           0 :     unsigned int nmax=setting.size();
     429           0 :     if(nmax>set_traits::maxset)nmax=set_traits::maxset;
     430           0 :     for(unsigned int n=0; n<nmax; n++)
     431           0 :       bits.set(to_bit(setting[n]), value);
     432           0 :     return *this;
     433             :   }
     434             : 
     435             :   EnumSet &set(std::vector<std::string> names, bool /* value = true */)
     436             :   {
     437             :     // value is not used here, commented out above to silence a compiler warning
     438             :     bits.reset();
     439             :     typename std::map<enum_type,EnumPar<val_type> >::iterator 
     440             :       it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     441             :     std::vector<std::string>::iterator iv, ivb=names.begin(), ive=names.end();
     442             :     for(iv=ivb; iv!=ive; ++iv)
     443             :       for(it=itb; it!=ite; ++it)if(it->second.str()==*iv)
     444             :         bits.set(to_bit(it->first));
     445             :     return *this;
     446             :   }
     447             : 
     448           0 :   EnumSet &reset()
     449             :   {
     450           0 :     bits.reset();
     451           0 :     return *this;
     452             :   }
     453             :   EnumSet &reset(enum_type resetting)
     454             :   {
     455             :     bits.reset(to_bit(resetting));
     456             :     return *this;
     457             :   }
     458           0 :   EnumSet &flip()
     459             :   {
     460           0 :     bits.flip();
     461           0 :     return *this;
     462             :   }
     463             :   EnumSet &flip(enum_type flipping)
     464             :   {
     465             :     bits.flip(to_bit(flipping));
     466             :     return *this;
     467             :   }
     468             :   EnumSet operator~() const
     469             :   {
     470             :     return EnumSet(*this).flip();
     471             :   }
     472             :   bool any() const
     473             :   {
     474             :     return bits.any();
     475             :   }
     476             :   bool none() const
     477             :   {
     478             :     return bits.none();
     479             :   }
     480             :   static void enumEnumerators(std::vector<enum_type>& v)
     481             :   {
     482             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     483             :     for(it=itb; it!=ite; ++it)v.push_back(it->first);
     484             :     return;
     485             :   }
     486             :   static std::set<std::string> enumMemberSet()
     487             :   {
     488             :     std::set<std::string> s;
     489             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     490             :     for(it=itb; it!=ite; ++it)s.insert(it->second.str());
     491             :     return s;
     492             :   }
     493             :   static std::vector<std::string> enumMemberList(){
     494             :     std::vector<std::string> v;
     495             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     496             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.str());
     497             :     return v;
     498             :   }
     499             :   static std::string doc(enum_type t){
     500             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     501             :     return itf->second.desc();
     502             :   }
     503             : 
     504             : //   static std::string val(enum_type t){
     505             : //     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     506             : //     return itf->second.val();
     507             : //   }
     508             : 
     509             :   /** Methods using bits and associated with enum_map */
     510             :   std::vector<int> id(){
     511             :     std::vector<int> v_id;
     512             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     513             :     for(it=itb; it!=ite; ++it)
     514             :       if(bits[it->first])v_id.push_back(it->second.id());
     515             :     return v_id;
     516             :   }
     517           0 :   std::string str(){
     518           0 :     return toString();
     519             :   }
     520           0 :   std::string toString(){
     521           0 :     std::ostringstream os;
     522           0 :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     523           0 :     for(it=itb; it!=ite; ++it)
     524           0 :       if(bits[it->first])os<<it->second.str()<<" ";
     525           0 :     if(os.str().length())
     526           0 :       return os.str().substr(0,os.str().length()-1);
     527             :     else
     528           0 :       return os.str();
     529           0 :   }
     530           0 :   std::vector<enum_type> toEnumType(){
     531           0 :     std::vector<enum_type> v;
     532           0 :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     533           0 :     for(it=itb; it!=ite; ++it)
     534           0 :       if(bits[it->first])v.push_back(it->first);
     535           0 :     return v;
     536           0 :   }
     537             :   // Method to define only when traits::maxset > 1
     538             :   EnumSet<enum_type,val_type>& fromString(std::vector<std::string> s){
     539             : //   EnumSet<enum_type,val_type>& fromString(std::vector<std::string> s, bool reset){
     540             : //     int id;
     541             : //     int nmax=s.size();
     542             : //     if(reset)bits.reset();
     543             : //     if(nmax>set_traits::maxset)nmax=set_traits::maxset;
     544             : //     int k=0;
     545             : //     for(int n=0; n<nmax; n++){
     546             : //       id = map_traits::fromStringToInt(s[n]);
     547             : //       if(id!=numeric_limits<int>::max())
     548             : //      bits.set(enum_type(id));
     549             : //     }
     550             : //     return *this;
     551             :     unsigned int nmax=s.size(); std::cout<<"nmax="<<nmax<<std::endl; 
     552             :     bits.reset();
     553             :     if(nmax>set_traits::maxset)
     554             :       std::cout<<"WARNING: the input number of enumerators, "<<nmax<<",exceeds the maximum number, "
     555             :                <<set_traits::maxset<<",  allowed for a compound with this EnumSet<"
     556             :                <<map_traits::typeName_<<"> type."<<std::endl;
     557             :     bool ok;
     558             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     559             :     int numSet=0;
     560             :     for(int n=0; n<nmax; n++){
     561             :       ok=false;
     562             :       for(it=itb;it!=ite;++it)
     563             :         if(s[n]==it->second.str()){ok=true; break;}
     564             :       if(ok){
     565             :         bits.set(it->first);
     566             :         numSet++;
     567             :       }else{
     568             :         std::cout<<"WARNING: "<<s[n]<<" is not a valid enumerator name for this enumeration "
     569             :                  <<map_traits::typeName_<<std::endl;
     570             :       }
     571             :       if(numSet==set_traits::maxset)break;
     572             :     }
     573             :     std::cout<<"numSet="<<numSet<<std::endl;
     574             :     return *this;
     575             :   }
     576             :   // Method useful when maxset>1.
     577             :   EnumSet<enum_type,val_type>& fromString(std::string s, bool reset){
     578             :     if(reset)bits.reset();
     579             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     580             :     for(it=itb;it!=ite;++it)
     581             :       if(s.find(it->second.str())!=std::string::npos)bits.set(it->first);
     582             :     return *this;
     583             :   }
     584             :   // Method to define only when traits::maxset > 1
     585           0 :   EnumSet <enum_type,val_type>& fromString(std::string setting)
     586             :   {
     587             :     // TODO traiter le cas de 2 enumerators comme CORRECTED and UNCORRECTED  car ==> blancs avt ou apres 
     588           0 :     unsigned int nmax=set_traits::maxset;
     589           0 :     if(nmax<set_traits::count)bits.reset();
     590           0 :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     591           0 :     for(it=itb;it!=ite;++it)
     592           0 :       if(setting.find(it->second.str())!=std::string::npos)bits.set(it->first);
     593           0 :     return *this;
     594             :   }
     595             :   // Method to get a vector of the names of the enumerators set on.
     596             :   std::vector<std::string> names()
     597             :   {
     598             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     599             :     std::vector<std::string> v_s;
     600             :     unsigned int numset=0;
     601             :     for(it=itb;it!=ite;++it){
     602             :       if(bits.test(to_bit(it->first))){
     603             :         v_s.push_back(it->second.str());
     604             :         numset++; 
     605             :       }
     606             :       if(set_traits::maxset==numset)break;
     607             :       if(set_traits::last==it->first)break;
     608             :     }
     609             :     return v_s;  
     610             :   }
     611             :   // Method to get the set of enumerators
     612             :   std::set<enum_type> enumSet()
     613             :   {
     614             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     615             :     std::set<enum_type> s_et;
     616             :     for(it=itb;it!=ite;++it)
     617             :       if(bits.test(to_bit(it->first)))s_et.insert(it->first);
     618             :     return s_et;
     619             :   }    
     620             : //   // Method to get the set of enumerator values
     621             : //   std::vector<std::string> enumVal()
     622             : //   {
     623             : //     std::vector<std::string> v_s;
     624             : //     std::set<enum_type> s_et=enumSet();
     625             : //     typename std::set<enum_type>::iterator its, itsb(s_et.begin()), itse(s_et.end());
     626             : //     typename std::map<enum_type,EnumPar<val_type> >::iterator itf;
     627             : //     for(its=itsb; its!=itse; ++its){
     628             : //       itf=map_traits::m_.find(*its);
     629             : //       v_s.push_back(itf->second.val());
     630             : //     }
     631             : //     return v_s;
     632             : //   }    
     633             : 
     634             : 
     635             : protected:
     636           0 :   static std::size_t to_bit(enum_type value)
     637             :   {
     638           0 :     return (value - set_traits::first) / set_traits::step;
     639             :   }
     640             :   std::bitset<set_traits::count> bits;
     641             : };
     642             : 
     643             : 
     644             : 
     645             : template< typename enum_type, 
     646             :           typename val_type,
     647             :           typename set_traits=enum_set_traits<enum_type>,
     648             :           typename map_traits=enum_map_traits<enum_type,val_type> >
     649             : class EnumVal
     650             : {
     651             : public:
     652             :   EnumVal()
     653             :   {
     654             :   }
     655             :   EnumVal(enum_type setting)
     656             :   {
     657             :     set(setting);
     658             :   }
     659             :   EnumVal &operator&=(const EnumVal &rhs)
     660             :   {
     661             :     bits &= rhs.bits;
     662             :     return *this;
     663             :   }
     664             :   EnumVal &operator|=(const EnumVal &rhs)
     665             :   {
     666             :     bits |= rhs.bits;
     667             :     return *this;
     668             :   }
     669             :   bool less (const EnumVal &rhs){
     670             :     if(bits.to_ulong()<rhs.bits.to_ulong())return true;
     671             :     return false;
     672             :   }
     673             :   bool operator!= (const EnumVal &rhs){
     674             :     if(bits.to_ulong()==rhs.bits.to_ulong())return false;
     675             :     return true;
     676             :   }
     677             :   bool operator== (const EnumVal &rhs){
     678             :     if(bits.to_ulong()==rhs.bits.to_ulong())return true;
     679             :     return false;
     680             :   }
     681             :   EnumVal &operator^=(const EnumVal &rhs)
     682             :   {
     683             :     bits ^= rhs.bits;
     684             :     return *this;
     685             :   }
     686             :   std::size_t count() const
     687             :   {
     688             :     return bits.count();
     689             :   }
     690             :   std::size_t size() const
     691             :   {
     692             :     return bits.size();
     693             :   }
     694             :   bool operator[](enum_type testing) const
     695             :   {
     696             :     return bits.test(to_bit(testing));
     697             :   }
     698             :   bool only(enum_type testing) const
     699             :   {
     700             :     if(count()!=1)return false;
     701             :     return bits.test(to_bit(testing));
     702             :   }
     703             :   bool operator^(enum_type testing) const   // xor operator (^ Python bitwise operator) 
     704             :   {
     705             :     if(only(testing))return true;
     706             :     if(bits.test(to_bit(testing)))return false;
     707             :     return true;
     708             :   }
     709             : 
     710             :   EnumVal &set()
     711             :   {
     712             :     bits.set();
     713             :     return *this;
     714             :   }
     715             :   /** Store a boolean value as the new value for bit at position setting.
     716             :    * @pre if the number if bits set is smaller than the maximum
     717             :    *      allowed number of bit set then the bitset is first reset
     718             :    * @param setting the position in the bitset where "value" must be stored
     719             :    * @param value the boolean value to store
     720             :    * @post all positions are unset (i.e. false), except the position "setting"
     721             :    *       would value=true
     722             :    */
     723             :   EnumVal &set(enum_type setting, bool value = true)
     724             :   {
     725             :     if(set_traits::maxset<set_traits::count)bits.reset();
     726             :     bits.set(to_bit(setting), value);
     727             :     return *this;
     728             :   }
     729             :   /** Store "true" at a set of positions.
     730             :    * @param setting vector of positions in the bitset (Order positions 
     731             :    *        are counted from the rightmost bit, which is order position 0.
     732             :    * @post the value "true" stored at these positions in the bitset.
     733             :    */
     734             :   EnumVal &set(std::vector<enum_type> setting)
     735             :   {
     736             :     bits.reset();
     737             :     unsigned int nmax=setting.size();
     738             :     if(nmax>set_traits::maxset)nmax=set_traits::maxset;
     739             :     for(int n=1; n<nmax; n++)
     740             :       bits.set(to_bit(setting[n]),true);
     741             :     return *this;
     742             :   }
     743             : 
     744             :   EnumVal &reset()
     745             :   {
     746             :     bits.reset();
     747             :     return *this;
     748             :   }
     749             :   EnumVal &reset(enum_type resetting)
     750             :   {
     751             :     bits.reset(to_bit(resetting));
     752             :     return *this;
     753             :   }
     754             :   EnumVal &flip()
     755             :   {
     756             :     bits.flip();
     757             :     return *this;
     758             :   }
     759             :   EnumVal &flip(enum_type flipping)
     760             :   {
     761             :     bits.flip(to_bit(flipping));
     762             :     return *this;
     763             :   }
     764             :   EnumVal operator~() const
     765             :   {
     766             :     return EnumVal(*this).flip();
     767             :   }
     768             :   bool any() const
     769             :   {
     770             :     return bits.any();
     771             :   }
     772             :   bool none() const
     773             :   {
     774             :     return bits.none();
     775             :   }
     776             :   static std::set<std::string> enumMemberSet()
     777             :   {
     778             :     std::set<std::string> s;
     779             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     780             :     for(it=itb; it!=ite; ++it)s.insert(it->second.str());
     781             :     return s;
     782             :   }
     783             :   static std::vector<std::string> enumMemberList(){
     784             :     std::vector<std::string> v;
     785             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     786             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.str());
     787             :     return v;
     788             :   }
     789             : 
     790             :   static std::vector<val_type> enumValues(){
     791             :     std::vector<val_type> v;
     792             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     793             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.val());
     794             :     return v;
     795             :   }
     796             : 
     797             :   static unsigned int enumNum(){
     798             :     return map_traits::m_.size();
     799             :   }
     800             : 
     801             :   static std::string doc(enum_type t){
     802             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     803             :     return itf->second.desc();
     804             :   }
     805             : 
     806             :   static val_type val(enum_type t){
     807             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
     808             :     return itf->second.val();
     809             :   }
     810             : 
     811             :   // Method to get the name of the enumerator set on, if set, else return empty string
     812             :   std::string name()
     813             :   {
     814             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     815             :     std::string s="";
     816             :     for(it=itb;it!=ite;++it){
     817             :       if(bits.test(to_bit(it->first)))
     818             :         return it->second.str();
     819             :       if(set_traits::last==it->first)break;
     820             :     }
     821             :     return s;
     822             :   }
     823             :   /** Methods using bits and associated with enum_map */
     824             :   int id(){
     825             :     int id;
     826             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     827             :     for(it=itb; it!=ite; ++it)
     828             :       if(bits[it->first])id=it->second.id();
     829             :     return id;
     830             :   }
     831             :   std::string str(){
     832             :     return toString();
     833             :   }
     834             :   std::string toString(){
     835             :     std::ostringstream os;
     836             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     837             :     for(it=itb; it!=ite; ++it)
     838             :       if(bits[it->first])os<<it->second.str();
     839             :     return os.str();
     840             :   }
     841             :   enum_type toEnumType(){
     842             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     843             :     for(it=itb; it!=ite; ++it)
     844             :       if(bits[it->first])return it->first;
     845             :     std::cout<<"ERROR: state with no enumerator set"<<std::endl;
     846             :   }
     847             : 
     848             :   EnumVal<enum_type,val_type>& fromString(std::string setting)
     849             :   {
     850             :     bits.reset();
     851             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     852             :     for(it=itb;it!=ite;++it)
     853             :       if(setting.find(it->second.str())!=std::string::npos)bits.set(it->first);
     854             :     return *this;
     855             :   }
     856             :   // Method to get the enumerator value for the bit currently set
     857             :   std::vector<val_type> enumVal()
     858             :   {
     859             :     std::vector<val_type> v;
     860             :     typename std::map<enum_type,EnumPar<val_type> >::iterator 
     861             :       it, 
     862             :       itb=map_traits::m_.begin(), 
     863             :       ite=map_traits::m_.end();
     864             :     for(it=itb; it!=ite; ++it)
     865             :       if(bits.test(it->first))v.push_back(it->second.val());
     866             :     return v;
     867             :   }    
     868             : 
     869             : 
     870             : protected:
     871             :   static std::size_t to_bit(enum_type value)
     872             :   {
     873             :     return (value - set_traits::first) / set_traits::step;
     874             :   }
     875             :   std::bitset<set_traits::count> bits;
     876             : };
     877             : 
     878             : 
     879             : template<typename enum_type,
     880             :          typename val_type=void, 
     881             :          typename set_traits=enum_set_traits<enum_type>,
     882             :          typename map_traits=enum_map_traits<enum_type,val_type> >
     883             : class Enum
     884             : {
     885             : public:
     886           0 :   Enum()
     887           0 :   {
     888           0 :   }
     889           0 :   Enum(const enum_type setting)
     890           0 :   {
     891           0 :     set(setting);
     892           0 :   }
     893             :   Enum &operator&=(const Enum &rhs)
     894             :   {
     895             :     bits &= rhs.bits;
     896             :     return *this;
     897             :   }
     898             :   Enum &operator|=(const Enum &rhs)
     899             :   {
     900             :     bits |= rhs.bits;
     901             :     return *this;
     902             :   }
     903             :   bool less (const Enum &rhs){
     904             :     if(bits.to_ulong()<rhs.bits.to_ulong())return true;
     905             :     return false;
     906             :   }
     907             :   bool operator!= (const Enum &rhs){
     908             :     if(bits.to_ulong()==rhs.bits.to_ulong())return false;
     909             :     return true;
     910             :   }
     911             :   bool operator== (const Enum &rhs){
     912             :     if(bits.to_ulong()==rhs.bits.to_ulong())return true;
     913             :     return false;
     914             :   }
     915             :   Enum &operator^=(const Enum &rhs)
     916             :   {
     917             :     bits ^= rhs.bits;
     918             :     return *this;
     919             :   }
     920           0 :   std::size_t count() const
     921             :   {
     922           0 :     return bits.count();
     923             :   }
     924             :   std::size_t size() const
     925             :   {
     926             :     return bits.size();
     927             :   }
     928           0 :   bool operator[](enum_type testing) const
     929             :   {
     930           0 :     return bits.test(to_bit(testing));
     931             :   }
     932             :   bool only(enum_type testing) const
     933             :   {
     934             :     if(count()!=1)return false;
     935             :     return bits.test(to_bit(testing));
     936             :   }
     937             :   bool operator^(enum_type testing) const   // xor operator (^ Python bitwise operator) 
     938             :   {
     939             :     if(only(testing))return true;
     940             :     if(bits.test(to_bit(testing)))return false;
     941             :     return true;
     942             :   }
     943             : 
     944             :   Enum &set()
     945             :   {
     946             :     bits.set();
     947             :     return *this;
     948             :   }
     949           0 :   Enum &set(enum_type setting)
     950             :   {
     951           0 :     bits.reset();
     952           0 :     bits.set(to_bit(setting), true);
     953           0 :     return *this;
     954             :   }
     955             :   Enum &reset()
     956             :   {
     957             :     bits.reset();
     958             :     return *this;
     959             :   }
     960             :   Enum &reset(enum_type resetting)
     961             :   {
     962             :     bits.reset(to_bit(resetting));
     963             :     return *this;
     964             :   }
     965             :   Enum &flip()
     966             :   {
     967             :     bits.flip();
     968             :     return *this;
     969             :   }
     970             :   Enum &flip(enum_type flipping)
     971             :   {
     972             :     bits.flip(to_bit(flipping));
     973             :     return *this;
     974             :   }
     975             :   Enum operator~() const
     976             :   {
     977             :     return Enum(*this).flip();
     978             :   }
     979             :   bool any() const
     980             :   {
     981             :     return bits.any();
     982             :   }
     983             :   bool none() const
     984             :   {
     985             :     return bits.none();
     986             :   }
     987             :   static std::set<std::string> enumMemberSet()
     988             :   {
     989             :     std::set<std::string> s;
     990             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     991             :     for(it=itb; it!=ite; ++it)s.insert(it->second.str());
     992             :     return s;
     993             :   }
     994             :   static std::vector<std::string> enumMemberList(){
     995             :     std::vector<std::string> v;
     996             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
     997             :     for(it=itb; it!=ite; ++it)v.push_back(it->second.str());
     998             :     return v;
     999             :   }
    1000             :   static std::string doc(enum_type t){
    1001             :     typename std::map<enum_type,EnumPar<val_type> >::iterator itf(map_traits::m_.find(t));
    1002             :     return itf->second.desc();
    1003             :   }
    1004             : 
    1005             :   // Method to get the name of the enumerator set on, if set, else return empty string
    1006             :   std::string name()
    1007             :   {
    1008             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
    1009             :     std::string s="";
    1010             :     for(it=itb;it!=ite;++it){
    1011             :       if(bits.test(to_bit(it->first)))
    1012             :         return it->second.str();
    1013             :       if(set_traits::last==it->first)break;
    1014             :     }
    1015             :     return s;
    1016             :   }
    1017             : 
    1018             :   unsigned int hash() {
    1019             :     std::string s = str();
    1020             :     unsigned int hash = 0;
    1021             :     for(size_t i = 0; i < s.size(); ++i) 
    1022             :       hash = 65599 * hash + s[i];
    1023             :     return hash ^ (hash >> 16);
    1024             :   }
    1025             : 
    1026             :   /** Methods using bits and associated with enum_map */
    1027             :   int id(){
    1028             :     int id;
    1029             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
    1030             :     for(it=itb; it!=ite; ++it)
    1031             :       if(bits[it->first])id=it->second.id();
    1032             :     return id;
    1033             :   }
    1034           0 :   std::string str(){
    1035           0 :     return toString();
    1036             :   }
    1037           0 :   std::string toString(){
    1038           0 :     std::ostringstream os;
    1039           0 :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
    1040           0 :     for(it=itb; it!=ite; ++it)
    1041           0 :       if(bits[it->first])os<<it->second.str();
    1042           0 :     return os.str();
    1043           0 :   }
    1044             :   enum_type toEnumType() const{
    1045             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
    1046             :     for(it=itb; it!=ite; ++it)
    1047             :       if(bits[it->first])return it->first;
    1048             :     std::cout<<"ERROR: state with no enumerator set"<<std::endl;
    1049             :   }
    1050             :   // Method useful when maxset>1.
    1051             :   Enum<enum_type,val_type>& fromString(std::string s){
    1052             :     bits.reset();
    1053             :     typename std::map<enum_type,EnumPar<val_type> >::iterator it, itb(map_traits::m_.begin()), ite(map_traits::m_.end());
    1054             :     for(it=itb;it!=ite;++it)
    1055             :       if(s.find(it->second.str())!=std::string::npos)bits.set(it->first);
    1056             :     return *this;
    1057             :   }
    1058             : 
    1059             : 
    1060             : protected:
    1061           0 :   static std::size_t to_bit(enum_type value)
    1062             :   {
    1063           0 :     return (value - set_traits::first) / set_traits::step;
    1064             :   }
    1065             :   std::bitset<set_traits::count> bits;
    1066             : };
    1067             : 
    1068             : 
    1069             : 
    1070             : #define _ENUM_H
    1071             : #endif