Connector.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
 
    This file is part of the TerraLib - a Framework for building GIS enabled applications.
 
    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.
 
    TerraLib 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 Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */
 
 /*!
   \file terralib/process/Connector.h
 
   \brief Abstraction that represents a Connector between parameters of a Task
 */
 
#ifndef __TERRALIB_PROCESS_INTERNAL_CONNECTOR_H
#define __TERRALIB_PROCESS_INTERNAL_CONNECTOR_H
 
 // TerraLib
#include "Config.h"
 
//STL include files
#include <memory>
#include <string>
 
namespace te
{
  namespace process
  {
    class Task;
 
    /*!
      \class Connector
 
      \brief Abstraction that represents a Connector between parameters of a Task
    */
    class TEPROCESSEXPORT Connector
    {
    public:
 
      /*!
        \brief It initializes the Connector
      */
      Connector();
 
      /*! \brief Virtual destructor. */
      virtual ~Connector();
 
      //!< Gets the id of the connector
      const std::string& getId() const;
 
      //< Sets the id of the connector. Generally used only of a deserialization
      void setId(const std::string& id);
 
      //!< Clears the association
      void clear();
 
      //!< Checks if the association is valid
      bool isValid() const;
 
      //!< Checks if the parameter from the task from is ready to be pushed into the taskTo
      bool isReady() const;
 
      //!< Gets the task 'from'
      const te::process::Task* getTaskFrom() const;
 
      //!< Gets the param index 'from'
      std::size_t getParamIndexFrom() const;
 
      //!< Gets the task 'to'
      const te::process::Task* getTaskTo() const;
 
      //!< Gets the param index 'to'
      std::size_t getParamIndexTo() const;
 
      //!< Check if an a association could be made between tasks and parameters indexes informed
      static bool canAssociate(te::process::Task* taskFrom, std::size_t paramIndexFrom, te::process::Task* taskTo, std::size_t paramIndexTo, std::string& info);
 
      //!< Associates the 'paramIndexFrom' output parameter of the 'taskFrom' to the 'paramIndexTo' input parameter of the 'taskTo'
      void associate(te::process::Task* taskFrom, std::size_t paramIndexFrom, te::process::Task* taskTo, std::size_t paramIndexTo);
 
      //!< Disassociates this connector from your tasks
      void disassociate();
 
      //!< Based on the association, gets the parameter from the taskFrom and pushes it into the taskTo. If the taskFrom is not ready, an exception will be thrown
      void apply();
 
    protected:
 
      std::string m_id; //!< The ID of the connector
      te::process::Task* m_taskFrom;
      std::size_t m_paramIndexFrom;
      te::process::Task* m_taskTo;
      std::size_t m_paramIndexTo;
      bool m_isValid;
 
    };
 
    //Typedef
    class TEPROCESSEXPORT ConnectorPtr : public std::unique_ptr<Connector>
    {
    public:
      explicit ConnectorPtr(te::process::Connector* pointer = nullptr);
      ~ConnectorPtr();
    };
 
    class TEPROCESSEXPORT ConnectorSharedPtr : public std::shared_ptr<Connector>
    {
    public:
      explicit ConnectorSharedPtr(te::process::Connector* pointer = nullptr);
      ~ConnectorSharedPtr();
    };
 
  } // end namespace process
}   // end namespace te
 
#endif  // __TERRALIB_PROCESS_INTERNAL_CONNECTOR_H