catboost 1.25.1 → 1.26.0

package/inc/util/stream/buffer.h

@@ -1,119 +0,0 @@
-#pragma once
-
-#include "zerocopy.h"
-#include "zerocopy_output.h"
-
-#include <util/generic/ptr.h>
-
-class TBuffer;
-
-/**
- * @addtogroup Streams_Buffers
- * @{
- */
-
-/**
- * Output stream that writes into a `TBuffer`.
- */
-class TBufferOutput: public IZeroCopyOutput {
-public:
-    class TImpl;
-
-    /**
-     * Constructs a stream that writes into an internal buffer.
-     *
-     * @param buflen                    Initial size of the internal buffer.
-     */
-    TBufferOutput(size_t buflen = 1024);
-
-    /**
-     * Constructs a stream that writes into the provided buffer. It's up to the
-     * user to make sure that the buffer doesn't get destroyed while this stream
-     * is in use.
-     *
-     * @param buffer                    Buffer to write into.
-     */
-    TBufferOutput(TBuffer& buffer);
-
-    TBufferOutput(TBufferOutput&&) noexcept;
-    TBufferOutput& operator=(TBufferOutput&&) noexcept;
-
-    ~TBufferOutput() override;
-
-    /**
-     * @returns                         Buffer that this stream writes into.
-     */
-    TBuffer& Buffer() const noexcept;
-
-private:
-    size_t DoNext(void** ptr) override;
-    void DoUndo(size_t len) override;
-    void DoWrite(const void* buf, size_t len) override;
-    void DoWriteC(char c) override;
-
-private:
-    THolder<TImpl> Impl_;
-};
-
-/**
- * Input stream that reads from an external `TBuffer`.
- */
-class TBufferInput: public IZeroCopyInputFastReadTo {
-public:
-    /**
-     * Constructs a stream that reads from an external buffer. It's up to the
-     * user to make sure that the buffer doesn't get destroyed before this
-     * stream.
-     *
-     * @param buffer                    External buffer to read from.
-     */
-    TBufferInput(const TBuffer& buffer);
-
-    ~TBufferInput() override;
-
-    const TBuffer& Buffer() const noexcept;
-
-    void Rewind() noexcept;
-
-protected:
-    size_t DoNext(const void** ptr, size_t len) override;
-    void DoUndo(size_t len) override;
-
-private:
-    const TBuffer& Buf_;
-    size_t Readed_;
-};
-
-/**
- * Input/output stream that works with a `TBuffer`.
- */
-class TBufferStream: public TBufferOutput, public TBufferInput {
-public:
-    /**
-     * Constructs a stream that works with an internal buffer.
-     *
-     * @param buflen                    Initial size of the internal buffer.
-     */
-    inline TBufferStream(size_t buflen = 1024)
-        : TBufferOutput(buflen)
-        , TBufferInput(TBufferOutput::Buffer())
-    {
-    }
-
-    /**
-     * Constructs a stream that works with the provided buffer.
-     *
-     * @param buffer                    Buffer to work with.
-     */
-    inline TBufferStream(TBuffer& buffer)
-        : TBufferOutput(buffer)
-        , TBufferInput(TBufferOutput::Buffer())
-    {
-    }
-
-    ~TBufferStream() override = default;
-
-    using TBufferOutput::Buffer;
-};
-
-/** @} */

package/inc/util/stream/buffered.h

