catboost 1.25.1 → 1.26.0

package/inc/util/stream/null.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "zerocopy.h"
-#include "output.h"
-
-/**
- * @addtogroup Streams
- * @{
- */
-
-/**
- * Null input stream. Does nothing, contains no data.
- */
-class TNullInput: public IZeroCopyInput {
-public:
-    TNullInput() noexcept;
-    ~TNullInput() override;
-
-private:
-    size_t DoRead(void* buf, size_t len) override;
-    size_t DoSkip(size_t len) override;
-    size_t DoNext(const void** ptr, size_t len) override;
-};
-
-/**
- * Null output stream. Just ignores whatever is written into it.
- */
-class TNullOutput: public IOutputStream {
-public:
-    TNullOutput() noexcept;
-    ~TNullOutput() override;
-
-    TNullOutput(TNullOutput&&) noexcept = default;
-    TNullOutput& operator=(TNullOutput&&) noexcept = default;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-};
-
-/**
- * Null input-output stream.
- *
- * @see TNullInput
- * @see TNullOutput
- */
-class TNullIO: public TNullInput, public TNullOutput {
-public:
-    TNullIO() noexcept;
-    ~TNullIO() override;
-};
-
-namespace NPrivate {
-    TNullIO& StdNullStream() noexcept;
-}
-
-/**
- * Standard null stream.
- */
-#define Cnull (::NPrivate::StdNullStream())
-
-/** @} */

package/inc/util/stream/output.h

