Schreiben/Lesen von Protokollpuffern

Question

Um komplexe JSON/JavaScript-Objekte über eine Verbindung an C++ - Binärdateien zu senden, verwende ich Protokollpuffer. Heutzutage gibt es eine native Protobuf-Unterstützung für Node.js, daher verwende ich keine anderen Bindungen.

// Set maximum execution time of binary to equal the 
// remainder of processing time, minus a second to allow 
// for parsing. 
var timeLimit = context.getRemainingTimeInMillis() - 1000; 

// Check if meta parameters are given in the request. 
// Assign default values if they are not. 
var model = new protocols.Model(); 

// Sort the resolutions. 
function descending(a, b) { 
    if (a.width > b.width) { 
     return -1; 
    } else if (a.width < b.width) { 
     return 1; 
    } 
    return 0; 
} 

// Construct image objects. 
var images = request.images.map(function(image) { 
    // Perform the sort. 
    image.resolutions.sort(descending); 

    // Create an image protobuffer. 
    var imageProto = new protocols.Model.Image(); 

    // Assign the original's resolution to the image. 
    imageProto.setWidth(image.resolutions[0].width); 
    imageProto.setHeight(image.resolutions[0].height); 

    // Return the result. 
    return imageProto; 
}); 

// Construct flag enumeration references. 
var flags = request.flags.map(function(flag) { 
    return protocols.Model.Flag[flag]; 
}); 

// Assign request properties to protobuf. 
model.setImagesList  (images             ); 
model.setFlagsList  (flags              ); 
model.setMinNoOfPages (request.minNoOfPages ? request.minNoOfPages : 1  ); 
model.setMaxNoOfPages (request.maxNoOfPages ? request.maxNoOfPages : 1  ); 
model.setMaxPerPage  (request.maxPerPage  ? request.maxPerPage : 5  ); 
model.setPageWidth  (request.pageWidth  ? request.pageWidth  : 3508  ); 
model.setPageHeight  (request.pageHeight  ? request.pageHeight : 2480  ); 
model.setTimeLimit  (request.timeLimit  ? request.timeLimit  : timeLimit); 
model.setBorderWidth (request.borderWidth ? request.borderWidth : 0  ); 
model.setMinDim   (request.minDim   ? request.minDim  : 0  ); 

// This is where things go wrong. 
var serialized = model.serializeBinary(); 
fs.writeFileSync('model.pb', serialized); 
var read = fs.readFileSync('model.pb'), 
    model2 = protocols.Model.deserializeBinary(read); 

console.log(model.toObject()); 
console.log(model2.toObject()); 

Oben ist das Stück Code, auf dem ich feststecke. Ich schaffte es eine protobuf Nachricht zu kompilieren:

syntax = "proto3"; 

package layout; 

message Model { 

    enum Flag { 
     FILL_PAGE = 0; 
     BORDERS = 1; 
    } 

    message Image { 
     int32 width = 1; 
     int32 height = 2; 
    } 

    repeated Flag flags = 1; 
    repeated Image images = 2; 

    string avoid_layout = 3; 
    int32 min_no_of_pages = 4; 
    int32 max_no_of_pages = 5; 
    int32 max_per_page = 6; 
    int32 page_width = 7; 
    int32 page_height = 8; 
    int32 time_limit = 9; 
    int32 border_width = 10; 
    int32 min_dim = 11; 
} 

jedoch Dokumentation über die JavaScript-Unterstützung für protobuf minimal ist (https://developers.google.com/protocol-buffers/docs/reference/javascript-generated#message) und ich kann nicht herausfinden, wie ich meine Nachrichten in eine Datei lesen kann, und sie dann wieder lesen . Kann mir jemand erklären, wie man das macht?

Ich stelle mir die Lösung eine gewisse Variation auf den letzten Zeilen meines Codes ist, aber zur Zeit bin ich immer diese Fehlermeldung:

AssertionError: Failure: Type not convertible to Uint8Array. 

Answer 1

Sie wahrscheinlich etwas obskuren Fall des Knotens Zeuge Buffer nicht erkannt Uint8Array. Ich habe eine relevant issue report gefunden. So versuchen, die Art mit

protocols.Model.deserializeBinary(new Uint8Array(read)); 

oder replacing the constructor zusetzen. Dieser Vorschlag ist Ihrem ähnlich - er liest auch eine Binärdatei.