google.protobuf.FieldOptions */ class FieldOptions extends \Google\Protobuf\Internal\Message { /** *
* The ctype option instructs the C++ code generator to use a different * representation of the field than it normally would. See the specific * options below. This option is not yet implemented in the open source * release -- sorry, we'll try to include it in a future version! ** *
optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
*/
private $ctype = 0;
private $has_ctype = false;
/**
* * The packed option can be enabled for repeated primitive fields to enable * a more efficient representation on the wire. Rather than repeatedly * writing the tag and type for each element, the entire array is encoded as * a single length-delimited blob. In proto3, only explicit setting it to * false will avoid using packed encoding. ** *
optional bool packed = 2;
*/
private $packed = false;
private $has_packed = false;
/**
* * The jstype option determines the JavaScript type used for values of the * field. The option is permitted only for 64 bit integral and fixed types * (int64, uint64, sint64, fixed64, sfixed64). By default these types are * represented as JavaScript strings. This avoids loss of precision that can * happen when a large value is converted to a floating point JavaScript * numbers. Specifying JS_NUMBER for the jstype causes the generated * JavaScript code to use the JavaScript "number" type instead of strings. * This option is an enum to permit additional types to be added, * e.g. goog.math.Integer. ** *
optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
*/
private $jstype = 0;
private $has_jstype = false;
/**
* * Should this field be parsed lazily? Lazy applies only to message-type * fields. It means that when the outer message is initially parsed, the * inner message's contents will not be parsed but instead stored in encoded * form. The inner message will actually be parsed when it is first accessed. * This is only a hint. Implementations are free to choose whether to use * eager or lazy parsing regardless of the value of this option. However, * setting this option true suggests that the protocol author believes that * using lazy parsing on this field is worth the additional bookkeeping * overhead typically needed to implement it. * This option does not affect the public interface of any generated code; * all method signatures remain the same. Furthermore, thread-safety of the * interface is not affected by this option; const methods remain safe to * call from multiple threads concurrently, while non-const methods continue * to require exclusive access. * Note that implementations may choose not to check required fields within * a lazy sub-message. That is, calling IsInitialized() on the outer message * may return true even if the inner message has missing required fields. * This is necessary because otherwise the inner message would have to be * parsed in order to perform the check, defeating the purpose of lazy * parsing. An implementation which chooses not to check required fields * must be consistent about it. That is, for any particular sub-message, the * implementation must either *always* check its required fields, or *never* * check its required fields, regardless of whether or not the message has * been parsed. ** *
optional bool lazy = 5 [default = false];
*/
private $lazy = false;
private $has_lazy = false;
/**
* * Is this field deprecated? * Depending on the target platform, this can emit Deprecated annotations * for accessors, or it will be completely ignored; in the very least, this * is a formalization for deprecating fields. ** *
optional bool deprecated = 3 [default = false];
*/
private $deprecated = false;
private $has_deprecated = false;
/**
* * For Google-internal migration only. Do not use. ** *
optional bool weak = 10 [default = false];
*/
private $weak = false;
private $has_weak = false;
/**
* * The parser stores options it doesn't recognize here. See above. ** *
repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
*/
private $uninterpreted_option;
private $has_uninterpreted_option = false;
public function __construct() {
\GPBMetadata\Google\Protobuf\Internal\Descriptor::initOnce();
parent::__construct();
}
/**
* * The ctype option instructs the C++ code generator to use a different * representation of the field than it normally would. See the specific * options below. This option is not yet implemented in the open source * release -- sorry, we'll try to include it in a future version! ** *
optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
*/
public function getCtype()
{
return $this->ctype;
}
/**
* * The ctype option instructs the C++ code generator to use a different * representation of the field than it normally would. See the specific * options below. This option is not yet implemented in the open source * release -- sorry, we'll try to include it in a future version! ** *
optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
*/
public function setCtype($var)
{
GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_CType::class);
$this->ctype = $var;
$this->has_ctype = true;
}
public function hasCtype()
{
return $this->has_ctype;
}
/**
* * The packed option can be enabled for repeated primitive fields to enable * a more efficient representation on the wire. Rather than repeatedly * writing the tag and type for each element, the entire array is encoded as * a single length-delimited blob. In proto3, only explicit setting it to * false will avoid using packed encoding. ** *
optional bool packed = 2;
*/
public function getPacked()
{
return $this->packed;
}
/**
* * The packed option can be enabled for repeated primitive fields to enable * a more efficient representation on the wire. Rather than repeatedly * writing the tag and type for each element, the entire array is encoded as * a single length-delimited blob. In proto3, only explicit setting it to * false will avoid using packed encoding. ** *
optional bool packed = 2;
*/
public function setPacked($var)
{
GPBUtil::checkBool($var);
$this->packed = $var;
$this->has_packed = true;
}
public function hasPacked()
{
return $this->has_packed;
}
/**
* * The jstype option determines the JavaScript type used for values of the * field. The option is permitted only for 64 bit integral and fixed types * (int64, uint64, sint64, fixed64, sfixed64). By default these types are * represented as JavaScript strings. This avoids loss of precision that can * happen when a large value is converted to a floating point JavaScript * numbers. Specifying JS_NUMBER for the jstype causes the generated * JavaScript code to use the JavaScript "number" type instead of strings. * This option is an enum to permit additional types to be added, * e.g. goog.math.Integer. ** *
optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
*/
public function getJstype()
{
return $this->jstype;
}
/**
* * The jstype option determines the JavaScript type used for values of the * field. The option is permitted only for 64 bit integral and fixed types * (int64, uint64, sint64, fixed64, sfixed64). By default these types are * represented as JavaScript strings. This avoids loss of precision that can * happen when a large value is converted to a floating point JavaScript * numbers. Specifying JS_NUMBER for the jstype causes the generated * JavaScript code to use the JavaScript "number" type instead of strings. * This option is an enum to permit additional types to be added, * e.g. goog.math.Integer. ** *
optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
*/
public function setJstype($var)
{
GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_JSType::class);
$this->jstype = $var;
$this->has_jstype = true;
}
public function hasJstype()
{
return $this->has_jstype;
}
/**
* * Should this field be parsed lazily? Lazy applies only to message-type * fields. It means that when the outer message is initially parsed, the * inner message's contents will not be parsed but instead stored in encoded * form. The inner message will actually be parsed when it is first accessed. * This is only a hint. Implementations are free to choose whether to use * eager or lazy parsing regardless of the value of this option. However, * setting this option true suggests that the protocol author believes that * using lazy parsing on this field is worth the additional bookkeeping * overhead typically needed to implement it. * This option does not affect the public interface of any generated code; * all method signatures remain the same. Furthermore, thread-safety of the * interface is not affected by this option; const methods remain safe to * call from multiple threads concurrently, while non-const methods continue * to require exclusive access. * Note that implementations may choose not to check required fields within * a lazy sub-message. That is, calling IsInitialized() on the outer message * may return true even if the inner message has missing required fields. * This is necessary because otherwise the inner message would have to be * parsed in order to perform the check, defeating the purpose of lazy * parsing. An implementation which chooses not to check required fields * must be consistent about it. That is, for any particular sub-message, the * implementation must either *always* check its required fields, or *never* * check its required fields, regardless of whether or not the message has * been parsed. ** *
optional bool lazy = 5 [default = false];
*/
public function getLazy()
{
return $this->lazy;
}
/**
* * Should this field be parsed lazily? Lazy applies only to message-type * fields. It means that when the outer message is initially parsed, the * inner message's contents will not be parsed but instead stored in encoded * form. The inner message will actually be parsed when it is first accessed. * This is only a hint. Implementations are free to choose whether to use * eager or lazy parsing regardless of the value of this option. However, * setting this option true suggests that the protocol author believes that * using lazy parsing on this field is worth the additional bookkeeping * overhead typically needed to implement it. * This option does not affect the public interface of any generated code; * all method signatures remain the same. Furthermore, thread-safety of the * interface is not affected by this option; const methods remain safe to * call from multiple threads concurrently, while non-const methods continue * to require exclusive access. * Note that implementations may choose not to check required fields within * a lazy sub-message. That is, calling IsInitialized() on the outer message * may return true even if the inner message has missing required fields. * This is necessary because otherwise the inner message would have to be * parsed in order to perform the check, defeating the purpose of lazy * parsing. An implementation which chooses not to check required fields * must be consistent about it. That is, for any particular sub-message, the * implementation must either *always* check its required fields, or *never* * check its required fields, regardless of whether or not the message has * been parsed. ** *
optional bool lazy = 5 [default = false];
*/
public function setLazy($var)
{
GPBUtil::checkBool($var);
$this->lazy = $var;
$this->has_lazy = true;
}
public function hasLazy()
{
return $this->has_lazy;
}
/**
* * Is this field deprecated? * Depending on the target platform, this can emit Deprecated annotations * for accessors, or it will be completely ignored; in the very least, this * is a formalization for deprecating fields. ** *
optional bool deprecated = 3 [default = false];
*/
public function getDeprecated()
{
return $this->deprecated;
}
/**
* * Is this field deprecated? * Depending on the target platform, this can emit Deprecated annotations * for accessors, or it will be completely ignored; in the very least, this * is a formalization for deprecating fields. ** *
optional bool deprecated = 3 [default = false];
*/
public function setDeprecated($var)
{
GPBUtil::checkBool($var);
$this->deprecated = $var;
$this->has_deprecated = true;
}
public function hasDeprecated()
{
return $this->has_deprecated;
}
/**
* * For Google-internal migration only. Do not use. ** *
optional bool weak = 10 [default = false];
*/
public function getWeak()
{
return $this->weak;
}
/**
* * For Google-internal migration only. Do not use. ** *
optional bool weak = 10 [default = false];
*/
public function setWeak($var)
{
GPBUtil::checkBool($var);
$this->weak = $var;
$this->has_weak = true;
}
public function hasWeak()
{
return $this->has_weak;
}
/**
* * The parser stores options it doesn't recognize here. See above. ** *
repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
*/
public function getUninterpretedOption()
{
return $this->uninterpreted_option;
}
/**
* * The parser stores options it doesn't recognize here. See above. ** *
repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
*/
public function setUninterpretedOption(&$var)
{
GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Protobuf\Internal\UninterpretedOption::class);
$this->uninterpreted_option = $var;
$this->has_uninterpreted_option = true;
}
public function hasUninterpretedOption()
{
return $this->has_uninterpreted_option;
}
}