Javaのプロトコルバッファー区切りのI / O関数に相当するC ++がありますか？

Question

C++とJavaの両方で、ファイルから複数のProtocol Buffersメッセージを読み書きしようとしています。 Googleはメッセージの前に長さの接頭辞を書くことをお勧めしますが、デフォルトでそれを行う方法はありません（私は見ることができます）。

ただし、バージョン2.1.0のJava APIは、明らかにそのジョブを実行する一連の「区切り」I/O関数を受け取りました。

parseDelimitedFrom
mergeDelimitedFrom
writeDelimitedTo

C++に相当するものはありますか？そうでない場合、Java APIがアタッチするサイズプレフィックスのワイヤフォーマットは何ですか。したがって、これらのメッセージをC++で解析できますか？

---

更新：

これらは現在 google/protobuf/util/delimited_message_util.h v3.3.0以降。

Answer 1

私はここでパーティーに少し遅れていますが、以下の実装には他の回答から欠落している最適化が含まれており、64MBの入力後に失敗しません（ただし、個々のメッセージごとに 64MB制限 を強制しますが、ストリーム全体ではありません）。

（私はC++とJava protobufライブラリの作者ですが、Googleで働いていません。このコードが公式ライブラリに組み込まれたことはありません。これは次のようになります。持っていた。）

bool writeDelimitedTo(
    const google::protobuf::MessageLite& message,
    google::protobuf::io::ZeroCopyOutputStream* rawOutput) {
  // We create a new coded stream for each message.  Don't worry, this is fast.
  google::protobuf::io::CodedOutputStream output(rawOutput);

  // Write the size.
  const int size = message.ByteSize();
  output.WriteVarint32(size);

  uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
  if (buffer != NULL) {
    // Optimization:  The message fits in one buffer, so use the faster
    // direct-to-array serialization path.
    message.SerializeWithCachedSizesToArray(buffer);
  } else {
    // Slightly-slower path when the message is multiple buffers.
    message.SerializeWithCachedSizes(&output);
    if (output.HadError()) return false;
  }

  return true;
}

bool readDelimitedFrom(
    google::protobuf::io::ZeroCopyInputStream* rawInput,
    google::protobuf::MessageLite* message) {
  // We create a new coded stream for each message.  Don't worry, this is fast,
  // and it makes sure the 64MB total size limit is imposed per-message rather
  // than on the whole stream.  (See the CodedInputStream interface for more
  // info on this limit.)
  google::protobuf::io::CodedInputStream input(rawInput);

  // Read the size.
  uint32_t size;
  if (!input.ReadVarint32(&size)) return false;

  // Tell the stream not to read beyond that size.
  google::protobuf::io::CodedInputStream::Limit limit =
      input.PushLimit(size);

  // Parse the message.
  if (!message->MergeFromCodedStream(&input)) return false;
  if (!input.ConsumedEntireMessage()) return false;

  // Release the limit.
  input.PopLimit(limit);

  return true;
}

Answer 2

わかりましたので、必要なものを実装するトップレベルのC++関数を見つけることができませんでしたが、Java APIリファレンスを介していくつかのスペルは、 MessageLite インターフェイス：

void writeDelimitedTo(OutputStream output)
/*  Like writeTo(OutputStream), but writes the size of 
    the message as a varint before writing the data.   */

したがって、Javaサイズプレフィックスは（プロトコルバッファ）varint！

その情報を武器に、C++ APIを掘り下げてみると、次のような CodedStream ヘッダーが見つかりました。

bool CodedInputStream::ReadVarint32(uint32 * value)
void CodedOutputStream::WriteVarint32(uint32 value)

これらを使用して、仕事をする独自のC++関数をロールバックできるはずです。

ただし、実際にはこれをメインのMessage APIに追加する必要があります。 Javaにあることを考慮すると、Marc Gravellの優れたprotobuf-net C＃ポート（SerializeWithLengthPrefixおよびDeserializeWithLengthPrefixを介して）を考慮すると、機能が失われます。

Answer 3

CodedOutputStream/ArrayOutputStreamを使用してメッセージ（サイズ付き）を書き込み、CodedInputStream/ArrayInputStreamを使用してメッセージ（サイズ付き）を読み取り、同じ問題を解決しました。

たとえば、次の擬似コードは、メッセージの後にメッセージサイズを書き込みます。

const unsigned bufLength = 256;
unsigned char buffer[bufLength];
Message protoMessage;

