Y a-t-il un moyen de créer un type d'alias dans protobuf (proto2)?

[ Mise À Jour : Août 2017. Adapté à la réécriture complète de protocole-gen-bug, actuellement 1.0.0-rc ]

Je n'ai pas de réponse pour les alias de type, mais j'en ai un pour ceci:

mon objectif immédiat est de faire de la documentation (générée avec protoc-gen-doc ) plus facilement compréhensible.

Et aussi, je tiens à souligner que protoc-gen-doc a été entièrement réécrit dans Go et utilise maintenant Docker pour la génération au lieu de apt-get .

j'ai créé quelques html et markdown démo de l'utilisation de formatage inline rich dans vos commentaires, comme l'ajout de liens, codes snippets, tableaux, gras, italique, etc.

et aussi décrire comment vous pouvez auto-générer et publier à GitHub Pages ( gh-pages branche) en utilisant TravisCI

Il y a quelques petits bugs qui doivent encore être résolus (Août 2017) pour qu'il soit prêt à la production.

voir la démo + description à:

• https://github.com/aschrijver/protoc-gen-doc-example

.

Par exemple markdown inline commentaires comme ces :

/**
* The **SLEEP** format is designed by the [Dat Project](https://datproject.org) 
* to allow for sparse replication, meaning you can efficiently download
* only the metadata and data required to resolve a single byte region 
* of a single file, which makes Dat suitable for a wide variety of streaming,
* _real-time_ and large dataset use cases.
*
* To take advantage of this, Dat includes a _network protocol_. It is message
* based and stateless, making it possible to implement on a variety of network
* transport protocols including UDP and TCP.
*
* Both metadata and content registers in **SLEEP** share the exact same
* replication protocol.
*
* Individual messages are encoded using Protocol Buffers and there are ten
* message types in total.
*
* ### Wire Protocol
*
* Over the wire messages are packed in the following lightweight
* container format:
*
* ```
* <varint - length of rest of message>
*   <varint - header>
*   <message>
* ```
*
* The `header` value is a single `varint` that has two pieces of information,
* the integer type that declares a 4-bit message type (used below), and a
* channel identifier, 0 for metadata and 1 for content.
*
* To generate this varint, you bitshift the 4-bit type integer onto the end of
* the channel identifier, e.g. channel << 4 | <4-bit-type>.
*
* ### Using in NodeJS
*
* The `protocol-bufers` package offers an intuitive javascript API, so you need
* not worry about low-level protocol concepts.
* 
* This example demonstrates how you create a feed and start streaming:
*
* ```javascript
*   var protocol = require('hypercore-protocol')
*   var stream = protocol()
*   
*   // open a feed specified by a 32 byte key
*   var feed = stream.feed(Buffer('deadbeefdeadbeefdeadbeefdeadbeef'))
*   
*   feed.request({block: 42})
*   feed.on('data', function (message) {
*     console.log(message) // contains message.index and message.value
*   })
*   
*   stream.pipe(anotherStream).pipe(stream)
* ```
*/

.

résultera en sortie similaire à ce :

---

HypercoreSpecV1_md.proto

le format SLEEP est conçu par le Dat Projet pour permettre la réplication éparse, ce qui signifie que vous pouvez télécharger efficacement seulement les métadonnées et les données nécessaire pour résoudre un seul région octet d'un seul fichier, ce qui rend Dat adapté à une grande variété de streaming, en temps réel et grand jeu de données de cas d'utilisation.

pour en profiter, Dat inclut un network protocol . Il est message basé et apatride, permettant de mettre en œuvre sur un variété de protocoles de transport réseau incluant UDP et TCP.

les registres de métadonnées et de contenu SOMMEIL partager exactement la même protocole de réplication.

les messages individuels sont encodés à l'aide de tampons de protocole et il y a dix types de messages au total.

Protocole Fil

sur les messages de fil sont emballés dans le poids léger suivant format du conteneur:

<varint - length of rest of message>
  <varint - header>
  <message>

la valeur header est un simple varint qui a deux pièces de information, le type entier qui déclare un type de message 4 bits (utilisé ci-dessous), et un identificateur de canal, 0 pour les métadonnées et 1 pour le contenu.

pour générer ce varint, vous bitshift le type de 4 bits entier sur le fin de l'identificateur du canal, p.ex. canal << 4 | <4-bit-type>.

à l'Aide de NodeJS

le paquet protocol-bufers offre une API JavaScript intuitive, donc vous ne devez pas vous soucier de bas niveau concepts de protocole.

Cet exemple montre comment créer un flux et commencer à diffuser:

var protocol = require('hypercore-protocol')
var stream = protocol()

// open a feed specified by a 32 byte key
var feed = stream.feed(Buffer('deadbeefdeadbeefdeadbeefdeadbeef'))

feed.request({block: 42})
feed.on('data', function (message) {
  console.log(message) // contains message.index and message.value
})

stream.pipe(anotherStream).pipe(stream)

---

( Note : le hypercore protocole est l'une des spécifications de base du projet Dat écosystème de modules pour la création décentralisée peer-to-peer applications designs. J'ai utilisé leur .proto fichier pour illustrer les concepts )