Skip to content

Commit

Permalink
ARROW-8279: [C++] Do not export Codec implementation symbols, remove …
Browse files Browse the repository at this point in the history 
…codec-specific headers

This reduces a lot of boilerplate associated with Codec implementation.

Closes #6774 from wesm/reduce-compression-headers

Authored-by: Wes McKinney <wesm+git@apache.org>
Signed-off-by: Wes McKinney <wesm+git@apache.org>
  • Loading branch information
@wesm
wesm committed Mar 31, 2020
1 parent 087464c commit 6ce0948
Show file tree
Hide file tree
Showing 17 changed files with 463 additions and 706 deletions.
40 changes: 8 additions & 32 deletions cpp/src/arrow/util/compression.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,37 +17,13 @@

#include "arrow/util/compression.h"

#include <limits>
#include <memory>
#include <string>
#include <utility>

#ifdef ARROW_WITH_BROTLI
#include "arrow/util/compression_brotli.h"
#endif

#ifdef ARROW_WITH_SNAPPY
#include "arrow/util/compression_snappy.h"
#endif

#ifdef ARROW_WITH_LZ4
#include "arrow/util/compression_lz4.h"
#endif

#ifdef ARROW_WITH_ZLIB
#include "arrow/util/compression_zlib.h"
#endif

#ifdef ARROW_WITH_ZSTD
#include "arrow/util/compression_zstd.h"
#endif

#ifdef ARROW_WITH_BZ2
#include "arrow/util/compression_bz2.h"
#endif

#include "arrow/result.h"
#include "arrow/status.h"
#include "arrow/util/compression_internal.h"

