Add Chunk as suffix for types and throw instead of making a guess.

4 files changed, 32 insertions, 30 deletions

diff --git a/searchlib/src/tests/transactionlog/chunks_test.cpp b/searchlib/src/tests/transactionlog/chunks_test.cpp
index c2f139cc310..de530884933 100644
--- a/searchlib/src/tests/transactionlog/chunks_test.cpp
+++ b/searchlib/src/tests/transactionlog/chunks_test.cpp
@@ -30,31 +30,31 @@ verifySerializationAndDeserialization(IChunk & org, size_t numEntries) {
 }
 
 TEST("test serialization and deserialization of current default uncompressed xxh64") {
-    XXH64None chunk;
+    XXH64NoneChunk chunk;
     verifySerializationAndDeserialization(chunk, 1);
 }
 
 TEST("test serialization and deserialization of legacy uncompressed ccittcrc32") {
-    CCITTCRC32None chunk;
+    CCITTCRC32NoneChunk chunk;
     verifySerializationAndDeserialization(chunk, 1);
 }
 
 TEST("test serialization and deserialization of future multientry xxh64 lz4 compression") {
     for (size_t level(1); level < 9; level++) {
-        XXH64Compressed chunk(CompressionConfig::Type::LZ4, level);
+        XXH64CompressedChunk chunk(CompressionConfig::Type::LZ4, level);
         verifySerializationAndDeserialization(chunk, 100);
     }
 }
 
 TEST("test serialization and deserialization of future multientry xxh64 zstd compression") {
     for (size_t level(1); level < 9; level++) {
-        XXH64Compressed chunk(CompressionConfig::Type::ZSTD, level);
+        XXH64CompressedChunk chunk(CompressionConfig::Type::ZSTD, level);
         verifySerializationAndDeserialization(chunk, 100);
     }
 }
 
 TEST("test serialization and deserialization of future multientry xxh64 no compression") {
-    XXH64Compressed chunk(CompressionConfig::Type::NONE_MULTI, 1);
+    XXH64CompressedChunk chunk(CompressionConfig::Type::NONE_MULTI, 1);
     verifySerializationAndDeserialization(chunk, 100);
 }
 
diff --git a/searchlib/src/vespa/searchlib/transactionlog/chunks.cpp b/searchlib/src/vespa/searchlib/transactionlog/chunks.cpp
index d630dfbf8e8..bc740a27cdb 100644
--- a/searchlib/src/vespa/searchlib/transactionlog/chunks.cpp
+++ b/searchlib/src/vespa/searchlib/transactionlog/chunks.cpp
@@ -54,7 +54,7 @@ toCompression(CompressionConfig::Type type) {
 }
 
 Encoding