@@ -1,225 +0,0 @@
-#pragma once
-
-#include "zerocopy.h"
-#include "zerocopy_output.h"
-
-#include <utility>
-#include <util/generic/ptr.h>
-#include <util/generic/typetraits.h>
-#include <util/generic/store_policy.h>
-
-/**
- * @addtogroup Streams_Buffered
- * @{
- */
-
-/**
- * Input stream that wraps the given stream and adds a buffer on top of it,
- * thus making sure that data is read from the underlying stream in big chunks.
- *
- * Note that it does not claim ownership of the underlying stream, so it's up
- * to the user to free it.
- */
-class TBufferedInput: public IZeroCopyInput {
-public:
-    TBufferedInput(IInputStream* slave, size_t buflen = 8192);
-
-    TBufferedInput(TBufferedInput&&) noexcept;
-    TBufferedInput& operator=(TBufferedInput&&) noexcept;
-
-    ~TBufferedInput() override;
-
-    /**
-     * Switches the underlying stream to the one provided. Does not clear the
-     * data that was already buffered.
-     *
-     * @param slave                     New underlying stream.
-     */
-    void Reset(IInputStream* slave);
-
-protected:
-    size_t DoRead(void* buf, size_t len) override;
-    size_t DoReadTo(TString& st, char ch) override;
-    size_t DoSkip(size_t len) override;
-    size_t DoNext(const void** ptr, size_t len) override;
-
-private:
-    class TImpl;
-    THolder<TImpl> Impl_;
-};
-
-/**
- * Output stream that wraps the given stream and adds a buffer on top of it,
- * thus making sure that data is written to the underlying stream in big chunks.
- *
- * Note that by default this stream does not propagate `Flush` and `Finish`
- * calls to the underlying stream, instead simply flushing out the buffer.
- * You can change this behavior by using propagation mode setters.
- *
- * Also note that this stream does not claim ownership of the underlying stream,
- * so it's up to the user to free it.
- */
-class TBufferedOutputBase: public IZeroCopyOutput {
-public:
-    /**
-     * Constructs a buffered stream that dynamically adjusts the size of the
-     * buffer. This works best when the amount of data that will be passed
-     * through this stream is not known and can range in size from several
-     * kilobytes to several gigabytes.
-     *
-     * @param slave                     Underlying stream.
-     */
-    TBufferedOutputBase(IOutputStream* slave);
-
-    /**
-     * Constructs a buffered stream with the given size of the buffer.
-     *
-     * @param slave                     Underlying stream.
-     * @param buflen                    Size of the buffer.
-     */
-    TBufferedOutputBase(IOutputStream* slave, size_t buflen);
-
-    TBufferedOutputBase(TBufferedOutputBase&&) noexcept;
-    TBufferedOutputBase& operator=(TBufferedOutputBase&&) noexcept;
-
-    ~TBufferedOutputBase() override;
-
-    /**
-     * @param propagate                 Whether `Flush` and `Finish` calls should
-     *                                  be propagated to the underlying stream.
-     *                                  By default they are not.
-     */
-    inline void SetPropagateMode(bool propagate) noexcept {
-        SetFlushPropagateMode(propagate);
-        SetFinishPropagateMode(propagate);
-    }
-
-    /**
-     * @param propagate                 Whether `Flush` calls should be propagated
-     *                                  to the underlying stream. By default they
-     *                                  are not.
-     */
-    void SetFlushPropagateMode(bool propagate) noexcept;
-
-    /**
-     * @param propagate                 Whether `Finish` calls should be propagated
-     *                                  to the underlying stream. By default they
-     *                                  are not.
-     */
-    void SetFinishPropagateMode(bool propagate) noexcept;
-
-    class TImpl;
-
-protected:
-    size_t DoNext(void** ptr) override;
-    void DoUndo(size_t len) override;
-    void DoWrite(const void* data, size_t len) override;
-    void DoWriteC(char c) override;
-    void DoFlush() override;
-    void DoFinish() override;
-
-private:
-    THolder<TImpl> Impl_;
-};
-
-/**
- * Buffered output stream with a fixed-size buffer.
- *
- * @see TBufferedOutputBase
- */
-class TBufferedOutput: public TBufferedOutputBase {
-public:
-    TBufferedOutput(IOutputStream* slave, size_t buflen = 8192);
-    ~TBufferedOutput() override;
-
-    TBufferedOutput(TBufferedOutput&&) noexcept = default;
-    TBufferedOutput& operator=(TBufferedOutput&&) noexcept = default;
-};
-
-/**
- * Buffered output stream that dynamically adjusts the size of the buffer based
- * on the amount of data that's passed through it.
- *
- * @see TBufferedOutputBase
- */
-class TAdaptiveBufferedOutput: public TBufferedOutputBase {
-public:
-    TAdaptiveBufferedOutput(IOutputStream* slave);
-    ~TAdaptiveBufferedOutput() override;
-
-    TAdaptiveBufferedOutput(TAdaptiveBufferedOutput&&) noexcept = default;
-    TAdaptiveBufferedOutput& operator=(TAdaptiveBufferedOutput&&) noexcept = default;
-};
-
-namespace NPrivate {
-    struct TMyBufferedOutput: public TBufferedOutput {
-        inline TMyBufferedOutput(IOutputStream* slave, size_t buflen)
-            : TBufferedOutput(slave, buflen)
-        {
-            SetFinishPropagateMode(true);
-        }
-    };
-
-    template <class T>
-    struct TBufferedStreamFor {
-        using TResult = std::conditional_t<std::is_base_of<IInputStream, T>::value, TBufferedInput, TMyBufferedOutput>;
-    };
-}
-
-/**
- * A mixin class that turns unbuffered stream into a buffered one.
- *
- * Note that using this mixin with a stream that is already buffered won't
- * result in double buffering, e.g. `TBuffered<TBuffered<TUnbufferedFileInput>>` and
- * `TBuffered<TUnbufferedFileInput>` are basically the same types.
- *
- * Example usage:
- * @code
- * TBuffered<TUnbufferedFileInput> file_input(1024, "/path/to/file");
- * TBuffered<TUnbufferedFileOutput> file_output(1024, "/path/to/file");
- * @endcode
- * Here 1024 is the size of the buffer.
- */
-template <class TSlave>
-class TBuffered: private TEmbedPolicy<TSlave>, public ::NPrivate::TBufferedStreamFor<TSlave>::TResult {
-    using TSlaveBase = TEmbedPolicy<TSlave>;
-    using TBufferedBase = typename ::NPrivate::TBufferedStreamFor<TSlave>::TResult;
-
-public:
-    template <typename... Args>
-    inline TBuffered(size_t b, Args&&... args)
-        : TSlaveBase(std::forward<Args>(args)...)
-        , TBufferedBase(TSlaveBase::Ptr(), b)
-    {
-    }
-
-    inline TSlave& Slave() noexcept {
-        return *this->Ptr();
-    }
-};
-
-/**
- * A mixin class that turns unbuffered stream into an adaptively buffered one.
- * Created stream differs from the one created via `TBuffered` template in that
- * it dynamically adjusts the size of the buffer based on the amount of data
- * that's passed through it.
- *
- * Example usage:
- * @code
- * TAdaptivelyBuffered<TUnbufferedFileOutput> file_output("/path/to/file");
- * @endcode
- */
-template <class TSlave>
-class TAdaptivelyBuffered: private TEmbedPolicy<TSlave>, public TAdaptiveBufferedOutput {
-    using TSlaveBase = TEmbedPolicy<TSlave>;
-
-public:
-    template <typename... Args>
-    inline TAdaptivelyBuffered(Args&&... args)
-        : TSlaveBase(std::forward<Args>(args)...)
-        , TAdaptiveBufferedOutput(TSlaveBase::Ptr())
-    {
-    }
-};
-
-/** @} */

