Brief implementation skeleton for bool field type.

16 files changed, 163 insertions, 40 deletions

diff --git a/document/src/vespa/document/datatype/datatype.cpp b/document/src/vespa/document/datatype/datatype.cpp
index 8d2721a4d9b..8c17ca4e383 100644
--- a/document/src/vespa/document/datatype/datatype.cpp
+++ b/document/src/vespa/document/datatype/datatype.cpp
@@ -21,6 +21,7 @@ NumericDataType INT_OBJ(DataType::T_INT);
 NumericDataType LONG_OBJ(DataType::T_LONG);
 NumericDataType FLOAT_OBJ(DataType::T_FLOAT);
 NumericDataType DOUBLE_OBJ(DataType::T_DOUBLE);
+NumericDataType BOOL_OBJ(DataType::T_BOOL);
 PrimitiveDataType STRING_OBJ(DataType::T_STRING);
 PrimitiveDataType RAW_OBJ(DataType::T_RAW);
 DocumentType DOCUMENT_OBJ("document");
@@ -37,6 +38,7 @@ const DataType *const DataType::INT(&INT_OBJ);
 const DataType *const DataType::LONG(&LONG_OBJ);
 const DataType *const DataType::FLOAT(&FLOAT_OBJ);
 const DataType *const DataType::DOUBLE(&DOUBLE_OBJ);
+const DataType *const DataType::BOOL(&BOOL_OBJ);
 const DataType *const DataType::STRING(&STRING_OBJ);
 const DataType *const DataType::RAW(&RAW_OBJ);
 const DocumentType *const DataType::DOCUMENT(&DOCUMENT_OBJ);
@@ -71,6 +73,7 @@ DataType2FieldValueId::DataType2FieldValueId()
     _type2FieldValueId[DataType::T_LONG] = LongFieldValue::classId;
     _type2FieldValueId[DataType::T_FLOAT] = FloatFieldValue::classId;
     _type2FieldValueId[DataType::T_DOUBLE] = DoubleFieldValue::classId;
+    _type2FieldValueId[DataType::T_BOOL] = BoolFieldValue::classId;
     _type2FieldValueId[DataType::T_STRING] = StringFieldValue::classId;
     _type2FieldValueId[DataType::T_RAW] = RawFieldValue::classId;
     _type2FieldValueId[DataType::T_URI] = StringFieldValue::classId;
@@ -103,6 +106,7 @@ DataType::getDefaultDataTypes()
     types.push_back(LONG);
     types.push_back(FLOAT);
     types.push_back(DOUBLE);
+    types.push_back(BOOL);
     types.push_back(STRING);
     types.push_back(RAW);
     types.push_back(DOCUMENT);
diff --git a/document/src/vespa/document/datatype/datatype.h b/document/src/vespa/document/datatype/datatype.h
index 4dd5d6aae64..723e7c69ed6 100644
--- a/document/src/vespa/document/datatype/datatype.h
+++ b/document/src/vespa/document/datatype/datatype.h
@@ -66,6 +66,7 @@ public:
         T_RAW         =  3,
         T_LONG        =  4,
         T_DOUBLE      =  5,
+        T_BOOL        =  6,
         T_DOCUMENT    =  8, // Type of super document type Document.0 that all documents inherit.
         // T_TIMESTAMP   =  9,  // Not used anymore, Id should probably not be reused
         T_URI         = 10,
@@ -88,6 +89,7 @@ public:
     static const DataType *const LONG;
     static const DataType *const FLOAT;
     static const DataType *const DOUBLE;
+    static const DataType *const BOOL;
     static const DataType *const STRING;
     static const DataType *const RAW;
     static const DocumentType *const DOCUMENT;
@@ -108,7 +110,7 @@ public:
      * Create a field value using this datatype.
      */
     virtual std::unique_ptr<FieldValue> createFieldValue() const = 0;
