Adding value_type and ordered_value_type to some files

Author: Victor Li

lib/op-attrs/src/op-attrs/dim_ordered/slice.cc

@@ -1,34 +1,26 @@
-#ifndef _FLEXFLOW_LIB_OP_ATTRS_INCLUDE_OP_ATTRS_DIM_ORDERED_SLICE_H
-#define _FLEXFLOW_LIB_OP_ATTRS_INCLUDE_OP_ATTRS_DIM_ORDERED_SLICE_H
-
 #include "op-attrs/dim_ordered/slice.h"
 #include "utils/archetypes/value_type.h"
 
 namespace FlexFlow {
 
 using T = value_type<0>;
 
-template
-  FFOrdered<T> ff_dim_t_nonoverloaded_slice(FFOrdered<T> const &d,
-                                            std::optional<ff_dim_t> const &start,
-                                            std::optional<ff_dim_t> const &end);
+template FFOrdered<T>
+    ff_dim_t_nonoverloaded_slice(FFOrdered<T> const &d,
+                                 std::optional<ff_dim_t> const &start,
+                                 std::optional<ff_dim_t> const &end);
 
-template
-  FFOrdered<T> relative_ff_dim_t_nonoverloaded_slice(
+template FFOrdered<T> relative_ff_dim_t_nonoverloaded_slice(
     FFOrdered<T> const &d,
     std::optional<relative_ff_dim_t> const &start,
     std::optional<relative_ff_dim_t> const &end);
 
-template
-  FFOrdered<T> slice(FFOrdered<T> const &d,
-                     std::optional<ff_dim_t> const &start,
-                     std::optional<ff_dim_t> const &end);
+template FFOrdered<T> slice(FFOrdered<T> const &d,
+                            std::optional<ff_dim_t> const &start,
+                            std::optional<ff_dim_t> const &end);
 
-template
-  FFOrdered<T> slice(FFOrdered<T> const &d,
-                     std::optional<relative_ff_dim_t> const &start,
-                     std::optional<relative_ff_dim_t> const &end);
+template FFOrdered<T> slice(FFOrdered<T> const &d,
+                            std::optional<relative_ff_dim_t> const &start,
+                            std::optional<relative_ff_dim_t> const &end);
 
 } // namespace FlexFlow
-
-#endif

lib/utils/include/utils/archetypes/ordered_value_type.h

@@ -0,0 +1,55 @@
+#ifndef _FLEXFLOW_LIB_UTILS_INCLUDE_UTILS_ARCHETYPES_ORDERED_VALUE_TYPE_H
+#define _FLEXFLOW_LIB_UTILS_INCLUDE_UTILS_ARCHETYPES_ORDERED_VALUE_TYPE_H
+
+#include <cassert>
+#include <functional>
+
+namespace FlexFlow {
+
+template <int TAG>
+struct ordered_value_type {
+  ordered_value_type() = delete;
+
+  ordered_value_type(ordered_value_type const &) {
+    assert(false);
+  }
+  ordered_value_type &operator=(ordered_value_type const &) {
+    assert(false);
+  }
+
+  ordered_value_type(ordered_value_type &&) {
+    assert(false);
+  }
+  ordered_value_type &operator=(ordered_value_type &&) {
+    assert(false);
+  }
+
+  bool operator==(ordered_value_type const &) const {
+    assert(false);
+  }
+  bool operator!=(ordered_value_type const &) const {
+    assert(false);
+  }
+
+  bool operator<(ordered_value_type const &) const {
+    assert(false);
+  }
+  bool operator>(ordered_value_type const &) const {
+    assert(false);
+  }
+};
+
+} // namespace FlexFlow
+
+namespace std {
+
+template <int TAG>
+struct hash<::FlexFlow::ordered_value_type<TAG>> {
+  size_t operator()(::FlexFlow::ordered_value_type<TAG> const &) const {
+    assert(false);
+  };
+};
+
+} // namespace std
+
+#endif

lib/utils/include/utils/stack_string.h

@@ -59,7 +59,7 @@ struct stack_basic_string {
 
   friend fmt::basic_string_view<Char>
       format_as(stack_basic_string<Char, MAXSIZE> const &s) {
-    return {s.contents.data(), s.length()};
+    return {s.contents.stack_contents().data(), s.length()};
   }
 
 private:

lib/utils/include/utils/stack_vector/stack_vector.h

@@ -292,8 +292,8 @@ struct stack_vector {
     return (this->m_size == 0);
   }
 
-  T const *data() const {
-    return this->contents.data();
+  std::array<element_type, MAXSIZE> stack_contents() const {
+    return this->contents;
   }
 
   friend std::string format_as(stack_vector<T, MAXSIZE> const &v) {

lib/utils/src/utils/archetypes/ordered_value_type.cc

@@ -0,0 +1,7 @@
+#include "utils/archetypes/ordered_value_type.h"
+
+namespace FlexFlow {
+
+template struct ordered_value_type<0>;
+
+} // namespace FlexFlow

lib/utils/src/utils/stack_vector/stack_vector.cc

@@ -1 +1,10 @@
 #include "utils/stack_vector/stack_vector.h"
+#include "utils/archetypes/ordered_value_type.h"
+
+namespace FlexFlow {
+
+using T = ordered_value_type<0>;
+
+template struct stack_vector<T, 5>;
+
+} // namespace FlexFlow

lib/utils/src/utils/stack_vector/stack_vector_of.cc

@@ -1 +1,10 @@
 #include "utils/stack_vector/stack_vector_of.h"
+#include "utils/archetypes/ordered_value_type.h"
+
+namespace FlexFlow {
+
+using T = ordered_value_type<0>;
+
+template stack_vector<T, 5> stack_vector_of<5>(std::vector<T> const &vector);
+
+} // namespace FlexFlow