zlib wrapper class

You called your header zlib.h, when you know (and depend on) a zlib.h in the standard include path? That's heading straight into confusion land - I don't recommend that.

    constexpr static size_t BUFFER_SIZE = 128;

There's no definition in scope for size_t. I guess this was intended to be std::size_t?

Don't use all-caps for identifiers - we normally reserve those for preprocessor macros, which need special care because they are unscoped text substitutions.

class ZLibCompressor : public ZLibBase_{

Does public inheritance really make sense here? I think this might be better as private. And perhaps move ZLibBase_ to an inner namespace to separate it from the public interface.

    const static int NO_COMPRESSION     ;
    const static int BEST_SPEED     ;
    const static int BEST_COMPRESSION   ;
    const static int DEFAULT_COMPRESSION    ;

These might be better as an enumeration.

    ZLibCompressor(int compressionLevel = DEFAULT_COMPRESSION);

I don't think we want this to be an implicit conversion - I recommend explicit here to avoid surprises.

bool operator()(const char *data_in, size_t const size_in, char *data_out, size_t &size_out);

const is unnecessary on the size_in argument, which is passed by value. It doesn't contribute to the function signature.

Prefer returning values rather than accepting out-parameter references: instead of returning a bool to indicate failure, prefer to return the size written, and throw if there's a failure (with the error message from the stream); if the size written is still important on failure, then perhaps return a pair or tuple that the the caller can unpack (e.g. with a structured binding).

Consider passing destination first, so the interface is more like std::memcpy() and therefore easier to remember.

class ZLibDeCompressor : private ZLibBase_{

That's a surprising capitalisation of "decompressor" that I'll probably mistype endless times. There's no need for a capital in the middle of that word.

template<bool OP>
struct ZLibOpsBase_;

I'm not a fan of using a bool as behaviour switch here. Prefer a scoped enumerator, which gives a clear name to identify which instantiation is compressor and which is decompressor.

       memset(zs, 0, sizeof(z_stream));

We've misspelt std::memset here. And prefer to match the size with the destination object: sizeof *zs.

In any case, writing all-bytes zero is not the correct way to initialise a z_stream as it contains pointers and function pointers.

            std::bad_alloc exception;
            throw exception;

No need for a variable - we can simply throw std::bad_alloc{}.

        if (data == nullptr || size == 0 || data_out == nullptr || size_out == 0)

I don't think it should be an error to specify zero-length input, at least for compression.

        zs->avail_in  = static_cast<uInt>( size );

Zlib's uInt is a type alias for unsigned int. This cast is not safe if size > UINT_MAX, so we should check that and take appropriate action if it's larger (decompressing in chunks, for instance).

    size_t osize = strlen(odata);

Here, we've misspelt std::strlen as well as std::size_t.

    std::cout << std::fixed << std::setprecision(2) << ( float(osize) / float(csize) ) << std::endl;

We don't need to flush output, so use '\n' rather than std::endl.

        std::cout << "Error" << std::endl;

This looks like an error, so we should use std::cerr << "Error\n";.

The design looks over-complicated for something that's just meant to be a combination of opaque implementation and strategy pattern. We can do that with a simple despatch table and much less inheritance:

#ifndef ZLIB_COMPRESSOR_H_
#define ZLIB_COMPRESSOR_H_

#include <cstddef>
#include <memory>

namespace detail
{
    struct impl;

    class ZLibProcessor
    {
    protected:
        std::unique_ptr<detail::impl> p;

        explicit ZLibProcessor(std::unique_ptr<detail::impl>,int);
        ~ZLibProcessor();

        std::size_t operator()(char *dst, std::size_t size,
                               const char *src, std::size_t len);
    };
};

class ZLibCompressor : detail::ZLibProcessor
{
public:
    enum class compression_level {
        none,
        fast,
        best,
        normal,
    };

    explicit ZLibCompressor(compression_level level = compression_level::normal);
    explicit ZLibCompressor(int compressionLevel);

    using ZLibProcessor::operator();
};

class ZLibDecompressor : detail::ZLibProcessor
{
public:
    ZLibDecompressor();