package/inc/util/stream/debug.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include "output.h"
-
-/**
- * @addtogroup Streams
- * @{
- */
-
-/**
- * Debug output stream. Writes into `stderr`.
- */
-class TDebugOutput: public IOutputStream {
-public:
-    inline TDebugOutput() noexcept = default;
-    ~TDebugOutput() override = default;
-
-    TDebugOutput(TDebugOutput&&) noexcept = default;
-    TDebugOutput& operator=(TDebugOutput&&) noexcept = default;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-};
-
-/**
- * @returns                             Standard debug stream.
- * @see Cdbg
- */
-IOutputStream& StdDbgStream() noexcept;
-
-/**
- * This function returns the current debug level as set via `DBGOUT` environment
- * variable.
- *
- * Note that the proper way to use this function is via `Y_DBGTRACE` macro.
- * There are very few cases when there is a need to use it directly.
- *
- * @returns                             Debug level.
- * @see ETraceLevel
- * @see DBGTRACE
- */
-int StdDbgLevel() noexcept;
-
-/**
- * Standard debug stream.
- *
- * Behavior of this stream is controlled via `DBGOUT` environment variable.
- * If this variable is set, then this stream is redirected into `stderr`,
- * otherwise whatever is written into it is simply ignored.
- */
-#define Cdbg (StdDbgStream())
-
-/** @} */