-    virtual DataType* clone() const override = 0;
+    DataType* clone() const override = 0;
 
     /**
      * Whether another datatype is a supertype of this one. Document types may
diff --git a/document/src/vespa/document/datatype/primitivedatatype.cpp b/document/src/vespa/document/datatype/primitivedatatype.cpp
index e48e4464acf..7ec47f52d9c 100644
--- a/document/src/vespa/document/datatype/primitivedatatype.cpp
+++ b/document/src/vespa/document/datatype/primitivedatatype.cpp
@@ -23,6 +23,7 @@ namespace {
     const char *Double = "Double";
     const char *Uri = "Uri";
     const char *Byte = "Byte";
+    const char *Bool = "Bool";
     const char *Predicate = "Predicate";
     const char *Tensor = "Tensor";
 
@@ -37,6 +38,7 @@ namespace {
             case DataType::T_DOUBLE: return Double;
             case DataType::T_URI: return Uri;
             case DataType::T_BYTE: return Byte;
+            case DataType::T_BOOL: return Bool;
             case DataType::T_PREDICATE: return Predicate;
             case DataType::T_TENSOR: return Tensor;
             default:
@@ -56,16 +58,17 @@ FieldValue::UP
 PrimitiveDataType::createFieldValue() const
 {
     switch (getId()) {
-        case T_INT: return FieldValue::UP(new IntFieldValue);
-        case T_SHORT: return FieldValue::UP(new ShortFieldValue);
-        case T_FLOAT: return FieldValue::UP(new FloatFieldValue);
-        case T_URI: return FieldValue::UP(new StringFieldValue);
-        case T_STRING: return FieldValue::UP(new StringFieldValue);
-        case T_RAW: return FieldValue::UP(new RawFieldValue);
-        case T_LONG: return FieldValue::UP(new LongFieldValue);
-        case T_DOUBLE: return FieldValue::UP(new DoubleFieldValue);
-        case T_BYTE: return FieldValue::UP(new ByteFieldValue);
-        case T_PREDICATE: return FieldValue::UP(new PredicateFieldValue);
+        case T_INT: return std::make_unique<IntFieldValue>();
+        case T_SHORT: return std::make_unique<ShortFieldValue>();
+        case T_FLOAT: return std::make_unique<FloatFieldValue>();
+        case T_URI: return std::make_unique<StringFieldValue>();
+        case T_STRING: return std::make_unique<StringFieldValue>();
+        case T_RAW: return std::make_unique<RawFieldValue>();
+        case T_LONG: return std::make_unique<LongFieldValue>();
+        case T_DOUBLE: return std::make_unique<DoubleFieldValue>();
+        case T_BOOL: return std::make_unique<BoolFieldValue>();
+        case T_BYTE: return std::make_unique<ByteFieldValue>();
+        case T_PREDICATE: return std::make_unique<PredicateFieldValue>();
         case T_TENSOR: return std::make_unique<TensorFieldValue>();
     }
     LOG_ABORT("getId() returned value out of range");
diff --git a/document/src/vespa/document/fieldvalue/CMakeLists.txt b/document/src/vespa/document/fieldvalue/CMakeLists.txt
index 0b161cff08a..dcef1bc8305 100644
--- a/document/src/vespa/document/fieldvalue/CMakeLists.txt
+++ b/document/src/vespa/document/fieldvalue/CMakeLists.txt
@@ -3,6 +3,7 @@ vespa_add_library(document_fieldvalues OBJECT
     SOURCES
     annotationreferencefieldvalue.cpp
     arrayfieldvalue.cpp
+    boolfieldvalue.cpp
     bytefieldvalue.cpp
     collectionfieldvalue.cpp
     document.cpp
diff --git a/document/src/vespa/document/fieldvalue/boolfieldvalue.cpp b/document/src/vespa/document/fieldvalue/boolfieldvalue.cpp
new file mode 100644
index 00000000000..8ee2556d751
--- /dev/null
+++ b/document/src/vespa/document/fieldvalue/boolfieldvalue.cpp
@@ -0,0 +1,60 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "boolfieldvalue.h"
+#include <vespa/document/datatype/datatype.h>
+#include <vespa/vespalib/util/xmlstream.h>
+#include <ostream>
+
+using namespace vespalib::xml;
+
+namespace document {
+
+IMPLEMENT_IDENTIFIABLE(BoolFieldValue, FieldValue);
+
+BoolFieldValue::BoolFieldValue(bool value)
+    : _value(value), _altered(false) {
+}
+
+BoolFieldValue::~BoolFieldValue() = default;
+
+FieldValue &BoolFieldValue::assign(const FieldValue &rhs) {
+    if (rhs.inherits(BoolFieldValue::classId)) {
+        operator=(static_cast<const BoolFieldValue &>(rhs));
+        return *this;
+    } else {
+        _altered = true;
+        return FieldValue::assign(rhs);
+    }
+}
+
+int BoolFieldValue::compare(const FieldValue&rhs) const {
+    int diff = FieldValue::compare(rhs);
+    if (diff != 0) return diff;
+    const BoolFieldValue &o = static_cast<const BoolFieldValue &>(rhs);
+    return (_value == o._value) ? 0 : _value ? 1 : -1;
+}
+
+void BoolFieldValue::printXml(XmlOutputStream& out) const {
+    out << XmlContent(getAsString());
+}
+
+void BoolFieldValue::print(std::ostream& out, bool, const std::string&) const {
+    out << (_value ? "true" : "false") << "\n";
+}
+
+const DataType *
+BoolFieldValue::getDataType() const {
+    return DataType::BOOL;
+}
+
+bool
+BoolFieldValue::hasChanged() const {
+    return _altered;
+}
+
+FieldValue *
+BoolFieldValue::clone() const {
+    return new BoolFieldValue(*this);
+}
+
+}  // namespace document
diff --git a/document/src/vespa/document/fieldvalue/boolfieldvalue.h b/document/src/vespa/document/fieldvalue/boolfieldvalue.h
new file mode 100644
index 00000000000..d81fa25848d
--- /dev/null
+++ b/document/src/vespa/document/fieldvalue/boolfieldvalue.h
@@ -0,0 +1,37 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#pragma once
+
+#include "fieldvalue.h"
+
+namespace document {
+
+class BoolFieldValue : public FieldValue {
+    bool _value;
+    bool _altered;
+
+public:
+    BoolFieldValue(bool value=false);
+    ~BoolFieldValue() override;
+
+    void accept(FieldValueVisitor &visitor) override { visitor.visit(*this); }
+    void accept(ConstFieldValueVisitor &visitor) const override { visitor.visit(*this); }
+
+    FieldValue *clone() const override;
+    int compare(const FieldValue &rhs) const override;
+
+    void printXml(XmlOutputStream &out) const override;
+    void print(std::ostream &out, bool verbose, const std::string &indent) const override;
+
+    const DataType *getDataType() const override;
+    bool hasChanged() const override;
+
+    bool getValue() const { return _value; }
+    void setValue(bool v) { _value = v; }
+
+    FieldValue &assign(const FieldValue &rhs) override;
+
+    DECLARE_IDENTIFIABLE(BoolFieldValue);
+};
+
+}
diff --git a/document/src/vespa/document/fieldvalue/document.cpp b/document/src/vespa/document/fieldvalue/document.cpp
index 7acc7e97be9..d915d9fd66d 100644
--- a/document/src/vespa/document/fieldvalue/document.cpp
+++ b/document/src/vespa/document/fieldvalue/document.cpp
@@ -10,6 +10,7 @@
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/document/util/serializableexceptions.h>
 #include <vespa/document/base/exceptions.h>
+#include <vespa/document/fieldset/fieldsets.h>
 #include <vespa/document/util/bytebuffer.h>
 #include <vespa/vespalib/util/xmlstream.h>
 #include <sstream>
diff --git a/document/src/vespa/document/fieldvalue/fieldvalues.h b/document/src/vespa/document/fieldvalue/fieldvalues.h
index 6d438bcd0d5..cc665cee95c 100644
--- a/document/src/vespa/document/fieldvalue/fieldvalues.h
+++ b/document/src/vespa/document/fieldvalue/fieldvalues.h
@@ -2,18 +2,19 @@
 
 #pragma once
 
-#include <vespa/document/fieldvalue/arrayfieldvalue.h>
-#include <vespa/document/fieldvalue/bytefieldvalue.h>
-#include <vespa/document/fieldvalue/document.h>
-#include <vespa/document/fieldvalue/doublefieldvalue.h>
-#include <vespa/document/fieldvalue/floatfieldvalue.h>
-#include <vespa/document/fieldvalue/intfieldvalue.h>
-#include <vespa/document/fieldvalue/longfieldvalue.h>
-#include <vespa/document/fieldvalue/mapfieldvalue.h>
-#include <vespa/document/fieldvalue/predicatefieldvalue.h>
-#include <vespa/document/fieldvalue/rawfieldvalue.h>
-#include <vespa/document/fieldvalue/shortfieldvalue.h>
-#include <vespa/document/fieldvalue/stringfieldvalue.h>
-#include <vespa/document/fieldvalue/weightedsetfieldvalue.h>
-#include <vespa/document/fieldvalue/tensorfieldvalue.h>
+#include "arrayfieldvalue.h"
+#include "boolfieldvalue.h"
+#include "bytefieldvalue.h"
+#include "document.h"
+#include "doublefieldvalue.h"
+#include "floatfieldvalue.h"
+#include "intfieldvalue.h"
+#include "longfieldvalue.h"
+#include "mapfieldvalue.h"
+#include "predicatefieldvalue.h"
+#include "rawfieldvalue.h"
+#include "shortfieldvalue.h"
+#include "stringfieldvalue.h"
+#include "weightedsetfieldvalue.h"
+#include "tensorfieldvalue.h"
 
diff --git a/document/src/vespa/document/fieldvalue/fieldvaluevisitor.h b/document/src/vespa/document/fieldvalue/fieldvaluevisitor.h
index ef07dd25212..778b1c77023 100644
--- a/document/src/vespa/document/fieldvalue/fieldvaluevisitor.h
+++ b/document/src/vespa/document/fieldvalue/fieldvaluevisitor.h
@@ -5,6 +5,7 @@
 namespace document {
 class AnnotationReferenceFieldValue;
 class ArrayFieldValue;
+class BoolFieldValue;
 class ByteFieldValue;
 class Document;
 class DoubleFieldValue;
@@ -26,6 +27,7 @@ struct FieldValueVisitor {
 
     virtual void visit(AnnotationReferenceFieldValue &value) = 0;
     virtual void visit(ArrayFieldValue &value) = 0;
+    virtual void visit(BoolFieldValue &value) = 0;
     virtual void visit(ByteFieldValue &value) = 0;
     virtual void visit(Document &value) = 0;
     virtual void visit(DoubleFieldValue &value) = 0;
@@ -48,6 +50,7 @@ struct ConstFieldValueVisitor {
 
     virtual void visit(const AnnotationReferenceFieldValue &value) = 0;
     virtual void visit(const ArrayFieldValue &value) = 0;
+    virtual void visit(const BoolFieldValue &value) = 0;
     virtual void visit(const ByteFieldValue &value) = 0;
     virtual void visit(const Document &value) = 0;
     virtual void visit(const DoubleFieldValue &value) = 0;
diff --git a/document/src/vespa/document/fieldvalue/numericfieldvalue.hpp b/document/src/vespa/document/fieldvalue/numericfieldvalue.hpp
index 90c93e7a944..91873f021d1 100644
--- a/document/src/vespa/document/fieldvalue/numericfieldvalue.hpp
+++ b/document/src/vespa/document/fieldvalue/numericfieldvalue.hpp
@@ -27,8 +27,7 @@ NumericFieldValue<Number>::assign(const FieldValue& value)
         _value = static_cast<Number>(value.getAsLong());
     } else if (value.getClass().id() == IDENTIFIABLE_CLASSID(FloatFieldValue)) {
         _value = static_cast<Number>(value.getAsFloat());
-    } else if (value.getClass().id() == IDENTIFIABLE_CLASSID(DoubleFieldValue))
-    {
+    } else if (value.getClass().id() == IDENTIFIABLE_CLASSID(DoubleFieldValue)) {
         _value = static_cast<Number>(value.getAsDouble());
     } else {
         return FieldValue::assign(value);
diff --git a/document/src/vespa/document/fieldvalue/predicatefieldvalue.h b/document/src/vespa/document/fieldvalue/predicatefieldvalue.h
index d5c58e862f5..e0df3a38353 100644
--- a/document/src/vespa/document/fieldvalue/predicatefieldvalue.h
+++ b/document/src/vespa/document/fieldvalue/predicatefieldvalue.h
@@ -40,5 +40,4 @@ public:
     DECLARE_IDENTIFIABLE(PredicateFieldValue);
 };
 
-}  // namespace document
-
+}
diff --git a/document/src/vespa/document/serialization/vespadocumentdeserializer.cpp b/document/src/vespa/document/serialization/vespadocumentdeserializer.cpp
index 4f30851ac4c..89172b0bc46 100644
--- a/document/src/vespa/document/serialization/vespadocumentdeserializer.cpp
+++ b/document/src/vespa/document/serialization/vespadocumentdeserializer.cpp
@@ -5,6 +5,7 @@
 #include <vespa/document/annotation/spantree.h>
 #include <vespa/document/fieldvalue/annotationreferencefieldvalue.h>
 #include <vespa/document/fieldvalue/arrayfieldvalue.h>
+#include <vespa/document/fieldvalue/boolfieldvalue.h>
 #include <vespa/document/fieldvalue/bytefieldvalue.h>
 #include <vespa/document/fieldvalue/document.h>
 #include <vespa/document/fieldvalue/doublefieldvalue.h>
@@ -190,12 +191,12 @@ void VespaDocumentDeserializer::read(MapFieldValue &value) {
 }
 
 namespace {
-template <typename T> struct ValueType { typedef typename T::Number Type; };
-template <> struct ValueType<ShortFieldValue> { typedef uint16_t Type; };
-template <> struct ValueType<IntFieldValue> { typedef uint32_t Type; };
-template <> struct ValueType<LongFieldValue> { typedef uint64_t Type; };
-template <>
-struct ValueType<RawFieldValue> { typedef vespalib::string Type; };
+template <typename T> struct ValueType { using Type = typename T::Number; };
+template <> struct ValueType<BoolFieldValue> { using Type = bool; };
+template <> struct ValueType<ShortFieldValue> { using Type = uint16_t; };
+template <> struct ValueType<IntFieldValue> { using Type = uint32_t; };
+template <> struct ValueType<LongFieldValue> { using Type = uint64_t; };
+template <> struct ValueType<RawFieldValue> { using Type = vespalib::string; };
 
 template <typename T>
 void readFieldValue(nbostream &input, T &value) {
@@ -214,6 +215,10 @@ stringref readAttributeString(Input &input) {
 }
 }  // namespace
 
+void VespaDocumentDeserializer::read(BoolFieldValue &value) {
+    readFieldValue(_stream, value);
+}
+
 void VespaDocumentDeserializer::read(ByteFieldValue &value) {
     readFieldValue(_stream, value);
 }
diff --git a/document/src/vespa/document/serialization/vespadocumentdeserializer.h b/document/src/vespa/document/serialization/vespadocumentdeserializer.h
index 64346428cdd..e6b490e1075 100644
--- a/document/src/vespa/document/serialization/vespadocumentdeserializer.h
+++ b/document/src/vespa/document/serialization/vespadocumentdeserializer.h
@@ -21,6 +21,7 @@ class VespaDocumentDeserializer : private FieldValueVisitor {
 
     void visit(AnnotationReferenceFieldValue &value) override { read(value); }
     void visit(ArrayFieldValue &value) override { read(value); }
+    void visit(BoolFieldValue &value) override { read(value); }
     void visit(ByteFieldValue &value) override { read(value); }
     void visit(Document &value) override { read(value); }
     void visit(DoubleFieldValue &value) override { read(value); }
@@ -63,6 +64,7 @@ public:
     void read(AnnotationReferenceFieldValue &value);
     void read(ArrayFieldValue &value);
     void read(MapFieldValue &value);
+    void read(BoolFieldValue &value);
     void read(ByteFieldValue &value);
     void read(DoubleFieldValue &value);
     void read(FloatFieldValue &value);
diff --git a/document/src/vespa/document/serialization/vespadocumentserializer.cpp b/document/src/vespa/document/serialization/vespadocumentserializer.cpp
index ae03bcc0d3c..3519f38baab 100644
--- a/document/src/vespa/document/serialization/vespadocumentserializer.cpp
+++ b/document/src/vespa/document/serialization/vespadocumentserializer.cpp
@@ -6,6 +6,7 @@
 #include "util.h"
 #include <vespa/document/fieldvalue/annotationreferencefieldvalue.h>
 #include <vespa/document/fieldvalue/arrayfieldvalue.h>
+#include <vespa/document/fieldvalue/boolfieldvalue.h>
 #include <vespa/document/fieldvalue/bytefieldvalue.h>
 #include <vespa/document/fieldvalue/document.h>
 #include <vespa/document/fieldvalue/doublefieldvalue.h>
@@ -24,6 +25,7 @@
 #include <vespa/document/update/updates.h>
 #include <vespa/document/update/fieldpathupdates.h>
 #include <vespa/document/util/bytebuffer.h>
+#include <vespa/document/fieldset/fieldsets.h>
 #include <vespa/vespalib/data/slime/binary_format.h>
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/data/databuffer.h>
@@ -185,6 +187,10 @@ void VespaDocumentSerializer::write(const MapFieldValue &value) {
     }
 }
 
+void VespaDocumentSerializer::write(const BoolFieldValue &value) {
+    _stream << value.getValue();
+}
+
 void VespaDocumentSerializer::write(const ByteFieldValue &value) {
     _stream << value.getValue();
 }
diff --git a/document/src/vespa/document/serialization/vespadocumentserializer.h b/document/src/vespa/document/serialization/vespadocumentserializer.h
index 818759d35b5..fde073c13b3 100644
--- a/document/src/vespa/document/serialization/vespadocumentserializer.h
+++ b/document/src/vespa/document/serialization/vespadocumentserializer.h
@@ -4,12 +4,10 @@
 
 #include <vespa/document/fieldvalue/fieldvaluevisitor.h>
 #include <vespa/document/fieldvalue/fieldvaluewriter.h>
-#include <vespa/document/fieldset/fieldsets.h>
+#include <vespa/document/fieldset/fieldset.h>
 #include <vespa/document/update/updatevisitor.h>
 
-namespace vespalib {
-    class nbostream;
-}
+namespace vespalib { class nbostream; }
 
 namespace document {
 
@@ -40,6 +38,7 @@ public:
     void write(const AnnotationReferenceFieldValue &value);
     void write(const ArrayFieldValue &value);
     void write(const MapFieldValue &map);
+    void write(const BoolFieldValue &value);
     void write(const ByteFieldValue &value);
     void write(const DoubleFieldValue &val);
     void write(const FloatFieldValue &value);
@@ -90,6 +89,7 @@ private:
 
     void visit(const AnnotationReferenceFieldValue &value) override { write(value); }
     void visit(const ArrayFieldValue &value)               override { write(value); }
+    void visit(const BoolFieldValue &value)                override { write(value); }
     void visit(const ByteFieldValue &value)                override { write(value); }
     void visit(const Document &value)                      override { write(value, COMPLETE); }
     void visit(const DoubleFieldValue &value)              override { write(value); }
diff --git a/document/src/vespa/document/util/identifiableid.h b/document/src/vespa/document/util/identifiableid.h
index c52888e8491..84cfc506bcc 100644
--- a/document/src/vespa/document/util/identifiableid.h
+++ b/document/src/vespa/document/util/identifiableid.h
@@ -19,7 +19,7 @@
 #define CID_StringFieldValue       DOCUMENT_CID(15)
 #define CID_RawFieldValue          DOCUMENT_CID(16)
 //Gone with vespa 6 #define CID_ContentFieldValue      DOCUMENT_CID(17)
-//Long gone #define CID_ContentMetaFieldValue  DOCUMENT_CID(18)
+#define CID_BoolFieldValue  DOCUMENT_CID(18)
 #define CID_ArrayFieldValue        DOCUMENT_CID(19)
 #define CID_WeightedSetFieldValue  DOCUMENT_CID(20)
 #define CID_FieldMapValue          DOCUMENT_CID(21)