    using ZLibProcessor::operator();
};

#endif

#include "zlib.h"

#include <stdexcept>

#include <zlib.h>

struct ZLibOps {
    int(*init)(z_stream*,int);
    int(*done)(z_stream*);
    int(*reset)(z_stream*);
    int(*process)(z_stream*,int);
};

struct detail::impl
{
    ZLibOps const& ops;
    z_stream zs = {
        .zalloc = Z_NULL,
        .zfree = Z_NULL,
        .opaque = nullptr
    };

    void init(int const compressionLevel)
    {
        switch (ops.init(&zs, compressionLevel)) {
        case Z_OK:
            return;
        case Z_MEM_ERROR:
            throw std::bad_alloc{};
        default:
            throw std::runtime_error{zs.msg};
        }
    }

    int done() noexcept
    {
        return ops.done(&zs);
    }

    std::size_t process(char *dest, std::size_t size,
                        char const *src, std::size_t len)
    {
        ops.reset(&zs);

        zs.next_out  = reinterpret_cast<Bytef*>(dest);
        zs.avail_out = static_cast<uInt>(size);
        zs.next_in   = reinterpret_cast<Bytef*>(const_cast<char*>(src));
        zs.avail_in  = static_cast<uInt>(len);

        // FIXME: loop until size and len are both less than UINT_MAX
        int const result = ops.process(&zs, Z_FINISH);

        switch (result) {
        case Z_STREAM_END:
            return zs.total_out;
        case Z_MEM_ERROR:
            throw std::bad_alloc{};
        default:
            throw std::runtime_error{zs.msg};
        }
    }

};

// Base processor
detail::ZLibProcessor::ZLibProcessor(std::unique_ptr<detail::impl> imp, int compressionLevel)
    : p{std::move(imp)}
{
    p->init(compressionLevel);
}

detail::ZLibProcessor::~ZLibProcessor()
{
    p->done();
};

std::size_t detail::ZLibProcessor::operator()(char *dest, std::size_t size,
                                              char const *src, std::size_t len) {
    return p->process(dest, size, src, len);
}

// Compressor
static constexpr ZLibOps deflate_ops = {
    .init = [](z_stream *zs,int level) { return deflateInit(zs, level);  },
    .done = deflateEnd,
    .reset = deflateReset,
    .process = deflate
};

static int convert(ZLibCompressor::compression_level level)
{
    switch (level) {
    case ZLibCompressor::compression_level::none: return Z_NO_COMPRESSION;
    case ZLibCompressor::compression_level::fast: return Z_BEST_SPEED;
    case ZLibCompressor::compression_level::best: return Z_BEST_COMPRESSION;
    case ZLibCompressor::compression_level::normal: return Z_DEFAULT_COMPRESSION;
    };
    throw std::logic_error{"Invalid compression level"};
}
ZLibCompressor::ZLibCompressor(ZLibCompressor::compression_level level)
    : ZLibCompressor{convert(level)}
{}

ZLibCompressor::ZLibCompressor(int compressionLevel)
    : ZLibProcessor{std::make_unique<detail::impl>(deflate_ops), compressionLevel}
{}

// Decompressor
static constexpr ZLibOps inflate_ops = {
    .init = [](z_stream *zs,int) { return inflateInit(zs);  },
    .done = inflateEnd,
    .reset = inflateReset,
    .process = inflate
};

ZLibDecompressor::ZLibDecompressor()
    : ZLibProcessor{std::make_unique<detail::impl>(inflate_ops), 0}
{}

#include "zlib.h"

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>

constexpr std::size_t SIZE = 1024;

int main()
{
    const char *odata = "Hello World";
    const std::size_t osize = std::strlen(odata);

    char cbuffer[SIZE];
    const std::size_t csize = SIZE;

    char dbuffer[SIZE];
    const std::size_t dsize = SIZE;

    try {
        auto const cr = ZLibCompressor{}(cbuffer, csize, odata, osize);
        auto const dr = ZLibDecompressor{}(dbuffer, dsize, cbuffer, csize);

        // should recompress to same content
        assert(dr == osize);
        assert(!std::strncmp(odata, dbuffer, osize));

        std::cout << std::fixed << std::setprecision(2) << (float(cr) / float(dr)) << '\n';
    } catch (std::exception& e) {
        std::cerr << e.what() << '\n';
        return EXIT_FAILURE;
    }
}