FN_multi_function_network.hh

Go to the documentation of this file.

/*
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include "FN_multi_function.hh"
 
#include "BLI_vector_set.hh"
 
namespace blender::fn {
 
class MFNode;
class MFFunctionNode;
class MFDummyNode;
class MFSocket;
class MFInputSocket;
class MFOutputSocket;
class MFNetwork;
 
class MFNode : NonCopyable, NonMovable {
 protected:
  MFNetwork *network_;
  Span<MFInputSocket *> inputs_;
  Span<MFOutputSocket *> outputs_;
  bool is_dummy_;
  int id_;
 
  friend MFNetwork;
 
 public:
  StringRefNull name() const;
 
  int id() const;
 
  MFNetwork &network();
  const MFNetwork &network() const;
 
  bool is_dummy() const;
  bool is_function() const;
 
  MFDummyNode &as_dummy();
  const MFDummyNode &as_dummy() const;
 
  MFFunctionNode &as_function();
  const MFFunctionNode &as_function() const;
 
  MFInputSocket &input(int index);
  const MFInputSocket &input(int index) const;
 
  MFOutputSocket &output(int index);
  const MFOutputSocket &output(int index) const;
 
  Span<MFInputSocket *> inputs();
  Span<const MFInputSocket *> inputs() const;
 
  Span<MFOutputSocket *> outputs();
  Span<const MFOutputSocket *> outputs() const;
 
  bool has_unlinked_inputs() const;
 
 private:
  void destruct_sockets();
};
 
class MFFunctionNode : public MFNode {
 private:
  const MultiFunction *function_;
  Span<int> input_param_indices_;
  Span<int> output_param_indices_;
 
  friend MFNetwork;
 
 public:
  StringRefNull name() const;
 
  const MultiFunction &function() const;
 
  const MFInputSocket &input_for_param(int param_index) const;
  const MFOutputSocket &output_for_param(int param_index) const;
};
 
class MFDummyNode : public MFNode {
 protected:
  StringRefNull name_;
  MutableSpan<StringRefNull> input_names_;
  MutableSpan<StringRefNull> output_names_;
 
  friend MFNetwork;
 
 public:
  StringRefNull name() const;
 
  Span<StringRefNull> input_names() const;
  Span<StringRefNull> output_names() const;
};
 
class MFSocket : NonCopyable, NonMovable {
 protected:
  MFNode *node_;
  bool is_output_;
  int index_;
  MFDataType data_type_;
  int id_;
  StringRefNull name_;
 
  friend MFNetwork;
 
 public:
  StringRefNull name() const;
 
  int id() const;
  int index() const;
 
  const MFDataType &data_type() const;
 
  MFNode &node();
  const MFNode &node() const;
 
  bool is_input() const;
  bool is_output() const;
 
  MFInputSocket &as_input();
  const MFInputSocket &as_input() const;
 
  MFOutputSocket &as_output();
  const MFOutputSocket &as_output() const;
};
 
class MFInputSocket : public MFSocket {
 private:
  MFOutputSocket *origin_;
 
  friend MFNetwork;
 
 public:
  MFOutputSocket *origin();
  const MFOutputSocket *origin() const;
};
 
class MFOutputSocket : public MFSocket {
 private:
  Vector<MFInputSocket *, 1> targets_;
 
  friend MFNetwork;
 
 public:
  Span<MFInputSocket *> targets();
  Span<const MFInputSocket *> targets() const;
};
 
class MFNetwork : NonCopyable, NonMovable {
 private:
  LinearAllocator<> allocator_;
 
  VectorSet<MFFunctionNode *> function_nodes_;
  VectorSet<MFDummyNode *> dummy_nodes_;
 
  Vector<MFNode *> node_or_null_by_id_;
  Vector<MFSocket *> socket_or_null_by_id_;
 
 public:
  MFNetwork() = default;
  ~MFNetwork();
 
  MFFunctionNode &add_function(const MultiFunction &function);
  MFDummyNode &add_dummy(StringRef name,
                         Span<MFDataType> input_types,
                         Span<MFDataType> output_types,
                         Span<StringRef> input_names,
                         Span<StringRef> output_names);
  void add_link(MFOutputSocket &from, MFInputSocket &to);
 
  MFOutputSocket &add_input(StringRef name, MFDataType data_type);
  MFInputSocket &add_output(StringRef name, MFDataType data_type);
 
  void relink(MFOutputSocket &old_output, MFOutputSocket &new_output);
 
  void remove(MFNode &node);
  void remove(Span<MFNode *> nodes);
 
  int socket_id_amount() const;
  int node_id_amount() const;
 
  Span<MFDummyNode *> dummy_nodes();
  Span<MFFunctionNode *> function_nodes();
 
  MFNode *node_or_null_by_id(int id);
  const MFNode *node_or_null_by_id(int id) const;
 
  MFSocket *socket_or_null_by_id(int id);
  const MFSocket *socket_or_null_by_id(int id) const;
 
  void find_dependencies(Span<const MFInputSocket *> sockets,
                         VectorSet<const MFOutputSocket *> &r_dummy_sockets,
                         VectorSet<const MFInputSocket *> &r_unlinked_inputs) const;
 
  bool have_dummy_or_unlinked_dependencies(Span<const MFInputSocket *> sockets) const;
 
  std::string to_dot(Span<const MFNode *> marked_nodes = {}) const;
};
 
/* --------------------------------------------------------------------
 * MFNode inline methods.
 */
 
