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