set up control_by_parameter map in a Mackie::Strip so that subsequent array-syntax...

[ardour.git] / libs / pbd / enumwriter.cc

diff --git a/libs/pbd/enumwriter.cc b/libs/pbd/enumwriter.cc
index 3ce296c664ccc695b0a774c65d82bc408079228d..ddc82151945e74fc84ebe0e75e123ef302a44df1 100644 (file)
--- a/libs/pbd/enumwriter.cc
+++ b/libs/pbd/enumwriter.cc
@@ -1,4 +1,4 @@
-/* 
+/*
     Copyright (C) 2006 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
@@ -19,6 +19,7 @@
 */
 
 #include <cctype>
+#include <algorithm>
 
 #include <cstring>
 #include <cstdlib>
@@ -35,16 +36,16 @@ using namespace PBD;
 EnumWriter* EnumWriter::_instance = 0;
 map<string,string> EnumWriter::hack_table;
 
-static int 
-nocase_cmp(const string & s1, const string& s2) 
+static int
+nocase_cmp(const string & s1, const string& s2)
 {
        string::const_iterator it1 = s1.begin();
        string::const_iterator it2 = s2.begin();
-       
-       while ((it1 != s1.end()) && (it2 != s2.end())) { 
+
+       while ((it1 != s1.end()) && (it2 != s2.end())) {
                if(::toupper(*it1) != ::toupper(*it2))  {//letters differ?
                        // return -1 to indicate 'smaller than', 1 otherwise
-                       return (::toupper(*it1) < ::toupper(*it2)) ? -1 : 1; 
+                       return (::toupper(*it1) < ::toupper(*it2)) ? -1 : 1;
                }
 
                ++it1;
@@ -64,11 +65,11 @@ nocase_cmp(const string & s1, const string& s2)
 }
 
 EnumWriter&
-EnumWriter::instance() 
+EnumWriter::instance()
 {
        if (_instance == 0) {
                _instance = new EnumWriter;
-       } 
+       }
 
        return *_instance;
 }
@@ -96,7 +97,7 @@ EnumWriter::register_distinct (string type, vector<int> v, vector<string> s)
 
        newpair.first = type;
        newpair.second = EnumRegistration (v, s, false);
-       
+
        result = registry.insert (newpair);
 
        if (!result.second) {
@@ -112,7 +113,7 @@ EnumWriter::register_bits (string type, vector<int> v, vector<string> s)
 
        newpair.first = type;
        newpair.second = EnumRegistration (v, s, true);
-       
+
        result = registry.insert (newpair);
 
        if (!result.second) {
@@ -127,7 +128,7 @@ EnumWriter::write (string type, int value)
 
        if (x == registry.end()) {
                error << string_compose (_("EnumWriter: unknown enumeration type \"%1\""), type) << endmsg;
-               throw unknown_enumeration();
+               throw unknown_enumeration (type);
        }
 
        if (x->second.bitwise) {
@@ -144,7 +145,7 @@ EnumWriter::read (string type, string value)
 
        if (x == registry.end()) {
                error << string_compose (_("EnumWriter: unknown enumeration type \"%1\""), type) << endmsg;
-               throw unknown_enumeration();
+               throw unknown_enumeration (type);
        }
 
        if (x->second.bitwise) {
@@ -152,7 +153,7 @@ EnumWriter::read (string type, string value)
        } else {
                return read_distinct (x->second, value);
        }
-}      
+}
 
 string
 EnumWriter::write_bits (EnumRegistration& er, int value)
@@ -165,7 +166,7 @@ EnumWriter::write_bits (EnumRegistration& er, int value)
                if (value & (*i)) {
                        if (!result.empty()) {
                                result += ',';
-                       } 
+                       }
                        result += (*s);
                }
        }
@@ -189,7 +190,7 @@ EnumWriter::write_distinct (EnumRegistration& er, int value)
 }
 
 int