inline StringRefNull MFNode::name() const
{
  if (is_dummy_) {
    return this->as_dummy().name();
  }
  else {
    return this->as_function().name();
  }
}
 
inline int MFNode::id() const
{
  return id_;
}
 
inline MFNetwork &MFNode::network()
{
  return *network_;
}
 
inline const MFNetwork &MFNode::network() const
{
  return *network_;
}
 
inline bool MFNode::is_dummy() const
{
  return is_dummy_;
}
 
inline bool MFNode::is_function() const
{
  return !is_dummy_;
}
 
inline MFDummyNode &MFNode::as_dummy()
{
  BLI_assert(is_dummy_);
  return static_cast<MFDummyNode &>(*this);
}
 
inline const MFDummyNode &MFNode::as_dummy() const
{
  BLI_assert(is_dummy_);
  return static_cast<const MFDummyNode &>(*this);
}
 
inline MFFunctionNode &MFNode::as_function()
{
  BLI_assert(!is_dummy_);
  return static_cast<MFFunctionNode &>(*this);
}
 
inline const MFFunctionNode &MFNode::as_function() const
{
  BLI_assert(!is_dummy_);
  return static_cast<const MFFunctionNode &>(*this);
}
 
inline MFInputSocket &MFNode::input(int index)
{
  return *inputs_[index];
}
 
inline const MFInputSocket &MFNode::input(int index) const
{
  return *inputs_[index];
}
 
inline MFOutputSocket &MFNode::output(int index)
{
  return *outputs_[index];
}
 
inline const MFOutputSocket &MFNode::output(int index) const
{
  return *outputs_[index];
}
 
inline Span<MFInputSocket *> MFNode::inputs()
{
  return inputs_;
}
 
inline Span<const MFInputSocket *> MFNode::inputs() const
{
  return inputs_;
}
 
inline Span<MFOutputSocket *> MFNode::outputs()
{
  return outputs_;
}
 
inline Span<const MFOutputSocket *> MFNode::outputs() const
{
  return outputs_;
}
 
inline bool MFNode::has_unlinked_inputs() const
{
  for (const MFInputSocket *socket : inputs_) {
    if (socket->origin() == nullptr) {
      return true;
    }
  }
  return false;
}
 
/* --------------------------------------------------------------------
 * MFFunctionNode inline methods.
 */
 
