chore: import upstream snapshot with attribution

paddle/ap/include/graph/node.h

@@ -0,0 +1,86 @@
+// Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <list>
+#include <variant>
+#include <vector>
+#include "paddle/ap/include/adt/adt.h"
+#include "paddle/ap/include/graph/node_list.h"
+#include "paddle/ap/include/graph/tags.h"
+
+namespace ap::graph {
+
+template <typename T>
+class NodeArena;
+
+template <typename T>
+struct Node {
+  tNodeId<size_t> node_id_;
+  std::weak_ptr<NodeArena<T>> node_arena_;
+
+  const tNodeId<size_t>& node_id() const { return node_id_; }
+  std::weak_ptr<NodeArena<T>> node_arena() const { return node_arena_; }
+
+  adt::Result<std::shared_ptr<NodeArena<T>>> GetNodeArena() const {
+    auto ptr = node_arena_.lock();
+    if (!ptr) {
+      return adt::errors::RuntimeError{"NodeArena is delete."};
+    }
+    return ptr;
+  }
+
+  adt::Result<T> Get() const;
+  adt::Result<NodeList<T>> DownstreamNodes() const;
+  adt::Result<NodeList<T>> UpstreamNodes() const;
+
+  adt::Result<adt::Ok> ConnectTo(
+      const Node& dst_node,
+      const ValidListTag<std::monostate>& src_downstream_type,
+      const ValidListTag<std::monostate>& dst_unstream_type) const;
+
+  bool operator<(const Node& other) const {
+    if (!(this->node_id_ == other.node_id_)) {
+      return this->node_id_.value() < other.node_id_.value();
+    }
+    return this->node_arena_.lock() < other.node_arena_.lock();
+  }
+
+  bool operator==(const Node& other) const {
+    return other.node_id_.value() == this->node_id_.value() &&
+           other.node_arena_.lock() == this->node_arena_.lock();
+  }
+
+  bool operator!=(const Node& other) const { return !(*this == other); }
+
+  std::size_t GetHashValue() const {
+    return adt::hash_combine(
+        this->node_id_.value(),
+        std::hash<std::shared_ptr<NodeArena<T>>>()(this->node_arena_.lock()));
+  }
+};
+
+}  // namespace ap::graph
+
+namespace std {
+
+template <typename T>
+struct hash<ap::graph::Node<T>> {
+  std::size_t operator()(const ap::graph::Node<T>& node) const {
+    return node.GetHashValue();
+  }
+};
+
+}  // namespace std