package/inc/util/stream/direct_io.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "input.h"
-#include "output.h"
-#include <util/system/direct_io.h>
-
-class TRandomAccessFileInput: public IInputStream {
-public:
-    TRandomAccessFileInput(TDirectIOBufferedFile& file, ui64 position);
-
-protected:
-    size_t DoRead(void* buf, size_t len) override;
-    size_t DoSkip(size_t len) override;
-
-private:
-    TDirectIOBufferedFile& File;
-    ui64 Position;
-};
-
-class TRandomAccessFileOutput: public IOutputStream {
-public:
-    TRandomAccessFileOutput(TDirectIOBufferedFile& file);
-
-    TRandomAccessFileOutput(TRandomAccessFileOutput&&) noexcept = default;
-    TRandomAccessFileOutput& operator=(TRandomAccessFileOutput&&) noexcept = default;
-
-protected:
-    TDirectIOBufferedFile* File;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-    void DoFlush() override;
-};
-
-class TBufferedFileOutputEx: public TRandomAccessFileOutput {
-public:
-    TBufferedFileOutputEx(const TString& path, EOpenMode oMode, size_t buflen = 1 << 17);
-
-private:
-    void DoFlush() override;
-    void DoFinish() override;
-    THolder<TDirectIOBufferedFile> FileHolder;
-};

package/inc/util/stream/file.h

@@ -1,108 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "input.h"
-#include "output.h"
-#include "buffered.h"
-#include "mem.h"
-
-#include <util/system/file.h>
-#include <utility>
-
-/**
- * @addtogroup Streams_Files
- * @{
- */
-
-/**
- * Unbuffered file input stream.
- *
- * Note that the input is not buffered, which means that `ReadLine` calls will
- * be _very_ slow.
- */
-class TUnbufferedFileInput: public IInputStream {
-public:
-    TUnbufferedFileInput(const TFile& file);
-    TUnbufferedFileInput(const TString& path);
-
-private:
-    size_t DoRead(void* buf, size_t len) override;
-    size_t DoSkip(size_t len) override;
-
-private:
-    TFile File_;
-};
-
-/**
- * Memory-mapped file input stream.
- */
-class TMappedFileInput: public TMemoryInput {
-public:
-    TMappedFileInput(const TFile& file);
-    TMappedFileInput(const TString& path);
-    ~TMappedFileInput() override;
-
-private:
-    class TImpl;
-    THolder<TImpl> Impl_;
-};
-
-/**
- * File output stream.
- *
- * Note that the output is unbuffered, thus writing in many small chunks is
- * likely to be quite slow.
- */
-class TUnbufferedFileOutput: public IOutputStream {
-public:
-    TUnbufferedFileOutput(const TString& path);
-    TUnbufferedFileOutput(const TFile& file);
-    ~TUnbufferedFileOutput() override;
-
-    TUnbufferedFileOutput(TUnbufferedFileOutput&&) noexcept = default;
-    TUnbufferedFileOutput& operator=(TUnbufferedFileOutput&&) noexcept = default;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-    void DoFlush() override;
-
-private:
-    TFile File_;
-};
-
-/**
- * Buffered file input stream.
- *
- * @see TBuffered
- */
-class TFileInput: public TBuffered<TUnbufferedFileInput> {
-public:
-    template <class T>
-    inline TFileInput(T&& t, size_t buf = 1 << 13)
-        : TBuffered<TUnbufferedFileInput>(buf, std::forward<T>(t))
-    {
-    }
-
-    ~TFileInput() override = default;
-};
-
-/**
- * Buffered file output stream.
- *
- * Currently deprecated, please use TFileOutput in new code.
- *
- * @deprecated
- * @see TBuffered
- */
-class TFixedBufferFileOutput: public TBuffered<TUnbufferedFileOutput> {
-public:
-    template <class T>
-    inline TFixedBufferFileOutput(T&& t, size_t buf = 1 << 13)
-        : TBuffered<TUnbufferedFileOutput>(buf, std::forward<T>(t))
-    {
-    }
-
-    ~TFixedBufferFileOutput() override = default;
-};
-
-/** @} */