google::protobuf::io::ArrayOutputStream arrayOutput(buffer, bufLength);
google::protobuf::io::CodedOutputStream codedOutput(&arrayOutput);

codedOutput.WriteLittleEndian32(protoMessage.ByteSize());
protoMessage.SerializeToCodedStream(&codedOutput);

書き込み時には、バッファがメッセージに合わせて十分な大きさ（サイズを含む）であることも確認する必要があります。また、読み取り時には、バッファにメッセージ全体（サイズを含む）が含まれていることを確認する必要があります。

Java API。

Answer 4

IsteamInputStreamは、stof :: istreamと共に使用すると簡単に発生するeofsやその他のエラーに対して非常に脆弱です。この後、protobufストリームは永続的に破損し、すでに使用されているバッファデータはすべて破棄されます。 protobufの従来のストリームからの読み取りに対する適切なサポートがあります。

_google::protobuf::io::CopyingInputStream_を実装し、それを CopyingInputStreamAdapter と組み合わせて使用​​します。出力バリアントについても同じことを行います。

実際には、解析呼び出しは、バッファが指定されているgoogle::protobuf::io::CopyingInputStream::Read(void* buffer, int size)になります。残された唯一のことは、何とかそれを読むことです。

Asio同期ストリーム（ SyncReadStream / SyncWriteStream ）で使用する例を次に示します。

_#include <google/protobuf/io/zero_copy_stream_impl_lite.h>

using namespace google::protobuf::io;


template <typename SyncReadStream>
class AsioInputStream : public CopyingInputStream {
    public:
        AsioInputStream(SyncReadStream& sock);
        int Read(void* buffer, int size);
    private:
        SyncReadStream& m_Socket;
};


template <typename SyncReadStream>
AsioInputStream<SyncReadStream>::AsioInputStream(SyncReadStream& sock) :
    m_Socket(sock) {}


template <typename SyncReadStream>
int
AsioInputStream<SyncReadStream>::Read(void* buffer, int size)
{
    std::size_t bytes_read;
    boost::system::error_code ec;
    bytes_read = m_Socket.read_some(boost::asio::buffer(buffer, size), ec);

    if(!ec) {
        return bytes_read;
    } else if (ec == boost::asio::error::eof) {
        return 0;
    } else {
        return -1;
    }
}


template <typename SyncWriteStream>
class AsioOutputStream : public CopyingOutputStream {
    public:
        AsioOutputStream(SyncWriteStream& sock);
        bool Write(const void* buffer, int size);
    private:
        SyncWriteStream& m_Socket;
};


template <typename SyncWriteStream>
AsioOutputStream<SyncWriteStream>::AsioOutputStream(SyncWriteStream& sock) :
    m_Socket(sock) {}


template <typename SyncWriteStream>
bool
AsioOutputStream<SyncWriteStream>::Write(const void* buffer, int size)
{   
    boost::system::error_code ec;
    m_Socket.write_some(boost::asio::buffer(buffer, size), ec);
    return !ec;
}
_

使用法：

_AsioInputStream<boost::asio::ip::tcp::socket> ais(m_Socket); // Where m_Socket is a instance of boost::asio::ip::tcp::socket
CopyingInputStreamAdaptor cis_adp(&ais);
CodedInputStream cis(&cis_adp);

Message protoMessage;
uint32_t msg_size;

/* Read message size */
if(!cis.ReadVarint32(&msg_size)) {
    // Handle error
 }

/* Make sure not to read beyond limit of message */
CodedInputStream::Limit msg_limit = cis.PushLimit(msg_size);
if(!msg.ParseFromCodedStream(&cis)) {
    // Handle error
}

/* Remove limit */
cis.PopLimit(msg_limit);
_

Answer 5

C++とPythonの両方で同じ問題に遭遇しました。

C++バージョンでは、このスレッドに投稿されたKenton Vardaのコードと、protobufチームに送信されたプルリクエストのコードを組み合わせて使用​​しました（ここに投稿されたバージョンはEOF =彼がgithubに送ったものはそうです）。

#include <google/protobuf/message_lite.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/coded_stream.h>


bool writeDelimitedTo(const google::protobuf::MessageLite& message,
    google::protobuf::io::ZeroCopyOutputStream* rawOutput)
{
    // We create a new coded stream for each message.  Don't worry, this is fast.
    google::protobuf::io::CodedOutputStream output(rawOutput);

    // Write the size.
    const int size = message.ByteSize();
    output.WriteVarint32(size);

    uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
    if (buffer != NULL)
    {
        // Optimization:  The message fits in one buffer, so use the faster
        // direct-to-array serialization path.
        message.SerializeWithCachedSizesToArray(buffer);
    }

    else
    {
        // Slightly-slower path when the message is multiple buffers.
        message.SerializeWithCachedSizes(&output);
        if (output.HadError())
            return false;
    }

    return true;
}

