php/src/Google/Protobuf/Internal/FieldOptions.php - third_party/protobuf - Git at Google

 <?php
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: google/protobuf/descriptor.proto

 namespace Google\Protobuf\Internal;

 use Google\Protobuf\Internal\GPBType;
 use Google\Protobuf\Internal\GPBWire;
 use Google\Protobuf\Internal\RepeatedField;
 use Google\Protobuf\Internal\InputStream;
 use Google\Protobuf\Internal\GPBUtil;
 use Google\Protobuf\Internal\GPBWrapperUtils;

 /**
  * Generated from protobuf message <code>google.protobuf.FieldOptions</code>
  */
 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!
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
      */
     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.
      *
      * Generated from protobuf field <code>optional bool packed = 2;</code>
      */
     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).  A field with jstype JS_STRING
      * is represented as JavaScript string, which avoids loss of precision that
      * can happen when a large value is converted to a floating point JavaScript.
      * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
      * use the JavaScript "number" type.  The behavior of the default option
      * JS_NORMAL is implementation dependent.
      * This option is an enum to permit additional types to be added, e.g.
      * goog.math.Integer.
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
      */
     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.
      *
      * Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
      */
     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.
      *
      * Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
      */
     private $deprecated = false;
     private $has_deprecated = false;
     /**
      * For Google-internal migration only. Do not use.
      *
      * Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
      */
     private $weak = false;
     private $has_weak = false;
     /**
      * The parser stores options it doesn't recognize here. See above.
      *
      * Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
      */
     private $uninterpreted_option;
     private $has_uninterpreted_option = false;

     /**
      * Constructor.
      *
      * @param array $data {
      *     Optional. Data for populating the Message object.
      *
      *     @type int $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!
      *     @type bool $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.
      *     @type int $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).  A field with jstype JS_STRING
      *           is represented as JavaScript string, which avoids loss of precision that
      *           can happen when a large value is converted to a floating point JavaScript.
      *           Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
      *           use the JavaScript "number" type.  The behavior of the default option
      *           JS_NORMAL is implementation dependent.
      *           This option is an enum to permit additional types to be added, e.g.
      *           goog.math.Integer.
      *     @type bool $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.
      *     @type bool $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.
      *     @type bool $weak
      *           For Google-internal migration only. Do not use.
      *     @type \Google\Protobuf\Internal\UninterpretedOption[]|\Google\Protobuf\Internal\RepeatedField $uninterpreted_option
      *           The parser stores options it doesn't recognize here. See above.
      * }
      */
     public function __construct($data = NULL) {
         \GPBMetadata\Google\Protobuf\Internal\Descriptor::initOnce();
         parent::__construct($data);
     }

     /**
      * 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!
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
      * @return int
      */
     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!
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
      * @param int $var
      * @return $this
      */
     public function setCtype($var)
     {
         GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_CType::class);
         $this->ctype = $var;
         $this->has_ctype = true;

         return $this;
     }

     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.
      *
      * Generated from protobuf field <code>optional bool packed = 2;</code>
      * @return bool
      */
     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.
      *
      * Generated from protobuf field <code>optional bool packed = 2;</code>
      * @param bool $var
      * @return $this
      */
     public function setPacked($var)
     {
         GPBUtil::checkBool($var);
         $this->packed = $var;
         $this->has_packed = true;

         return $this;
     }

     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).  A field with jstype JS_STRING
      * is represented as JavaScript string, which avoids loss of precision that
      * can happen when a large value is converted to a floating point JavaScript.
      * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
      * use the JavaScript "number" type.  The behavior of the default option
      * JS_NORMAL is implementation dependent.
      * This option is an enum to permit additional types to be added, e.g.
      * goog.math.Integer.
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
      * @return int
      */
     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).  A field with jstype JS_STRING
      * is represented as JavaScript string, which avoids loss of precision that
      * can happen when a large value is converted to a floating point JavaScript.
      * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
      * use the JavaScript "number" type.  The behavior of the default option
      * JS_NORMAL is implementation dependent.
      * This option is an enum to permit additional types to be added, e.g.
      * goog.math.Integer.
      *
      * Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
      * @param int $var
      * @return $this
      */
     public function setJstype($var)
     {
         GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_JSType::class);
         $this->jstype = $var;
         $this->has_jstype = true;

         return $this;
     }

     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.
      *
      * Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
      * @return bool
      */
     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.
      *
      * Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
      * @param bool $var
      * @return $this
      */
     public function setLazy($var)
     {
         GPBUtil::checkBool($var);
         $this->lazy = $var;
         $this->has_lazy = true;

         return $this;
     }

     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.
      *
      * Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
      * @return bool
      */
     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.
      *
      * Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
      * @param bool $var
      * @return $this
      */
     public function setDeprecated($var)
     {
         GPBUtil::checkBool($var);
         $this->deprecated = $var;
         $this->has_deprecated = true;

         return $this;
     }

     public function hasDeprecated()
     {
         return $this->has_deprecated;
     }

     /**
      * For Google-internal migration only. Do not use.
      *
      * Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
      * @return bool
      */
     public function getWeak()
     {
         return $this->weak;
     }

     /**
      * For Google-internal migration only. Do not use.
      *
      * Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
      * @param bool $var
      * @return $this
      */
     public function setWeak($var)
     {
         GPBUtil::checkBool($var);
         $this->weak = $var;
         $this->has_weak = true;

         return $this;
     }

     public function hasWeak()
     {
         return $this->has_weak;
     }

     /**
      * The parser stores options it doesn't recognize here. See above.
      *
      * Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
      * @return \Google\Protobuf\Internal\RepeatedField
      */
     public function getUninterpretedOption()
     {
         return $this->uninterpreted_option;
     }

     /**
      * The parser stores options it doesn't recognize here. See above.
      *
      * Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
      * @param \Google\Protobuf\Internal\UninterpretedOption[]|\Google\Protobuf\Internal\RepeatedField $var
      * @return $this
      */
     public function setUninterpretedOption($var)
     {
         $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Protobuf\Internal\UninterpretedOption::class);
         $this->uninterpreted_option = $arr;
         $this->has_uninterpreted_option = true;

         return $this;
     }

     public function hasUninterpretedOption()
     {
         return $this->has_uninterpreted_option;
     }

 }
	<?php
	# Generated by the protocol buffer compiler. DO NOT EDIT!
	# source: google/protobuf/descriptor.proto

	namespace Google\Protobuf\Internal;

	use Google\Protobuf\Internal\GPBType;
	use Google\Protobuf\Internal\GPBWire;
	use Google\Protobuf\Internal\RepeatedField;
	use Google\Protobuf\Internal\InputStream;
	use Google\Protobuf\Internal\GPBUtil;
	use Google\Protobuf\Internal\GPBWrapperUtils;

	/**
	* Generated from protobuf message <code>google.protobuf.FieldOptions</code>
	*/
	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!
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool packed = 2;</code>
	*/
	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). A field with jstype JS_STRING
	* is represented as JavaScript string, which avoids loss of precision that
	* can happen when a large value is converted to a floating point JavaScript.
	* Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
	* use the JavaScript "number" type. The behavior of the default option
	* JS_NORMAL is implementation dependent.
	* This option is an enum to permit additional types to be added, e.g.
	* goog.math.Integer.
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
	*/
	private $deprecated = false;
	private $has_deprecated = false;
	/**
	* For Google-internal migration only. Do not use.
	*
	* Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
	*/
	private $weak = false;
	private $has_weak = false;
	/**
	* The parser stores options it doesn't recognize here. See above.
	*
	* Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
	*/
	private $uninterpreted_option;
	private $has_uninterpreted_option = false;

	/**
	* Constructor.
	*
	* @param array $data {
	* Optional. Data for populating the Message object.
	*
	* @type int $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!
	* @type bool $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.
	* @type int $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). A field with jstype JS_STRING
	* is represented as JavaScript string, which avoids loss of precision that
	* can happen when a large value is converted to a floating point JavaScript.
	* Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
	* use the JavaScript "number" type. The behavior of the default option
	* JS_NORMAL is implementation dependent.
	* This option is an enum to permit additional types to be added, e.g.
	* goog.math.Integer.
	* @type bool $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.
	* @type bool $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.
	* @type bool $weak
	* For Google-internal migration only. Do not use.
	* @type \Google\Protobuf\Internal\UninterpretedOption[]\|\Google\Protobuf\Internal\RepeatedField $uninterpreted_option
	* The parser stores options it doesn't recognize here. See above.
	* }
	*/
	public function __construct($data = NULL) {
	\GPBMetadata\Google\Protobuf\Internal\Descriptor::initOnce();
	parent::__construct($data);
	}

	/**
	* 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!
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
	* @return int
	*/
	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!
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
	* @param int $var
	* @return $this
	*/
	public function setCtype($var)
	{
	GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_CType::class);
	$this->ctype = $var;
	$this->has_ctype = true;

	return $this;
	}

	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.
	*
	* Generated from protobuf field <code>optional bool packed = 2;</code>
	* @return bool
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool packed = 2;</code>
	* @param bool $var
	* @return $this
	*/
	public function setPacked($var)
	{
	GPBUtil::checkBool($var);
	$this->packed = $var;
	$this->has_packed = true;

	return $this;
	}

	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). A field with jstype JS_STRING
	* is represented as JavaScript string, which avoids loss of precision that
	* can happen when a large value is converted to a floating point JavaScript.
	* Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
	* use the JavaScript "number" type. The behavior of the default option
	* JS_NORMAL is implementation dependent.
	* This option is an enum to permit additional types to be added, e.g.
	* goog.math.Integer.
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
	* @return int
	*/
	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). A field with jstype JS_STRING
	* is represented as JavaScript string, which avoids loss of precision that
	* can happen when a large value is converted to a floating point JavaScript.
	* Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
	* use the JavaScript "number" type. The behavior of the default option
	* JS_NORMAL is implementation dependent.
	* This option is an enum to permit additional types to be added, e.g.
	* goog.math.Integer.
	*
	* Generated from protobuf field <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
	* @param int $var
	* @return $this
	*/
	public function setJstype($var)
	{
	GPBUtil::checkEnum($var, \Google\Protobuf\Internal\FieldOptions_JSType::class);
	$this->jstype = $var;
	$this->has_jstype = true;

	return $this;
	}

	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.
	*
	* Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
	* @return bool
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool lazy = 5 [default = false];</code>
	* @param bool $var
	* @return $this
	*/
	public function setLazy($var)
	{
	GPBUtil::checkBool($var);
	$this->lazy = $var;
	$this->has_lazy = true;

	return $this;
	}

	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.
	*
	* Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
	* @return bool
	*/
	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.
	*
	* Generated from protobuf field <code>optional bool deprecated = 3 [default = false];</code>
	* @param bool $var
	* @return $this
	*/
	public function setDeprecated($var)
	{
	GPBUtil::checkBool($var);
	$this->deprecated = $var;
	$this->has_deprecated = true;

	return $this;
	}

	public function hasDeprecated()
	{
	return $this->has_deprecated;
	}

	/**
	* For Google-internal migration only. Do not use.
	*
	* Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
	* @return bool
	*/
	public function getWeak()
	{
	return $this->weak;
	}

	/**
	* For Google-internal migration only. Do not use.
	*
	* Generated from protobuf field <code>optional bool weak = 10 [default = false];</code>
	* @param bool $var
	* @return $this
	*/
	public function setWeak($var)
	{
	GPBUtil::checkBool($var);
	$this->weak = $var;
	$this->has_weak = true;

	return $this;
	}

	public function hasWeak()
	{
	return $this->has_weak;
	}

	/**
	* The parser stores options it doesn't recognize here. See above.
	*
	* Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
	* @return \Google\Protobuf\Internal\RepeatedField
	*/
	public function getUninterpretedOption()
	{
	return $this->uninterpreted_option;
	}

	/**
	* The parser stores options it doesn't recognize here. See above.
	*
	* Generated from protobuf field <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
	* @param \Google\Protobuf\Internal\UninterpretedOption[]\|\Google\Protobuf\Internal\RepeatedField $var
	* @return $this
	*/
	public function setUninterpretedOption($var)
	{
	$arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Protobuf\Internal\UninterpretedOption::class);
	$this->uninterpreted_option = $arr;
	$this->has_uninterpreted_option = true;

	return $this;
	}

	public function hasUninterpretedOption()
	{
	return $this->has_uninterpreted_option;
	}

	}