vocabulary.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_VOCABULARY_H_
#define A11_FLOW_VOCABULARY_H_
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include <absl/base/nullability.h>
#include <absl/container/flat_hash_set.h>
#include <absl/types/span.h>
 
namespace a11::flow {
 
namespace vocabulary {
 
std::string Canonical(std::string_view word);
 
bool IsShouted(std::string_view word);
 
enum class StageArgument {
  kNone,
  kNumber,
  kExpression,
  kString,
  kOptionalString,
  kOptionalExpression,
  kSortKey,
  kFold,
  kDuration,
  kStream,
  kLog,
  kLogFormat,
};
 
struct EntryPort {
  std::string_view name;
  std::string_view type;
  bool unary;
  std::string_view description;
};
 
absl::Span<const EntryPort> EntryPorts();
 
absl::Span<const std::string_view> Stages();
 
std::optional<StageArgument> StageTakes(std::string_view canonical_name);
 
std::string_view StageArgumentName(StageArgument argument);
 
struct WordDoc {
  std::string_view summary;
  std::string_view takes;
  std::string_view detail;
  std::string_view example;
};
 
const WordDoc* absl_nullable StageDocumentation(
    std::string_view canonical_name);
 
const WordDoc* absl_nullable BuiltinDocumentation(
    std::string_view canonical_name);
 
enum class WordRole {
  kStage,
  kBuiltin,
  kStatement,
  kDeclaration,
  kClause,
  kModifier,
  kSource,
  kPortModifier,
  kFieldModifier,
  kType,
  kConstant,
  kOperatorWord,
  kStatusCode,
  kLogLevel,
  kStatusField,
  kDurationUnit,
  kSymbol,
};
 
const WordDoc* absl_nullable AnyDocumentation(std::string_view canonical_name);
 
absl::Span<const WordRole> WordRoles();
 
std::string_view WordRoleName(WordRole role);
 
std::vector<std::string_view> WordsOf(WordRole role);
 
const WordDoc* absl_nullable Documentation(WordRole role,
                                           std::string_view canonical_name);
 
absl::Span<const std::string_view> OrderedSymbols();
 
const absl::flat_hash_set<std::string_view>& BareStages();
 
const absl::flat_hash_set<std::string_view>& ParallelStages();
 
const absl::flat_hash_set<std::string_view>& ReducingStages();
 
const absl::flat_hash_set<std::string_view>& PositionalStages();
 
const absl::flat_hash_set<std::string_view>& Builtins();
 
const absl::flat_hash_set<std::string_view>& TypeNames();
 
absl::Span<const int> TypeParameters(std::string_view canonical_name);
 
absl::Span<const std::string_view> OrderedTypeNames();
 
absl::Span<const std::string_view> OrderedBuiltins();
 
const absl::flat_hash_set<std::string_view>& StatementWords();
 
absl::Span<const std::string_view> OrderedStatements();
 
const absl::flat_hash_set<std::string_view>& ClauseWords();
 
absl::Span<const std::string_view> OrderedClauseWords();
 
const absl::flat_hash_set<std::string_view>& DeclarationWords();
 
absl::Span<const std::string_view> OrderedDeclarations();
 
const absl::flat_hash_set<std::string_view>& ModifierWords();
 
absl::Span<const std::string_view> OrderedModifiers();
 
const absl::flat_hash_set<std::string_view>& SourceWords();
 
const absl::flat_hash_set<std::string_view>& PortModifierWords();
 
absl::Span<const std::string_view> OrderedPortModifiers();
 
const absl::flat_hash_set<std::string_view>& FieldModifierWords();
 
absl::Span<const std::string_view> OrderedFieldModifiers();
 
absl::Span<const std::string_view> StatusCodes();
 
bool IsStatusCode(std::string_view word);
 
absl::Span<const std::string_view> LogLevels();
 
bool IsLogLevel(std::string_view word);
 
const absl::flat_hash_set<std::string_view>& StatusFields();
 
absl::Span<const std::string_view> OrderedStatusFields();
 
const absl::flat_hash_set<std::string_view>& ConstantWords();
 
const absl::flat_hash_set<std::string_view>& OperatorWords();
 
absl::Span<const std::string_view> DurationUnits();
 
std::optional<double> DurationUnitSeconds(std::string_view unit);
 
}  // namespace vocabulary
}  // namespace a11::flow
 
#endif  // A11_FLOW_VOCABULARY_H_