remove tensor factory

3 files changed, 49 insertions, 52 deletions

diff --git a/document/src/tests/serialization/vespadocumentserializer_test.cpp b/document/src/tests/serialization/vespadocumentserializer_test.cpp
index c573eef6147..4b5c3e6f195 100644
--- a/document/src/tests/serialization/vespadocumentserializer_test.cpp
+++ b/document/src/tests/serialization/vespadocumentserializer_test.cpp
@@ -40,8 +40,7 @@
 #include <vespa/eval/tensor/types.h>
 #include <vespa/eval/tensor/tensor_builder.h>
 #include <vespa/eval/tensor/tensor.h>
-#include <vespa/eval/tensor/default_tensor.h>
-#include <vespa/eval/tensor/tensor_factory.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
 #include <vespa/vespalib/io/fileutil.h>
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/testkit/testapp.h>
@@ -53,10 +52,9 @@ using vespalib::Slime;
 using vespalib::nbostream;
 using vespalib::nbostream_longlivedbuf;
 using vespalib::slime::Cursor;
+using vespalib::eval::TensorSpec;
 using vespalib::tensor::Tensor;
-using vespalib::tensor::TensorBuilder;
-using vespalib::tensor::TensorCells;
-using vespalib::tensor::TensorDimensions;
+using vespalib::tensor::DefaultTensorEngine;
 using vespalib::compression::CompressionConfig;
 using namespace document;
 using std::string;
@@ -828,13 +826,14 @@ TEST("Require that predicate deserialization matches Java") {
 namespace
 {
 
-Tensor::UP
-createTensor(const TensorCells &cells, const TensorDimensions &dimensions) {
-    vespalib::tensor::DefaultTensor::builder builder;
-    return vespalib::tensor::TensorFactory::create(cells, dimensions, builder);
+Tensor::UP createTensor(const TensorSpec &spec) {
+    auto value = DefaultTensorEngine::ref().from_spec(spec);
+    Tensor *tensor = dynamic_cast<Tensor*>(value.get());
+    ASSERT_TRUE(tensor != nullptr);
+    value.release();
+    return Tensor::UP(tensor);
 }
 
-
 }
 
 TEST("Require that tensors can be serialized")
@@ -846,12 +845,12 @@ TEST("Require that tensors can be serialized")
     nbostream stream;
     serializeAndDeserialize(noTensorValue, stream);
     stream.clear();
-    emptyTensorValue = createTensor({}, {"x", "y"});
+    emptyTensorValue = createTensor(TensorSpec("tensor(x{},y{})"));
     serializeAndDeserialize(emptyTensorValue, stream);
     stream.clear();
-    twoCellsTwoDimsValue = createTensor({ {{{"y", "3"}}, 3},
-                                             {{{"x", "4"}, {"y", "5"}}, 7} },
-                                        {"x", "y"});
+    twoCellsTwoDimsValue = createTensor(TensorSpec("tensor(x{},y{})")
+                                        .add({{"x", ""}, {"y", "3"}}, 3)
+                                        .add({{"x", "4"}, {"y", "5"}}, 7));
     serializeAndDeserialize(twoCellsTwoDimsValue, stream);
     EXPECT_NOT_EQUAL(noTensorValue, emptyTensorValue);
     EXPECT_NOT_EQUAL(noTensorValue, twoCellsTwoDimsValue);
@@ -859,6 +858,7 @@ TEST("Require that tensors can be serialized")
 }
 
 
+
 const int tensor_doc_type_id = 321;
 const string tensor_field_name = "my_tensor";
 
@@ -904,15 +904,15 @@ void checkDeserialization(const string &name, std::unique_ptr<Tensor> tensor) {
     deserializeAndCheck(data_dir + name + "__java", value);
 }
 
+
 TEST("Require that tensor deserialization matches Java") {
     checkDeserialization("non_existing_tensor", std::unique_ptr<Tensor>());
-    checkDeserialization("empty_tensor", createTensor({}, {"dimX", "dimY"}));
+    checkDeserialization("empty_tensor", createTensor(TensorSpec("tensor(dimX{},dimY{})")));
     checkDeserialization("multi_cell_tensor",
-                         createTensor({ {{{"dimX", "a"}, {"dimY", "bb"}}, 2.0 },
-                                           {{{"dimX", "ccc"},
-                                                   {"dimY", "dddd"}}, 3.0},
-                                           {{{"dimX", "e"},{"dimY","ff"}}, 5.0} },
-                                      { "dimX", "dimY" }));
+                         createTensor(TensorSpec("tensor(dimX{},dimY{})")
+                                 .add({{"dimX", "a"}, {"dimY", "bb"}}, 2.0)
+                                 .add({{"dimX", "ccc"}, {"dimY", "dddd"}}, 3.0)
+                                 .add({{"dimX", "e"}, {"dimY", "ff"}}, 5.0)));
 }
 
 struct TensorDocFixture {
@@ -980,14 +980,14 @@ DeserializedTensorDoc::getTensor() const
 TEST("Require that wrong tensor type hides tensor")
 {
     TensorDocFixture f(tensor_doc_repo,
-                       createTensor({    {{{"dimX", "a"},{"dimY", "bb"}}, 2.0 },
-                                         {{{"dimX", "ccc"},{"dimY", "dddd"}}, 3.0},
-                                         {{{"dimX", "e"},{"dimY","ff"}}, 5.0} },
-                                    { "dimX", "dimY" }));
+                       createTensor(TensorSpec("tensor(dimX{},dimY{})")
+                                    .add({{"dimX", "a"}, {"dimY", "bb"}}, 2.0)
+                                    .add({{"dimX", "ccc"}, {"dimY", "dddd"}}, 3.0)
+                                    .add({{"dimX", "e"}, {"dimY", "ff"}}, 5.0)));
     TensorDocFixture f1(tensor_doc_repo1,
-                        createTensor({    {{{"dimX", "a"}}, 20.0 },
-                                          {{{"dimX", "ccc"}}, 30.0} },
-                                     { "dimX" }));
+                        createTensor(TensorSpec("tensor(dimX{})")
+                                .add({{"dimX", "a"}}, 20.0)
+                                .add({{"dimX", "ccc"}}, 30.0)));
     DeserializedTensorDoc doc;
     doc.setup(tensor_doc_repo, f._blob);
     EXPECT_TRUE(doc.getTensor() != nullptr);