-CCITTCRC32None::onEncode(nbostream &os) const {
+CCITTCRC32NoneChunk::onEncode(nbostream &os) const {
     size_t start = os.wp();
     assert(getEntries().size() == 1);
     serializeEntries(os);
@@ -63,7 +63,7 @@ CCITTCRC32None::onEncode(nbostream &os) const {
 }
 
 void
-CCITTCRC32None::onDecode(nbostream &is) {
+CCITTCRC32NoneChunk::onDecode(nbostream &is) {
     verifyCrc(is, Encoding::Crc::ccitt_crc32);
     nbostream data(is.peek(), is.size() - sizeof(int32_t));
     deserializeEntries(data);
@@ -71,7 +71,7 @@ CCITTCRC32None::onDecode(nbostream &is) {
 }
 
 Encoding
-XXH64None::onEncode(nbostream &os) const {
+XXH64NoneChunk::onEncode(nbostream &os) const {
     size_t start = os.wp();
     assert(getEntries().size() == 1);
     serializeEntries(os);
@@ -80,7 +80,7 @@ XXH64None::onEncode(nbostream &os) const {
 }
 
 void
-XXH64None::onDecode(nbostream &is) {
+XXH64NoneChunk::onDecode(nbostream &is) {
     verifyCrc(is, Encoding::Crc::xxh64);
     nbostream data(is.peek(), is.size() - sizeof(int32_t));
     deserializeEntries(data);
@@ -88,7 +88,7 @@ XXH64None::onDecode(nbostream &is) {
 }
 
 void
-XXH64Compressed::decompress(nbostream & is, uint32_t uncompressedLen) {
+XXH64CompressedChunk::decompress(nbostream & is, uint32_t uncompressedLen) {
     vespalib::DataBuffer uncompressed;
     ConstBufferRef compressed(is.peek(), is.size() - sizeof(int32_t));
     ::decompress(_type, uncompressedLen, compressed, uncompressed, false);
@@ -97,13 +97,13 @@ XXH64Compressed::decompress(nbostream & is, uint32_t uncompressedLen) {
     is.adjustReadPos(is.size());
 }
 
-XXH64Compressed::XXH64Compressed(CompressionConfig::Type type, uint8_t level)
+XXH64CompressedChunk::XXH64CompressedChunk(CompressionConfig::Type type, uint8_t level)
     : _type(type),
       _level(level)
 { }
 
 Encoding
-XXH64Compressed::compress(nbostream & os, Encoding::Crc crc) const {
+XXH64CompressedChunk::compress(nbostream & os, Encoding::Crc crc) const {
     nbostream org;
     serializeEntries(org);
     DataBuffer compressed;
@@ -118,12 +118,12 @@ XXH64Compressed::compress(nbostream & os, Encoding::Crc crc) const {
 }
 
 Encoding
-XXH64Compressed::onEncode(IChunk::nbostream &os) const {
+XXH64CompressedChunk::onEncode(IChunk::nbostream &os) const {
     return compress(os, Encoding::Crc::xxh64);
 }
 
 void
-XXH64Compressed::onDecode(IChunk::nbostream &is) {
+XXH64CompressedChunk::onDecode(IChunk::nbostream &is) {
     uint32_t uncompressedLen;
     is >> uncompressedLen;
     verifyCrc(is, Encoding::Crc::xxh64);
diff --git a/searchlib/src/vespa/searchlib/transactionlog/chunks.h b/searchlib/src/vespa/searchlib/transactionlog/chunks.h
index cf7116511dc..9b09a0b20fb 100644
--- a/searchlib/src/vespa/searchlib/transactionlog/chunks.h
+++ b/searchlib/src/vespa/searchlib/transactionlog/chunks.h
@@ -8,7 +8,7 @@
 namespace search::transactionlog {
 
 /// Current default chunk serialisation format
-class XXH64None : public IChunk {
+class XXH64NoneChunk : public IChunk {
 protected:
     Encoding onEncode(nbostream &os) const override;
     void onDecode(nbostream &is) override;
@@ -16,7 +16,7 @@ public:
 };
 
 /// TODO Legacy chunk serialisation format to be removed soon.
-class CCITTCRC32None : public IChunk {
+class CCITTCRC32NoneChunk : public IChunk {
 protected:
     Encoding onEncode(nbostream &os) const override;
     void onDecode(nbostream &is) override;
@@ -24,10 +24,10 @@ public:
 };
 
 /// Future default chunk serialisation format
-class XXH64Compressed : public IChunk {
+class XXH64CompressedChunk : public IChunk {
 public:
     using CompressionConfig = vespalib::compression::CompressionConfig;
-    XXH64Compressed(CompressionConfig::Type, uint8_t level);
+    XXH64CompressedChunk(CompressionConfig::Type, uint8_t level);
 protected:
     void decompress(nbostream & os, uint32_t uncompressedLen);
     Encoding compress(nbostream & os, Encoding::Crc crc) const;
diff --git a/searchlib/src/vespa/searchlib/transactionlog/ichunk.cpp b/searchlib/src/vespa/searchlib/transactionlog/ichunk.cpp
index 16387e0c563..36edd832c5a 100644
--- a/searchlib/src/vespa/searchlib/transactionlog/ichunk.cpp
+++ b/searchlib/src/vespa/searchlib/transactionlog/ichunk.cpp
@@ -3,19 +3,20 @@
 #include "chunks.h"
 #include <vespa/vespalib/util/stringfmt.h>
 #include <vespa/vespalib/util/crc.h>
+#include <vespa/vespalib/util/exceptions.h>
 #include <xxhash.h>
 #include <cassert>
 
-using std::runtime_error;
 using std::make_unique;
-using vespalib::make_string;
+using vespalib::make_string_short::fmt;
 using vespalib::nbostream_longlivedbuf;
 using vespalib::compression::CompressionConfig;
+using vespalib::IllegalArgumentException;
 
 namespace search::transactionlog {
 
 Encoding::Encoding(Crc crc, Compression compression)
-    : _raw(crc | (compression << 4))
+    : _raw(crc | (compression << 4u))
 {
     assert(crc <= Crc::xxh64);
     assert(compression <= Compression::zstd);
@@ -71,26 +72,27 @@ IChunk::create(Encoding encoding, uint8_t compressionLevel) {
         case Encoding::Crc::xxh64:
             switch (encoding.getCompression()) {
                 case Encoding::Compression::none:
-                    return make_unique<XXH64None>();
+                    return make_unique<XXH64NoneChunk>();
                 case Encoding::Compression::none_multi:
-                    return make_unique<XXH64Compressed>(CompressionConfig::NONE_MULTI, compressionLevel);
+                    return make_unique<XXH64CompressedChunk>(CompressionConfig::NONE_MULTI, compressionLevel);
                 case Encoding::Compression::lz4:
-                    return make_unique<XXH64Compressed>(CompressionConfig::LZ4, compressionLevel);
+                    return make_unique<XXH64CompressedChunk>(CompressionConfig::LZ4, compressionLevel);
                 case Encoding::Compression::zstd:
-                    return make_unique<XXH64Compressed>(CompressionConfig::ZSTD, compressionLevel);
+                    return make_unique<XXH64CompressedChunk>(CompressionConfig::ZSTD, compressionLevel);
                 default:
-                    return make_unique<XXH64Compressed>(CompressionConfig::LZ4, compressionLevel);
+                    throw IllegalArgumentException(fmt("Unhandled compression type '%d' for xxh64, compression=",
+                                                       encoding.getCompression()));
             }
         case Encoding::Crc::ccitt_crc32:
             switch (encoding.getCompression()) {
                 case Encoding::Compression::none:
-                    return make_unique<CCITTCRC32None>();
+                    return make_unique<CCITTCRC32NoneChunk>();
                 default:
-                    throw runtime_error(make_string("Unhandled compression type '%d' for ccitt_crc32 compression",
-                                                    encoding.getCompression()));
+                    throw IllegalArgumentException(fmt("Unhandled compression type '%d' for ccitt_crc32, compression=",
+                                                       encoding.getCompression()));
             }
         default:
-            throw runtime_error(make_string("Unhandled crc type '%d'", encoding.getCrc()));
+            throw IllegalArgumentException(fmt("Unhandled crc type '%d'", encoding.getCrc()));
     }
 }