protobufjs-dota

protobuf.js 5  
=====================================
Protocol Buffers are a language-neutral, platform-neutral, extensible way of serializing structured data for use
in communications protocols, data storage, and more, originally designed at Google (see).

protobuf.js is a pure JavaScript implementation on top of bytebuffer.js
including a .proto parser, message class building and simple encoding and decoding. There is no compilation step
required, it's super easy to use and it works out of the box on .proto files!

Getting started
---------------
* Step 1: Become familar with Google's Protocol Buffers (protobuf)
* Step 2: Read on or head straight to our wiki for additional information
* Step 3: Build something cool! :-)

Features
--------
* RequireJS/AMD compatible
* node.js/CommonJS compatible, also available via npm
* Browser compatible
* Closure Compiler compatible (fully annotated, externs)
* Fully documented using jsdoc3
* Well tested through test.js
* bytebuffer.js is the only production dependency
* Fully compatible to the official implementation including advanced features
* proto2js command line utility

Installation
------------

$3

``
$> npm install protobufjs
`

`js
var ProtoBuf = require("protobufjs");
...
`

$3

Requires bytebuffer.js. Optionally depends on long.js for long (int64) support. If you do not require long support, you can skip the Long.js config. RequireJS example:

`js
require(["protobuf"], function(ProtoBuf) {
...
});
`

Or as a module dependency:

`js
define("MyModule", ["protobuf"], function(ProtoBuf) {
...
});
`

$3

Requires bytebuffer.js. Optionally depends on long.js for long (int64) support. If you do not require long support, you can skip the Long.js include.

`html




`

`js
var ProtoBuf = dcodeIO.ProtoBuf;
...
`

Getting started
---------------

Note: You'll need the full build to load .proto data. light builds are able to load JSON only.

$3

To load a .proto file, use:

API: ProtoBuf.loadProtoFile(source[, callback[, builder]]):Builder|undefined

`js
// Synchronously
var builder = ProtoBuf.loadProtoFile("path/to/file.proto");

// Asynchronously
ProtoBuf.loadProtoFile("path/to/file.proto", function(err, builder) {
...
});
`

ProtoBuf.loadProtoFile also accepts an object specifying the import root directory and the file to load as its first parameter: {root: string, file: string}. Additionally, an already created and then reused builder can be specified as the last argument, which is useful if all the definitions shall reside in a single namespace.

$3

API: ProtoBuf.loadProto(source[, builder][, filename]):Builder

`js
var builder = ProtoBuf.loadProto(...protoString..., "myproto.proto");
`

$3

To load the (raw) JSON counterpart generated through pbjs, use ProtoBuf.loadJsonFile respectively ProtoBuf.loadJson. It's the same API.

If you generated classes or modules with it, loading is done just by including respectively requiring the resulting file. Loading is handled transparently in this case.

When using JSON only, you can use protobuf-light.js or protobuf-light.min.js instead, which do NOT include the ProtoBuf.DotProto package for parsing and are therefore smaller.

Command line
------------
Since ProtoBuf.js 4.0.0 the library ships with the pbjs command line utility. With it it's possible to convert between .proto and JSON descriptors and even to generate the code required to access runtime structures as pure JS (classes), an AMD module or a CommonJS module.

`

_ |_ . _
|_)|_)|_) ProtoBuf.js v4.0.0-b3 https://github.com/dcodeIO/ProtoBuf.js
| '

CLI utility to convert between .proto and JSON syntax / to generate classes.

Usage: pbjs [options] [> outFile]

Options:
--help, -h Show help [boolean]
--version, -v Show version number [boolean]
--source, -s Specifies the source format. Valid formats are:

json Plain JSON descriptor
proto Plain .proto descriptor

--target, -t Specifies the target format. Valid formats are:

amd Runtime structures as AMD module
commonjs Runtime structures as CommonJS module
js Runtime structures
json Plain JSON descriptor
proto Plain .proto descriptor

--using, -u Specifies an option to apply to the volatile builder
loading the source, e.g. convertFieldsToCamelCase.
--min, -m Minifies the output. [default: false]
--path, -p Adds a directory to the include path.
--legacy, -l Includes legacy descriptors from google/protobuf/ if
explicitly referenced. [default: false]
--quiet, -q Suppresses any informatory output to stderr. [default: false]
--use, -i Specifies an option to apply to the emitted builder
utilized by your program, e.g. populateAccessors.
--exports, -e Specifies the namespace to export. Defaults to export
the root namespace.
--dependency, -d Library dependency to use when generating classes.
Defaults to 'protobufjs' for CommonJS, 'ProtoBuf' for
AMD modules and 'dcodeIO.ProtoBuf' for classes.
`

Documentation
-------------
* Read the official protobuf guide
* Read the API docs
* Check out the examples

Tests
-----
* View source

Downloads
---------
* Distributions
* ZIP-Archive
* Tarball

CDN usage
---------
`html

``
With the version pointing to the exact release your project depends upon.

License: Apache License, Version 2.0