diff --git a/document/src/tests/tensor_fieldvalue/tensor_fieldvalue_test.cpp b/document/src/tests/tensor_fieldvalue/tensor_fieldvalue_test.cpp
index dc91df0b5a0..9d2da9c983a 100644
--- a/document/src/tests/tensor_fieldvalue/tensor_fieldvalue_test.cpp
+++ b/document/src/tests/tensor_fieldvalue/tensor_fieldvalue_test.cpp
@@ -9,8 +9,7 @@ LOG_SETUP("fieldvalue_test");
 #include <vespa/document/fieldvalue/tensorfieldvalue.h>
 #include <vespa/eval/tensor/tensor.h>
 #include <vespa/eval/tensor/types.h>
-#include <vespa/eval/tensor/default_tensor.h>
-#include <vespa/eval/tensor/tensor_factory.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
 #include <vespa/eval/tensor/test/test_utils.h>
 
 #include <vespa/vespalib/testkit/testapp.h>
@@ -19,6 +18,7 @@ using namespace document;
 using namespace vespalib::tensor;
 using vespalib::eval::TensorSpec;
 using vespalib::eval::ValueType;
+using vespalib::tensor::DefaultTensorEngine;
 using vespalib::tensor::test::makeTensor;
 
 namespace
@@ -27,10 +27,12 @@ namespace
 TensorDataType xSparseTensorDataType(ValueType::from_spec("tensor(x{})"));
 TensorDataType xySparseTensorDataType(ValueType::from_spec("tensor(x{},y{})"));
 