bool readDelimitedFrom(google::protobuf::io::ZeroCopyInputStream* rawInput, google::protobuf::MessageLite* message, bool* clean_eof)
{
    // We create a new coded stream for each message.  Don't worry, this is fast,
    // and it makes sure the 64MB total size limit is imposed per-message rather
    // than on the whole stream.  (See the CodedInputStream interface for more
    // info on this limit.)
    google::protobuf::io::CodedInputStream input(rawInput);
    const int start = input.CurrentPosition();
    if (clean_eof)
        *clean_eof = false;


    // Read the size.
    uint32_t size;
    if (!input.ReadVarint32(&size))
    {
        if (clean_eof)
            *clean_eof = input.CurrentPosition() == start;
        return false;
    }
    // Tell the stream not to read beyond that size.
    google::protobuf::io::CodedInputStream::Limit limit = input.PushLimit(size);

    // Parse the message.
    if (!message->MergeFromCodedStream(&input)) return false;
    if (!input.ConsumedEntireMessage()) return false;

    // Release the limit.
    input.PopLimit(limit);

    return true;
}

そして、ここに私のpython2実装があります：

from google.protobuf.internal import encoder
from google.protobuf.internal import decoder

#I had to implement this because the tools in google.protobuf.internal.decoder
#read from a buffer, not from a file-like objcet
def readRawVarint32(stream):
    mask = 0x80 # (1 << 7)
    raw_varint32 = []
    while 1:
        b = stream.read(1)
        #eof
        if b == "":
            break
        raw_varint32.append(b)
        if not (ord(b) & mask):
            #we found a byte starting with a 0, which means it's the last byte of this varint
            break
    return raw_varint32

def writeDelimitedTo(message, stream):
    message_str = message.SerializeToString()
    delimiter = encoder._VarintBytes(len(message_str))
    stream.write(delimiter + message_str)

def readDelimitedFrom(MessageType, stream):
    raw_varint32 = readRawVarint32(stream)
    message = None

    if raw_varint32:
        size, _ = decoder._DecodeVarint32(raw_varint32, 0)

        data = stream.read(size)
        if len(data) < size:
            raise Exception("Unexpected end of file")

        message = MessageType()
        message.ParseFromString(data)

    return message

#In place version that takes an already built protobuf object
#In my tests, this is around 20% faster than the other version 
#of readDelimitedFrom()
def readDelimitedFrom_inplace(message, stream):
    raw_varint32 = readRawVarint32(stream)

    if raw_varint32:
        size, _ = decoder._DecodeVarint32(raw_varint32, 0)

        data = stream.read(size)
        if len(data) < size:
            raise Exception("Unexpected end of file")

        message.ParseFromString(data)

        return message
    else:
        return None

それは最高の外観のコードではないかもしれませんし、かなりリファクタリングできると確信していますが、少なくともそれを行うための1つの方法を示しているはずです。

今大きな問題：それは[〜＃〜] slow [〜＃〜]です。

Python-protobufのC++実装を使用する場合でも、純粋なC++よりも1桁遅くなります。ファイルからそれぞれ約30バイトの10M protobufメッセージを読み取るベンチマークがあります。 C++では〜0.9秒、Pythonでは35秒かかります。

少し速くするための1つの方法は、varintデコーダを再実装して、ファイルから読み取り、このコードが現在行うようにデコードするのではなく、ファイルから読み取り、一度にデコードするようにすることです。 （プロファイリングは、varintエンコーダー/デコーダーにかなりの時間が費やされることを示しています）。しかし、言うまでもなく、pythonバージョンとC++バージョンの間のギャップを埋めるのに十分ではありません。

高速化するアイデアは大歓迎です:)

Answer 6

どうぞ：

#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/io/coded_stream.h>

using namespace google::protobuf::io;

class FASWriter 
{
    std::ofstream mFs;
    OstreamOutputStream *_OstreamOutputStream;
    CodedOutputStream *_CodedOutputStream;
public:
    FASWriter(const std::string &file) : mFs(file,std::ios::out | std::ios::binary)
    {
        assert(mFs.good());

        _OstreamOutputStream = new OstreamOutputStream(&mFs);
        _CodedOutputStream = new CodedOutputStream(_OstreamOutputStream);
    }

