BaseNetwork.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2008 Fundació Barcelona Media 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 _BaseNetwork_hxx_
#define _BaseNetwork_hxx_

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

namespace CLAM
{
// abstract clase of a base Network
class BaseNetwork : public Component
{
public:
        // used types
        typedef std::list<std::string> NamesList;
        typedef std::map <std::string, Processing* > ProcessingsMap;
        typedef std::list<InPortBase *> InPortsList;

        typedef struct { int x, y, width, height; } Geometry;
        typedef std::map <std::string, Geometry> ProcessingsGeometriesMap;
        typedef struct { std::string sourceName, sinkName; } Connection;
        typedef std::list<Connection> ConnectionsList;

        // constructor / destructor
        BaseNetwork() {}
        virtual ~BaseNetwork() {}
        virtual const char * GetClassName() const = 0;
        virtual void Clear() = 0;

        // serialization methods
        virtual void StoreOn( Storage & storage) const = 0;
        virtual void LoadFrom( Storage & storage) = 0;

        // name and processing id 
        virtual const std::string& GetName() const = 0;
        virtual void SetName( const std::string& name ) = 0;
        virtual const std::string & GetNetworkId(const Processing * proc) const = 0;

        // accessors to nodes and processing
        virtual ProcessingsMap::iterator BeginProcessings() = 0; // { return _processings.begin(); }
        virtual ProcessingsMap::iterator EndProcessings() = 0;// { return _processings.end(); }
        virtual ProcessingsMap::const_iterator BeginProcessings() const = 0; //{ return _processings.begin(); }
        virtual BaseNetwork::ProcessingsMap::const_iterator EndProcessings() const = 0; //{ return _processings.end(); }

        virtual NamesList  GetInPortsConnectedTo( const std::string & producer ) const = 0;
        virtual NamesList  GetInControlsConnectedTo( const std::string & producer ) const = 0;
        virtual InPortsList GetInPortsConnectedTo( OutPortBase & producer ) const = 0;
        virtual std::string GetConnectorIdentifier( const std::string& ) const = 0;
        virtual std::string GetProcessingIdentifier( const std::string& ) const = 0;
        virtual InPortBase & GetInPortByCompleteName( const std::string & name ) const = 0;
        virtual OutPortBase & GetOutPortByCompleteName( const std::string & name ) const = 0;
        virtual InControl & GetInControlByCompleteName( const std::string & name ) const = 0;
        virtual OutControl & GetOutControlByCompleteName( const std::string & name ) const = 0;

        // methods related to connect/disconnect interface
        virtual bool ConnectPorts( const std::string &, const std::string & ) = 0;
        virtual bool ConnectControls( const std::string &, const std::string & ) = 0;
        virtual bool DisconnectPorts( const std::string &, const std::string & ) = 0;
        virtual bool DisconnectControls( const std::string &, const std::string & ) = 0;

        virtual std::string GetUnconnectedInPorts() const = 0;
        virtual bool HasProcessing( const std::string & name ) const = 0;
        virtual Processing& GetProcessing( const std::string & name ) const = 0;
        virtual void AddProcessing( const std::string &, Processing* ) = 0;
        virtual void AddProcessing( const std::string & name, const std::string & key ) = 0;
        virtual std::string AddProcessing( const std::string& key ) = 0;
        virtual std::string GetUnusedName( const std::string& prefix ) const = 0;
        virtual bool RenameProcessing( const std::string & oldName, const std::string & newName ) = 0;
        virtual void RemoveProcessing ( const std::string & ) = 0;

        virtual bool IsReady() const = 0;
        virtual bool IsEmpty() const = 0;
        virtual bool HasMisconfiguredProcessings() const = 0;
        virtual bool HasUnconnectedInPorts() const = 0;
        virtual bool HasSyncSource() const = 0;
        virtual bool ConfigureProcessing( const std::string &, const ProcessingConfig & ) = 0;
        virtual void ReconfigureAllProcessings() = 0;
        virtual std::string GetConfigurationErrors() const = 0;
        // methods related to copy&paste processings from canvas
        virtual bool UpdateSelections (const NamesList & processingsNamesList) = 0;
        virtual void setPasteMode() = 0;
        // canvas related geometries
        virtual bool SetProcessingsGeometries (const ProcessingsGeometriesMap & processingsGeometries) = 0;
        virtual const ProcessingsGeometriesMap GetAndClearGeometries() = 0;
/*// TODO: make individual geometries loadings/storings??
        const Geometry GetAndEraseGeometry(std::string name);*/

        virtual unsigned BackendBufferSize() = 0;
        virtual unsigned BackendSampleRate() = 0;

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 '.';
        }
        // attributes for canvas copy & paste
        typedef std::set<std::string> NamesSet;
        virtual bool HasSelectionAndContains(const std::string & name) const = 0;

        //virtual const ConnectionsList GetPortsConnections() =0;
        //virtual const ConnectionsList GetControlsConnections()=0;
        //virtual void RefreshConnections() =0;
};
}
#endif

---