Network.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2007 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#ifndef _Network_hxx_
#define _Network_hxx_

#include "Processing.hxx"
#include "InPort.hxx"
#include "OutPort.hxx"
#include "InControl.hxx"
#include "OutControl.hxx"
#include "Component.hxx"
#include "Text.hxx"
#include <string>
#include <list>
#include <map>
#include <set>
//#include <utility>

namespace CLAM
{

class NetworkPlayer;
class FlowControl;
class ControlSink;
class ControlSource;

class InformationText
{
public:
        int x;
        int y;
        Text text;
};


class Network : public Component
{

public:
        // used types
        typedef std::list<std::string> NamesList;
        typedef std::map <std::string, Processing* > ProcessingsMap;
        typedef std::list<InPortBase *> InPortsList;

        typedef std::vector<Processing*> Processings;
        typedef std::vector<ControlSource*> ControlSources;
        typedef std::vector<ControlSink*> ControlSinks;

        typedef std::vector<InformationText*> InformationTexts;

        typedef struct { int x, y, width, height; } Geometry;
        typedef struct { Processing* processing; Geometry geometry; } ProcessingAndGeometry;
        typedef std::map <std::string, Geometry> ProcessingsGeometriesMap;
        typedef struct { std::string sourceName, sinkName; } Connection;
        typedef std::list<Connection> ConnectionsList;
        // attributes for canvas copy & paste
        typedef std::set<std::string> NamesSet;
public:
        // constructor / destructor
        Network();
        virtual ~Network();

        // Methods related to network itself
        const std::string& GetName() const { return _name; }
        void SetName( const std::string& name ) { _name=name; }

        const Text& GetDescription() const {return _description;};
        void SetDescription( const Text& description ) {_description=description;};

        virtual const char * GetClassName() const
        {
                return "Network";
        }

        // Methods related with player and flow
        bool IsStopped() const;
        bool IsPlaying() const;
        bool IsPaused() const;
        bool IsRealTime() const;
        void Start();
        void Stop();
        void Pause();
        void Do();
        void AddFlowControl( FlowControl* );
        void Clear();
        void SetPlayer( NetworkPlayer* player);
        unsigned BackendBufferSize();
        unsigned BackendSampleRate();

        virtual void StoreOn( Storage & storage) const;
        virtual void LoadFrom( Storage & storage);

        bool UpdateSelections (const NamesList & processingsNamesList);
        void setPasteMode() { _setPasteMode=true; }

        bool SetProcessingsGeometries (const ProcessingsGeometriesMap & processingsGeometries);
        const ProcessingsGeometriesMap GetAndClearGeometries();

        const Geometry findProcessingGeometry(Processing* ) const;
        const Processings getOrderedProcessings(const std::string & type, bool horizontalOrder) const;
        const Processings getOrderedProcessingsByAttribute(const std::string & attribute, bool horizontalOrder=false) const;
        const ControlSinks getOrderedControlSinks() const;
        const ControlSources getOrderedControlSources() const;
        static const bool compareGeometriesUpperYThan(ProcessingAndGeometry &, ProcessingAndGeometry &);
        static const bool compareGeometriesUpperXThan(ProcessingAndGeometry &, ProcessingAndGeometry &);

/*// TODO: make individual geometries loadings/storings??
        const Geometry GetAndEraseGeometry(std::string name);*/
        bool ConnectPorts( const std::string &, const std::string & );
        bool ConnectControls( const std::string &, const std::string & );
        bool DisconnectPorts( const std::string &, const std::string & );
        bool DisconnectControls( const std::string &, const std::string & );

        Processing& GetProcessing( const std::string & name ) const;
        void AddProcessing( const std::string & name, Processing* processing, const ProcessingConfig * config=0 );
        Processing & AddProcessing( const std::string & name, const std::string & key );
        std::string AddProcessing( const std::string& key );
        std::string GetUnusedName( const std::string& prefix, const bool cutOnLastSeparator=false, const std::string separator="_") const;
        void RemoveProcessing ( const std::string & );
        bool HasProcessing( const std::string & name ) const;
        bool ConfigureProcessing( const std::string &, const ProcessingConfig & );
        void ReconfigureAllProcessings();
        bool RenameProcessing( const std::string & oldName, const std::string & newName );      
        
        const std::string & GetNetworkId(const Processing * proc) const;
        
        // accessors to nodes and processing
        ProcessingsMap::iterator BeginProcessings();
        ProcessingsMap::iterator EndProcessings();
        ProcessingsMap::const_iterator BeginProcessings() const;
        ProcessingsMap::const_iterator EndProcessings() const;

        // accessors to txt boxes
        void addInformationText(InformationText * informationText);
        void removeInformationText(InformationText * informationText);

        InformationTexts::iterator BeginInformationTexts();
        InformationTexts::iterator EndInformationTexts();
        InformationTexts::const_iterator BeginInformationTexts() const;
        InformationTexts::const_iterator EndInformationTexts() const;

        InPortBase & GetInPortByCompleteName( const std::string& ) const;
        OutPortBase & GetOutPortByCompleteName( const std::string& ) const;
        InControlBase & GetInControlByCompleteName( const std::string& ) const;
        OutControlBase & GetOutControlByCompleteName( const std::string& ) const;

        NamesList GetInPortsConnectedTo( const std::string & ) const;
        NamesList GetInControlsConnectedTo( const std::string & ) const;
        InPortsList GetInPortsConnectedTo( OutPortBase & ) const;

        std::string GetConnectorIdentifier( const std::string& ) const;
        std::string GetProcessingIdentifier( const std::string& ) const;

        bool IsReady() const;

        bool IsEmpty() const;

        bool HasMisconfiguredProcessings() const;

        bool HasUnconnectedInPorts() const;

        bool HasSyncSource() const;

        bool SupportsVariableAudioSize() const;

        std::string GetConfigurationErrors() const;
        std::string GetUnconnectedInPorts() const;

        typedef std::pair<bool, std::string> ConnectionState; 
        ConnectionState GetConnectionReport() const;
        void ResetConnectionReport();

private:
        // fields
        std::string _name;
        Text _description;
        ProcessingsMap _processings;
        FlowControl* _flowControl;
        NetworkPlayer* _player;
        InformationTexts _informationTexts;

        // attributes for canvas copy & paste
        mutable NamesSet _selectedProcessings;
        bool _setPasteMode;
        
        bool HasSelectionAndContains(const std::string & name) const;

        // attributes for canvas processing geometries
        mutable ProcessingsGeometriesMap _processingsGeometries;
        void StringPairToInts(const std::string & geometryInString, int & a, int & b);
        const std::string IntsToString (const int & a, const int & b) const;

protected:
        static std::size_t PositionOfLastIdentifier( const std::string& str)
        {
                std::size_t result = str.find_last_of( NamesIdentifiersSeparator() );
                CLAM_ASSERT( result!=std::string::npos, "Malformed port/control name. It should be ProcessingName.[Port/Control]Name");
                return result;
        }
        static std::size_t PositionOfProcessingIdentifier( const std::string& str)
        {
                std::size_t endPos = PositionOfLastIdentifier(str)-1;
                std::size_t     last_ofResult = str.find_last_of( NamesIdentifiersSeparator(), endPos );
                return last_ofResult == std::string::npos ? 0 : last_ofResult+1;
        }
        static char NamesIdentifiersSeparator()
        {
                return '.';
        }
private:
        bool BrokenConnection( const std::string & producer, const std::string & consumer );
        std::vector<std::string> _brokenConnections;
};

}// namespace
#endif