    inline void operator()(const ::google::protobuf::Message &msg)
    {
        _CodedOutputStream->WriteVarint32(msg.ByteSize());

        if ( !msg.SerializeToCodedStream(_CodedOutputStream) )
            std::cout << "SerializeToCodedStream error " << std::endl;
    }

    ~FASWriter()
    {
        delete _CodedOutputStream;
        delete _OstreamOutputStream;
        mFs.close();
    }
};

class FASReader
{
    std::ifstream mFs;

    IstreamInputStream *_IstreamInputStream;
    CodedInputStream *_CodedInputStream;
public:
    FASReader(const std::string &file), mFs(file,std::ios::in | std::ios::binary)
    {
        assert(mFs.good());

        _IstreamInputStream = new IstreamInputStream(&mFs);
        _CodedInputStream = new CodedInputStream(_IstreamInputStream);      
    }

    template<class T>
    bool ReadNext()
    {
        T msg;
        unsigned __int32 size;

        bool ret;
        if ( ret = _CodedInputStream->ReadVarint32(&size) )
        {   
            CodedInputStream::Limit msgLimit = _CodedInputStream->PushLimit(size);
            if ( ret = msg.ParseFromCodedStream(_CodedInputStream) )
            {
                _CodedInputStream->PopLimit(msgLimit);      
                std::cout << mFeed << " FASReader ReadNext: " << msg.DebugString() << std::endl;
            }
        }

        return ret;
    }

    ~FASReader()
    {
        delete _CodedInputStream;
        delete _IstreamInputStream;
        mFs.close();
    }
};

Answer 7

これに対する解決策も探していました。いくつかのJavaコードがwriteDelimitedToを含むMyRecordメッセージをファイルに書き込んだと仮定して、ソリューションの中核を以下に示します。

 if（someCodedInputStream-> ReadVarint32（＆bytes））{
 CodedInputStream :: Limit msgLimit = someCodedInputStream-> PushLimit（bytes）; 
 if（myRecord-> ParseFromCodedStream（someCodedInputStream）） {[。 msgLimit）; 
} else {
 //おそらくファイルの終わり
} 

それが役に立てば幸い。

Answer 8

上記のKenton Vardaの回答に対するコメントとしてこれを書くことは許可されていないため、彼が投稿したコード（および提供された他の回答）にバグがあると思います。次のコード：

...
google::protobuf::io::CodedInputStream input(rawInput);

// Read the size.
uint32_t size;
if (!input.ReadVarint32(&size)) return false;

// Tell the stream not to read beyond that size.
google::protobuf::io::CodedInputStream::Limit limit =
    input.PushLimit(size);
...

入力から既に読み取られたvarint32のサイズを考慮しないため、誤った制限を設定します。これにより、次のメッセージの一部である可能性のある追加のバイトがストリームから読み取られるため、データの損失/破損が発生する可能性があります。これを正しく処理する通常の方法は、サイズの読み取りに使用されるCodedInputStreamを削除し、ペイロードを読み取るための新しいサイズを作成することです。

...
uint32_t size;
{
  google::protobuf::io::CodedInputStream input(rawInput);

  // Read the size.
  if (!input.ReadVarint32(&size)) return false;
}

google::protobuf::io::CodedInputStream input(rawInput);

// Tell the stream not to read beyond that size.
google::protobuf::io::CodedInputStream::Limit limit =
    input.PushLimit(size);
...

Answer 9

Protocol-buffersのObjective-Cバージョンを使用して、私はこの正確な問題に遭遇しました。 iOSクライアントから、長さを最初のバイトとして予期するparseDelimitedFromを使用するJavaベースのサーバーに送信する際に、最初にCodeROutputByteに対してwriteRawByteを呼び出す必要がありました。この問題に突き当たります。この問題を解決している間、Googleのproto-bufsにはこれを行うための単純なフラグが付いていると思います...

    Request* request = [rBuild build];

    [self sendMessage:request];
} 


- (void) sendMessage:(Request *) request {

    //** get length
    NSData* n = [request data];
    uint8_t len = [n length];

    PBCodedOutputStream* os = [PBCodedOutputStream streamWithOutputStream:outputStream];
    //** prepend it to message, such that Request.parseDelimitedFrom(in) can parse it properly
    [os writeRawByte:len];
    [request writeToCodedOutputStream:os];
    [os flush];
}