@@ -1,304 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "labeled.h"
-
-#include <util/generic/noncopyable.h>
-#include <util/generic/string.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/typetraits.h>
-
-#include <type_traits>
-
-/**
- * @addtogroup Streams_Base
- * @{
- */
-
-/**
- * Abstract output stream.
- */
-class IOutputStream: public TNonCopyable {
-public:
-    /**
-     * Data block for output.
-     */
-    struct TPart {
-        inline TPart(const void* Buf, size_t Len) noexcept
-            : buf(Buf)
-            , len(Len)
-        {
-        }
-
-        inline TPart(const TStringBuf s) noexcept
-            : buf(s.data())
-            , len(s.size())
-        {
-        }
-
-        inline TPart() noexcept
-            : buf(nullptr)
-            , len(0)
-        {
-        }
-
-        inline ~TPart() = default;
-
-        static inline TPart CrLf() noexcept {
-            return TPart("\r\n", 2);
-        }
-
-        const void* buf;
-        size_t len;
-    };
-
-    IOutputStream() noexcept;
-    virtual ~IOutputStream();
-
-    IOutputStream(IOutputStream&&) noexcept {
-    }
-
-    IOutputStream& operator=(IOutputStream&&) noexcept {
-        return *this;
-    };
-
-    /**
-     * Writes into this stream.
-     *
-     * @param buf                       Data to write.
-     * @param len                       Number of bytes to write.
-     */
-    inline void Write(const void* buf, size_t len) {
-        if (len) {
-            DoWrite(buf, len);
-        }
-    }
-
-    /**
-     * Writes a string into this stream.
-     *
-     * @param st                        String to write.
-     */
-    inline void Write(const TStringBuf st) {
-        Write(st.data(), st.size());
-    }
-
-    /**
-     * Writes several data blocks into this stream.
-     *
-     * @param parts                     Pointer to the start of the data blocks
-     *                                  array.
-     * @param count                     Number of data blocks to write.
-     */
-    inline void Write(const TPart* parts, size_t count) {
-        if (count > 1) {
-            DoWriteV(parts, count);
-        } else if (count) {
-            DoWrite(parts->buf, parts->len);
-        }
-    }
-
-    /**
-     * Writes a single character into this stream.
-     *
-     * @param ch                        Character to write.
-     */
-    inline void Write(char ch) {
-        DoWriteC(ch);
-    }
-
-    /**
-     * Flushes this stream's buffer, if any.
-     *
-     * Note that this can also be done with a `Flush` manipulator:
-     * @code
-     * stream << "some string" << Flush;
-     * @endcode
-     */
-    inline void Flush() {
-        DoFlush();
-    }
-
-    /**
-     * Flushes and closes this stream. No more data can be written into a stream
-     * once it's closed.
-     */
-    inline void Finish() {
-        DoFinish();
-    }
-
-protected:
-    /**
-     * Writes into this stream.
-     *
-     * @param buf                       Data to write.
-     * @param len                       Number of bytes to write.
-     * @throws yexception               If IO error occurs.
-     */
-    virtual void DoWrite(const void* buf, size_t len) = 0;
-
-    /**
-     * Writes several data blocks into this stream.
-     *
-     * @param parts                     Pointer to the start of the data blocks
-     *                                  array.
-     * @param count                     Number of data blocks to write.
-     * @throws yexception               If IO error occurs.
-     */
-    virtual void DoWriteV(const TPart* parts, size_t count);
-
-    /**
-     * Writes a single character into this stream. Can be overridden with a faster implementation.
-     *
-     * @param ch                        Character to write.
-     */
-    virtual void DoWriteC(char ch);
-
-    /**
-     * Flushes this stream's buffer, if any.
-     *
-     * @throws yexception               If IO error occurs.
-     */
-    virtual void DoFlush();
-
-    /**
-     * Flushes and closes this stream. No more data can be written into a stream
-     * once it's closed.
-     *
-     * @throws yexception               If IO error occurs.
-     */
-    virtual void DoFinish();
-};
-
-/**
- * `operator<<` for `IOutputStream` by default delegates to this function.
- *
- * Note that while `operator<<` uses overloading (and thus argument-dependent
- * lookup), `Out` uses template specializations. This makes it possible to
- * have a single `Out` declaration, and then just provide specializations in
- * cpp files, letting the linker figure everything else out. This approach
- * reduces compilation times.
- *
- * However, if the flexibility of overload resolution is needed, then one should
- * just overload `operator<<`.
- *
- * @param out                           Output stream to write into.
- * @param value                         Value to write.
- */
-template <class T>
-void Out(IOutputStream& out, typename TTypeTraits<T>::TFuncParam value);
-
-#define Y_DECLARE_OUT_SPEC(MODIF, T, stream, value) \
-    template <>                                     \
-    MODIF void Out<T>(IOutputStream & stream, TTypeTraits<T>::TFuncParam value)
-
-template <>
-inline void Out<const char*>(IOutputStream& o, const char* t) {
-    if (t) {
-        o.Write(t);
-    } else {
-        o.Write("(null)");
-    }
-}
-
-template <>
-void Out<const wchar16*>(IOutputStream& o, const wchar16* w);
-
-template <>
-void Out<const wchar32*>(IOutputStream& o, const wchar32* w);
-
-static inline IOutputStream& operator<<(IOutputStream& o, TStreamManipulator m) {
-    m(o);
-
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, const char* t) {
-    Out<const char*>(o, t);
-
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, char* t) {
-    Out<const char*>(o, t);
-
-    return o;
-}
-
-template <class T>
-static inline std::enable_if_t<std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o, T t) {
-    Out<T>(o, t);
-
-    return o;
-}
-
-template <class T>
-static inline std::enable_if_t<!std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o, const T& t) {
-    Out<T>(o, t);
-
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, const wchar16* t) {
-    Out<const wchar16*>(o, t);
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, wchar16* t) {
-    Out<const wchar16*>(o, t);
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, const wchar32* t) {
-    Out<const wchar32*>(o, t);
-    return o;
-}
-
-static inline IOutputStream& operator<<(IOutputStream& o, wchar32* t) {
-    Out<const wchar32*>(o, t);
-    return o;
-}
-
-namespace NPrivate {
-    IOutputStream& StdOutStream() noexcept;
-    IOutputStream& StdErrStream() noexcept;
-}
-
-/**
- * Standard output stream.
- */
-#define Cout (::NPrivate::StdOutStream())
-
-/**
- * Standard error stream.
- */
-#define Cerr (::NPrivate::StdErrStream())
-
-/**
- * Standard log stream.
- */
-#define Clog Cerr
-
-/**
- * End-of-line output manipulator, basically the same as `std::endl`.
- */
-static inline void Endl(IOutputStream& o) {
-    (o << '\n').Flush();
-}
-
-/**
- * Flushing stream manipulator, basically the same as `std::flush`.
- */
-static inline void Flush(IOutputStream& o) {
-    o.Flush();
-}
-
-/*
- * Also see format.h for additional manipulators.
- */
-
-#include "debug.h"
-
-void RedirectStdioToAndroidLog(bool redirect);
-
-/** @} */

package/inc/util/stream/pipe.h

