object_path.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 TVM_NODE_OBJECT_PATH_H_
#define TVM_NODE_OBJECT_PATH_H_
 
#include <tvm/runtime/container/optional.h>
#include <tvm/runtime/container/string.h>
#include <tvm/runtime/object.h>
 
#include <string>
 
namespace tvm {
 
using runtime::Object;
using runtime::ObjectPtr;
using runtime::ObjectRef;
 
class ObjectPath;
 
class ObjectPathNode : public Object {
 public:
  Optional<ObjectPath> GetParent() const;
  int32_t Length() const;
 
  ObjectPath GetPrefix(int32_t length) const;
 
  bool IsPrefixOf(const ObjectPath& other) const;
 
  bool PathsEqual(const ObjectPath& other) const;
 
  ObjectPath Attr(const char* attr_key) const;
 
  ObjectPath Attr(Optional<String> attr_key) const;
 
  ObjectPath ArrayIndex(int32_t index) const;
 
  ObjectPath MissingArrayElement(int32_t index) const;
 
  ObjectPath MapValue(ObjectRef key) const;
 
  ObjectPath MissingMapEntry() const;
 
  static constexpr const char* _type_key = "ObjectPath";
  TVM_DECLARE_BASE_OBJECT_INFO(ObjectPathNode, Object);
 
 protected:
  explicit ObjectPathNode(const ObjectPathNode* parent);
 
  friend class ObjectPath;
  friend std::string GetObjectPathRepr(const ObjectPathNode* node);
 
  const ObjectPathNode* ParentNode() const;
 
  virtual bool LastNodeEqual(const ObjectPathNode* other) const = 0;
 
  virtual std::string LastNodeString() const = 0;
 
 private:
  Optional<ObjectRef> parent_;
  int32_t length_;
};
 
class ObjectPath : public ObjectRef {
 public:
  static ObjectPath Root(Optional<String> name = NullOpt);
 
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(ObjectPath, ObjectRef, ObjectPathNode);
};
 
//-------------------------------------------------------------------------
//-----   Concrete object path nodes   ------------------------------------
//-------------------------------------------------------------------------
 
// ----- Root -----
 
class RootPathNode final : public ObjectPathNode {
 public:
  Optional<String> name;
 
  explicit RootPathNode(Optional<String> name = NullOpt);
 
  static constexpr const char* _type_key = "RootPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(RootPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class RootPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(RootPath, ObjectPath, RootPathNode);
};
 
// ----- Attribute access -----
 
class AttributeAccessPathNode final : public ObjectPathNode {
 public:
  String attr_key;
 
  explicit AttributeAccessPathNode(const ObjectPathNode* parent, String attr_key);
 
  static constexpr const char* _type_key = "AttributeAccessPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(AttributeAccessPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class AttributeAccessPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(AttributeAccessPath, ObjectPath,
                                            AttributeAccessPathNode);
};
 
// ----- Unknown attribute access -----
 
class UnknownAttributeAccessPathNode final : public ObjectPathNode {
 public:
  explicit UnknownAttributeAccessPathNode(const ObjectPathNode* parent);
 
  static constexpr const char* _type_key = "UnknownAttributeAccessPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(UnknownAttributeAccessPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class UnknownAttributeAccessPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(UnknownAttributeAccessPath, ObjectPath,
                                            UnknownAttributeAccessPathNode);
};
 
// ----- Array element access by index -----
 
class ArrayIndexPathNode : public ObjectPathNode {
 public:
  int32_t index;
 
  explicit ArrayIndexPathNode(const ObjectPathNode* parent, int32_t index);
 
  static constexpr const char* _type_key = "ArrayIndexPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(ArrayIndexPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class ArrayIndexPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(ArrayIndexPath, ObjectPath, ArrayIndexPathNode);
};
 
// ----- Missing array element -----
 
class MissingArrayElementPathNode : public ObjectPathNode {
 public:
  int32_t index;
 
  explicit MissingArrayElementPathNode(const ObjectPathNode* parent, int32_t index);
 
  static constexpr const char* _type_key = "MissingArrayElementPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(MissingArrayElementPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class MissingArrayElementPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(MissingArrayElementPath, ObjectPath,
                                            MissingArrayElementPathNode);
};
 
// ----- Map value -----
 
class MapValuePathNode : public ObjectPathNode {
 public:
  ObjectRef key;
 
  explicit MapValuePathNode(const ObjectPathNode* parent, ObjectRef key);
 
  static constexpr const char* _type_key = "MapValuePath";
  TVM_DECLARE_FINAL_OBJECT_INFO(MapValuePathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class MapValuePath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(MapValuePath, ObjectPath, MapValuePathNode);
};
 
// ----- Missing map entry -----
 
class MissingMapEntryPathNode : public ObjectPathNode {
 public:
  explicit MissingMapEntryPathNode(const ObjectPathNode* parent);
 
  static constexpr const char* _type_key = "MissingMapEntryPath";
  TVM_DECLARE_FINAL_OBJECT_INFO(MissingMapEntryPathNode, ObjectPathNode);
 
 protected:
  bool LastNodeEqual(const ObjectPathNode* other) const final;
  std::string LastNodeString() const final;
};
 
class MissingMapEntryPath : public ObjectPath {
 public:
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(MissingMapEntryPath, ObjectPath,
                                            MissingMapEntryPathNode);
};
 
}  // namespace tvm
 
#endif  // TVM_NODE_OBJECT_PATH_H_