// Copyright 2011 Google Inc. All Rights Reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "snappy_version.hpp"

#if SNAPPY_NEW_VERSION

#include <stddef.h>

#include <cstring>

#include "snappy-sinksource.h"

namespace duckdb_snappy {

Source::~Source() = default;

Sink::~Sink() = default;

char* Sink::GetAppendBuffer(size_t length, char* scratch) {

  // TODO: Switch to [[maybe_unused]] when we can assume C++17.

  (void)length;

  return scratch;

}

char* Sink::GetAppendBufferVariable(

      size_t min_size, size_t desired_size_hint, char* scratch,

      size_t scratch_size, size_t* allocated_size) {

  // TODO: Switch to [[maybe_unused]] when we can assume C++17.

  (void)min_size;

  (void)desired_size_hint;

  *allocated_size = scratch_size;

  return scratch;

}

void Sink::AppendAndTakeOwnership(

    char* bytes, size_t n,

    void (*deleter)(void*, const char*, size_t),

    void *deleter_arg) {

  Append(bytes, n);

  (*deleter)(deleter_arg, bytes, n);

}

ByteArraySource::~ByteArraySource() = default;

size_t ByteArraySource::Available() const { return left_; }

const char* ByteArraySource::Peek(size_t* len) {

  *len = left_;

  return ptr_;

}

void ByteArraySource::Skip(size_t n) {

  left_ -= n;

  ptr_ += n;

}

UncheckedByteArraySink::~UncheckedByteArraySink() { }

void UncheckedByteArraySink::Append(const char* data, size_t n) {

  // Do no copying if the caller filled in the result of GetAppendBuffer()

  if (data != dest_) {

    std::memcpy(dest_, data, n);

  }

  dest_ += n;

}

char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {

  // TODO: Switch to [[maybe_unused]] when we can assume C++17.

  (void)len;

  (void)scratch;

  return dest_;

}

void UncheckedByteArraySink::AppendAndTakeOwnership(

    char* bytes, size_t n,

    void (*deleter)(void*, const char*, size_t),

    void *deleter_arg) {

  if (bytes != dest_) {

    std::memcpy(dest_, bytes, n);

    (*deleter)(deleter_arg, bytes, n);

  }

  dest_ += n;

}

char* UncheckedByteArraySink::GetAppendBufferVariable(

      size_t min_size, size_t desired_size_hint, char* scratch,

      size_t scratch_size, size_t* allocated_size) {

  // TODO: Switch to [[maybe_unused]] when we can assume C++17.

  (void)min_size;

  (void)scratch;

  (void)scratch_size;

  *allocated_size = desired_size_hint;

  return dest_;

}

}  // namespace duckdb_snappy

#else // #if SNAPPY_NEW_VERSION

#include <string.h>

#include "snappy-sinksource.h"

namespace duckdb_snappy {

Source::~Source() { }

Sink::~Sink() { }

char* Sink::GetAppendBuffer(size_t length, char* scratch) {

  return scratch;

}

char* Sink::GetAppendBufferVariable(

    size_t min_size, size_t desired_size_hint, char* scratch,

    size_t scratch_size, size_t* allocated_size) {

  *allocated_size = scratch_size;

  return scratch;

}

void Sink::AppendAndTakeOwnership(

  char* bytes, size_t n,

  void (*deleter)(void*, const char*, size_t),

  void *deleter_arg) {

  Append(bytes, n);

  (*deleter)(deleter_arg, bytes, n);

}

ByteArraySource::~ByteArraySource() { }

size_t ByteArraySource::Available() const { return left_; }

const char* ByteArraySource::Peek(size_t* len) {

  *len = left_;

  return ptr_;

}

void ByteArraySource::Skip(size_t n) {

  left_ -= n;

  ptr_ += n;

}

UncheckedByteArraySink::~UncheckedByteArraySink() { }

void UncheckedByteArraySink::Append(const char* data, size_t n) {

  // Do no copying if the caller filled in the result of GetAppendBuffer()

  if (data != dest_) {

    memcpy(dest_, data, n);

  }

  dest_ += n;

}

char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {

  return dest_;

}

void UncheckedByteArraySink::AppendAndTakeOwnership(

  char* data, size_t n,

  void (*deleter)(void*, const char*, size_t),

  void *deleter_arg) {

  if (data != dest_) {

    memcpy(dest_, data, n);

    (*deleter)(deleter_arg, data, n);

  }

  dest_ += n;

}

char* UncheckedByteArraySink::GetAppendBufferVariable(

    size_t min_size, size_t desired_size_hint, char* scratch,

    size_t scratch_size, size_t* allocated_size) {

  *allocated_size = desired_size_hint;

  return dest_;

}

}  // namespace duckdb_snappy

#endif  // #if SNAPPY_NEW_VERSION # else