inline StringRefNull MFFunctionNode::name() const
{
  return function_->name();
}
 
inline const MultiFunction &MFFunctionNode::function() const
{
  return *function_;
}
 
inline const MFInputSocket &MFFunctionNode::input_for_param(int param_index) const
{
  return this->input(input_param_indices_.first_index(param_index));
}
 
inline const MFOutputSocket &MFFunctionNode::output_for_param(int param_index) const
{
  return this->output(output_param_indices_.first_index(param_index));
}
 
/* --------------------------------------------------------------------
 * MFDummyNode inline methods.
 */
 
inline StringRefNull MFDummyNode::name() const
{
  return name_;
}
 
inline Span<StringRefNull> MFDummyNode::input_names() const
{
  return input_names_;
}
 
inline Span<StringRefNull> MFDummyNode::output_names() const
{
  return output_names_;
}
 
/* --------------------------------------------------------------------
 * MFSocket inline methods.
 */
 
inline StringRefNull MFSocket::name() const
{
  return name_;
}
 
inline int MFSocket::id() const
{
  return id_;
}
 
inline int MFSocket::index() const
{
  return index_;
}
 
inline const MFDataType &MFSocket::data_type() const
{
  return data_type_;
}
 
inline MFNode &MFSocket::node()
{
  return *node_;
}
 
inline const MFNode &MFSocket::node() const
{
  return *node_;
}
 
inline bool MFSocket::is_input() const
{
  return !is_output_;
}
 
inline bool MFSocket::is_output() const
{
  return is_output_;
}
 
inline MFInputSocket &MFSocket::as_input()
{
  BLI_assert(this->is_input());
  return static_cast<MFInputSocket &>(*this);
}
 
inline const MFInputSocket &MFSocket::as_input() const
{
  BLI_assert(this->is_input());
  return static_cast<const MFInputSocket &>(*this);
}
 
inline MFOutputSocket &MFSocket::as_output()
{
  BLI_assert(this->is_output());
  return static_cast<MFOutputSocket &>(*this);
}
 
inline const MFOutputSocket &MFSocket::as_output() const
{
  BLI_assert(this->is_output());
  return static_cast<const MFOutputSocket &>(*this);
}
 
/* --------------------------------------------------------------------
 * MFInputSocket inline methods.
 */
 
inline MFOutputSocket *MFInputSocket::origin()
{
  return origin_;
}
 
inline const MFOutputSocket *MFInputSocket::origin() const
{
  return origin_;
}
 
/* --------------------------------------------------------------------
 * MFOutputSocket inline methods.
 */
 
inline Span<MFInputSocket *> MFOutputSocket::targets()
{
  return targets_;
}
 
inline Span<const MFInputSocket *> MFOutputSocket::targets() const
{
  return targets_;
}
 
/* --------------------------------------------------------------------
 * MFNetwork inline methods.
 */
 
inline Span<MFDummyNode *> MFNetwork::dummy_nodes()
{
  return dummy_nodes_;
}
 
inline Span<MFFunctionNode *> MFNetwork::function_nodes()
{
  return function_nodes_;
}
 
inline MFNode *MFNetwork::node_or_null_by_id(int id)
{
  return node_or_null_by_id_[id];
}
 
inline const MFNode *MFNetwork::node_or_null_by_id(int id) const
{
  return node_or_null_by_id_[id];
}
 
inline MFSocket *MFNetwork::socket_or_null_by_id(int id)
{
  return socket_or_null_by_id_[id];
}
 
inline const MFSocket *MFNetwork::socket_or_null_by_id(int id) const
{
  return socket_or_null_by_id_[id];
}
 
inline int MFNetwork::socket_id_amount() const
{
  return socket_or_null_by_id_.size();
}
 
inline int MFNetwork::node_id_amount() const
{
  return node_or_null_by_id_.size();
}
 
}  // namespace blender::fn