NamedValuesSchema.h

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the declarations for the NamedValuesSchema, a schema to
/// represent an array of named nodes inside CAS.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CAS_NAMEDVALUESSCHEMA_H
#define LLVM_CAS_NAMEDVALUESSCHEMA_H
 
#include "llvm/CAS/CASNodeSchema.h"
#include "llvm/CAS/ObjectStore.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Compiler.h"
 
namespace llvm::cas {
 
class NamedValuesProxy;
 
/// Represents an entry in NamedValuesSchema.
struct NamedValuesEntry {
  NamedValuesEntry(StringRef Name, ObjectRef Ref) : Name(Name), Ref(Ref) {}
 
  StringRef Name;
  ObjectRef Ref;
 
  friend bool operator==(const NamedValuesEntry &LHS,
                         const NamedValuesEntry &RHS) {
    return LHS.Ref == RHS.Ref && LHS.Name == RHS.Name;
  }
 
  /// Ordering the entries by name. Items should have unique names.
  friend bool operator<(const NamedValuesEntry &LHS,
                        const NamedValuesEntry &RHS) {
    return LHS.Name < RHS.Name;
  }
};
 
/// A schema for representing an array of named nodes in a CAS. The name of the
/// nodes are stored in the root node so child node can be loaded on demand
/// based on name and the name for all nodes need to be unique.
class LLVM_ABI NamedValuesSchema
    : public RTTIExtends<NamedValuesSchema, NodeSchema> {
  void anchor() override;
 
public:
  static char ID;
 
  bool isRootNode(const ObjectProxy &Node) const final {
    // NamedValuesSchema only has one node, thus root node.
    return isNode(Node);
  }
 
  /// Check if a proxy represents a valid node.
  bool isNode(const ObjectProxy &Node) const final;
 
  /// Create a NamedValuesSchema.
  static Expected<NamedValuesSchema> create(ObjectStore &CAS);
 
  /// Load NamedValuesProxy from an ObjectRef.
  Expected<NamedValuesProxy> load(ObjectRef Object) const;
 
  /// Load NamedValuesProxy from an ObjectProxy.
  Expected<NamedValuesProxy> load(ObjectProxy Object) const;
 
  /// Construct a \c NamedValuesSchema CAS object with the given entries.
  Expected<NamedValuesProxy> construct(ArrayRef<NamedValuesEntry> Entries);
 
  /// A builder class for creating nodes in NamedValuesSchema.
  class Builder {
  public:
    Builder(ObjectStore &CAS) : CAS(CAS) {}
 
    /// Add an entry to the builder.
    LLVM_ABI void add(StringRef Name, ObjectRef Ref);
 
    /// Build the node from added entries.
    LLVM_ABI Expected<NamedValuesProxy> build();
 
  private:
    ObjectStore &CAS;
    SmallVector<NamedValuesEntry> Nodes;
    BumpPtrAllocator Alloc;
  };
 
private:
  friend class NamedValuesProxy;
 
  NamedValuesSchema(ObjectStore &CAS, Error &E);
 
  /// Get the number of entries.
  size_t getNumEntries(NamedValuesProxy Values) const;
 
  /// Iterate over entries with a callback.
  Error
  forEachEntry(NamedValuesProxy Values,
               function_ref<Error(const NamedValuesEntry &)> Callback) const;
 
  /// Lookup an entry by name.
  std::optional<size_t> lookupEntry(NamedValuesProxy Values,
                                    StringRef Name) const;
 
  /// Load an entry by index.
  NamedValuesEntry loadEntry(NamedValuesProxy Values, size_t I) const;
 
  /// Name for the schema.
  static constexpr StringLiteral SchemaName =
      "llvm::cas::schema::namedvalues::v1";
  std::optional<ObjectRef> NamedValuesKindRef;
};
 
/// A proxy for a loaded CAS Object in NamedValuesSchema.
class NamedValuesProxy : public ObjectProxy {
public:
  /// Get the schema associated with this proxy.
  const NamedValuesSchema &getSchema() const { return *Schema; }
 
  /// Iterate over entries with a callback.
  Error
  forEachEntry(function_ref<Error(const NamedValuesEntry &)> Callback) const {
    return Schema->forEachEntry(*this, Callback);
  }
 
  /// Check if the object is empty.
  bool empty() const { return size() == 0; }
 
  /// Get the number of entries in the CAS object.
  size_t size() const { return Schema->getNumEntries(*this); }
 
  /// Lookup an entry by name.
  std::optional<NamedValuesEntry> lookup(StringRef Name) const {
    if (auto I = Schema->lookupEntry(*this, Name))
      return get(*I);
    return std::nullopt;
  }
 
  /// Get the name of an entry by index.
  LLVM_ABI StringRef getName(size_t I) const;
 
  /// Get an entry by index.
  NamedValuesEntry get(size_t I) const { return Schema->loadEntry(*this, I); }
 
private:
  NamedValuesProxy(const NamedValuesSchema &Schema, const ObjectProxy &Node)
      : ObjectProxy(Node), Schema(&Schema) {}
 
  friend class NamedValuesSchema;
  const NamedValuesSchema *Schema;
};
 
} // namespace llvm::cas
 
#endif