runtime.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 Authors
 *
 * 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.
 */
 
#ifndef A11_FLOW_RUNTIME_H_
#define A11_FLOW_RUNTIME_H_
 
#include <cstddef>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include <absl/base/nullability.h>
#include <absl/status/status.h>
#include <absl/status/statusor.h>
 
#include "a11/actions/action.h"
#include "a11/actions/schema.h"
#include "a11/flow/graph.h"
#include "a11/flow/parser.h"
#include "a11/flow/plan.h"
#include "a11/flow/resolve.h"
#include "a11/flow/values.h"
 
namespace a11::net {
class WireStream;
}  // namespace a11::net
 
namespace a11::flow {
 
inline constexpr size_t kQueueDepth = 8;
 
// One flow file, compiled: the plans, the graphs, and the tree they borrow. A
// graph points into the parse tree it was resolved from, so the two have one
// owner and one lifetime.
class CompiledProgram {
 public:
  static absl::StatusOr<std::shared_ptr<CompiledProgram>> Compile(
      std::string source, std::string source_name = {});
 
  [[nodiscard]] const Program& program() const { return resolved_.program; }
 
  [[nodiscard]] const std::string& source() const { return source_; }
 
  [[nodiscard]] const std::string& source_name() const { return source_name_; }
 
  [[nodiscard]] const std::vector<Diagnostic>& diagnostics() const {
    return resolved_.diagnostics;
  }
 
  [[nodiscard]] const std::vector<ResolvedFlow>& flows() const {
    return resolved_.flows;
  }
 
  [[nodiscard]] const ResolvedFlow* absl_nullable Flow(
      std::string_view name) const;
 
  [[nodiscard]] const ResolvedFlow* absl_nullable Entry() const;
 
 private:
  CompiledProgram() = default;
 
  std::string source_;
  std::string source_name_;
  ParseResult parsed_;
  ResolveResult resolved_;
};
 
absl::StatusOr<actions::ActionSchema> FlowSchema(const FlowPlan& plan);
 
struct RunOptions {
  std::shared_ptr<HostBridge> bridge;
 
  // For a flow a **client** runs over a session it already holds: the `call`
  // steps that belong to the peer are bound to this stream, and the flow's own
  // action is not.
  std::shared_ptr<net::WireStream> dispatch_stream;
};
 
absl::StatusOr<actions::ActionHandler> MakeHandler(
    std::shared_ptr<const CompiledProgram> program, std::string_view flow,
    RunOptions options = {});
 
absl::StatusOr<actions::ActionHandler> MakeEntryHandler(
    std::shared_ptr<const CompiledProgram> program, RunOptions options = {});
 
}  // namespace a11::flow
 
#endif  // A11_FLOW_RUNTIME_H_