-EnumWriter::validate (EnumRegistration& er, int val)
+EnumWriter::validate (EnumRegistration& er, int val) const
 {
         if (er.values.empty()) {
                 return val;
@@ -203,26 +204,41 @@ EnumWriter::validate (EnumRegistration& er, int val)
 
         vector<int>::iterator i;
         string enum_name = _("unknown enumeration");
-        
-        for (Registry::iterator x = registry.begin(); x != registry.end(); ++x) {
+
+        for (Registry::const_iterator x = registry.begin(); x != registry.end(); ++x) {
                 if (&er == &(*x).second) {
                         enum_name = (*x).first;
                 }
         }
-        
+
 
         for (i = er.values.begin(); i != er.values.end(); ++i) {
                 if (*i == val) {
                         return val;
                 }
         }
-        
+
         warning << string_compose (_("Illegal value loaded for %1 (%2) - %3 used instead"),
-                                   enum_name, val, er.names.front()) 
+                                   enum_name, val, er.names.front())
                 << endmsg;
         return er.values.front();
 }
 
+int
+EnumWriter::validate_bitwise (EnumRegistration& er, int val) const
+{
+       int result = 0;
+       for (int p = 1; p <= val; p = p << 1) {
+               if (std::find (er.values.begin(), er.values.end(), p) == er.values.end()) {
+                       continue;
+               }
+               if (p & val) {
+                       result |= p;
+               }
+       }
+       return result;
+}
+
 int
 EnumWriter::read_bits (EnumRegistration& er, string str)
 {
@@ -236,18 +252,18 @@ EnumWriter::read_bits (EnumRegistration& er, string str)
 
        if (str.length() > 2 && str[0] == '0' && str[1] == 'x') {
                int val = strtol (str.c_str(), (char **) 0, 16);
-                return validate (er, val);
+                return validate_bitwise (er, val);
        }
 
        /* catch old style dec numerics */
 
        if (strspn (str.c_str(), "0123456789") == str.length()) {
                int val = strtol (str.c_str(), (char **) 0, 10);
-                return validate (er, val);
+                return validate_bitwise (er, val);
         }
 
        do {
-               
+
                comma = str.find_first_of (',');
                string segment = str.substr (0, comma);
 
@@ -267,7 +283,7 @@ EnumWriter::read_bits (EnumRegistration& er, string str)
        } while (true);
 
        if (!found) {
-               throw unknown_enumeration();
+               throw unknown_enumeration (str);
        }
 
        return result;
@@ -279,6 +295,23 @@ EnumWriter::read_distinct (EnumRegistration& er, string str)
        vector<int>::iterator i;
        vector<string>::iterator s;
 
+       /* first, check to see if there a hack for the name we're looking up */
+
+       map<string,string>::iterator x;
+
+       if ((x  = hack_table.find (str)) != hack_table.end()) {
+
+               cerr << "found hack for " << str << " = " << x->second << endl;
+
+               str = x->second;
+
+               for (i = er.values.begin(), s = er.names.begin(); i != er.values.end(); ++i, ++s) {
+                       if (str == (*s) || nocase_cmp (str, *s) == 0) {
+                               return (*i);
+                       }
+               }
+       }
+
        /* catch old-style hex numerics */
 
        if (str.length() > 2 && str[0] == '0' && str[1] == 'x') {
@@ -299,24 +332,7 @@ EnumWriter::read_distinct (EnumRegistration& er, string str)
                }
        }
 
-       /* failed to find it as-is. check to see if there a hack for the name we're looking up */
-
-       map<string,string>::iterator x;
-
-       if ((x  = hack_table.find (str)) != hack_table.end()) {
-
-               cerr << "found hack for " << str << " = " << x->second << endl;
-
-               str = x->second;
-
-               for (i = er.values.begin(), s = er.names.begin(); i != er.values.end(); ++i, ++s) {
-                       if (str == (*s) || nocase_cmp (str, *s) == 0) {
-                               return (*i);
-                       }
-               }
-       }
-
-       throw unknown_enumeration();
+       throw unknown_enumeration(str);
 }
 
 void