@@ -1,112 +0,0 @@
-#pragma once
-
-#include "input.h"
-#include "output.h"
-
-#include <util/system/pipe.h>
-#include <util/generic/ptr.h>
-#include <util/generic/string.h>
-
-/**
- * @addtogroup Streams_Pipes
- * @{
- */
-
-/**
- * Base class for starting a process and communicating with it via pipes.
- */
-class TPipeBase {
-protected:
-    /**
-     * Starts a new process and opens a pipe.
-     *
-     * @param command                   Command line to start a process with.
-     * @param mode                      Data transfer mode for the pipe. Use
-     *                                  "r" for reading and "w" for writing.
-     */
-    TPipeBase(const TString& command, const char* mode);
-    virtual ~TPipeBase();
-
-protected:
-    class TImpl;
-    THolder<TImpl> Impl_;
-};
-
-/**
- * Input stream that binds to a standard output stream of a newly started process.
- *
- * Note that if the process ends with non-zero exit status, `Read` function will
- * throw an exception.
- */
-class TPipeInput: protected TPipeBase, public IInputStream {
-public:
-    /**
-     * Starts a new process and opens a pipe.
-     *
-     * @param command                   Command line to start a process with.
-     */
-    TPipeInput(const TString& command);
-
-private:
-    size_t DoRead(void* buf, size_t len) override;
-};
-
-/**
- * Output stream that binds to a standard input stream of a newly started process.
- *
- * Note that if the process ends with non-zero exit status, `Close` function will
- * throw an exception.
- */
-class TPipeOutput: protected TPipeBase, public IOutputStream {
-public:
-    /**
-     * Starts a new process and opens a pipe.
-     *
-     * @param command                   Command line to start a process with.
-     */
-    TPipeOutput(const TString& command);
-
-    /**
-     * Waits for the process to terminate and throws an exception if it ended
-     * with a non-zero exit status.
-     */
-    void Close();
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-};
-
-class TPipedBase {
-protected:
-    TPipedBase(PIPEHANDLE fd);
-    virtual ~TPipedBase();
-
-protected:
-    TPipeHandle Handle_;
-};
-
-/**
- * Input stream that binds to a standard output stream of an existing process.
- */
-class TPipedInput: public TPipedBase, public IInputStream {
-public:
-    TPipedInput(PIPEHANDLE fd);
-    ~TPipedInput() override;
-
-private:
-    size_t DoRead(void* buf, size_t len) override;
-};
-
-/**
- * Output stream that binds to a standard input stream of an existing process.
- */
-class TPipedOutput: public TPipedBase, public IOutputStream {
-public:
-    TPipedOutput(PIPEHANDLE fd);
-    ~TPipedOutput() override;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-};
-
-/** @} */

package/inc/util/stream/printf.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <util/system/compat.h>
-
-class IOutputStream;
-
-/**
- * Stream-based `printf` function. Prints formatted data into the provided stream.
- * Works the same way as a standard C `printf`.
- *
- * @param out                           Stream to write into.
- * @param fmt                           Format string.
- * @param ...                           Additional arguments.
- */
-size_t Y_PRINTF_FORMAT(2, 3) Printf(IOutputStream& out, const char* fmt, ...);
-
-/**
- * Stream-based `vprintf` function. Prints formatted data from variable argument
- * list into the provided stream. Works the same way as a standard C `vprintf`.
- *
- * @param out                           Stream to write into.
- * @param fmt                           Format string.
- * @param params                        Additional arguments as a variable argument list.
- */
-size_t Y_PRINTF_FORMAT(2, 0) Printf(IOutputStream& out, const char* fmt, va_list params);

package/inc/util/stream/str.h

