diff options
author | Geir Storli <geirst@yahoo-inc.com> | 2017-04-04 19:23:13 +0000 |
---|---|---|
committer | Geir Storli <geirst@yahoo-inc.com> | 2017-04-05 07:49:16 +0000 |
commit | ae812c64492160223a0a3e674f38c2d5a59c2663 (patch) | |
tree | 75835e5e0e833a9c7cc3e2d4a853a489d5aaa202 /searchcommon | |
parent | d8b05c79c106204ee76726aff4d3f0cb84d8fc99 (diff) |
Change schema::DataType and schema::CollectionType to enum class.
Diffstat (limited to 'searchcommon')
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; } |