-Tensor::UP
-createTensor(const TensorCells &cells, const TensorDimensions &dimensions) {
-    vespalib::tensor::DefaultTensor::builder builder;
-    return vespalib::tensor::TensorFactory::create(cells, dimensions, builder);
+Tensor::UP createTensor(const TensorSpec &spec) {
+    auto value = DefaultTensorEngine::ref().from_spec(spec);
+    Tensor *tensor = dynamic_cast<Tensor*>(value.get());
+    ASSERT_TRUE(tensor != nullptr);
+    value.release();
+    return Tensor::UP(tensor);
 }
 
 std::unique_ptr<Tensor>
@@ -54,10 +56,10 @@ TEST("require that TensorFieldValue can be assigned tensors and cloned") {
     TensorFieldValue noTensorValue(xySparseTensorDataType);
     TensorFieldValue emptyTensorValue(xySparseTensorDataType);
     TensorFieldValue twoCellsTwoDimsValue(xySparseTensorDataType);
-    emptyTensorValue = createTensor({}, {"x", "y"});
-    twoCellsTwoDimsValue = createTensor({ {{{"y", "3"}}, 3},
-                                             {{{"x", "4"}, {"y", "5"}}, 7} },
-                                        {"x", "y"});
+    emptyTensorValue = createTensor(TensorSpec("tensor(x{},y{})"));
+    twoCellsTwoDimsValue = createTensor(TensorSpec("tensor(x{},y{})")
+                                        .add({{"x", ""}, {"y", "3"}}, 3)
+                                        .add({{"x", "4"}, {"y", "5"}}, 7));
     EXPECT_NOT_EQUAL(noTensorValue, emptyTensorValue);
     EXPECT_NOT_EQUAL(noTensorValue, twoCellsTwoDimsValue);
     EXPECT_NOT_EQUAL(emptyTensorValue, noTensorValue);
@@ -74,10 +76,9 @@ TEST("require that TensorFieldValue can be assigned tensors and cloned") {
     EXPECT_NOT_EQUAL(*twoClone, *noneClone);
     EXPECT_NOT_EQUAL(*twoClone, *emptyClone);
     TensorFieldValue twoCellsTwoDimsValue2(xySparseTensorDataType);
-    twoCellsTwoDimsValue2 =
-        createTensor({ {{{"y", "3"}}, 3},
-                          {{{"x", "4"}, {"y", "5"}}, 7} },
-                     {"x", "y"});
+    twoCellsTwoDimsValue2 = createTensor(TensorSpec("tensor(x{},y{})")
+                                         .add({{"x", ""}, {"y", "3"}}, 3)
+                                         .add({{"x", "4"}, {"y", "5"}}, 7));
     EXPECT_NOT_EQUAL(*noneClone, twoCellsTwoDimsValue2);
     EXPECT_NOT_EQUAL(*emptyClone, twoCellsTwoDimsValue2);
     EXPECT_EQUAL(*twoClone, twoCellsTwoDimsValue2);
@@ -87,8 +88,8 @@ TEST("require that TensorFieldValue::toString works")
 {
     TensorFieldValue tensorFieldValue(xSparseTensorDataType);
     EXPECT_EQUAL("{TensorFieldValue: null}", tensorFieldValue.toString());
-    tensorFieldValue = createTensor({{{{"x","a"}}, 3}}, {"x"});
-    EXPECT_EQUAL("{TensorFieldValue: {\"dimensions\":[\"x\"],\"cells\":[{\"address\":{\"x\":\"a\"},\"value\":3}]}}", tensorFieldValue.toString());
+    tensorFieldValue = createTensor(TensorSpec("tensor(x{})").add({{"x", "a"}}, 3));
+    EXPECT_EQUAL("{TensorFieldValue: spec(tensor(x{})) {\n  [a]: 3\n}}", tensorFieldValue.toString());
 }
 
 TEST("require that wrong tensor type for special case assign throws exception")
diff --git a/document/src/vespa/document/fieldvalue/tensorfieldvalue.cpp b/document/src/vespa/document/fieldvalue/tensorfieldvalue.cpp
index f209358c901..9b318a39f0a 100644
--- a/document/src/vespa/document/fieldvalue/tensorfieldvalue.cpp
+++ b/document/src/vespa/document/fieldvalue/tensorfieldvalue.cpp
@@ -4,16 +4,16 @@
 #include <vespa/document/base/exceptions.h>
 #include <vespa/document/datatype/tensor_data_type.h>
 #include <vespa/vespalib/util/xmlstream.h>
+#include <vespa/eval/eval/tensor_spec.h>
 #include <vespa/eval/tensor/tensor.h>
-#include <vespa/eval/tensor/serialization/slime_binary_format.h>
-#include <vespa/vespalib/data/slime/slime.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
 #include <ostream>
 #include <cassert>
 
-using vespalib::slime::JsonFormat;
 using vespalib::tensor::Tensor;
-using vespalib::tensor::SlimeBinaryFormat;
+using vespalib::eval::TensorSpec;
 using vespalib::eval::ValueType;
+using Engine = vespalib::tensor::DefaultTensorEngine;
 using namespace vespalib::xml;
 
 namespace document {
@@ -148,11 +148,7 @@ TensorFieldValue::print(std::ostream& out, bool verbose,
     (void) indent;
     out << "{TensorFieldValue: ";
     if (_tensor) {
-        auto slime = SlimeBinaryFormat::serialize(*_tensor);
-        vespalib::SimpleBuffer buf;
-        JsonFormat::encode(*slime, buf, true);
-        auto json = buf.get().make_string();
-        out << json;
+        out << Engine::ref().to_spec(*_tensor).to_string();
     } else {
         out << "null";
     }