Merge pull request #627 from yahoo/toregge/stop-using-blind-static-casts

Replace use of static_cast with dynamic_cast and check for sucess.

4 files changed, 149 insertions, 82 deletions

diff --git a/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor.cpp b/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor.cpp
index caa54bc7606..c2fa7b762af 100644
--- a/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor.cpp
+++ b/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor.cpp
@@ -84,18 +84,22 @@ CompactTensor::sum() const
 Tensor::UP
 CompactTensor::add(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensor &rhs = static_cast<const CompactTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
 }
 
 Tensor::UP
 CompactTensor::subtract(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensor &rhs = static_cast<const CompactTensor &>(arg);
-    return joinTensorsNegated(*this, rhs,
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensorsNegated(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
     // Note that -rhsCell.second is passed to the lambda function, that is why we do addition.
 }
@@ -103,37 +107,46 @@ CompactTensor::subtract(const Tensor &arg) const
 Tensor::UP
 CompactTensor::multiply(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    return CompactTensorProduct(*this, static_cast<const CompactTensor &>(arg)).result();
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return CompactTensorProduct(*this, *rhs).result();
 }
 
 Tensor::UP
 CompactTensor::min(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensor &rhs = static_cast<const CompactTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue) { return std::min(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 CompactTensor::max(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensor &rhs = static_cast<const CompactTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue) { return std::max(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 CompactTensor::match(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensor &rhs = static_cast<const CompactTensor &>(arg);
-    DirectTensorBuilder<CompactTensor> builder(combineDimensionsWith(rhs));
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    DirectTensorBuilder<CompactTensor> builder(combineDimensionsWith(*rhs));
     for (const auto &lhsCell : cells()) {
-        auto rhsItr = rhs.cells().find(lhsCell.first);
-        if (rhsItr != rhs.cells().end()) {
+        auto rhsItr = rhs->cells().find(lhsCell.first);
+        if (rhsItr != rhs->cells().end()) {
             builder.insertCell(lhsCell.first, lhsCell.second * rhsItr->second);
         }
     }
@@ -155,7 +168,11 @@ CompactTensor::sum(const vespalib::string &dimension) const
 bool
 CompactTensor::equals(const Tensor &arg) const
 {
-    return *this == static_cast<const CompactTensor &>(arg);
+    const CompactTensor *rhs = dynamic_cast<const CompactTensor *>(&arg);
+    if (!rhs) {
+        return false;
+    }
+    return *this == *rhs;
 }
 
 vespalib::string
diff --git a/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor_v2.cpp b/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor_v2.cpp
index 056637f2a1c..48962791e59 100644
--- a/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor_v2.cpp
+++ b/vespalib/src/vespa/vespalib/tensor/compact/compact_tensor_v2.cpp
@@ -86,52 +86,66 @@ CompactTensorV2::sum() const
 Tensor::UP
 CompactTensorV2::add(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensorV2 &rhs = static_cast<const CompactTensorV2 &>(arg);
-    return joinCompactTensorsV2(*this, rhs,
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinCompactTensorsV2(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
 }
 
 Tensor::UP
 CompactTensorV2::subtract(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensorV2 &rhs = static_cast<const CompactTensorV2 &>(arg);
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
     // Note that -rhsCell.second is passed to the lambda function, that is why we do addition.
-    return joinCompactTensorsV2Negated(*this, rhs,
+    return joinCompactTensorsV2Negated(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
 }
 
 Tensor::UP
 CompactTensorV2::multiply(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    return CompactTensorV2Product(*this, static_cast<const CompactTensorV2 &>(arg)).result();
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return CompactTensorV2Product(*this, *rhs).result();
 }
 
 Tensor::UP
 CompactTensorV2::min(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensorV2 &rhs = static_cast<const CompactTensorV2 &>(arg);
-    return joinCompactTensorsV2(*this, rhs,
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinCompactTensorsV2(*this, *rhs,
             [](double lhsValue, double rhsValue) { return std::min(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 CompactTensorV2::max(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const CompactTensorV2 &rhs = static_cast<const CompactTensorV2 &>(arg);
-    return joinCompactTensorsV2(*this, rhs,
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinCompactTensorsV2(*this, *rhs,
             [](double lhsValue, double rhsValue) { return std::max(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 CompactTensorV2::match(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    return CompactTensorV2Match(*this, static_cast<const CompactTensorV2 &>(arg)).result();
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return CompactTensorV2Match(*this, *rhs).result();
 }
 
 Tensor::UP
@@ -149,7 +163,11 @@ CompactTensorV2::sum(const vespalib::string &dimension) const
 bool
 CompactTensorV2::equals(const Tensor &arg) const
 {
-    return *this == static_cast<const CompactTensorV2 &>(arg);
+    const CompactTensorV2 *rhs = dynamic_cast<const CompactTensorV2 *>(&arg);
+    if (!rhs) {
+        return false;
+    }
+    return *this == *rhs;
 }
 
 vespalib::string
diff --git a/vespalib/src/vespa/vespalib/tensor/dense/dense_tensor.cpp b/vespalib/src/vespa/vespalib/tensor/dense/dense_tensor.cpp
index 7aaa4e0a71a..1f1b318d9a2 100644
--- a/vespalib/src/vespa/vespalib/tensor/dense/dense_tensor.cpp
+++ b/vespalib/src/vespa/vespalib/tensor/dense/dense_tensor.cpp
@@ -202,10 +202,12 @@ DenseTensor::sum() const
 Tensor::UP
 DenseTensor::add(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
-    checkDimensions(*this, rhs, "add");
-    return joinDenseTensors(*this, rhs,
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    checkDimensions(*this, *rhs, "add");
+    return joinDenseTensors(*this, *rhs,
                             [](double lhsValue, double rhsValue)
                             { return lhsValue + rhsValue; });
 }
@@ -213,11 +215,13 @@ DenseTensor::add(const Tensor &arg) const
 Tensor::UP
 DenseTensor::subtract(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
     // Note that - *rhsCellItr is passed to the lambda function, that is why we do addition.
-    checkDimensions(*this, rhs, "subtract");
-    return joinDenseTensorsNegated(*this, rhs,
+    checkDimensions(*this, *rhs, "subtract");
+    return joinDenseTensorsNegated(*this, *rhs,
                                    [](double lhsValue, double rhsValue)
                                    { return lhsValue + rhsValue; });
 }
@@ -225,18 +229,22 @@ DenseTensor::subtract(const Tensor &arg) const
 Tensor::UP
 DenseTensor::multiply(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
-    return DenseTensorProduct(*this, rhs).result();
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return DenseTensorProduct(*this, *rhs).result();
 }
 
 Tensor::UP
 DenseTensor::min(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
-    checkDimensions(*this, rhs, "min");
-    return joinDenseTensors(*this, rhs,
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    checkDimensions(*this, *rhs, "min");
+    return joinDenseTensors(*this, *rhs,
                             [](double lhsValue, double rhsValue)
                             { return std::min(lhsValue, rhsValue); });
 }
@@ -244,10 +252,12 @@ DenseTensor::min(const Tensor &arg) const
 Tensor::UP
 DenseTensor::max(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
-    checkDimensions(*this, rhs, "max");
-    return joinDenseTensors(*this, rhs,
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    checkDimensions(*this, *rhs, "max");
+    return joinDenseTensors(*this, *rhs,
                             [](double lhsValue, double rhsValue)
                             { return std::max(lhsValue,rhsValue); });
 }
@@ -255,10 +265,12 @@ DenseTensor::max(const Tensor &arg) const
 Tensor::UP
 DenseTensor::match(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const DenseTensor &rhs = static_cast<const DenseTensor &>(arg);
-    checkDimensions(*this, rhs, "match");
-    return joinDenseTensors(*this, rhs,
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    checkDimensions(*this, *rhs, "match");
+    return joinDenseTensors(*this, *rhs,
                             [](double lhsValue, double rhsValue)
                             { return (lhsValue * rhsValue); });
 }
@@ -286,7 +298,11 @@ DenseTensor::sum(const vespalib::string &dimension) const
 bool
 DenseTensor::equals(const Tensor &arg) const
 {
-    return *this == static_cast<const DenseTensor &>(arg);
+    const DenseTensor *rhs = dynamic_cast<const DenseTensor *>(&arg);
+    if (!rhs) {
+        return false;
+    }
+    return *this == *rhs;
 }
 
 vespalib::string
diff --git a/vespalib/src/vespa/vespalib/tensor/simple/simple_tensor.cpp b/vespalib/src/vespa/vespalib/tensor/simple/simple_tensor.cpp
index 0d284b7e9b6..cd1dd935fe8 100644
--- a/vespalib/src/vespa/vespalib/tensor/simple/simple_tensor.cpp
+++ b/vespalib/src/vespa/vespalib/tensor/simple/simple_tensor.cpp
@@ -59,56 +59,69 @@ SimpleTensor::sum() const
 Tensor::UP
 SimpleTensor::add(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const SimpleTensor &rhs = static_cast<const SimpleTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
 }
 
 Tensor::UP
 SimpleTensor::subtract(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const SimpleTensor &rhs = static_cast<const SimpleTensor &>(arg);
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
     // Note that -rhsCell.second is passed to the lambda function, that is why we do addition.
-    return joinTensorsNegated(*this, rhs,
+    return joinTensorsNegated(*this, *rhs,
             [](double lhsValue, double rhsValue) { return lhsValue + rhsValue; });
 }
 
 Tensor::UP
 SimpleTensor::multiply(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    return SimpleTensorProduct(*this, static_cast<const SimpleTensor &>(arg)).result();
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return SimpleTensorProduct(*this, *rhs).result();
 }
 
 Tensor::UP
 SimpleTensor::min(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const SimpleTensor &rhs = static_cast<const SimpleTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue){ return std::min(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 SimpleTensor::max(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const SimpleTensor &rhs = static_cast<const SimpleTensor &>(arg);
-    return joinTensors(*this, rhs,
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    return joinTensors(*this, *rhs,
             [](double lhsValue, double rhsValue){ return std::max(lhsValue, rhsValue); });
 }
 
 Tensor::UP
 SimpleTensor::match(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    const SimpleTensor &rhs = static_cast<const SimpleTensor &>(arg);
-    DirectTensorBuilder<SimpleTensor> builder(combineDimensionsWith(rhs));
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return Tensor::UP();
+    }
+    DirectTensorBuilder<SimpleTensor> builder(combineDimensionsWith(*rhs));
     for (const auto &lhsCell : cells()) {
-        auto rhsItr = rhs.cells().find(lhsCell.first);
-        if (rhsItr != rhs.cells().end()) {
+        auto rhsItr = rhs->cells().find(lhsCell.first);
+        if (rhsItr != rhs->cells().end()) {
             builder.insertCell(lhsCell.first, lhsCell.second * rhsItr->second);
         }
     }
@@ -130,8 +143,11 @@ SimpleTensor::sum(const vespalib::string &dimension) const
 bool
 SimpleTensor::equals(const Tensor &arg) const
 {
-    // TODO (geirst): Better type handling when multiple implementations are available.
-    return *this == static_cast<const SimpleTensor &>(arg);
+    const SimpleTensor *rhs = dynamic_cast<const SimpleTensor *>(&arg);
+    if (!rhs) {
+        return false;
+    }
+    return *this == *rhs;
 }
 
 vespalib::string