我试图在python中使用协议缓冲区提交响应.以下是结构.
message BidResponse {
message Ad {
optional string html_snippet = 1;
message TemplateParameter {
optional string parameter_value = 1;
optional string blank_ad_parameter_value = 8;
optional string buyer_creative_id = 2;
optional string click_through_url = 3;
optional int32 left = 4;
optional int32 right = 5;
optional int32 top = 6;
optional int32 bottom = 7;
optional int32 backup_index = 9;
};
repeated TemplateParameter template_parameter = 13;
repeated string click_through_url = 4;
repeated int32 vendor_type = 5;
message AdSlot {
required …我有以下单元测试代码,它基本上通过序列化和反序列化来复制对象:
FloatMat mat2;
assert(mat2.ParseFromString(mat.SerializeAsString()));
cout << mat.vec_size() << "\n";
cout << mat2.vec_size() << "\n";
使用cmake调试模式构建时,它会按预期方式给出:
2
2
但是当使用cmake release模式构建时,它会给出:
2
0
我对发布模式的构建不太熟悉,请帮忙!谢谢!
最近,我读了HBase的代码.我发现客户端使用protobuf与HBase代码中的服务器进行通信.
Java具有"可序列化".为什么不用它？
我正在使用 Golang protobuf 包并尝试编写一些测试以确保我的 API 正常工作。
我使用生成的.pb.go文件在服务器端构建了一个对象。
并返回它
data, err := proto.Marshal(p)
fmt.Fprint(w, data)
在我的测试中我做
func TestGetProduct(t *testing.T) {
log.Println("Starting server")
go startAPITestServer()
time.Sleep(0 * time.Second)
log.Println("Server started")
//rq, err := http.NewRequest("GET", "localhost:8181/product/1", nil)
client := &http.Client{}
log.Println("Starting Request")
resp, err := client.Get("http://localhost:8181/product/1")
log.Println("Finished Request")
if err != nil {
t.Log(err)
}
defer resp.Body.Close()
log.Println("Reading Request")
data, err := ioutil.ReadAll(resp.Body)
log.Println("Reading finished")
if err != nil {
t.Log(err)
}
log.Println("HTTP Resp", data)
p := &Product{}
proto.UnmarshalText(string(data), p)
proto.Unmarshal(data, …我正在使用Nanopb尝试从基于VxWorks的National Compact Compact RIO（9025）发送protobuf消息。我的交叉编译效果很好，甚至可以发送不需要额外编码的数据类型的完整消息。让我着迷的是回调。我的代码是通过LabVIEW交叉编译和调用的，基于Nanopb的基于回调的结构似乎在目标计算机上中断（错误，崩溃，目标重新启动等）。如果我不带任何回调地运行它，则效果很好。
这是有问题的代码：
bool encode_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
{
char *str = "Woo hoo!";
if (!pb_encode_tag_for_field(stream, field))
return false;
return pb_encode_string(stream, (uint8_t*)str, strlen(str));
}
extern "C" uint16_t getPacket(uint8_t* packet)
{
uint8_t buffer[256];
uint16_t packetSize;
ExampleMsg msg = {};
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
msg.name.funcs.encode = &encode_string;
msg.value = 17;
msg.number = 18;
pb_encode(&stream, ExampleMsg_fields, &msg);
packetSize = stream.bytes_written;
memcpy(packet, buffer, 256);
return packetSize;
}
这是原始文件：
syntax = "proto2"
message ExampleMsg { …我有一个程序,用Java中的Protobuf序列化数据,在byte [] Array中写入二进制数据,然后将其保存在".txt"文件中.我在字符串流中接收C++端的数据.现在我想用C++解析那个二进制数据,但是Protobuf-Parsing-Method"parseFromString()"不起作用!我的测试消息中的字段未设置.我为此写了一个小测试,我可以给你看一些代码:
Java序列化
byte[] s = test.build().toByteArray(); //This is serialized to "C:\test.txt" as binary
C++解析:
Test t1; // My Protobuf Message
std::ifstream myFile("C:\\test.txt");
std::string s;
myFile >> s;
t1.ParseFromString(s);
std::cout << "Decoded: " << t2.s() << std::endl; // Check if parsing was correct
但它只是返回:"解码:",好像t2是空的,但它不应该!如何用C++解析二进制数据？
我想使用protobuf并以文本格式创建序列化输出文件，以进行测试和替换json。我不知道如何独自编写它，并且正在寻找示例。这是一个二进制输出：
#include <iostream>
#include <fstream>
#include <string>
#include "addressbook.pb.h"
using namespace std;
// This function fills in a Person message based on user input.
void PromptForAddress(tutorial::Person* person) {
cout << "Enter person ID number: ";
int id;
cin >> id;
person->set_id(id);
cin.ignore(256, '\n');
cout << "Enter name: ";
getline(cin, *person->mutable_name());
cout << "Enter email address (blank for none): ";
string email;
getline(cin, email);
if (!email.empty()) {
person->set_email(email);
}
while (true) {
cout << "Enter a phone number (or leave blank …我在将值存储到 void* 并成功检索我最初存储的内容时遇到问题。以下是我的伪代码/思路：
客户端内部方法 1
StatusCode doSomething() {
string filename = "somefile.txt";
void* server_checksum;
//Stat signature (string &filename, void* file_status)
StatusCode fileStatus = Stat(filename, &server_checksum); //Passing the address of the pointer
//We received the fileStatus from Stat, I expect the value of server_checksum to match what the server sent
//However, this prints a completely different number, and I do not know how to ensure it holds the right value
cout << *((uint32_t *)serverCrc) << endl;
return StatusCode::OK;
}
在客户端的 Stat …
在 gRPC 中，它期望参数是 protobuf 消息。假设我想发送一个int，我必须创建一个消息message Int { int32 value = 1; }并使用这个消息发送一个int。
下面是函数定义的一个例子： rpc Range(Int) returns (stream Int) {}
但我不想为每个默认标量类型创建这样的消息结构，例如 bool、int32、int64、float 等。如何在 gRPC 函数参数中使用标量类型？
我有一个“代理”，它将二进制文件解析到一个缓冲区中，每当该缓冲区被填满时，就通过 protobuf 消息将其发送到服务器，然后继续进行下一个二进制解析块，然后再次发送，等等。
在服务器上，我使用一个简单的net/conn包来侦听代理连接并在 while-for 循环中从它读取到缓冲区。当解析完成代理端，它terminate在 protobuf 消息中发送一个布尔值，表明这是最后一条消息，服务器可以继续处理收到的完整数据。
但是，如果我将调试打印留在我的发送方，这会很好地工作，使终端打印显着减慢通过connection.Write().
如果我取消注释这个记录器，那么它发送消息的速度太快，服务器处理的第一个传入消息是一个包含terminate标志的数据包，例如，它没有收到实际的有效负载，而是立即收到最后一条消息。
我知道 TCP 并没有真正区分不同的 []byte 数据包，这很可能是导致这种行为的原因。有没有更好的方法来做到这一点，任何替代方案？
伪代码代理端：
buffer := make([]byte, 1024)
for {
n, ioErr := reader.Read(buffer)
if ioErr == io.EOF {
isPayloadFinal = true
// Create protobuf message
terminalMessage, err := CreateMessage_FilePackage(
2234,
protobuf.MessageType_PACKAGE,
make([]byte, 1),
isPayloadFinal,
)
// Send terminate message
sendProtoBufMessage(connection, terminalMessage)
break
}
// Create regular protobuf message
message, err := CreateMessage_FilePackage(
2234,
protobuf.MessageType_PACKAGE,
(buffer)[:n],
isPayloadFinal)
sendProtoBufMessage(connection, message)
} …