Complete constant.hpp template methods for string Tensor

Signed-off-by: Kazantsev, Roman <roman.kazantsev@intel.com>

src/core/include/openvino/op/constant.hpp

@@ -161,6 +161,9 @@ public:
         case Type_t::nf4:
             fill_data<Type_t::nf4>(value);
             break;
+        case Type_t::string:
+            fill_data<Type_t::string>(value);
+            break;
         case Type_t::undefined:
         case Type_t::dynamic:
             OPENVINO_THROW("unsupported type");
@@ -364,6 +367,9 @@ public:
         case Type_t::u64:
             cast_vector<Type_t::u64>(rc, num_elements_to_cast);
             break;
+        case Type_t::string:
+            cast_vector<Type_t::string>(rc, num_elements_to_cast);
+            break;
         default:
             OPENVINO_THROW("unsupported type");
         }
@@ -454,7 +460,7 @@ private:
     template <element::Type_t Type,
               typename OUT_T,
               typename std::enable_if<Type != element::Type_t::u1 && Type != element::Type_t::u4 &&
-                                          Type != element::Type_t::i4,
+                                          Type != element::Type_t::i4 && Type != element::Type_t::string,
                                       bool>::type = true>
     void cast_vector(std::vector<OUT_T>& output_vector, size_t num_elements) const {
         // this function is workaround for waring during windows building
@@ -511,6 +517,24 @@ private:
         });
     }
 
+    template <element::Type_t Type, typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void cast_vector(std::vector<std::string>& output_vector, size_t num_elements) const {
+        auto output_size = std::min(num_elements, shape_size(m_shape));
+        output_vector.reserve(output_size);
+        const auto p = get_data_ptr<Type>();
+        std::copy(p, p + output_size, std::back_inserter(output_vector));
+    }
+
+    template <element::Type_t Type,
+              typename OUT_T,
+              typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void cast_vector(std::vector<OUT_T>& output_vector, size_t num_elements) const {
+        auto output_type = std::string(typeid(OUT_T{}).name());
+        OPENVINO_ASSERT(false,
+                        "cast_vector does not support casting string ov::Tensor to std::vector with elements of type " +
+                            output_type);
+    }
+
     template <element::Type_t Type,
               typename OUT_T,
               typename std::enable_if<Type == element::Type_t::u1, bool>::type = true>
@@ -569,11 +593,19 @@ private:
         output.resize(element_number);
     }
 
+    template <element::Type_t Type,
+              typename StorageDataType = fundamental_type_for<Type>,
+              typename std::enable_if<Type != element::Type_t::string, bool>::type = true>
+    void fill_data(const std::string& value) {
+        OPENVINO_THROW("Called fill_data(std::string) with non-string element_type");
+    }
+
     template <element::Type_t Type,
               typename T,
               typename StorageDataType = fundamental_type_for<Type>,
               typename std::enable_if<Type != element::Type_t::u1 && Type != element::Type_t::u4 &&
-                                          Type != element::Type_t::i4 && Type != element::Type_t::nf4,
+                                          Type != element::Type_t::i4 && Type != element::Type_t::nf4 &&
+                                          Type != element::Type_t::string,
                                       bool>::type = true>
     void fill_data(const T& value) {
 #ifdef __clang__
@@ -614,6 +646,22 @@ private:
         std::fill_n(get_data_ptr_nc<Type>(), size, v);
     }
 
+    template <element::Type_t Type, typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void fill_data(const std::string& value) {
+        auto num_elements = shape_size(m_shape);
+        std::fill_n(get_data_ptr_nc<Type>(), num_elements, value);
+    }
+
+    template <element::Type_t Type,
+              typename T,
+              typename StorageDataType = fundamental_type_for<Type>,
+              typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void fill_data(const T& value) {
+        std::string type_name(typeid(value).name());
+        OPENVINO_ASSERT(false,
+                        "fill_data does not support to fill ov::Tensor of string type with value of " + type_name);
+    }
+
     template <element::Type_t Type,
               typename T,
               typename StorageDataType = fundamental_type_for<Type>,
@@ -658,7 +706,8 @@ private:
               typename T,
               typename StorageDataType = fundamental_type_for<Type>,
               typename std::enable_if<Type != element::Type_t::nf4 && Type != element::Type_t::u1 &&
-                                          Type != element::Type_t::u4 && Type != element::Type_t::i4,
+                                          Type != element::Type_t::u4 && Type != element::Type_t::i4 &&
+                                          Type != element::Type_t::string,
                                       bool>::type = true>
     void write_buffer(const std::vector<T>& source) {
         auto p = get_data_ptr_nc<Type>();
@@ -667,6 +716,33 @@ private:
         }
     }
 
+    template <element::Type_t Type, typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void write_buffer(const std::vector<std::string>& source) {
+        // elements of string ov::Tensor is already pre-initialized in allocate_buffer
+        auto p = get_data_ptr_nc<Type>();
+        auto num_elements = std::min(shape_size(m_shape), source.size());
+        std::copy_n(source.begin(), num_elements, p);
+    }
+
+    template <element::Type_t Type, typename std::enable_if<Type != element::Type_t::string, bool>::type = true>
+    void write_buffer(const std::vector<std::string>& source) {
+        OPENVINO_ASSERT(false,
+                        "write_buffer does not support writing std::string elements into ov::Tensor of type:" +
+                            ov::element::Type(Type).to_string());
+    }
+
+    template <element::Type_t Type,
+              typename T,
+              typename std::enable_if<Type == element::Type_t::string, bool>::type = true>
+    void write_buffer(const std::vector<T>& source) {
+        if (source.size() > 0) {
+            auto source_type = std::string(typeid(source[0]).name());
+            OPENVINO_ASSERT(
+                false,
+                "write_buffer does not support writing elements of type " + source_type + " into string ov::Tensor");
+        }
+    }
+
     template <element::Type_t Type,
               typename T,
               typename StorageDataType = fundamental_type_for<Type>,
@@ -801,6 +877,9 @@ private:
         case Type_t::nf4:
             write_buffer<Type_t::nf4>(source);
             break;
+        case Type_t::string:
+            write_buffer<Type_t::string>(source);
+            break;
         case element::Type_t::undefined:
         case element::Type_t::dynamic:
             OPENVINO_THROW("unsupported type");