Merge branch 'master' of https://github.com/maxious/ACTBus-ui
[busui.git] / lib / Protobuf-PHP / README.md
Maxious 1 Protobuf for PHP
2 ================
3
4 Protobuf for PHP is an implementation of Google's Protocol Buffers for the PHP
5 language, supporting its binary data serialization and including a `protoc`
6 plugin to generate PHP classes from .proto files.
7
8 Great effort has been put into generating PHP files that include all sort of type
9 hints to aide IDE's with autocompletion. Therefore, it can not only be used to
10 communicate with Protocol Buffers services but also as a generation tool for
11 _data objects_ no matter what the final serialization is.
12
13 For more information see the [included man pages](http://drslump.github.com/Protobuf-PHP/).
14
15
16 ## Requirements
17
18 - PHP 5.3
19 - Pear's Console_CommandLine (for the protoc wrapper tool)
20 - Google's `protoc` compiler version 2.3 or above
21 - GMP or BC Math extensions ¹
22
23 ¹ Only needed for negative values in `int32`, `int64` or `fixed64` types. See
24 the _known issues_ section.
25
26
27 ## Features
28
29 ### Working
30
31 - Standard types (numbers, string, enums, messages, etc)
32 - Pluggable serialization backends (codecs)
33 - Standard Binary
34 - Standard TextFormat ¹
35 - PhpArray
36 - JSON
37 - [ProtoJson](https://github.com/drslump/ProtoJson) (_TagMap_ and _Indexed_ variants)
38 - XML
39 - Protoc compiler plugin to generate the PHP classes
40 - Extensions
41 - Unknown fields
42 - Packed fields
43 - Reflection
44 - Dynamic messages with annotations support
45 - Generates service interfaces
46 - Includes comments from .proto files in the generated files
47 - Pear package for easy installation
48
49 ¹ Only serialization is supported
50
51 ### Future
52
53 - Speed optimized code generation mode
54 - Support numbers beyond PHP's native limits
55
56
57
58 ## Example usage
59
60 $person = new Tutorial\Person();
61 $person->name = 'DrSlump';
62 $person->setId(12);
63
64 $book = new Tutorial\AddressBook();
65 $book->addPerson($person);
66
67 // Use default codec
68 $data = $book->serialize();
69
70 // Use custom codec
71 $codec = new \DrSlump\Protobuf\Codec\Binary();
72 $data = $codec->encode($book);
73 // ... or ...
74 $data = $book->serialize($codec);
75
76
77 ## Installation
78
79 Install with Pear
80
81 pear channel-discover pear.pollinimini.net
82 pear install drslump/Protobuf-beta
83
84 You can also get the latest version by checking out a copy of the
85 repository in your computer.
86
87
88
89 ## Known issues
90
91
92 ### Types
93
94 PHP is very weak when dealing with numbers processing. Several work arounds have been applied
95 to the standard binary codec to reduce incompatibilities between Protobuf types and PHP ones.
96
97 - Protobuf stores floating point values using the [IEEE 754](http://en.wikipedia.org/wiki/IEEE_754) standard
98 with 64bit words for the `double` and 32bit for the `float` types. PHP supports IEEE 754 natively although
99 the precission is platform dependant, however it typically supports 64bit doubles. It means that
100 if your PHP was compiled with 64bit sized doubles (or greater) you shouldn't have any problem encoding
101 and decoded float and double typed values with Protobuf.
102
103 - Integer values are also [platform dependant in PHP](http://www.php.net/manual/en/language.types.integer.php).
104 The library has been developed and tested against PHP binaries compiled with 64bit integers. The encoding and
105 decoding algorithm should in theory work no matter if PHP uses 32bit or 64bit integers internally, just take
106 into account that with 32bit integers the numbers cannot exceed in any case the `PHP_INT_MAX` value (2147483647).
107
108 While Protobuf supports unsigned integers PHP does not. In fact, numbers above the compiled PHP maximum
109 integer (`PHP_INT_MAX`, 0x7FFFFFFFFFFFFFFF for 64bits) will be automatically casted to doubles, which
110 typically will offer 53bits of decimal precission, allowing to safely work with numbers upto
111 0x20000000000000 (2^53), even if they are represented in PHP as floats instead of integers. Higher numbers
112 will loose precission or might even return an _infinity_ value, note that the library does not include
113 any checking for these numbers and using them might provoke unexpected behaviour.
114
115 Negative values when encoded as `int32`, `int64` or `fixed64` types require the big integer extensions
116 [GMP](http://www.php.net/gmp) or [BC Math](http://www.php.net/bc) (the later only for 64bit architectures)
117 to be available in your PHP environment. The reason is that when encoding these negative numbers without
118 using _zigzag_ the binary representation uses the most significant bit for the sign, thus the numbers become
119 above the maximum supported values in PHP. The library will check for these conditions and will automatically
120 try to use GMP or BC to process the value.
121
122
123 ### Strings
124
125 The binary codec expects strings to be encoded using UTF-8. PHP does not natively support string encodings,
126 PHP's string data type is basically a length delimited stream of bytes, so it's not trivial to include
127 automatic encoding conversion into the library encoding and decoding routines. Instead of trying to guess
128 or offer a configuration interface for the encoding, the binary codec will process the `string` type just as
129 it would process `byte` one, delegating on your application the task of encoding or decoding in the desired
130 character set.
131
132 ### Memory usage
133
134 Large messages might be troublesome since the way the library is modelled does not allow to parse or
135 serialize messages as a streams, instead the whole operation is performed in memory, which allows for faster
136 processing but could consume too much RAM if messages are too large.
137
138
139 ### Unknown fields
140
141 Since wire types are different across different codec's formats, it's not possible to transcode unkwnon
142 fields consumed in one codec to another. This means, for example, that when consuming a message using the
143 binary codec, if it contains unknown fields, they won't be included when serializing the message using the
144 Json codec.
145
146
147 ## Generating PHP classes
148
149 The generation tool is designed to be run as a `protoc` plugin, thus it should
150 work with any proto file supported by the official compiler.
151
152 protoc --plugin=protoc-gen-php --php_out=./build tutorial.proto
153
154 To make use of non-standard options in your proto files (like `php.namespace`) you'll
155 have to import the `php.proto` file included with the library. It's location will
156 depend on where you've installed this library.
157
158 protoc -I=./Protobuf-PHP/library/DrSlump/Protobuf/Compiler/protos \
159 --plugin=protoc-gen-php --php_out=./build tutorial.proto
160
161 In order to make your life easier, the supplied protoc plugin offers an additional
162 execution mode, where it acts as a wrapper for the `protoc` invocation. It will
163 automatically include the `php.proto` path so that you don't need to worry about it.
164
165 protoc-gen-php -o ./build tutorial.proto
166
167
168 ## LICENSE:
169
170 The MIT License
171
172 Copyright (c) 2011 Iván -DrSlump- Montes
173
174 Permission is hereby granted, free of charge, to any person obtaining
175 a copy of this software and associated documentation files (the
176 'Software'), to deal in the Software without restriction, including
177 without limitation the rights to use, copy, modify, merge, publish,
178 distribute, sublicense, and/or sell copies of the Software, and to
179 permit persons to whom the Software is furnished to do so, subject to
180 the following conditions:
181
182 The above copyright notice and this permission notice shall be
183 included in all copies or substantial portions of the Software.
184
185 THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
186 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
187 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
188 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
189 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
190 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
191 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
192
193
194
195
196
197
198