Change schema::DataType and schema::CollectionType to enum class.

5 files changed, 123 insertions, 102 deletions

diff --git a/searchcommon/src/tests/schema/schema_test.cpp b/searchcommon/src/tests/schema/schema_test.cpp
index f399215dbda..1365de0fd96 100644
--- a/searchcommon/src/tests/schema/schema_test.cpp
+++ b/searchcommon/src/tests/schema/schema_test.cpp
@@ -13,6 +13,8 @@ using vespalib::string;
 namespace search {
 namespace index {
 
+using schema::DataType;
+using schema::CollectionType;
 using SIAF = Schema::ImportedAttributeField;
 
 void assertField(const Schema::Field & exp, const Schema::Field & act) {
@@ -72,34 +74,34 @@ TEST("testBasic") {
     EXPECT_EQUAL(0u, s.getNumSummaryFields());
     EXPECT_EQUAL(0u, s.getNumImportedAttributeFields());
 
-    s.addIndexField(Schema::IndexField("foo", schema::STRING));
-    s.addIndexField(Schema::IndexField("bar", schema::INT32));
+    s.addIndexField(Schema::IndexField("foo", DataType::STRING));
+    s.addIndexField(Schema::IndexField("bar", DataType::INT32));
 
-    s.addAttributeField(Schema::AttributeField("foo", schema::STRING, schema::ARRAY));
-    s.addAttributeField(Schema::AttributeField("bar", schema::INT32,  schema::WEIGHTEDSET));
-    s.addAttributeField(Schema::AttributeField("cox", schema::STRING));
+    s.addAttributeField(Schema::AttributeField("foo", DataType::STRING, CollectionType::ARRAY));
+    s.addAttributeField(Schema::AttributeField("bar", DataType::INT32,  CollectionType::WEIGHTEDSET));
+    s.addAttributeField(Schema::AttributeField("cox", DataType::STRING));
 
-    s.addSummaryField(Schema::SummaryField("foo", schema::STRING, schema::ARRAY));
-    s.addSummaryField(Schema::SummaryField("bar", schema::INT32,  schema::WEIGHTEDSET));
-    s.addSummaryField(Schema::SummaryField("cox", schema::STRING));
-    s.addSummaryField(Schema::SummaryField("fox", schema::RAW));
+    s.addSummaryField(Schema::SummaryField("foo", DataType::STRING, CollectionType::ARRAY));
+    s.addSummaryField(Schema::SummaryField("bar", DataType::INT32,  CollectionType::WEIGHTEDSET));
+    s.addSummaryField(Schema::SummaryField("cox", DataType::STRING));
+    s.addSummaryField(Schema::SummaryField("fox", DataType::RAW));
 
     s.addFieldSet(Schema::FieldSet("default").addField("foo").addField("bar"));
 
-    s.addImportedAttributeField(SIAF("imported", schema::INT32));
+    s.addImportedAttributeField(SIAF("imported", DataType::INT32));
 
     EXPECT_EQUAL(2u, s.getNumIndexFields());
     {
         EXPECT_EQUAL("foo", s.getIndexField(0).getName());
-        EXPECT_EQUAL(schema::STRING, s.getIndexField(0).getDataType());
-        EXPECT_EQUAL(schema::SINGLE, s.getIndexField(0).getCollectionType());
+        EXPECT_EQUAL(DataType::STRING, s.getIndexField(0).getDataType());
+        EXPECT_EQUAL(CollectionType::SINGLE, s.getIndexField(0).getCollectionType());
         EXPECT_TRUE(!s.getIndexField(0).hasPrefix());
         EXPECT_TRUE(!s.getIndexField(0).hasPhrases());
         EXPECT_TRUE(s.getIndexField(0).hasPositions());
 
         EXPECT_EQUAL("bar", s.getIndexField(1).getName());
-        EXPECT_EQUAL(schema::INT32, s.getIndexField(1).getDataType());
-        EXPECT_EQUAL(schema::SINGLE, s.getIndexField(1).getCollectionType());
+        EXPECT_EQUAL(DataType::INT32, s.getIndexField(1).getDataType());
+        EXPECT_EQUAL(CollectionType::SINGLE, s.getIndexField(1).getCollectionType());
 
         EXPECT_EQUAL(0u, s.getIndexFieldId("foo"));
         EXPECT_EQUAL(1u, s.getIndexFieldId("bar"));
@@ -108,16 +110,16 @@ TEST("testBasic") {
     EXPECT_EQUAL(3u, s.getNumAttributeFields());
     {
         EXPECT_EQUAL("foo", s.getAttributeField(0).getName());
-        EXPECT_EQUAL(schema::STRING, s.getAttributeField(0).getDataType());
-        EXPECT_EQUAL(schema::ARRAY, s.getAttributeField(0).getCollectionType());
+        EXPECT_EQUAL(DataType::STRING, s.getAttributeField(0).getDataType());
+        EXPECT_EQUAL(CollectionType::ARRAY, s.getAttributeField(0).getCollectionType());
 
         EXPECT_EQUAL("bar", s.getAttributeField(1).getName());
-        EXPECT_EQUAL(schema::INT32, s.getAttributeField(1).getDataType());
-        EXPECT_EQUAL(schema::WEIGHTEDSET, s.getAttributeField(1).getCollectionType());
+        EXPECT_EQUAL(DataType::INT32, s.getAttributeField(1).getDataType());
+        EXPECT_EQUAL(CollectionType::WEIGHTEDSET, s.getAttributeField(1).getCollectionType());
 
         EXPECT_EQUAL("cox", s.getAttributeField(2).getName());
-        EXPECT_EQUAL(schema::STRING, s.getAttributeField(2).getDataType());
-        EXPECT_EQUAL(schema::SINGLE, s.getAttributeField(2).getCollectionType());
+        EXPECT_EQUAL(DataType::STRING, s.getAttributeField(2).getDataType());
+        EXPECT_EQUAL(CollectionType::SINGLE, s.getAttributeField(2).getCollectionType());
 
         EXPECT_EQUAL(0u, s.getAttributeFieldId("foo"));
         EXPECT_EQUAL(1u, s.getAttributeFieldId("bar"));
@@ -127,20 +129,20 @@ TEST("testBasic") {
     EXPECT_EQUAL(4u, s.getNumSummaryFields());
     {
         EXPECT_EQUAL("foo", s.getSummaryField(0).getName());
-        EXPECT_EQUAL(schema::STRING, s.getSummaryField(0).getDataType());
-        EXPECT_EQUAL(schema::ARRAY, s.getSummaryField(0).getCollectionType());
+        EXPECT_EQUAL(DataType::STRING, s.getSummaryField(0).getDataType());
+        EXPECT_EQUAL(CollectionType::ARRAY, s.getSummaryField(0).getCollectionType());
 
         EXPECT_EQUAL("bar", s.getSummaryField(1).getName());
-        EXPECT_EQUAL(schema::INT32, s.getSummaryField(1).getDataType());
-        EXPECT_EQUAL(schema::WEIGHTEDSET, s.getSummaryField(1).getCollectionType());
+        EXPECT_EQUAL(DataType::INT32, s.getSummaryField(1).getDataType());
+        EXPECT_EQUAL(CollectionType::WEIGHTEDSET, s.getSummaryField(1).getCollectionType());
 
         EXPECT_EQUAL("cox", s.getSummaryField(2).getName());
-        EXPECT_EQUAL(schema::STRING, s.getSummaryField(2).getDataType());
-        EXPECT_EQUAL(schema::SINGLE, s.getSummaryField(2).getCollectionType());
+        EXPECT_EQUAL(DataType::STRING, s.getSummaryField(2).getDataType());
+        EXPECT_EQUAL(CollectionType::SINGLE, s.getSummaryField(2).getCollectionType());
 
         EXPECT_EQUAL("fox", s.getSummaryField(3).getName());
-        EXPECT_EQUAL(schema::RAW, s.getSummaryField(3).getDataType());
-        EXPECT_EQUAL(schema::SINGLE, s.getSummaryField(3).getCollectionType());
+        EXPECT_EQUAL(DataType::RAW, s.getSummaryField(3).getDataType());
+        EXPECT_EQUAL(CollectionType::SINGLE, s.getSummaryField(3).getCollectionType());
 
         EXPECT_EQUAL(0u, s.getSummaryFieldId("foo"));
         EXPECT_EQUAL(1u, s.getSummaryFieldId("bar"));
@@ -159,7 +161,7 @@ TEST("testBasic") {
     {
         const auto &imported = s.getImportedAttributeFields();
         EXPECT_EQUAL(1u, imported.size());
-        TEST_DO(assertField(SIAF("imported", schema::INT32, schema::SINGLE), imported[0]));
+        TEST_DO(assertField(SIAF("imported", DataType::INT32, CollectionType::SINGLE), imported[0]));
     }
 }
 
@@ -219,7 +221,7 @@ TEST("testLoadAndSave") {
         EXPECT_TRUE(s3.loadFromFile("schema.txt"));
         assertSchema(s, s3); // test that saved file is loaded correctly
         s3.addIndexField(SIF("foo", SDT::STRING));
-        s3.addImportedAttributeField(SIAF("imported", schema::INT32));
+        s3.addImportedAttributeField(SIAF("imported", DataType::INT32));
         EXPECT_TRUE(s3.loadFromFile("schema.txt")); // load should clear the current content
         assertSchema(s, s3);
     }
@@ -228,7 +230,7 @@ TEST("testLoadAndSave") {
         EXPECT_TRUE(s.saveToFile("schema2.txt"));
         Schema s2;
         s2.addIndexField(SIF("foo", SDT::STRING));
-        s2.addImportedAttributeField(SIAF("imported", schema::INT32));
+        s2.addImportedAttributeField(SIAF("imported", DataType::INT32));
         EXPECT_TRUE(s2.loadFromFile("schema2.txt"));
         assertSchema(s, s2);
     }
@@ -243,7 +245,7 @@ TEST("require that schema can save and load timestamps for fields") {
     const fastos::TimeStamp timestamp(42);
     const std::string file_name = "schema-with-timestamps.txt";
     Schema s;
-    Schema::IndexField f("foo", schema::STRING);
+    Schema::IndexField f("foo", DataType::STRING);
     f.setTimestamp(timestamp);
     s.addIndexField(f);
     ASSERT_TRUE(s.saveToFile(file_name));
@@ -256,7 +258,7 @@ TEST("require that schema can save and load timestamps for fields") {
 TEST("require that timestamps are omitted when 0.") {
     const std::string file_name = "schema-without-timestamps.txt";
     Schema s;
-    s.addIndexField(Schema::IndexField("foo", schema::STRING));
+    s.addIndexField(Schema::IndexField("foo", DataType::STRING));
     ASSERT_TRUE(s.saveToFile(file_name));
 
     std::ifstream file(file_name.c_str());
@@ -274,15 +276,15 @@ TEST("require that timestamps are omitted when 0.") {
 
 void addAllFieldTypes(const string &name, Schema &schema,
                       fastos::TimeStamp timestamp) {
-    Schema::IndexField index_field(name, schema::STRING);
+    Schema::IndexField index_field(name, DataType::STRING);
     index_field.setTimestamp(timestamp);
     schema.addIndexField(index_field);
 
-    Schema::AttributeField attribute_field(name, schema::STRING);
+    Schema::AttributeField attribute_field(name, DataType::STRING);
     attribute_field.setTimestamp(timestamp);
     schema.addAttributeField(attribute_field);
 
-    Schema::SummaryField summary_field(name, schema::STRING);
+    Schema::SummaryField summary_field(name, DataType::STRING);
     summary_field.setTimestamp(timestamp);
     schema.addSummaryField(summary_field);
 
@@ -387,9 +389,9 @@ TEST("require that schema can calculate intersection") {
 TEST("require that incompatible fields are removed from intersection") {
     const string name = "foo";
     Schema s1;
-    s1.addIndexField(Schema::IndexField(name, schema::STRING));
+    s1.addIndexField(Schema::IndexField(name, DataType::STRING));
     Schema s2;
-    s2.addIndexField(Schema::IndexField(name, schema::INT32));
+    s2.addIndexField(Schema::IndexField(name, DataType::INT32));
     Schema::UP schema = Schema::intersect(s1, s2);
     EXPECT_EQUAL(0u, schema->getNumIndexFields());
     EXPECT_FALSE(schema->isIndexField(name));
@@ -400,7 +402,7 @@ TEST("require that imported attribute fields are not saved to disk")
     const vespalib::string fileName = "schema-no-imported-fields.txt";
     {
         Schema s;
-        s.addImportedAttributeField(Schema::ImportedAttributeField("imported", schema::INT32));
+        s.addImportedAttributeField(Schema::ImportedAttributeField("imported", DataType::INT32));
         s.saveToFile(fileName);
     }
     {
@@ -416,8 +418,8 @@ TEST("require that schema can be built from imported-fields config")
     SchemaConfigurer configurer(s, "dir:" + TEST_PATH("imported-fields-cfg"));
     const auto &imported = s.getImportedAttributeFields();
     EXPECT_EQUAL(2u, imported.size());
-    TEST_DO(assertField(SIAF("imported_a", schema::STRING, schema::SINGLE), imported[0]));
-    TEST_DO(assertField(SIAF("imported_b", schema::STRING, schema::SINGLE), imported[1]));
+    TEST_DO(assertField(SIAF("imported_a", DataType::STRING, CollectionType::SINGLE), imported[0]));
+    TEST_DO(assertField(SIAF("imported_b", DataType::STRING, CollectionType::SINGLE), imported[1]));
 }
 
 }  // namespace index
diff --git a/searchcommon/src/vespa/searchcommon/common/datatype.cpp b/searchcommon/src/vespa/searchcommon/common/datatype.cpp
index b28fc06b3fd..ef6dcfc3ad6 100644
--- a/searchcommon/src/vespa/searchcommon/common/datatype.cpp
+++ b/searchcommon/src/vespa/searchcommon/common/datatype.cpp
@@ -13,20 +13,20 @@ using config::InvalidConfigException;
 
 DataType
 dataTypeFromName(const vespalib::stringref &name) {
-    if      (name == "UINT1")   { return UINT1; }
-    else if (name == "UINT2")   { return UINT2; }
-    else if (name == "UINT4")   { return UINT4; }
-    else if (name == "INT8")    { return INT8; }
-    else if (name == "INT16")   { return INT16; }
-    else if (name == "INT32")   { return INT32; }
-    else if (name == "INT64")   { return INT64; }
-    else if (name == "FLOAT")   { return FLOAT; }
-    else if (name == "DOUBLE")  { return DOUBLE; }
-    else if (name == "STRING")  { return STRING; }
-    else if (name == "RAW")     { return RAW; }
-    else if (name == "BOOLEANTREE") { return BOOLEANTREE; }
-    else if (name == "TENSOR") { return TENSOR; }
-    else if (name == "REFERENCE") { return REFERENCE; }
+    if      (name == "UINT1")   { return DataType::UINT1; }
+    else if (name == "UINT2")   { return DataType::UINT2; }
+    else if (name == "UINT4")   { return DataType::UINT4; }
+    else if (name == "INT8")    { return DataType::INT8; }
+    else if (name == "INT16")   { return DataType::INT16; }
+    else if (name == "INT32")   { return DataType::INT32; }
+    else if (name == "INT64")   { return DataType::INT64; }
+    else if (name == "FLOAT")   { return DataType::FLOAT; }
+    else if (name == "DOUBLE")  { return DataType::DOUBLE; }
+    else if (name == "STRING")  { return DataType::STRING; }
+    else if (name == "RAW")     { return DataType::RAW; }
+    else if (name == "BOOLEANTREE") { return DataType::BOOLEANTREE; }
+    else if (name == "TENSOR") { return DataType::TENSOR; }
+    else if (name == "REFERENCE") { return DataType::REFERENCE; }
     else {
         throw InvalidConfigException("Illegal enum value '" + name + "'");
     }
@@ -50,19 +50,26 @@ const char *datatype_str[] = { "UINT1",
 
 vespalib::string
 getTypeName(DataType type) {
-    if (type > vespalib::arraysize(datatype_str)) {
+    if (static_cast<size_t>(type) > vespalib::arraysize(datatype_str)) {
         vespalib::asciistream ost;
-        ost << "UNKNOWN(" << type << ")";
+        ost << "UNKNOWN(" << static_cast<size_t>(type) << ")";
         return ost.str();
     }
-    return datatype_str[type];
+    return datatype_str[static_cast<size_t>(type)];
+}
+
+std::ostream &
+operator<<(std::ostream &os, const DataType &type)
+{
+    os << getTypeName(type);
+    return os;
 }
 
 CollectionType
 collectionTypeFromName(const vespalib::stringref &name) {
-    if (name == "SINGLE") { return SINGLE; }
-    else if (name == "ARRAY") { return ARRAY; }
-    else if (name == "WEIGHTEDSET") { return WEIGHTEDSET; }
+    if (name == "SINGLE") { return CollectionType::SINGLE; }
+    else if (name == "ARRAY") { return CollectionType::ARRAY; }
+    else if (name == "WEIGHTEDSET") { return CollectionType::WEIGHTEDSET; }
     else {
         throw InvalidConfigException("Illegal enum value '" + name + "'");
     }
@@ -74,14 +81,20 @@ const char *collectiontype_str[] = { "SINGLE",
 
 vespalib::string
 getTypeName(CollectionType type) {
-    if (type > vespalib::arraysize(collectiontype_str)) {
+    if (static_cast<size_t>(type) > vespalib::arraysize(collectiontype_str)) {
         vespalib::asciistream ost;
-        ost << "UNKNOWN(" << type << ")";
+        ost << "UNKNOWN(" << static_cast<size_t>(type) << ")";
         return ost.str();
     }
-    return collectiontype_str[type];
+    return collectiontype_str[static_cast<size_t>(type)];
 }
 
+std::ostream &
+operator<<(std::ostream &os, const CollectionType &type)
+{
+    os << getTypeName(type);
+    return os;
+}
 
 }
 }
diff --git a/searchcommon/src/vespa/searchcommon/common/datatype.h b/searchcommon/src/vespa/searchcommon/common/datatype.h
index f73274d58c0..1570bfdb688 100644
--- a/searchcommon/src/vespa/searchcommon/common/datatype.h
+++ b/searchcommon/src/vespa/searchcommon/common/datatype.h
@@ -11,7 +11,7 @@ namespace schema {
 /**
  * Basic data type for a field.
  **/
-enum DataType { UINT1 = 0,
+enum class DataType { UINT1 = 0,
     UINT2 = 1,
     UINT4 = 2,
     INT8 = 3,
@@ -31,15 +31,19 @@ enum DataType { UINT1 = 0,
 /**
  * Collection type for a field.
  **/
-enum CollectionType { SINGLE = 0,
+enum class CollectionType { SINGLE = 0,
     ARRAY = 1,
     WEIGHTEDSET = 2
 };
 
 DataType dataTypeFromName(const vespalib::stringref &name);
 vespalib::string getTypeName(DataType type);
+std::ostream &operator<<(std::ostream &os, const DataType &type);
+
 CollectionType collectionTypeFromName(const vespalib::stringref &n);
 vespalib::string getTypeName(CollectionType type);
+std::ostream &operator<<(std::ostream &os, const CollectionType &type);
+
 
 }
 }
diff --git a/searchcommon/src/vespa/searchcommon/common/schema.cpp b/searchcommon/src/vespa/searchcommon/common/schema.cpp
index f2e64cd943e..720b4572fa8 100644
--- a/searchcommon/src/vespa/searchcommon/common/schema.cpp
+++ b/searchcommon/src/vespa/searchcommon/common/schema.cpp
@@ -72,7 +72,7 @@ const uint32_t Schema::UNKNOWN_FIELD_ID(std::numeric_limits<uint32_t>::max());
 Schema::Field::Field(const vespalib::stringref &n, DataType dt)
     : _name(n),
       _dataType(dt),
-      _collectionType(schema::SINGLE),
+      _collectionType(schema::CollectionType::SINGLE),
       _timestamp(0)
 {
 }
diff --git a/searchcommon/src/vespa/searchcommon/common/schemaconfigurer.cpp b/searchcommon/src/vespa/searchcommon/common/schemaconfigurer.cpp
index 195483855cd..cc6d1f972f6 100644
--- a/searchcommon/src/vespa/searchcommon/common/schemaconfigurer.cpp
+++ b/searchcommon/src/vespa/searchcommon/common/schemaconfigurer.cpp
@@ -12,19 +12,21 @@ using namespace vespa::config::search;
 namespace search {
 namespace index {
 
+using schema::DataType;
+using schema::CollectionType;
 
 Schema::DataType
 SchemaBuilder::convert(const IndexschemaConfig::Indexfield::Datatype &type)
 {
     switch (type) {
     case IndexschemaConfig::Indexfield::STRING:
-        return schema::STRING;
+        return DataType::STRING;
     case IndexschemaConfig::Indexfield::INT64:
-        return schema::INT64;
+        return DataType::INT64;
     case IndexschemaConfig::Indexfield::BOOLEANTREE:
-        return schema::BOOLEANTREE;
+        return DataType::BOOLEANTREE;
     }
-    return schema::STRING;
+    return DataType::STRING;
 }
 
 
@@ -33,13 +35,13 @@ SchemaBuilder::convert(const IndexschemaConfig::Indexfield::Collectiontype & typ
 {
     switch (type) {
     case IndexschemaConfig::Indexfield::SINGLE:
-        return schema::SINGLE;
+        return CollectionType::SINGLE;
     case IndexschemaConfig::Indexfield::ARRAY:
-        return schema::ARRAY;
+        return CollectionType::ARRAY;
     case IndexschemaConfig::Indexfield::WEIGHTEDSET:
-        return schema::WEIGHTEDSET;
+        return CollectionType::WEIGHTEDSET;
     }
-    return schema::SINGLE;
+    return CollectionType::SINGLE;
 }
 
 
@@ -48,36 +50,36 @@ SchemaBuilder::convert(const AttributesConfig::Attribute::Datatype &type)
 {
     switch (type) {
     case AttributesConfig::Attribute::STRING:
-        return schema::STRING;
+        return DataType::STRING;
     case AttributesConfig::Attribute::UINT1:
-        return schema::UINT1;
+        return DataType::UINT1;
     case AttributesConfig::Attribute::UINT2:
-        return schema::UINT2;
+        return DataType::UINT2;
     case AttributesConfig::Attribute::UINT4:
-        return schema::UINT4;
+        return DataType::UINT4;
     case AttributesConfig::Attribute::INT8:
-        return schema::INT8;
+        return DataType::INT8;
     case AttributesConfig::Attribute::INT16:
-        return schema::INT16;
+        return DataType::INT16;
     case AttributesConfig::Attribute::INT32:
-        return schema::INT32;
+        return DataType::INT32;
     case AttributesConfig::Attribute::INT64:
-        return schema::INT64;
+        return DataType::INT64;
     case AttributesConfig::Attribute::FLOAT:
-        return schema::FLOAT;
+        return DataType::FLOAT;
     case AttributesConfig::Attribute::DOUBLE:
-        return schema::DOUBLE;
+        return DataType::DOUBLE;
     case AttributesConfig::Attribute::PREDICATE:
-        return schema::BOOLEANTREE;
+        return DataType::BOOLEANTREE;
     case AttributesConfig::Attribute::TENSOR:
-        return schema::TENSOR;
+        return DataType::TENSOR;
     case AttributesConfig::Attribute::REFERENCE:
-        return schema::REFERENCE;
+        return DataType::REFERENCE;
     default:
         break;
     }
     // TODO: exception?
-    return schema::STRING;
+    return DataType::STRING;
 }
 
 
@@ -86,13 +88,13 @@ SchemaBuilder::convert(const AttributesConfig::Attribute::Collectiontype &type)
 {
     switch (type) {
     case AttributesConfig::Attribute::SINGLE:
-        return schema::SINGLE;
+        return CollectionType::SINGLE;
     case AttributesConfig::Attribute::ARRAY:
-        return schema::ARRAY;
+        return CollectionType::ARRAY;
     case AttributesConfig::Attribute::WEIGHTEDSET:
-        return schema::WEIGHTEDSET;
+        return CollectionType::WEIGHTEDSET;
     }
-    return schema::SINGLE;
+    return CollectionType::SINGLE;
 }
 
 
@@ -100,30 +102,30 @@ Schema::DataType
 SchemaBuilder::convertSummaryType(const vespalib::string & type)
 {
     if (type == "byte") {
-        return schema::INT8;
+        return DataType::INT8;
     } else if (type == "short") {
-        return schema::INT16;
+        return DataType::INT16;
     } else if (type == "integer") {
-        return schema::INT32;
+        return DataType::INT32;
     } else if (type == "int64") {
-        return schema::INT64;
+        return DataType::INT64;
     } else if (type == "float") {
-        return schema::FLOAT;
+        return DataType::FLOAT;
     } else if (type == "double") {
-        return schema::DOUBLE;
+        return DataType::DOUBLE;
     } else if (type == "string" ||
                type == "longstring" ||
                type == "xmlstring" ||
                type == "featuredata" ||
                type == "jsonstring")
     {
-        return schema::STRING;
+        return DataType::STRING;
     } else if (type == "data" ||
                type == "longdata")
     {
-        return schema::RAW;
+        return DataType::RAW;
     }
-    return schema::RAW;
+    return DataType::RAW;
 }