Class TTcp2Message

library/cpp/neh/tcp2.cpp:150–271

buffer for read input data, - header + message data

        //buffer for read input data, - header + message data
        struct TTcp2Message {
            TTcp2Message()
                : Loader_(&TTcp2Message::LoadBaseHeader)
                , RequireBytesForComplete_(sizeof(TBaseHeader))
                , Header_(sizeof(TBaseHeader))
            {
            }

            void Clear() {
                Loader_ = &TTcp2Message::LoadBaseHeader;
                RequireBytesForComplete_ = sizeof(TBaseHeader);
                Header_.Clear();
                Content_.clear();
            }

            TBuffer& Header() noexcept {
                return Header_;
            }

            const TString& Content() const noexcept {
                return Content_;
            }

            bool IsComplete() const noexcept {
                return RequireBytesForComplete_ == 0;
            }

            size_t LoadFrom(const char* buf, size_t len) {
                return (this->*Loader_)(buf, len);
            }

            const TBaseHeader& BaseHeader() const {
                return *reinterpret_cast<const TBaseHeader*>(Header_.Data());
            }

            const TRequestHeader& RequestHeader() const {
                return *reinterpret_cast<const TRequestHeader*>(Header_.Data());
            }

            const TResponseHeader& ResponseHeader() const {
                return *reinterpret_cast<const TResponseHeader*>(Header_.Data());
            }

        private:
            size_t LoadBaseHeader(const char* buf, size_t len) {
                size_t useBytes = Min<size_t>(sizeof(TBaseHeader) - Header_.Size(), len);
                Header_.Append(buf, useBytes);
                if (Y_UNLIKELY(sizeof(TBaseHeader) > Header_.Size())) {
                    //base header yet not complete
                    return useBytes;
                }
                {
                    const TBaseHeader& hdr = BaseHeader();
                    if (BaseHeader().HeaderLength > 32000) { //some heuristic header size limit
                        throw yexception() << TStringBuf("to large neh/tcp2 header size: ") << BaseHeader().HeaderLength;
                    }
                    //header completed
                    Header_.Reserve(hdr.HeaderLength);