Use PBD::copy_file in Session::create() to copy the template file.

[ardour.git] / libs / ardour / ardour / data_type.h

diff --git a/libs/ardour/ardour/data_type.h b/libs/ardour/ardour/data_type.h
index d49ed108cd22810799ad3a025ab2be55eba96c13..3818a8d74fc26527211621fe568caf3ecbdbd139 100644 (file)
--- a/libs/ardour/ardour/data_type.h
+++ b/libs/ardour/ardour/data_type.h
@@ -19,54 +19,103 @@
 #ifndef __ardour_data_type_h__
 #define __ardour_data_type_h__
 
+#include <string>
+#include <ardour/data_type.h>
 #include <jack/jack.h>
 
 namespace ARDOUR {
 
+
+/** A type of Data Ardour is capable of processing.
+ *
+ * The majority of this class is dedicated to conversion to and from various
+ * other type representations, simple comparison between then, etc.  This code
+ * is deliberately 'ugly' so other code doesn't have to be.
+ */
 class DataType
 {
 public:
+       /// WARNING: make REALLY sure you don't mess up indexes if you change this
        enum Symbol {
                NIL = 0,
                AUDIO,
                MIDI
        };
+       
+       /** Number of types (not including NIL).
+        * WARNING: make sure this matches Symbol!
+        */
+       static const size_t num_types = 2;
 
        DataType(const Symbol& symbol)
        : _symbol(symbol)
        {}
 
-       /** Construct from a string (Used for loading from XML) */
-       DataType(const string& str) {
+       /** Construct from a string (Used for loading from XML and Ports)
+        * The string can be as in an XML file (eg "audio" or "midi"), or a
+        * Jack type string (from jack_port_type) */
+       DataType(const std::string& str) {
                if (str == "audio")
                        _symbol = AUDIO;
-               //else if (str == "midi")
-               //      _symbol = MIDI;
+               else if (str == JACK_DEFAULT_AUDIO_TYPE)
+                       _symbol = AUDIO;
+               else if (str == "midi")
+                       _symbol = MIDI;
+               else if (str == JACK_DEFAULT_MIDI_TYPE)
+                       _symbol = MIDI;
                else
                        _symbol = NIL;
        }
 
-       bool operator==(const Symbol symbol) { return _symbol == symbol; }
-       bool operator!=(const Symbol symbol) { return _symbol != symbol; }
-
        /** Get the Jack type this DataType corresponds to */
-       const char* to_jack_type() {
+       const char* to_jack_type() const {
                switch (_symbol) {
                        case AUDIO: return JACK_DEFAULT_AUDIO_TYPE;
-                       //case MIDI:  return JACK_DEFAULT_MIDI_TYPE;
+                       case MIDI:  return JACK_DEFAULT_MIDI_TYPE;
                        default:    return "";
                }
        }
        
        /** Inverse of the from-string constructor */
-       const char* to_string() {
+       const char* to_string() const {
                switch (_symbol) {
                        case AUDIO: return "audio";
-                       //case MIDI:  return "midi";
+                       case MIDI:  return "midi";
                        default:    return "unknown"; // reeeally shouldn't ever happen
                }
        }
 
+       //Symbol        to_symbol() const { return _symbol; }
+       inline size_t to_index() const { return (size_t)_symbol - 1; }
+
+       /** DataType iterator, for writing generic loops that iterate over all
+        * available types.
+        */
+       class iterator {
+       public:
+
+               iterator(size_t index) : _index(index) {}
+
+               DataType  operator*()  { return DataType((Symbol)_index); }
+               iterator& operator++() { ++_index; return *this; } // yes, prefix only
+               bool operator==(const iterator& other) { return (_index == other._index); }
+               bool operator!=(const iterator& other) { return (_index != other._index); }
+
+       private:
+               friend class DataType;
+
+               size_t _index;
+       };
+
+       static iterator begin() { return iterator(1); }
+       static iterator end()   { return iterator(num_types+1); }
+       
+       bool operator==(const Symbol symbol) { return (_symbol == symbol); }
+       bool operator!=(const Symbol symbol) { return (_symbol != symbol); }
+       
+       bool operator==(const DataType other) { return (_symbol == other._symbol); }
+       bool operator!=(const DataType other) { return (_symbol != other._symbol); }
+
 private:
        Symbol _symbol;
 };