@@ -1,207 +0,0 @@
-#pragma once
-
-#include "zerocopy.h"
-#include "zerocopy_output.h"
-
-#include <util/generic/string.h>
-#include <util/generic/noncopyable.h>
-#include <util/generic/store_policy.h>
-
-/**
- * @addtogroup Streams_Strings
- * @{
- */
-
-/**
- * Input stream for reading data from a string.
- */
-class TStringInput: public IZeroCopyInputFastReadTo {
-public:
-    /**
-     * Constructs a string input stream that reads character data from the
-     * provided string.
-     *
-     * Note that this stream keeps a reference to the provided string, so it's
-     * up to the user to make sure that the string doesn't get destroyed while
-     * this stream is in use.
-     *
-     * For reading data from `TStringBuf`s, see `TMemoryInput` (`util/stream/mem.h`).
-     *
-     * @param s                         String to read from.
-     */
-    inline TStringInput(const TString& s) noexcept
-        : S_(&s)
-        , Pos_(0)
-    {
-    }
-
-    TStringInput(const TString&&) = delete;
-
-    ~TStringInput() override;
-
-    TStringInput(TStringInput&&) noexcept = default;
-    TStringInput& operator=(TStringInput&&) noexcept = default;
-
-protected:
-    size_t DoNext(const void** ptr, size_t len) override;
-    void DoUndo(size_t len) override;
-
-private:
-    const TString* S_;
-    size_t Pos_;
-
-    friend class TStringStream;
-};
-
-/**
- * Stream for writing data into a string.
- */
-class TStringOutput: public IZeroCopyOutput {
-public:
-    /**
-     * Constructs a string output stream that appends character data to the
-     * provided string.
-     *
-     * Note that this stream keeps a reference to the provided string, so it's
-     * up to the user to make sure that the string doesn't get destroyed while
-     * this stream is in use.
-     *
-     * @param s                         String to append to.
-     */
-    inline TStringOutput(TString& s) noexcept
-        : S_(s)
-    {
-    }
-
-     TStringOutput(TStringOutput&& s) noexcept = default;
-
-    ~TStringOutput() override;
-
-    /**
-     * @param size                      Number of additional characters to
-     *                                  reserve in output string.
-     */
-    inline void Reserve(size_t size) {
-        S_.reserve(S_.size() + size);
-    }
-
-protected:
-    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:
-    TString& S_;
-};
-
-/**
- * String input/output stream, similar to `std::stringstream`.
- */
-class TStringStream: private TEmbedPolicy<TString>, public TStringInput, public TStringOutput {
-    using TEmbeddedString = TEmbedPolicy<TString>;
-
-public:
-    inline TStringStream()
-        : TEmbeddedString()
-        , TStringInput(*TEmbeddedString::Ptr())
-        , TStringOutput(*TEmbeddedString::Ptr())
-    {
-    }
-
-    inline TStringStream(const TString& string)
-        : TEmbeddedString(string)
-        , TStringInput(*TEmbeddedString::Ptr())
-        , TStringOutput(*TEmbeddedString::Ptr())
-    {
-    }
-
-    inline TStringStream(const TStringStream& other)
-        : TEmbeddedString(other.Str())
-        , TStringInput(*TEmbeddedString::Ptr())
-        , TStringOutput(*TEmbeddedString::Ptr())
-    {
-    }
-
-    inline TStringStream& operator=(const TStringStream& other) {
-        // All references remain alive, we need to change position only
-        Str() = other.Str();
-        Pos_ = other.Pos_;
-        return *this;
-    }
-
-    ~TStringStream() override;
-
-    /**
-     * @returns                         Whether @c this contains any data
-     */
-    explicit operator bool() const noexcept {
-        return !Empty();
-    }
-
-    /**
-     * @returns                         String that this stream is writing into.
-     */
-    inline TString& Str() noexcept {
-        return *Ptr();
-    }
-
-    /**
-     * @returns                         String that this stream is writing into.
-     */
-    inline const TString& Str() const noexcept {
-        return *Ptr();
-    }
-
-    /**
-     * @returns                         Pointer to the character data contained
-     *                                  in this stream. The data is guaranteed
-     *                                  to be null-terminated.
-     */
-    inline const char* Data() const noexcept {
-        return Ptr()->data();
-    }
-
-    /**
-     * @returns                         Total number of characters in this
-     *                                  stream. Note that this is not the same
-     *                                  as the total number of characters
-     *                                  available for reading.
-     */
-    inline size_t Size() const noexcept {
-        return Ptr()->size();
-    }
-
-    /**
-     * @returns                         Whether the string that this stream
-     *                                  operates on is empty.
-     */
-    Y_PURE_FUNCTION
-    inline bool Empty() const noexcept {
-        return Str().empty();
-    }
-
-    using TStringOutput::Reserve;
-
-    /**
-     * Clears the string that this stream operates on and resets the
-     * read/write pointers.
-     */
-    inline void Clear() {
-        Str().clear();
-        Pos_ = 0;
-    }
-
-    // TODO: compatibility with existing code, remove
-
-    Y_PURE_FUNCTION
-    bool empty() const {
-        return Empty();
-    }
-
-    void clear() {
-        Clear();
-    }
-};
-
-/** @} */