export_multiplication.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2015 Paul Davis <paul@linuxaudiosystems.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
/* This file is not used at the moment. It includes code related to export a
 * multiplication graph system that can be used together with the ExportMultiplicator
 * class in the gtk2_ardour folder.
 * - Sakari Bergen 6.8.2008 -
 */
 
/*** Graph classes ***/
  public:
 
        class GraphNode {
          public:
                GraphNode ();
                virtual ~GraphNode ();
 
                uint32_t id() const { return _id; }
 
                /* Children and parents. Note: only children are kept in order! */
 
                list<GraphNode *> const & get_parents () const { return parents; }
 
                void add_child (GraphNode * child, GraphNode * left_sibling);
                void remove_child (GraphNode * child);
                GraphNode * first_child () const { return children.front(); }
                GraphNode * last_child () const { return children.back(); }
                list<GraphNode *> const & get_children () const { return children; }
 
                /* Relation functions */
 
                bool is_ancestor_of (GraphNode const * node) const;
                bool is_descendant_of (GraphNode const * node) const;
                bool equals (GraphNode const * node) const { return node == this; }
 
                /* Selection functions */
 
                bool selected () const { return _selected; }
                void select (bool value);
 
                PBD::Signal1<void,bool> SelectChanged;
 
          protected:
 
                /* Parent manipulation functions should be used only from child manipulation functions! */
 
                void add_parent (GraphNode * parent);
                void remove_parent (GraphNode * parent);
 
                list<GraphNode *> parents;
                list<GraphNode *> children;
 
                bool           _selected;
                uint32_t       _id;
                static uint32_t id_counter;
        };
 
        template <typename T>
        class DataNode : public GraphNode {
          private:
                typedef std::shared_ptr<T> DataPtr;
                typedef std::shared_ptr<DataNode<T> > SelfPtr;
                typedef std::weak_ptr<DataNode<T> > WeakSelfPtr;
 
                DataNode (DataPtr data) : _data (data) {}
                void set_self_ptr (std::shared_ptr<DataNode<T> > ptr) { _self_ptr = ptr; }
 
          public:
                static SelfPtr create (T * data)
                {
                        SelfPtr ptr = SelfPtr (new DataNode<T> (DataPtr (data)));
                        ptr->set_self_ptr (ptr);
                        return ptr;
                }
 
                static SelfPtr create (DataPtr data)
                {
                        SelfPtr ptr = SelfPtr (new DataNode<T> (data));
                        ptr->set_self_ptr (ptr);
                        return ptr;
                }
 
                DataPtr data() { return _data; }
                SelfPtr self_ptr () { return _self_ptr.lock(); }
 
                template<typename P> // Parent's data type
                void sort_parents (list<std::shared_ptr<DataNode<P> > > const & sort_list)
                {
                        parents.sort (NodeSorter<P> (sort_list));
                }
 
          private:
                DataPtr     _data;
                WeakSelfPtr _self_ptr;
        };
 
  private:
        /* Sorts GraphNodes according to a list of DataNodes */
 
        template<typename T>
        class NodeSorter {
          public:
                typedef list<std::shared_ptr<DataNode<T> > > ListType;
 
                NodeSorter (ListType const & list) : list (list) {}
 
                bool operator() (GraphNode * one, GraphNode * other) // '<' operator
                {
                        if (one == other) { return false; } // Strict weak ordering
                        for (typename ListType::const_iterator it = list.begin(); it != list.end(); ++it) {
                                if (it->get() == one) {
                                        return true;
                                }
                                if (it->get() == other) {
                                        return false;
                                }
                        }
 
                        std::cerr << "Invalid comparison list given to NodeSorter" << std::endl;
 
                        abort();
                }
 
          private:
                ListType const & list;
        };
 
/*** Multiplication management ***/
  public:
 
        typedef DataNode<TimespanState> TimespanNode;
        typedef std::shared_ptr<TimespanNode> TimespanNodePtr;
 
        typedef DataNode<ChannelConfigState> ChannelConfigNode;
        typedef std::shared_ptr<ChannelConfigNode> ChannelConfigNodePtr;
 
        typedef DataNode<FormatState> FormatNode;
        typedef std::shared_ptr<FormatNode> FormatNodePtr;
 
        typedef DataNode<FilenameState> FilenameNode;
        typedef std::shared_ptr<FilenameNode> FilenameNodePtr;
 
        struct MultiplicationGraph {
                list<TimespanNodePtr>      timespans;
                list<ChannelConfigNodePtr> channel_configs;
                list<FormatNodePtr>        formats;
                list<FilenameNodePtr>      filenames;
        };
 
        MultiplicationGraph const & get_graph () { return graph; }
 
        void split_node (GraphNode * node, float position);
        void remove_node (GraphNode * node);
 
        PBD::Signal0<void> GraphChanged;
 
  private:
 
        void purge_graph ();
 
        template<typename T>
        static void insert_after (list<T> & the_list, T const & position, T const & element);
 
        template<typename T>
        static void remove_by_element (list<T> & the_list, T const & element);
 
        bool nodes_have_one_common_child (list<GraphNode *> const & the_list);
        list<GraphNode *>::const_iterator end_of_common_child_range (list<GraphNode *> const & the_list, list<GraphNode *>::const_iterator beginning);
        void split_node_at_position (GraphNode * old_node, GraphNode * new_node, float position);
 
        void split_timespan (TimespanNodePtr node, float position = 0.5);
        void split_channel_config (ChannelConfigNodePtr node, float position = 0.5);
        void split_format (FormatNodePtr node, float position = 0.5);
        void split_filename (FilenameNodePtr node, float position = 0.5);
 
        void duplicate_timespan_children (TimespanNodePtr source, TimespanNodePtr target, GraphNode * insertion_point = 0);
        void duplicate_channel_config_children (ChannelConfigNodePtr source, ChannelConfigNodePtr target, GraphNode * insertion_point = 0);
        void duplicate_format_children (FormatNodePtr source, FormatNodePtr target, GraphNode * insertion_point = 0);
 
        TimespanNodePtr duplicate_timespan_node (TimespanNodePtr node);
        ChannelConfigNodePtr duplicate_channel_config_node (ChannelConfigNodePtr node);
        FormatNodePtr duplicate_format_node (FormatNodePtr node);
        FilenameNodePtr duplicate_filename_node (FilenameNodePtr node);
 
        void remove_timespan (TimespanNodePtr node);
        void remove_channel_config (ChannelConfigNodePtr node);
        void remove_format (FormatNodePtr node);
        void remove_filename (FilenameNodePtr node);
 
        MultiplicationGraph graph;