namespace arrow {
namespace util {
Expand Down Expand Up @@ -126,14 +102,14 @@ Result<std::unique_ptr<Codec>> Codec::Create(Compression::type codec_type,
if (compression_level_set) {
return Status::Invalid("Snappy doesn't support setting a compression level.");
}
codec.reset(new SnappyCodec());
codec = internal::MakeSnappyCodec();
break;
#else
return Status::NotImplemented("Snappy codec support not built");
#endif
case Compression::GZIP:
#ifdef ARROW_WITH_ZLIB
codec.reset(new GZipCodec(compression_level));
codec = internal::MakeGZipCodec(compression_level);
break;
#else
return Status::NotImplemented("Gzip codec support not built");
Expand All @@ -145,7 +121,7 @@ Result<std::unique_ptr<Codec>> Codec::Create(Compression::type codec_type,
return Status::NotImplemented("LZO codec not implemented");
case Compression::BROTLI:
#ifdef ARROW_WITH_BROTLI
codec.reset(new BrotliCodec(compression_level));
codec = internal::MakeBrotliCodec(compression_level);
break;
#else
return Status::NotImplemented("Brotli codec support not built");
Expand All @@ -155,7 +131,7 @@ Result<std::unique_ptr<Codec>> Codec::Create(Compression::type codec_type,
if (compression_level_set) {
return Status::Invalid("LZ4 doesn't support setting a compression level.");
}
codec.reset(new Lz4Codec());
codec = internal::MakeLz4RawCodec();
break;
#else
return Status::NotImplemented("LZ4 codec support not built");
Expand All @@ -165,21 +141,21 @@ Result<std::unique_ptr<Codec>> Codec::Create(Compression::type codec_type,
if (compression_level_set) {
return Status::Invalid("LZ4 doesn't support setting a compression level.");
}
codec.reset(new Lz4FrameCodec());
codec = internal::MakeLz4FrameCodec();
break;
#else
return Status::NotImplemented("LZ4 codec support not built");
#endif
case Compression::ZSTD:
#ifdef ARROW_WITH_ZSTD
codec.reset(new ZSTDCodec(compression_level));
codec = internal::MakeZSTDCodec(compression_level);
break;
#else
return Status::NotImplemented("ZSTD codec support not built");
#endif
case Compression::BZ2:
#ifdef ARROW_WITH_BZ2
codec.reset(new BZ2Codec(compression_level));
codec = internal::MakeBZ2Codec(compression_level);
break;
#else
return Status::NotImplemented("BZ2 codec support not built");
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/util/compression.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,8 +22,8 @@
#include <memory>
#include <string>

#include "arrow/result.h"
#include "arrow/status.h"
#include "arrow/type_fwd.h"
#include "arrow/util/visibility.h"

namespace arrow {
Expand Down
4 changes: 3 additions & 1 deletion cpp/src/arrow/util/compression_benchmark.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,16 +17,18 @@

#include "benchmark/benchmark.h"

#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
#include <random>
#include <string>
#include <vector>

#include "arrow/result.h"
#include "arrow/testing/gtest_util.h"
#include "arrow/util/compression.h"
#include "arrow/util/logging.h"
#include "arrow/util/macros.h"

namespace arrow {
namespace util {
Expand Down
106 changes: 62 additions & 44 deletions cpp/src/arrow/util/compression_brotli.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,10 +15,11 @@
// specific language governing permissions and limitations
// under the License.

#include "arrow/util/compression_brotli.h"
#include "arrow/util/compression_internal.h"

#include <cstddef>
#include <cstdint>
#include <memory>

#include <brotli/decode.h>
#include <brotli/encode.h>
Expand All @@ -31,6 +32,9 @@

namespace arrow {
namespace util {
namespace internal {

namespace {

class BrotliDecompressor : public Decompressor {
public:
Expand Down Expand Up @@ -169,55 +173,69 @@ class BrotliCompressor : public Compressor {
// ----------------------------------------------------------------------
// Brotli codec implementation

BrotliCodec::BrotliCodec(int compression_level) {
compression_level_ = compression_level == kUseDefaultCompressionLevel
? kBrotliDefaultCompressionLevel
: compression_level;
}
class BrotliCodec : public Codec {
public:
explicit BrotliCodec(int compression_level) {
compression_level_ = compression_level == kUseDefaultCompressionLevel
? kBrotliDefaultCompressionLevel
: compression_level;
}

Result<std::shared_ptr<Compressor>> BrotliCodec::MakeCompressor() {
auto ptr = std::make_shared<BrotliCompressor>(compression_level_);
RETURN_NOT_OK(ptr->Init());
return ptr;
}
Result<int64_t> Decompress(int64_t input_len, const uint8_t* input,
int64_t output_buffer_len, uint8_t* output_buffer) override {
DCHECK_GE(input_len, 0);
DCHECK_GE(output_buffer_len, 0);
std::size_t output_size = static_cast<size_t>(output_buffer_len);
if (BrotliDecoderDecompress(static_cast<size_t>(input_len), input, &output_size,
output_buffer) != BROTLI_DECODER_RESULT_SUCCESS) {
return Status::IOError("Corrupt brotli compressed data.");
}
return output_size;
}

Result<std::shared_ptr<Decompressor>> BrotliCodec::MakeDecompressor() {
auto ptr = std::make_shared<BrotliDecompressor>();
RETURN_NOT_OK(ptr->Init());
return ptr;
}
int64_t MaxCompressedLen(int64_t input_len,
const uint8_t* ARROW_ARG_UNUSED(input)) override {
DCHECK_GE(input_len, 0);
return BrotliEncoderMaxCompressedSize(static_cast<size_t>(input_len));
}

Result<int64_t> BrotliCodec::Decompress(int64_t input_len, const uint8_t* input,
int64_t output_buffer_len,
uint8_t* output_buffer) {
DCHECK_GE(input_len, 0);
DCHECK_GE(output_buffer_len, 0);
std::size_t output_size = static_cast<size_t>(output_buffer_len);
if (BrotliDecoderDecompress(static_cast<size_t>(input_len), input, &output_size,
output_buffer) != BROTLI_DECODER_RESULT_SUCCESS) {
return Status::IOError("Corrupt brotli compressed data.");
}
return output_size;
}
Result<int64_t> Compress(int64_t input_len, const uint8_t* input,
int64_t output_buffer_len, uint8_t* output_buffer) override {
DCHECK_GE(input_len, 0);
DCHECK_GE(output_buffer_len, 0);
std::size_t output_size = static_cast<size_t>(output_buffer_len);
if (BrotliEncoderCompress(compression_level_, BROTLI_DEFAULT_WINDOW,
BROTLI_DEFAULT_MODE, static_cast<size_t>(input_len), input,
&output_size, output_buffer) == BROTLI_FALSE) {
return Status::IOError("Brotli compression failure.");
}
return output_size;
}

int64_t BrotliCodec::MaxCompressedLen(int64_t input_len,
const uint8_t* ARROW_ARG_UNUSED(input)) {
DCHECK_GE(input_len, 0);
return BrotliEncoderMaxCompressedSize(static_cast<size_t>(input_len));
}
Result<std::shared_ptr<Compressor>> MakeCompressor() override {
auto ptr = std::make_shared<BrotliCompressor>(compression_level_);
RETURN_NOT_OK(ptr->Init());
return ptr;
}

Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
auto ptr = std::make_shared<BrotliDecompressor>();
RETURN_NOT_OK(ptr->Init());
return ptr;
}

const char* name() const override { return "brotli"; }

private:
int compression_level_;
};

} // namespace

Result<int64_t> BrotliCodec::Compress(int64_t input_len, const uint8_t* input,
int64_t output_buffer_len, uint8_t* output_buffer) {
DCHECK_GE(input_len, 0);
DCHECK_GE(output_buffer_len, 0);
std::size_t output_size = static_cast<size_t>(output_buffer_len);
if (BrotliEncoderCompress(compression_level_, BROTLI_DEFAULT_WINDOW,
BROTLI_DEFAULT_MODE, static_cast<size_t>(input_len), input,
&output_size, output_buffer) == BROTLI_FALSE) {
return Status::IOError("Brotli compression failure.");
}
return output_size;
std::unique_ptr<Codec> MakeBrotliCodec(int compression_level) {
return std::unique_ptr<Codec>(new BrotliCodec(compression_level));
}

} // namespace internal
} // namespace util
} // namespace arrow
58 changes: 0 additions & 58 deletions cpp/src/arrow/util/compression_brotli.h
View file

This file was deleted.

Loading

0 comments on commit 6ce0948

Please sign in to comment.