port.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2015
  @author Russell Standish
  This file is part of Minsky.

  Minsky 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 3 of the License, or
  (at your option) any later version.

  Minsky 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 Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PORT_H
#define PORT_H
#include "classdesc_access.h"
#include "units.h"
#include <error.h>
#include <vector>
#include <memory>

namespace minsky
{
  class Item;
  class Wire;
  class Group;
  class VariableValue;
  typedef std::shared_ptr<Group> GroupPtr;

  struct PortExclude
  {
    // const_cast hack required to work around classdesc::Exclude API
    PortExclude(const Item& item): m_item(const_cast<Item&>(item)) {}
    virtual ~PortExclude()=default;
    void setVariableValue(const std::shared_ptr<VariableValue>& v);
    std::shared_ptr<VariableValue> getVariableValue() const;
    virtual bool input() const=0;
    GroupPtr group() const;
  protected:
    Item& m_item;
    std::weak_ptr<VariableValue> variableValue; //refers to variable value representing this port
    std::vector<Wire*> m_wires;
  };
  
  class Port: public classdesc::Exclude<PortExclude>
  {
  public:
  private:
    float m_x{0}, m_y{0};
    CLASSDESC_ACCESS(Port);
    friend struct SchemaHelper;
    Port(const Port&)=delete;
    void operator=(const Port&)=delete;
    friend class Wire;
  public:
    // this is an accessor to prevent serialisation infinite loops
    Item& item() {return m_item;};
    const Item& item() const {return m_item;}

    std::vector<Wire*> const& wires() const {return m_wires;}
    std::size_t numWires() const {return m_wires.size();}
    
    void eraseWire(Wire*);
    void deleteWires();

    virtual bool input() const {return false;}

    virtual bool multiWireAllowed() const {return false;}
    virtual void combineInput(double& x, double y) const {x=y;}
    virtual double identity() const {return 0;}

    float x() const;
    float y() const;
    void moveTo(float x, float y);
    Port(Item& item): classdesc::Exclude<PortExclude>(item) {}

    // destruction of this port must also destroy all attached wires
    ~Port() {deleteWires();}

    double value() const;
    Units units(bool) const;
    Units checkUnits() const {return units(true);}
  };

  struct InputPort: public Port
  {
    bool input() const override {return true;}
    InputPort(Item& item): Port(item) {}
  };
  
  struct MultiWireInputPort: public InputPort
  {
    bool multiWireAllowed() const override {return true;}
    MultiWireInputPort(Item& item): InputPort(item) {}
  };
}

#ifdef CLASSDESC
#pragma omit RESTProcess minsky::PortExclude
#endif

#include "port.cd"
#endif