diff options
| -rw-r--r-- | php/tests/test.pb.php | 948 | ||||
| -rw-r--r-- | php/tests/test.proto | 5 | ||||
| -rw-r--r-- | php/tests/test_include.pb.php | 12 | ||||
| -rw-r--r-- | src/google/protobuf/compiler/php/php_generator.cc | 383 |
4 files changed, 1229 insertions, 119 deletions
diff --git a/php/tests/test.pb.php b/php/tests/test.pb.php index ed316b6e..87332ae9 100644 --- a/php/tests/test.pb.php +++ b/php/tests/test.pb.php @@ -10,834 +10,1458 @@ use Google\Protobuf\Internal\GPBType; use Google\Protobuf\Internal\RepeatedField; use Google\Protobuf\Internal\GPBUtil; +/** + * Protobuf type <code>foo.TestMessage</code> + */ class TestMessage extends \Google\Protobuf\Internal\Message { + /** + * <pre> + * Singular + * </pre> + * + * <code>optional int32 optional_int32 = 1;</code> + */ private $optional_int32 = 0; + /** + * <code>optional int64 optional_int64 = 2;</code> + */ private $optional_int64 = 0; + /** + * <code>optional uint32 optional_uint32 = 3;</code> + */ private $optional_uint32 = 0; + /** + * <code>optional uint64 optional_uint64 = 4;</code> + */ private $optional_uint64 = 0; + /** + * <code>optional sint32 optional_sint32 = 5;</code> + */ private $optional_sint32 = 0; + /** + * <code>optional sint64 optional_sint64 = 6;</code> + */ private $optional_sint64 = 0; + /** + * <code>optional fixed32 optional_fixed32 = 7;</code> + */ private $optional_fixed32 = 0; + /** + * <code>optional fixed64 optional_fixed64 = 8;</code> + */ private $optional_fixed64 = 0; + /** + * <code>optional sfixed32 optional_sfixed32 = 9;</code> + */ private $optional_sfixed32 = 0; + /** + * <code>optional sfixed64 optional_sfixed64 = 10;</code> + */ private $optional_sfixed64 = 0; + /** + * <code>optional float optional_float = 11;</code> + */ private $optional_float = 0.0; + /** + * <code>optional double optional_double = 12;</code> + */ private $optional_double = 0.0; + /** + * <code>optional bool optional_bool = 13;</code> + */ private $optional_bool = false; + /** + * <code>optional string optional_string = 14;</code> + */ private $optional_string = ''; + /** + * <code>optional bytes optional_bytes = 15;</code> + */ private $optional_bytes = ''; + /** + * <code>optional .foo.TestEnum optional_enum = 16;</code> + */ private $optional_enum = 0; + /** + * <code>optional .foo.TestMessage.Sub optional_message = 17;</code> + */ private $optional_message = null; + /** + * <code>optional .bar.TestInclude optional_included_message = 18;</code> + */ private $optional_included_message = null; + /** + * <code>optional .foo.TestMessage recursive = 19;</code> + */ private $recursive = null; + /** + * <pre> + * Repeated + * </pre> + * + * <code>repeated int32 repeated_int32 = 31;</code> + */ private $repeated_int32; + /** + * <code>repeated int64 repeated_int64 = 32;</code> + */ private $repeated_int64; + /** + * <code>repeated uint32 repeated_uint32 = 33;</code> + */ private $repeated_uint32; + /** + * <code>repeated uint64 repeated_uint64 = 34;</code> + */ private $repeated_uint64; + /** + * <code>repeated sint32 repeated_sint32 = 35;</code> + */ private $repeated_sint32; + /** + * <code>repeated sint64 repeated_sint64 = 36;</code> + */ private $repeated_sint64; + /** + * <code>repeated fixed32 repeated_fixed32 = 37;</code> + */ private $repeated_fixed32; + /** + * <code>repeated fixed64 repeated_fixed64 = 38;</code> + */ private $repeated_fixed64; + /** + * <code>repeated sfixed32 repeated_sfixed32 = 39;</code> + */ private $repeated_sfixed32; + /** + * <code>repeated sfixed64 repeated_sfixed64 = 40;</code> + */ private $repeated_sfixed64; + /** + * <code>repeated float repeated_float = 41;</code> + */ private $repeated_float; + /** + * <code>repeated double repeated_double = 42;</code> + */ private $repeated_double; + /** + * <code>repeated bool repeated_bool = 43;</code> + */ private $repeated_bool; + /** + * <code>repeated string repeated_string = 44;</code> + */ private $repeated_string; + /** + * <code>repeated bytes repeated_bytes = 45;</code> + */ private $repeated_bytes; + /** + * <code>repeated .foo.TestEnum repeated_enum = 46;</code> + */ private $repeated_enum; + /** + * <code>repeated .foo.TestMessage.Sub repeated_message = 47;</code> + */ private $repeated_message; + /** + * <code>repeated .foo.TestMessage repeated_recursive = 48;</code> + */ private $repeated_recursive; + /** + * <code>map<int32, int32> map_int32_int32 = 71;</code> + */ private $map_int32_int32; + /** + * <code>map<int64, int64> map_int64_int64 = 72;</code> + */ private $map_int64_int64; + /** + * <code>map<uint32, uint32> map_uint32_uint32 = 73;</code> + */ private $map_uint32_uint32; + /** + * <code>map<uint64, uint64> map_uint64_uint64 = 74;</code> + */ private $map_uint64_uint64; + /** + * <code>map<sint32, sint32> map_sint32_sint32 = 75;</code> + */ private $map_sint32_sint32; + /** + * <code>map<sint64, sint64> map_sint64_sint64 = 76;</code> + */ private $map_sint64_sint64; + /** + * <code>map<fixed32, fixed32> map_fixed32_fixed32 = 77;</code> + */ private $map_fixed32_fixed32; + /** + * <code>map<fixed64, fixed64> map_fixed64_fixed64 = 78;</code> + */ private $map_fixed64_fixed64; + /** + * <code>map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 79;</code> + */ private $map_sfixed32_sfixed32; + /** + * <code>map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 80;</code> + */ private $map_sfixed64_sfixed64; + /** + * <code>map<int32, float> map_int32_float = 81;</code> + */ private $map_int32_float; + /** + * <code>map<int32, double> map_int32_double = 82;</code> + */ private $map_int32_double; + /** + * <code>map<bool, bool> map_bool_bool = 83;</code> + */ private $map_bool_bool; + /** + * <code>map<string, string> map_string_string = 84;</code> + */ private $map_string_string; + /** + * <code>map<int32, bytes> map_int32_bytes = 85;</code> + */ private $map_int32_bytes; + /** + * <code>map<int32, .foo.TestEnum> map_int32_enum = 86;</code> + */ private $map_int32_enum; + /** + * <code>map<int32, .foo.TestMessage.Sub> map_int32_message = 87;</code> + */ private $map_int32_message; + /** + * <code>map<int32, .foo.TestMessage> map_recursive = 88;</code> + */ private $map_recursive; protected $my_oneof; + /** + * <pre> + * Singular + * </pre> + * + * <code>optional int32 optional_int32 = 1;</code> + */ public function getOptionalInt32() { return $this->optional_int32; } + /** + * <pre> + * Singular + * </pre> + * + * <code>optional int32 optional_int32 = 1;</code> + */ public function setOptionalInt32($var) { GPBUtil::checkInt32($var); $this->optional_int32 = $var; } + /** + * <code>optional int64 optional_int64 = 2;</code> + */ public function getOptionalInt64() { return $this->optional_int64; } + /** + * <code>optional int64 optional_int64 = 2;</code> + */ public function setOptionalInt64($var) { GPBUtil::checkInt64($var); $this->optional_int64 = $var; } + /** + * <code>optional uint32 optional_uint32 = 3;</code> + */ public function getOptionalUint32() { return $this->optional_uint32; } + /** + * <code>optional uint32 optional_uint32 = 3;</code> + */ public function setOptionalUint32($var) { GPBUtil::checkUint32($var); $this->optional_uint32 = $var; } + /** + * <code>optional uint64 optional_uint64 = 4;</code> + */ public function getOptionalUint64() { return $this->optional_uint64; } + /** + * <code>optional uint64 optional_uint64 = 4;</code> + */ public function setOptionalUint64($var) { GPBUtil::checkUint64($var); $this->optional_uint64 = $var; } + /** + * <code>optional sint32 optional_sint32 = 5;</code> + */ public function getOptionalSint32() { return $this->optional_sint32; } + /** + * <code>optional sint32 optional_sint32 = 5;</code> + */ public function setOptionalSint32($var) { GPBUtil::checkInt32($var); $this->optional_sint32 = $var; } + /** + * <code>optional sint64 optional_sint64 = 6;</code> + */ public function getOptionalSint64() { return $this->optional_sint64; } + /** + * <code>optional sint64 optional_sint64 = 6;</code> + */ public function setOptionalSint64($var) { GPBUtil::checkInt64($var); $this->optional_sint64 = $var; } + /** + * <code>optional fixed32 optional_fixed32 = 7;</code> + */ public function getOptionalFixed32() { return $this->optional_fixed32; } + /** + * <code>optional fixed32 optional_fixed32 = 7;</code> + */ public function setOptionalFixed32($var) { GPBUtil::checkUint32($var); $this->optional_fixed32 = $var; } + /** + * <code>optional fixed64 optional_fixed64 = 8;</code> + */ public function getOptionalFixed64() { return $this->optional_fixed64; } + /** + * <code>optional fixed64 optional_fixed64 = 8;</code> + */ public function setOptionalFixed64($var) { GPBUtil::checkUint64($var); $this->optional_fixed64 = $var; } + /** + * <code>optional sfixed32 optional_sfixed32 = 9;</code> + */ public function getOptionalSfixed32() { return $this->optional_sfixed32; } + /** + * <code>optional sfixed32 optional_sfixed32 = 9;</code> + */ public function setOptionalSfixed32($var) { GPBUtil::checkInt32($var); $this->optional_sfixed32 = $var; } + /** + * <code>optional sfixed64 optional_sfixed64 = 10;</code> + */ public function getOptionalSfixed64() { return $this->optional_sfixed64; } + /** + * <code>optional sfixed64 optional_sfixed64 = 10;</code> + */ public function setOptionalSfixed64($var) { GPBUtil::checkInt64($var); $this->optional_sfixed64 = $var; } + /** + * <code>optional float optional_float = 11;</code> + */ public function getOptionalFloat() { return $this->optional_float; } + /** + * <code>optional float optional_float = 11;</code> + */ public function setOptionalFloat($var) { GPBUtil::checkFloat($var); $this->optional_float = $var; } + /** + * <code>optional double optional_double = 12;</code> + */ public function getOptionalDouble() { return $this->optional_double; } + /** + * <code>optional double optional_double = 12;</code> + */ public function setOptionalDouble($var) { GPBUtil::checkDouble($var); $this->optional_double = $var; } + /** + * <code>optional bool optional_bool = 13;</code> + */ public function getOptionalBool() { return $this->optional_bool; } + /** + * <code>optional bool optional_bool = 13;</code> + */ public function setOptionalBool($var) { GPBUtil::checkBool($var); $this->optional_bool = $var; } + /** + * <code>optional string optional_string = 14;</code> + */ public function getOptionalString() { return $this->optional_string; } + /** + * <code>optional string optional_string = 14;</code> + */ public function setOptionalString($var) { GPBUtil::checkString($var, True); $this->optional_string = $var; } + /** + * <code>optional bytes optional_bytes = 15;</code> + */ public function getOptionalBytes() { return $this->optional_bytes; } + /** + * <code>optional bytes optional_bytes = 15;</code> + */ public function setOptionalBytes($var) { GPBUtil::checkString($var, False); $this->optional_bytes = $var; } + /** + * <code>optional .foo.TestEnum optional_enum = 16;</code> + */ public function getOptionalEnum() { return $this->optional_enum; } + /** + * <code>optional .foo.TestEnum optional_enum = 16;</code> + */ public function setOptionalEnum($var) { GPBUtil::checkEnum($var, \Foo\TestEnum::class); $this->optional_enum = $var; } + /** + * <code>optional .foo.TestMessage.Sub optional_message = 17;</code> + */ public function getOptionalMessage() { return $this->optional_message; } + /** + * <code>optional .foo.TestMessage.Sub optional_message = 17;</code> + */ public function setOptionalMessage(&$var) { GPBUtil::checkMessage($var, \Foo\TestMessage_Sub::class); $this->optional_message = $var; } + /** + * <code>optional .bar.TestInclude optional_included_message = 18;</code> + */ public function getOptionalIncludedMessage() { return $this->optional_included_message; } + /** + * <code>optional .bar.TestInclude optional_included_message = 18;</code> + */ public function setOptionalIncludedMessage(&$var) { GPBUtil::checkMessage($var, \Bar\TestInclude::class); $this->optional_included_message = $var; } + /** + * <code>optional .foo.TestMessage recursive = 19;</code> + */ public function getRecursive() { return $this->recursive; } + /** + * <code>optional .foo.TestMessage recursive = 19;</code> + */ public function setRecursive(&$var) { GPBUtil::checkMessage($var, \Foo\TestMessage::class); $this->recursive = $var; } + /** + * <pre> + * Repeated + * </pre> + * + * <code>repeated int32 repeated_int32 = 31;</code> + */ public function getRepeatedInt32() { return $this->repeated_int32; } + /** + * <pre> + * Repeated + * </pre> + * + * <code>repeated int32 repeated_int32 = 31;</code> + */ public function setRepeatedInt32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT32); $this->repeated_int32 = $var; } + /** + * <code>repeated int64 repeated_int64 = 32;</code> + */ public function getRepeatedInt64() { return $this->repeated_int64; } + /** + * <code>repeated int64 repeated_int64 = 32;</code> + */ public function setRepeatedInt64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT64); $this->repeated_int64 = $var; } + /** + * <code>repeated uint32 repeated_uint32 = 33;</code> + */ public function getRepeatedUint32() { return $this->repeated_uint32; } + /** + * <code>repeated uint32 repeated_uint32 = 33;</code> + */ public function setRepeatedUint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT32); $this->repeated_uint32 = $var; } + /** + * <code>repeated uint64 repeated_uint64 = 34;</code> + */ public function getRepeatedUint64() { return $this->repeated_uint64; } + /** + * <code>repeated uint64 repeated_uint64 = 34;</code> + */ public function setRepeatedUint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT64); $this->repeated_uint64 = $var; } + /** + * <code>repeated sint32 repeated_sint32 = 35;</code> + */ public function getRepeatedSint32() { return $this->repeated_sint32; } + /** + * <code>repeated sint32 repeated_sint32 = 35;</code> + */ public function setRepeatedSint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT32); $this->repeated_sint32 = $var; } + /** + * <code>repeated sint64 repeated_sint64 = 36;</code> + */ public function getRepeatedSint64() { return $this->repeated_sint64; } + /** + * <code>repeated sint64 repeated_sint64 = 36;</code> + */ public function setRepeatedSint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT64); $this->repeated_sint64 = $var; } + /** + * <code>repeated fixed32 repeated_fixed32 = 37;</code> + */ public function getRepeatedFixed32() { return $this->repeated_fixed32; } + /** + * <code>repeated fixed32 repeated_fixed32 = 37;</code> + */ public function setRepeatedFixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED32); $this->repeated_fixed32 = $var; } + /** + * <code>repeated fixed64 repeated_fixed64 = 38;</code> + */ public function getRepeatedFixed64() { return $this->repeated_fixed64; } + /** + * <code>repeated fixed64 repeated_fixed64 = 38;</code> + */ public function setRepeatedFixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED64); $this->repeated_fixed64 = $var; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 39;</code> + */ public function getRepeatedSfixed32() { return $this->repeated_sfixed32; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 39;</code> + */ public function setRepeatedSfixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED32); $this->repeated_sfixed32 = $var; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 40;</code> + */ public function getRepeatedSfixed64() { return $this->repeated_sfixed64; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 40;</code> + */ public function setRepeatedSfixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED64); $this->repeated_sfixed64 = $var; } + /** + * <code>repeated float repeated_float = 41;</code> + */ public function getRepeatedFloat() { return $this->repeated_float; } + /** + * <code>repeated float repeated_float = 41;</code> + */ public function setRepeatedFloat(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FLOAT); $this->repeated_float = $var; } + /** + * <code>repeated double repeated_double = 42;</code> + */ public function getRepeatedDouble() { return $this->repeated_double; } + /** + * <code>repeated double repeated_double = 42;</code> + */ public function setRepeatedDouble(&$var) { GPBUtil::checkRepeatedField($var, GPBType::DOUBLE); $this->repeated_double = $var; } + /** + * <code>repeated bool repeated_bool = 43;</code> + */ public function getRepeatedBool() { return $this->repeated_bool; } + /** + * <code>repeated bool repeated_bool = 43;</code> + */ public function setRepeatedBool(&$var) { GPBUtil::checkRepeatedField($var, GPBType::BOOL); $this->repeated_bool = $var; } + /** + * <code>repeated string repeated_string = 44;</code> + */ public function getRepeatedString() { return $this->repeated_string; } + /** + * <code>repeated string repeated_string = 44;</code> + */ public function setRepeatedString(&$var) { GPBUtil::checkRepeatedField($var, GPBType::STRING); $this->repeated_string = $var; } + /** + * <code>repeated bytes repeated_bytes = 45;</code> + */ public function getRepeatedBytes() { return $this->repeated_bytes; } + /** + * <code>repeated bytes repeated_bytes = 45;</code> + */ public function setRepeatedBytes(&$var) { GPBUtil::checkRepeatedField($var, GPBType::BYTES); $this->repeated_bytes = $var; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 46;</code> + */ public function getRepeatedEnum() { return $this->repeated_enum; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 46;</code> + */ public function setRepeatedEnum(&$var) { GPBUtil::checkRepeatedField($var, GPBType::ENUM, Foo\TestEnum::class); $this->repeated_enum = $var; } + /** + * <code>repeated .foo.TestMessage.Sub repeated_message = 47;</code> + */ public function getRepeatedMessage() { return $this->repeated_message; } + /** + * <code>repeated .foo.TestMessage.Sub repeated_message = 47;</code> + */ public function setRepeatedMessage(&$var) { GPBUtil::checkRepeatedField($var, GPBType::MESSAGE, \Foo\TestMessage_Sub::class); $this->repeated_message = $var; } + /** + * <code>repeated .foo.TestMessage repeated_recursive = 48;</code> + */ public function getRepeatedRecursive() { return $this->repeated_recursive; } + /** + * <code>repeated .foo.TestMessage repeated_recursive = 48;</code> + */ public function setRepeatedRecursive(&$var) { GPBUtil::checkRepeatedField($var, GPBType::MESSAGE, \Foo\TestMessage::class); $this->repeated_recursive = $var; } + /** + * <code>optional int32 oneof_int32 = 51;</code> + */ public function getOneofInt32() { return $this->readOneof(51); } + /** + * <code>optional int32 oneof_int32 = 51;</code> + */ public function setOneofInt32($var) { GPBUtil::checkInt32($var); $this->writeOneof(51, $var); } + /** + * <code>optional int64 oneof_int64 = 52;</code> + */ public function getOneofInt64() { return $this->readOneof(52); } + /** + * <code>optional int64 oneof_int64 = 52;</code> + */ public function setOneofInt64($var) { GPBUtil::checkInt64($var); $this->writeOneof(52, $var); } + /** + * <code>optional uint32 oneof_uint32 = 53;</code> + */ public function getOneofUint32() { return $this->readOneof(53); } + /** + * <code>optional uint32 oneof_uint32 = 53;</code> + */ public function setOneofUint32($var) { GPBUtil::checkUint32($var); $this->writeOneof(53, $var); } + /** + * <code>optional uint64 oneof_uint64 = 54;</code> + */ public function getOneofUint64() { return $this->readOneof(54); } + /** + * <code>optional uint64 oneof_uint64 = 54;</code> + */ public function setOneofUint64($var) { GPBUtil::checkUint64($var); $this->writeOneof(54, $var); } + /** + * <code>optional uint32 oneof_sint32 = 55;</code> + */ public function getOneofSint32() { return $this->readOneof(55); } + /** + * <code>optional uint32 oneof_sint32 = 55;</code> + */ public function setOneofSint32($var) { GPBUtil::checkUint32($var); $this->writeOneof(55, $var); } + /** + * <code>optional uint64 oneof_sint64 = 56;</code> + */ public function getOneofSint64() { return $this->readOneof(56); } + /** + * <code>optional uint64 oneof_sint64 = 56;</code> + */ public function setOneofSint64($var) { GPBUtil::checkUint64($var); $this->writeOneof(56, $var); } + /** + * <code>optional uint32 oneof_fixed32 = 57;</code> + */ public function getOneofFixed32() { return $this->readOneof(57); } + /** + * <code>optional uint32 oneof_fixed32 = 57;</code> + */ public function setOneofFixed32($var) { GPBUtil::checkUint32($var); $this->writeOneof(57, $var); } + /** + * <code>optional uint64 oneof_fixed64 = 58;</code> + */ public function getOneofFixed64() { return $this->readOneof(58); } + /** + * <code>optional uint64 oneof_fixed64 = 58;</code> + */ public function setOneofFixed64($var) { GPBUtil::checkUint64($var); $this->writeOneof(58, $var); } + /** + * <code>optional uint32 oneof_sfixed32 = 59;</code> + */ public function getOneofSfixed32() { return $this->readOneof(59); } + /** + * <code>optional uint32 oneof_sfixed32 = 59;</code> + */ public function setOneofSfixed32($var) { GPBUtil::checkUint32($var); $this->writeOneof(59, $var); } + /** + * <code>optional uint64 oneof_sfixed64 = 60;</code> + */ public function getOneofSfixed64() { return $this->readOneof(60); } + /** + * <code>optional uint64 oneof_sfixed64 = 60;</code> + */ public function setOneofSfixed64($var) { GPBUtil::checkUint64($var); $this->writeOneof(60, $var); } + /** + * <code>optional double oneof_double = 61;</code> + */ public function getOneofDouble() { return $this->readOneof(61); } + /** + * <code>optional double oneof_double = 61;</code> + */ public function setOneofDouble($var) { GPBUtil::checkDouble($var); $this->writeOneof(61, $var); } + /** + * <code>optional float oneof_float = 62;</code> + */ public function getOneofFloat() { return $this->readOneof(62); } + /** + * <code>optional float oneof_float = 62;</code> + */ public function setOneofFloat($var) { GPBUtil::checkFloat($var); $this->writeOneof(62, $var); } + /** + * <code>optional bool oneof_bool = 63;</code> + */ public function getOneofBool() { return $this->readOneof(63); } + /** + * <code>optional bool oneof_bool = 63;</code> + */ public function setOneofBool($var) { GPBUtil::checkBool($var); $this->writeOneof(63, $var); } + /** + * <code>optional string oneof_string = 64;</code> + */ public function getOneofString() { return $this->readOneof(64); } + /** + * <code>optional string oneof_string = 64;</code> + */ public function setOneofString($var) { GPBUtil::checkString($var, True); $this->writeOneof(64, $var); } + /** + * <code>optional bytes oneof_bytes = 65;</code> + */ public function getOneofBytes() { return $this->readOneof(65); } + /** + * <code>optional bytes oneof_bytes = 65;</code> + */ public function setOneofBytes($var) { GPBUtil::checkString($var, False); $this->writeOneof(65, $var); } + /** + * <code>optional .foo.TestEnum oneof_enum = 66;</code> + */ public function getOneofEnum() { return $this->readOneof(66); } + /** + * <code>optional .foo.TestEnum oneof_enum = 66;</code> + */ public function setOneofEnum($var) { GPBUtil::checkEnum($var, \Foo\TestEnum::class); $this->writeOneof(66, $var); } + /** + * <code>optional .foo.TestMessage.Sub oneof_message = 67;</code> + */ public function getOneofMessage() { return $this->readOneof(67); } + /** + * <code>optional .foo.TestMessage.Sub oneof_message = 67;</code> + */ public function setOneofMessage(&$var) { GPBUtil::checkMessage($var, \Foo\TestMessage_Sub::class); $this->writeOneof(67, $var); } + /** + * <code>map<int32, int32> map_int32_int32 = 71;</code> + */ public function getMapInt32Int32() { return $this->map_int32_int32; } + /** + * <code>map<int32, int32> map_int32_int32 = 71;</code> + */ public function setMapInt32Int32(&$var) { $this->map_int32_int32 = $var; } + /** + * <code>map<int64, int64> map_int64_int64 = 72;</code> + */ public function getMapInt64Int64() { return $this->map_int64_int64; } + /** + * <code>map<int64, int64> map_int64_int64 = 72;</code> + */ public function setMapInt64Int64(&$var) { $this->map_int64_int64 = $var; } + /** + * <code>map<uint32, uint32> map_uint32_uint32 = 73;</code> + */ public function getMapUint32Uint32() { return $this->map_uint32_uint32; } + /** + * <code>map<uint32, uint32> map_uint32_uint32 = 73;</code> + */ public function setMapUint32Uint32(&$var) { $this->map_uint32_uint32 = $var; } + /** + * <code>map<uint64, uint64> map_uint64_uint64 = 74;</code> + */ public function getMapUint64Uint64() { return $this->map_uint64_uint64; } + /** + * <code>map<uint64, uint64> map_uint64_uint64 = 74;</code> + */ public function setMapUint64Uint64(&$var) { $this->map_uint64_uint64 = $var; } + /** + * <code>map<sint32, sint32> map_sint32_sint32 = 75;</code> + */ public function getMapSint32Sint32() { return $this->map_sint32_sint32; } + /** + * <code>map<sint32, sint32> map_sint32_sint32 = 75;</code> + */ public function setMapSint32Sint32(&$var) { $this->map_sint32_sint32 = $var; } + /** + * <code>map<sint64, sint64> map_sint64_sint64 = 76;</code> + */ public function getMapSint64Sint64() { return $this->map_sint64_sint64; } + /** + * <code>map<sint64, sint64> map_sint64_sint64 = 76;</code> + */ public function setMapSint64Sint64(&$var) { $this->map_sint64_sint64 = $var; } + /** + * <code>map<fixed32, fixed32> map_fixed32_fixed32 = 77;</code> + */ public function getMapFixed32Fixed32() { return $this->map_fixed32_fixed32; } + /** + * <code>map<fixed32, fixed32> map_fixed32_fixed32 = 77;</code> + */ public function setMapFixed32Fixed32(&$var) { $this->map_fixed32_fixed32 = $var; } + /** + * <code>map<fixed64, fixed64> map_fixed64_fixed64 = 78;</code> + */ public function getMapFixed64Fixed64() { return $this->map_fixed64_fixed64; } + /** + * <code>map<fixed64, fixed64> map_fixed64_fixed64 = 78;</code> + */ public function setMapFixed64Fixed64(&$var) { $this->map_fixed64_fixed64 = $var; } + /** + * <code>map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 79;</code> + */ public function getMapSfixed32Sfixed32() { return $this->map_sfixed32_sfixed32; } + /** + * <code>map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 79;</code> + */ public function setMapSfixed32Sfixed32(&$var) { $this->map_sfixed32_sfixed32 = $var; } + /** + * <code>map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 80;</code> + */ public function getMapSfixed64Sfixed64() { return $this->map_sfixed64_sfixed64; } + /** + * <code>map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 80;</code> + */ public function setMapSfixed64Sfixed64(&$var) { $this->map_sfixed64_sfixed64 = $var; } + /** + * <code>map<int32, float> map_int32_float = 81;</code> + */ public function getMapInt32Float() { return $this->map_int32_float; } + /** + * <code>map<int32, float> map_int32_float = 81;</code> + */ public function setMapInt32Float(&$var) { $this->map_int32_float = $var; } + /** + * <code>map<int32, double> map_int32_double = 82;</code> + */ public function getMapInt32Double() { return $this->map_int32_double; } + /** + * <code>map<int32, double> map_int32_double = 82;</code> + */ public function setMapInt32Double(&$var) { $this->map_int32_double = $var; } + /** + * <code>map<bool, bool> map_bool_bool = 83;</code> + */ public function getMapBoolBool() { return $this->map_bool_bool; } + /** + * <code>map<bool, bool> map_bool_bool = 83;</code> + */ public function setMapBoolBool(&$var) { $this->map_bool_bool = $var; } + /** + * <code>map<string, string> map_string_string = 84;</code> + */ public function getMapStringString() { return $this->map_string_string; } + /** + * <code>map<string, string> map_string_string = 84;</code> + */ public function setMapStringString(&$var) { $this->map_string_string = $var; } + /** + * <code>map<int32, bytes> map_int32_bytes = 85;</code> + */ public function getMapInt32Bytes() { return $this->map_int32_bytes; } + /** + * <code>map<int32, bytes> map_int32_bytes = 85;</code> + */ public function setMapInt32Bytes(&$var) { $this->map_int32_bytes = $var; } + /** + * <code>map<int32, .foo.TestEnum> map_int32_enum = 86;</code> + */ public function getMapInt32Enum() { return $this->map_int32_enum; } + /** + * <code>map<int32, .foo.TestEnum> map_int32_enum = 86;</code> + */ public function setMapInt32Enum(&$var) { $this->map_int32_enum = $var; } + /** + * <code>map<int32, .foo.TestMessage.Sub> map_int32_message = 87;</code> + */ public function getMapInt32Message() { return $this->map_int32_message; } + /** + * <code>map<int32, .foo.TestMessage.Sub> map_int32_message = 87;</code> + */ public function setMapInt32Message(&$var) { $this->map_int32_message = $var; } + /** + * <code>map<int32, .foo.TestMessage> map_recursive = 88;</code> + */ public function getMapRecursive() { return $this->map_recursive; } + /** + * <code>map<int32, .foo.TestMessage> map_recursive = 88;</code> + */ public function setMapRecursive(&$var) { $this->map_recursive = $var; @@ -850,15 +1474,27 @@ class TestMessage extends \Google\Protobuf\Internal\Message } +/** + * Protobuf type <code>foo.TestMessage.Sub</code> + */ class TestMessage_Sub extends \Google\Protobuf\Internal\Message { + /** + * <code>optional int32 a = 1;</code> + */ private $a = 0; + /** + * <code>optional int32 a = 1;</code> + */ public function getA() { return $this->a; } + /** + * <code>optional int32 a = 1;</code> + */ public function setA($var) { GPBUtil::checkInt32($var); @@ -867,171 +1503,300 @@ class TestMessage_Sub extends \Google\Protobuf\Internal\Message } +/** + * Protobuf type <code>foo.TestPackedMessage</code> + */ class TestPackedMessage extends \Google\Protobuf\Internal\Message { + /** + * <code>repeated int32 repeated_int32 = 90 [packed = true];</code> + */ private $repeated_int32; + /** + * <code>repeated int64 repeated_int64 = 91 [packed = true];</code> + */ private $repeated_int64; + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = true];</code> + */ private $repeated_uint32; + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = true];</code> + */ private $repeated_uint64; + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = true];</code> + */ private $repeated_sint32; + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = true];</code> + */ private $repeated_sint64; + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = true];</code> + */ private $repeated_fixed32; + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = true];</code> + */ private $repeated_fixed64; + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = true];</code> + */ private $repeated_sfixed32; + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = true];</code> + */ private $repeated_sfixed64; + /** + * <code>repeated float repeated_float = 100 [packed = true];</code> + */ private $repeated_float; + /** + * <code>repeated double repeated_double = 101 [packed = true];</code> + */ private $repeated_double; + /** + * <code>repeated bool repeated_bool = 102 [packed = true];</code> + */ private $repeated_bool; + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = true];</code> + */ private $repeated_enum; + /** + * <code>repeated int32 repeated_int32 = 90 [packed = true];</code> + */ public function getRepeatedInt32() { return $this->repeated_int32; } + /** + * <code>repeated int32 repeated_int32 = 90 [packed = true];</code> + */ public function setRepeatedInt32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT32); $this->repeated_int32 = $var; } + /** + * <code>repeated int64 repeated_int64 = 91 [packed = true];</code> + */ public function getRepeatedInt64() { return $this->repeated_int64; } + /** + * <code>repeated int64 repeated_int64 = 91 [packed = true];</code> + */ public function setRepeatedInt64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT64); $this->repeated_int64 = $var; } + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = true];</code> + */ public function getRepeatedUint32() { return $this->repeated_uint32; } + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = true];</code> + */ public function setRepeatedUint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT32); $this->repeated_uint32 = $var; } + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = true];</code> + */ public function getRepeatedUint64() { return $this->repeated_uint64; } + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = true];</code> + */ public function setRepeatedUint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT64); $this->repeated_uint64 = $var; } + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = true];</code> + */ public function getRepeatedSint32() { return $this->repeated_sint32; } + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = true];</code> + */ public function setRepeatedSint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT32); $this->repeated_sint32 = $var; } + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = true];</code> + */ public function getRepeatedSint64() { return $this->repeated_sint64; } + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = true];</code> + */ public function setRepeatedSint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT64); $this->repeated_sint64 = $var; } + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = true];</code> + */ public function getRepeatedFixed32() { return $this->repeated_fixed32; } + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = true];</code> + */ public function setRepeatedFixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED32); $this->repeated_fixed32 = $var; } + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = true];</code> + */ public function getRepeatedFixed64() { return $this->repeated_fixed64; } + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = true];</code> + */ public function setRepeatedFixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED64); $this->repeated_fixed64 = $var; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = true];</code> + */ public function getRepeatedSfixed32() { return $this->repeated_sfixed32; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = true];</code> + */ public function setRepeatedSfixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED32); $this->repeated_sfixed32 = $var; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = true];</code> + */ public function getRepeatedSfixed64() { return $this->repeated_sfixed64; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = true];</code> + */ public function setRepeatedSfixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED64); $this->repeated_sfixed64 = $var; } + /** + * <code>repeated float repeated_float = 100 [packed = true];</code> + */ public function getRepeatedFloat() { return $this->repeated_float; } + /** + * <code>repeated float repeated_float = 100 [packed = true];</code> + */ public function setRepeatedFloat(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FLOAT); $this->repeated_float = $var; } + /** + * <code>repeated double repeated_double = 101 [packed = true];</code> + */ public function getRepeatedDouble() { return $this->repeated_double; } + /** + * <code>repeated double repeated_double = 101 [packed = true];</code> + */ public function setRepeatedDouble(&$var) { GPBUtil::checkRepeatedField($var, GPBType::DOUBLE); $this->repeated_double = $var; } + /** + * <code>repeated bool repeated_bool = 102 [packed = true];</code> + */ public function getRepeatedBool() { return $this->repeated_bool; } + /** + * <code>repeated bool repeated_bool = 102 [packed = true];</code> + */ public function setRepeatedBool(&$var) { GPBUtil::checkRepeatedField($var, GPBType::BOOL); $this->repeated_bool = $var; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = true];</code> + */ public function getRepeatedEnum() { return $this->repeated_enum; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = true];</code> + */ public function setRepeatedEnum(&$var) { GPBUtil::checkRepeatedField($var, GPBType::ENUM, Foo\TestEnum::class); @@ -1040,171 +1805,304 @@ class TestPackedMessage extends \Google\Protobuf\Internal\Message } +/** + * <pre> + * Need to be in sync with TestPackedMessage. + * </pre> + * + * Protobuf type <code>foo.TestUnpackedMessage</code> + */ class TestUnpackedMessage extends \Google\Protobuf\Internal\Message { + /** + * <code>repeated int32 repeated_int32 = 90 [packed = false];</code> + */ private $repeated_int32; + /** + * <code>repeated int64 repeated_int64 = 91 [packed = false];</code> + */ private $repeated_int64; + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = false];</code> + */ private $repeated_uint32; + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = false];</code> + */ private $repeated_uint64; + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = false];</code> + */ private $repeated_sint32; + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = false];</code> + */ private $repeated_sint64; + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = false];</code> + */ private $repeated_fixed32; + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = false];</code> + */ private $repeated_fixed64; + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = false];</code> + */ private $repeated_sfixed32; + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = false];</code> + */ private $repeated_sfixed64; + /** + * <code>repeated float repeated_float = 100 [packed = false];</code> + */ private $repeated_float; + /** + * <code>repeated double repeated_double = 101 [packed = false];</code> + */ private $repeated_double; + /** + * <code>repeated bool repeated_bool = 102 [packed = false];</code> + */ private $repeated_bool; + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = false];</code> + */ private $repeated_enum; + /** + * <code>repeated int32 repeated_int32 = 90 [packed = false];</code> + */ public function getRepeatedInt32() { return $this->repeated_int32; } + /** + * <code>repeated int32 repeated_int32 = 90 [packed = false];</code> + */ public function setRepeatedInt32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT32); $this->repeated_int32 = $var; } + /** + * <code>repeated int64 repeated_int64 = 91 [packed = false];</code> + */ public function getRepeatedInt64() { return $this->repeated_int64; } + /** + * <code>repeated int64 repeated_int64 = 91 [packed = false];</code> + */ public function setRepeatedInt64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::INT64); $this->repeated_int64 = $var; } + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = false];</code> + */ public function getRepeatedUint32() { return $this->repeated_uint32; } + /** + * <code>repeated uint32 repeated_uint32 = 92 [packed = false];</code> + */ public function setRepeatedUint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT32); $this->repeated_uint32 = $var; } + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = false];</code> + */ public function getRepeatedUint64() { return $this->repeated_uint64; } + /** + * <code>repeated uint64 repeated_uint64 = 93 [packed = false];</code> + */ public function setRepeatedUint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::UINT64); $this->repeated_uint64 = $var; } + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = false];</code> + */ public function getRepeatedSint32() { return $this->repeated_sint32; } + /** + * <code>repeated sint32 repeated_sint32 = 94 [packed = false];</code> + */ public function setRepeatedSint32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT32); $this->repeated_sint32 = $var; } + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = false];</code> + */ public function getRepeatedSint64() { return $this->repeated_sint64; } + /** + * <code>repeated sint64 repeated_sint64 = 95 [packed = false];</code> + */ public function setRepeatedSint64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SINT64); $this->repeated_sint64 = $var; } + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = false];</code> + */ public function getRepeatedFixed32() { return $this->repeated_fixed32; } + /** + * <code>repeated fixed32 repeated_fixed32 = 96 [packed = false];</code> + */ public function setRepeatedFixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED32); $this->repeated_fixed32 = $var; } + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = false];</code> + */ public function getRepeatedFixed64() { return $this->repeated_fixed64; } + /** + * <code>repeated fixed64 repeated_fixed64 = 97 [packed = false];</code> + */ public function setRepeatedFixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FIXED64); $this->repeated_fixed64 = $var; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = false];</code> + */ public function getRepeatedSfixed32() { return $this->repeated_sfixed32; } + /** + * <code>repeated sfixed32 repeated_sfixed32 = 98 [packed = false];</code> + */ public function setRepeatedSfixed32(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED32); $this->repeated_sfixed32 = $var; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = false];</code> + */ public function getRepeatedSfixed64() { return $this->repeated_sfixed64; } + /** + * <code>repeated sfixed64 repeated_sfixed64 = 99 [packed = false];</code> + */ public function setRepeatedSfixed64(&$var) { GPBUtil::checkRepeatedField($var, GPBType::SFIXED64); $this->repeated_sfixed64 = $var; } + /** + * <code>repeated float repeated_float = 100 [packed = false];</code> + */ public function getRepeatedFloat() { return $this->repeated_float; } + /** + * <code>repeated float repeated_float = 100 [packed = false];</code> + */ public function setRepeatedFloat(&$var) { GPBUtil::checkRepeatedField($var, GPBType::FLOAT); $this->repeated_float = $var; } + /** + * <code>repeated double repeated_double = 101 [packed = false];</code> + */ public function getRepeatedDouble() { return $this->repeated_double; } + /** + * <code>repeated double repeated_double = 101 [packed = false];</code> + */ public function setRepeatedDouble(&$var) { GPBUtil::checkRepeatedField($var, GPBType::DOUBLE); $this->repeated_double = $var; } + /** + * <code>repeated bool repeated_bool = 102 [packed = false];</code> + */ public function getRepeatedBool() { return $this->repeated_bool; } + /** + * <code>repeated bool repeated_bool = 102 [packed = false];</code> + */ public function setRepeatedBool(&$var) { GPBUtil::checkRepeatedField($var, GPBType::BOOL); $this->repeated_bool = $var; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = false];</code> + */ public function getRepeatedEnum() { return $this->repeated_enum; } + /** + * <code>repeated .foo.TestEnum repeated_enum = 103 [packed = false];</code> + */ public function setRepeatedEnum(&$var) { GPBUtil::checkRepeatedField($var, GPBType::ENUM, Foo\TestEnum::class); @@ -1213,16 +2111,58 @@ class TestUnpackedMessage extends \Google\Protobuf\Internal\Message } +/** + * <pre> + * /**/@<>&\{ + * </pre> + * + * Protobuf type <code>foo.TestPhpDoc</code> + */ +class TestPhpDoc extends \Google\Protobuf\Internal\Message +{ + /** + * <code>optional int32 a = 1;</code> + */ + private $a = 0; + + /** + * <code>optional int32 a = 1;</code> + */ + public function getA() + { + return $this->a; + } + + /** + * <code>optional int32 a = 1;</code> + */ + public function setA($var) + { + GPBUtil::checkInt32($var); + $this->a = $var; + } + +} + +/** + * Protobuf enum <code>foo.TestEnum</code> + */ class TestEnum { + /** + * <code>ZERO = 0;</code> + */ const ZERO = 0; + /** + * <code>ONE = 1;</code> + */ const ONE = 1; } $pool = DescriptorPool::getGeneratedPool(); $pool->internalAddGeneratedFile(hex2bin( - "0a83250a0a746573742e70726f746f1203666f6f1a12746573745f696e63" . + "0a9c250a0a746573742e70726f746f1203666f6f1a12746573745f696e63" . "6c7564652e70726f746f22be1d0a0b546573744d65737361676512160a0e" . "6f7074696f6e616c5f696e74333218012001280512160a0e6f7074696f6e" . "616c5f696e74363418022001280312170a0f6f7074696f6e616c5f75696e" . @@ -1378,8 +2318,8 @@ $pool->internalAddGeneratedFile(hex2bin( "666c6f617418642003280242021000121b0a0f72657065617465645f646f" . "75626c651865200328014202100012190a0d72657065617465645f626f6f" . "6c1866200328084202100012280a0d72657065617465645f656e756d1867" . - "2003280e320d2e666f6f2e54657374456e756d420210002a1d0a08546573" . - "74456e756d12080a045a45524f100012070a034f4e451001620670726f74" . - "6f33" + "2003280e320d2e666f6f2e54657374456e756d4202100022170a0a546573" . + "74506870446f6312090a01611801200128052a1d0a0854657374456e756d" . + "12080a045a45524f100012070a034f4e451001620670726f746f33" )); diff --git a/php/tests/test.proto b/php/tests/test.proto index 15709c83..f15f6297 100644 --- a/php/tests/test.proto +++ b/php/tests/test.proto @@ -134,3 +134,8 @@ message TestUnpackedMessage { repeated bool repeated_bool = 102 [packed = false]; repeated TestEnum repeated_enum = 103 [packed = false]; } + +// /**/@<>&\{ +message TestPhpDoc { + int32 a = 1; +} diff --git a/php/tests/test_include.pb.php b/php/tests/test_include.pb.php index 2c43cc41..11ff59cb 100644 --- a/php/tests/test_include.pb.php +++ b/php/tests/test_include.pb.php @@ -9,15 +9,27 @@ use Google\Protobuf\Internal\GPBType; use Google\Protobuf\Internal\RepeatedField; use Google\Protobuf\Internal\GPBUtil; +/** + * Protobuf type <code>bar.TestInclude</code> + */ class TestInclude extends \Google\Protobuf\Internal\Message { + /** + * <code>optional int32 a = 1;</code> + */ private $a = 0; + /** + * <code>optional int32 a = 1;</code> + */ public function getA() { return $this->a; } + /** + * <code>optional int32 a = 1;</code> + */ public function setA($var) { GPBUtil::checkInt32($var); diff --git a/src/google/protobuf/compiler/php/php_generator.cc b/src/google/protobuf/compiler/php/php_generator.cc index 83e629b9..aac4e8af 100644 --- a/src/google/protobuf/compiler/php/php_generator.cc +++ b/src/google/protobuf/compiler/php/php_generator.cc @@ -52,25 +52,28 @@ namespace php { // Forward decls. std::string PhpName(const std::string& full_name, bool is_descriptor); -std::string DefaultForField(google::protobuf::FieldDescriptor* field); +std::string DefaultForField(FieldDescriptor* field); std::string IntToString(int32 value); std::string GeneratedFileName(const std::string& proto_file, bool is_descriptor); -std::string LabelForField(google::protobuf::FieldDescriptor* field); -std::string TypeName(google::protobuf::FieldDescriptor* field); +std::string LabelForField(FieldDescriptor* field); +std::string TypeName(FieldDescriptor* field); std::string UnderscoresToCamelCase(const string& name, bool cap_first_letter); std::string EscapeDollor(const string& to_escape); std::string BinaryToHex(const string& binary); -void GenerateMessage(const string& name_prefix, - const google::protobuf::Descriptor* message, - bool is_descriptor, - google::protobuf::io::Printer* printer); -void GenerateEnum(const google::protobuf::EnumDescriptor* en, - google::protobuf::io::Printer* printer); -void Indent(google::protobuf::io::Printer* printer); -void Outdent(google::protobuf::io::Printer* printer); - -std::string MessagePrefix(const google::protobuf::Descriptor* message) { +void GenerateMessage(const string& name_prefix, const Descriptor* message, + bool is_descriptor, io::Printer* printer); +void GenerateEnum(const EnumDescriptor* en, io::Printer* printer); +void Indent(io::Printer* printer); +void Outdent(io::Printer* printer); +void GenerateMessageDocComment(io::Printer* printer, const Descriptor* message); +void GenerateFieldDocComment(io::Printer* printer, + const FieldDescriptor* field); +void GenerateEnumDocComment(io::Printer* printer, const EnumDescriptor* enum_); +void GenerateEnumValueDocComment(io::Printer* printer, + const EnumValueDescriptor* value); + +std::string MessagePrefix(const Descriptor* message) { // Empty cannot be php class name. if (message->name() == "Empty" && message->file()->package() == "google.protobuf") { @@ -80,10 +83,9 @@ std::string MessagePrefix(const google::protobuf::Descriptor* message) { } } -std::string MessageName(const google::protobuf::Descriptor* message, - bool is_descriptor) { +std::string MessageName(const Descriptor* message, bool is_descriptor) { string message_name = message->name(); - const google::protobuf::Descriptor* descriptor = message->containing_type(); + const Descriptor* descriptor = message->containing_type(); while (descriptor != NULL) { message_name = descriptor->name() + '_' + message_name; descriptor = descriptor->containing_type(); @@ -94,8 +96,7 @@ std::string MessageName(const google::protobuf::Descriptor* message, message_name; } -std::string MessageFullName(const google::protobuf::Descriptor* message, - bool is_descriptor) { +std::string MessageFullName(const Descriptor* message, bool is_descriptor) { if (is_descriptor) { return StringReplace(message->full_name(), "google.protobuf", @@ -105,8 +106,7 @@ std::string MessageFullName(const google::protobuf::Descriptor* message, } } -std::string EnumFullName(const google::protobuf::EnumDescriptor* envm, - bool is_descriptor) { +std::string EnumFullName(const EnumDescriptor* envm, bool is_descriptor) { if (is_descriptor) { return StringReplace(envm->full_name(), "google.protobuf", @@ -116,9 +116,9 @@ std::string EnumFullName(const google::protobuf::EnumDescriptor* envm, } } -std::string EnumClassName(const google::protobuf::EnumDescriptor* envm) { +std::string EnumClassName(const EnumDescriptor* envm) { string enum_class_name = envm->name(); - const google::protobuf::Descriptor* descriptor = envm->containing_type(); + const Descriptor* descriptor = envm->containing_type(); while (descriptor != NULL) { enum_class_name = descriptor->name() + '_' + enum_class_name; descriptor = descriptor->containing_type(); @@ -126,8 +126,7 @@ std::string EnumClassName(const google::protobuf::EnumDescriptor* envm) { return enum_class_name; } -std::string EnumName(const google::protobuf::EnumDescriptor* envm, - bool is_descriptor) { +std::string EnumName(const EnumDescriptor* envm, bool is_descriptor) { string enum_name = EnumClassName(envm); return PhpName(envm->file()->package(), is_descriptor) + '\\' + enum_name; } @@ -154,7 +153,7 @@ std::string PhpName(const std::string& full_name, bool is_descriptor) { return result; } -std::string DefaultForField(const google::protobuf::FieldDescriptor* field) { +std::string DefaultForField(const FieldDescriptor* field) { switch (field->type()) { case FieldDescriptor::TYPE_INT32: case FieldDescriptor::TYPE_INT64: @@ -194,7 +193,7 @@ std::string IntToString(int32 value) { return os.str(); } -std::string LabelForField(const google::protobuf::FieldDescriptor* field) { +std::string LabelForField(const FieldDescriptor* field) { switch (field->label()) { case FieldDescriptor::LABEL_OPTIONAL: return "optional"; case FieldDescriptor::LABEL_REQUIRED: return "required"; @@ -203,7 +202,7 @@ std::string LabelForField(const google::protobuf::FieldDescriptor* field) { } } -std::string TypeName(const google::protobuf::FieldDescriptor* field) { +std::string TypeName(const FieldDescriptor* field) { switch (field->type()) { case FieldDescriptor::TYPE_INT32: return "int32"; case FieldDescriptor::TYPE_INT64: return "int64"; @@ -228,7 +227,7 @@ std::string TypeName(const google::protobuf::FieldDescriptor* field) { } std::string EnumOrMessageSuffix( - const google::protobuf::FieldDescriptor* field, bool is_descriptor) { + const FieldDescriptor* field, bool is_descriptor) { if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) { return ", '" + MessageFullName(field->message_type(), is_descriptor) + "'"; } @@ -299,74 +298,77 @@ std::string BinaryToHex(const string& src) { return dest; } -void Indent(google::protobuf::io::Printer* printer) { +void Indent(io::Printer* printer) { printer->Indent(); printer->Indent(); } -void Outdent(google::protobuf::io::Printer* printer) { +void Outdent(io::Printer* printer) { printer->Outdent(); printer->Outdent(); } -void GenerateField(const google::protobuf::FieldDescriptor* field, - google::protobuf::io::Printer* printer, bool is_descriptor) { +void GenerateField(const FieldDescriptor* field, io::Printer* printer, + bool is_descriptor) { if (field->is_repeated()) { + GenerateFieldDocComment(printer, field); printer->Print( - "private $@name@;\n", + "private $^name^;\n", "name", field->name()); } else if (field->containing_oneof()) { // Oneof fields are handled by GenerateOneofField. return; } else { + GenerateFieldDocComment(printer, field); printer->Print( - "private $@name@ = @default@;\n", + "private $^name^ = ^default^;\n", "name", field->name(), "default", DefaultForField(field)); } if (is_descriptor) { printer->Print( - "private $has_@name@ = false;\n", + "private $has_^name^ = false;\n", "name", field->name()); } } -void GenerateOneofField(const google::protobuf::OneofDescriptor* oneof, - google::protobuf::io::Printer* printer) { +void GenerateOneofField(const OneofDescriptor* oneof, io::Printer* printer) { // Oneof property needs to be protected in order to be accessed by parent // class in implementation. printer->Print( - "protected $@name@;\n", + "protected $^name^;\n", "name", oneof->name()); } -void GenerateFieldAccessor(const google::protobuf::FieldDescriptor* field, - bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateFieldAccessor(const FieldDescriptor* field, bool is_descriptor, + io::Printer* printer) { const OneofDescriptor* oneof = field->containing_oneof(); // Generate getter. if (oneof != NULL) { + GenerateFieldDocComment(printer, field); printer->Print( - "public function get@camel_name@()\n" + "public function get^camel_name^()\n" "{\n" - " return $this->readOneof(@number@);\n" + " return $this->readOneof(^number^);\n" "}\n\n", "camel_name", UnderscoresToCamelCase(field->name(), true), "number", IntToString(field->number())); } else { + GenerateFieldDocComment(printer, field); printer->Print( - "public function get@camel_name@()\n" + "public function get^camel_name^()\n" "{\n" - " return $this->@name@;\n" + " return $this->^name^;\n" "}\n\n", "camel_name", UnderscoresToCamelCase(field->name(), true), "name", field->name()); } // Generate setter. + GenerateFieldDocComment(printer, field); printer->Print( - "public function set@camel_name@(@var@)\n" + "public function set^camel_name^(^var^)\n" "{\n", "camel_name", UnderscoresToCamelCase(field->name(), true), "var", (field->is_repeated() || @@ -379,16 +381,16 @@ void GenerateFieldAccessor(const google::protobuf::FieldDescriptor* field, if (field->is_map()) { } else if (field->is_repeated()) { printer->Print( - "GPBUtil::checkRepeatedField($var, GPBType::@type@", + "GPBUtil::checkRepeatedField($var, GPBType::^type^", "type", ToUpper(field->type_name())); if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) { printer->Print( - ", \\@class_name@);\n", + ", \\^class_name^);\n", "class_name", MessageName(field->message_type(), is_descriptor) + "::class"); } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) { printer->Print( - ", @class_name@);\n", + ", ^class_name^);\n", "class_name", EnumName(field->enum_type(), is_descriptor) + "::class"); } else { @@ -396,37 +398,37 @@ void GenerateFieldAccessor(const google::protobuf::FieldDescriptor* field, } } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) { printer->Print( - "GPBUtil::checkMessage($var, \\@class_name@::class);\n", + "GPBUtil::checkMessage($var, \\^class_name^::class);\n", "class_name", MessageName(field->message_type(), is_descriptor)); } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) { printer->Print( - "GPBUtil::checkEnum($var, \\@class_name@::class);\n", + "GPBUtil::checkEnum($var, \\^class_name^::class);\n", "class_name", EnumName(field->enum_type(), is_descriptor)); } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) { printer->Print( - "GPBUtil::checkString($var, @utf8@);\n", + "GPBUtil::checkString($var, ^utf8^);\n", "utf8", field->type() == FieldDescriptor::TYPE_STRING ? "True": "False"); } else { printer->Print( - "GPBUtil::check@type@($var);\n", + "GPBUtil::check^type^($var);\n", "type", UnderscoresToCamelCase(field->cpp_type_name(), true)); } if (oneof != NULL) { printer->Print( - "$this->writeOneof(@number@, $var);\n", + "$this->writeOneof(^number^, $var);\n", "number", IntToString(field->number())); } else { printer->Print( - "$this->@name@ = $var;\n", + "$this->^name^ = $var;\n", "name", field->name()); } // Set has bit for proto2 only. if (is_descriptor) { printer->Print( - "$this->has_@field_name@ = true;\n", + "$this->has_^field_name^ = true;\n", "field_name", field->name()); } @@ -438,39 +440,36 @@ void GenerateFieldAccessor(const google::protobuf::FieldDescriptor* field, // Generate has method for proto2 only. if (is_descriptor) { printer->Print( - "public function has@camel_name@()\n" + "public function has^camel_name^()\n" "{\n" - " return $this->has_@field_name@;\n" + " return $this->has_^field_name^;\n" "}\n\n", "camel_name", UnderscoresToCamelCase(field->name(), true), "field_name", field->name()); } } -void GenerateRepeatedFieldDecode( - const google::protobuf::FieldDescriptor* field, - google::protobuf::io::Printer* printer) { +void GenerateRepeatedFieldDecode(const FieldDescriptor* field, + io::Printer* printer) { printer->Print( - "if ($input->read@cap_wire_type@($var)) return False;\n" - "$this->get@cap_field_name@() []= $var;\n", + "if ($input->read^cap_wire_type^($var)) return False;\n" + "$this->get^cap_field_name^() []= $var;\n", "cap_field_name", UnderscoresToCamelCase(field->name(), true), "cap_wire_type", UnderscoresToCamelCase(field->type_name(), true)); } -void GeneratePrimitiveFieldDecode( - const google::protobuf::FieldDescriptor* field, - google::protobuf::io::Printer* printer) { +void GeneratePrimitiveFieldDecode(const FieldDescriptor* field, + io::Printer* printer) { printer->Print( - "if ($input->read@cap_wire_type@($var)) return False;\n" - "$this->set@cap_field_name@($var);\n", + "if ($input->read^cap_wire_type^($var)) return False;\n" + "$this->set^cap_field_name^($var);\n", "cap_field_name", UnderscoresToCamelCase(field->name(), true), "cap_wire_type", UnderscoresToCamelCase(field->type_name(), true)); } -void GenerateFieldDecode(const google::protobuf::FieldDescriptor* field, - google::protobuf::io::Printer* printer) { +void GenerateFieldDecode(const FieldDescriptor* field, io::Printer* printer) { printer->Print( - "case @number@:\n", + "case ^number^:\n", "number", IntToString(field->number())); Indent(printer); @@ -485,23 +484,23 @@ void GenerateFieldDecode(const google::protobuf::FieldDescriptor* field, Outdent(printer); } -void GenerateMessage(const string& name_prefix, - const google::protobuf::Descriptor* message, - bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateMessage(const string& name_prefix, const Descriptor* message, + bool is_descriptor, io::Printer* printer) { // Don't generate MapEntry messages -- we use the PHP extension's native // support for map fields instead. if (message->options().map_entry()) { return; } + GenerateMessageDocComment(printer, message); + string message_name = name_prefix.empty() ? message->name() : name_prefix + "_" + MessagePrefix(message) + message->name(); printer->Print( - "class @name@ extends \\Google\\Protobuf\\Internal\\Message\n" + "class ^name^ extends \\Google\\Protobuf\\Internal\\Message\n" "{\n", "name", message_name); Indent(printer); @@ -523,11 +522,11 @@ void GenerateMessage(const string& name_prefix, GenerateFieldAccessor(field, is_descriptor, printer); } for (int i = 0; i < message->oneof_decl_count(); i++) { - const google::protobuf::OneofDescriptor* oneof = message->oneof_decl(i); + const OneofDescriptor* oneof = message->oneof_decl(i); printer->Print( - "public function get@camel_name@()\n" + "public function get^camel_name^()\n" "{\n" - " return $this->@name@;\n" + " return $this->^name^;\n" "}\n\n", "camel_name", UnderscoresToCamelCase(oneof->name(), true), "name", oneof->name()); @@ -546,11 +545,10 @@ void GenerateMessage(const string& name_prefix, } } -void GenerateEnumToPool(const google::protobuf::EnumDescriptor* en, - bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateEnumToPool(const EnumDescriptor* en, bool is_descriptor, + io::Printer* printer) { printer->Print( - "$pool->addEnum('@name@', @class_name@::class)\n", + "$pool->addEnum('^name^', ^class_name^::class)\n", "name", EnumFullName(en, is_descriptor), "class_name", en->name()); Indent(printer); @@ -558,7 +556,7 @@ void GenerateEnumToPool(const google::protobuf::EnumDescriptor* en, for (int i = 0; i < en->value_count(); i++) { const EnumValueDescriptor* value = en->value(i); printer->Print( - "->value(\"@name@\", @number@)\n", + "->value(\"^name^\", ^number^)\n", "name", value->name(), "number", IntToString(value->number())); } @@ -566,10 +564,8 @@ void GenerateEnumToPool(const google::protobuf::EnumDescriptor* en, Outdent(printer); } -void GenerateMessageToPool(const string& name_prefix, - const google::protobuf::Descriptor* message, - bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateMessageToPool(const string& name_prefix, const Descriptor* message, + bool is_descriptor, io::Printer* printer) { // Don't generate MapEntry messages -- we use the PHP extension's native // support for map fields instead. if (message->options().map_entry()) { @@ -579,7 +575,7 @@ void GenerateMessageToPool(const string& name_prefix, message->name() : name_prefix + "_" + message->name(); printer->Print( - "$pool->addMessage('@message@', @class_name@::class)\n", + "$pool->addMessage('^message^', ^class_name^::class)\n", "message", MessageFullName(message, is_descriptor), "class_name", class_name); @@ -593,8 +589,8 @@ void GenerateMessageToPool(const string& name_prefix, const FieldDescriptor* val = field->message_type()->FindFieldByName("value"); printer->Print( - "->map('@field@', GPBType::@key@, " - "GPBType::@value@, @number@@other@)\n", + "->map('^field^', GPBType::^key^, " + "GPBType::^value^, ^number^^other^)\n", "field", field->name(), "key", ToUpper(key->type_name()), "value", ToUpper(val->type_name()), @@ -602,7 +598,7 @@ void GenerateMessageToPool(const string& name_prefix, "other", EnumOrMessageSuffix(val, is_descriptor)); } else if (!field->containing_oneof()) { printer->Print( - "->@label@('@field@', GPBType::@type@, @number@@other@)\n", + "->^label^('^field^', GPBType::^type^, ^number^^other^)\n", "field", field->name(), "label", LabelForField(field), "type", ToUpper(field->type_name()), @@ -614,13 +610,13 @@ void GenerateMessageToPool(const string& name_prefix, // oneofs. for (int i = 0; i < message->oneof_decl_count(); i++) { const OneofDescriptor* oneof = message->oneof_decl(i); - printer->Print("->oneof(@name@)\n", + printer->Print("->oneof(^name^)\n", "name", oneof->name()); Indent(printer); for (int index = 0; index < oneof->field_count(); index++) { const FieldDescriptor* field = oneof->field(index); printer->Print( - "->value('@field@', GPBType::@type@, @number@@other@)\n", + "->value('^field^', GPBType::^type^, ^number^^other^)\n", "field", field->name(), "type", ToUpper(field->type_name()), "number", SimpleItoa(field->number()), @@ -647,9 +643,8 @@ void GenerateMessageToPool(const string& name_prefix, } } -void GenerateAddFileToPool(const google::protobuf::FileDescriptor* file, - bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateAddFileToPool(const FileDescriptor* file, bool is_descriptor, + io::Printer* printer) { if (is_descriptor) { printer->Print("$pool = DescriptorPool::getGeneratedPool();\n\n"); @@ -679,7 +674,7 @@ void GenerateAddFileToPool(const google::protobuf::FileDescriptor* file, static const int kBytesPerLine = 30; for (int i = 0; i < files_data.size(); i += kBytesPerLine) { printer->Print( - "\"@data@\"@dot@\n", + "\"^data^\"^dot^\n", "data", BinaryToHex(files_data.substr(i, kBytesPerLine)), "dot", i + kBytesPerLine < files_data.size() ? " ." : ""); } @@ -691,17 +686,18 @@ void GenerateAddFileToPool(const google::protobuf::FileDescriptor* file, } -void GenerateEnum(const google::protobuf::EnumDescriptor* en, - google::protobuf::io::Printer* printer) { +void GenerateEnum(const EnumDescriptor* en, io::Printer* printer) { + GenerateEnumDocComment(printer, en); printer->Print( - "class @name@\n" + "class ^name^\n" "{\n", "name", EnumClassName(en)); Indent(printer); for (int i = 0; i < en->value_count(); i++) { const EnumValueDescriptor* value = en->value(i); - printer->Print("const @name@ = @number@;\n", + GenerateEnumValueDocComment(printer, value); + printer->Print("const ^name^ = ^number^;\n", "name", value->name(), "number", IntToString(value->number())); } @@ -709,8 +705,7 @@ void GenerateEnum(const google::protobuf::EnumDescriptor* en, printer->Print("}\n\n"); } -void GenerateUseDeclaration(bool is_descriptor, - google::protobuf::io::Printer* printer) { +void GenerateUseDeclaration(bool is_descriptor, io::Printer* printer) { if (!is_descriptor) { printer->Print( "use Google\\Protobuf\\Internal\\DescriptorPool;\n" @@ -728,22 +723,22 @@ void GenerateUseDeclaration(bool is_descriptor, } } -void GenerateFile(const google::protobuf::FileDescriptor* file, - bool is_descriptor, google::protobuf::io::Printer* printer) { +void GenerateFile(const FileDescriptor* file, bool is_descriptor, + io::Printer* printer) { printer->Print( "<?php\n" "# Generated by the protocol buffer compiler. DO NOT EDIT!\n" - "# source: @filename@\n" + "# source: ^filename^\n" "\n", "filename", file->name()); if (!file->package().empty()) { - printer->Print("namespace @name@;\n\n", + printer->Print("namespace ^name^;\n\n", "name", PhpName(file->package(), is_descriptor)); } for (int i = 0; i < file->dependency_count(); i++) { const std::string& name = file->dependency(i)->name(); - printer->Print("require_once('@name@');\n", "name", + printer->Print("require_once('^name^');\n", "name", GeneratedFileName(name, is_descriptor)); } @@ -759,11 +754,169 @@ void GenerateFile(const google::protobuf::FileDescriptor* file, GenerateAddFileToPool(file, is_descriptor, printer); } -bool Generator::Generate( - const FileDescriptor* file, - const string& parameter, - GeneratorContext* generator_context, - string* error) const { +static string EscapePhpdoc(const string& input) { + string result; + result.reserve(input.size() * 2); + + char prev = '*'; + + for (string::size_type i = 0; i < input.size(); i++) { + char c = input[i]; + switch (c) { + case '*': + // Avoid "/*". + if (prev == '/') { + result.append("*"); + } else { + result.push_back(c); + } + break; + case '/': + // Avoid "*/". + if (prev == '*') { + result.append("/"); + } else { + result.push_back(c); + } + break; + case '@': + // '@' starts phpdoc tags including the @deprecated tag, which will + // cause a compile-time error if inserted before a declaration that + // does not have a corresponding @Deprecated annotation. + result.append("@"); + break; + case '<': + // Avoid interpretation as HTML. + result.append("<"); + break; + case '>': + // Avoid interpretation as HTML. + result.append(">"); + break; + case '&': + // Avoid interpretation as HTML. + result.append("&"); + break; + case '\\': + // Java interprets Unicode escape sequences anywhere! + result.append("\"); + break; + default: + result.push_back(c); + break; + } + + prev = c; + } + + return result; +} + +static void GenerateDocCommentBodyForLocation( + io::Printer* printer, const SourceLocation& location) { + string comments = location.leading_comments.empty() ? + location.trailing_comments : location.leading_comments; + if (!comments.empty()) { + // TODO(teboring): Ideally we should parse the comment text as Markdown and + // write it back as HTML, but this requires a Markdown parser. For now + // we just use <pre> to get fixed-width text formatting. + + // If the comment itself contains block comment start or end markers, + // HTML-escape them so that they don't accidentally close the doc comment. + comments = EscapePhpdoc(comments); + + vector<string> lines = Split(comments, "\n"); + while (!lines.empty() && lines.back().empty()) { + lines.pop_back(); + } + + printer->Print(" * <pre>\n"); + for (int i = 0; i < lines.size(); i++) { + // Most lines should start with a space. Watch out for lines that start + // with a /, since putting that right after the leading asterisk will + // close the comment. + if (!lines[i].empty() && lines[i][0] == '/') { + printer->Print(" * ^line^\n", "line", lines[i]); + } else { + printer->Print(" *^line^\n", "line", lines[i]); + } + } + printer->Print( + " * </pre>\n" + " *\n"); + } +} + +template <typename DescriptorType> +static void GenerateDocCommentBody( + io::Printer* printer, const DescriptorType* descriptor) { + SourceLocation location; + if (descriptor->GetSourceLocation(&location)) { + GenerateDocCommentBodyForLocation(printer, location); + } +} + +static string FirstLineOf(const string& value) { + string result = value; + + string::size_type pos = result.find_first_of('\n'); + if (pos != string::npos) { + result.erase(pos); + } + + return result; +} + +void GenerateMessageDocComment(io::Printer* printer, + const Descriptor* message) { + printer->Print("/**\n"); + GenerateDocCommentBody(printer, message); + printer->Print( + " * Protobuf type <code>^fullname^</code>\n" + " */\n", + "fullname", EscapePhpdoc(message->full_name())); +} + +void GenerateFieldDocComment(io::Printer* printer, + const FieldDescriptor* field) { + // In theory we should have slightly different comments for setters, getters, + // etc., but in practice everyone already knows the difference between these + // so it's redundant information. + + // We start the comment with the main body based on the comments from the + // .proto file (if present). We then end with the field declaration, e.g.: + // optional string foo = 5; + // If the field is a group, the debug string might end with {. + printer->Print("/**\n"); + GenerateDocCommentBody(printer, field); + printer->Print( + " * <code>^def^</code>\n", + "def", EscapePhpdoc(FirstLineOf(field->DebugString()))); + printer->Print(" */\n"); +} + +void GenerateEnumDocComment(io::Printer* printer, const EnumDescriptor* enum_) { + printer->Print("/**\n"); + GenerateDocCommentBody(printer, enum_); + printer->Print( + " * Protobuf enum <code>^fullname^</code>\n" + " */\n", + "fullname", EscapePhpdoc(enum_->full_name())); +} + +void GenerateEnumValueDocComment(io::Printer* printer, + const EnumValueDescriptor* value) { + printer->Print("/**\n"); + GenerateDocCommentBody(printer, value); + printer->Print( + " * <code>^def^</code>\n" + " */\n", + "def", EscapePhpdoc(FirstLineOf(value->DebugString()))); +} + +bool Generator::Generate(const FileDescriptor* file, const string& parameter, + GeneratorContext* generator_context, + string* error) const { bool is_descriptor = parameter == "internal"; if (is_descriptor && file->name() != kDescriptorFile) { @@ -782,7 +935,7 @@ bool Generator::Generate( std::string filename = GeneratedFileName(file->name(), is_descriptor); scoped_ptr<io::ZeroCopyOutputStream> output( generator_context->Open(filename)); - io::Printer printer(output.get(), '@'); + io::Printer printer(output.get(), '^'); GenerateFile(file, is_descriptor, &printer); |