<?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;

/**
 * Protobuf type <code>google.protobuf.FieldOptions</code>
 */
class FieldOptions extends \Google\Protobuf\Internal\Message
{
    /**
     * <pre>
     * 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!
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
     */
    private $ctype = 0;
    private $has_ctype = false;
    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool packed = 2;</code>
     */
    private $packed = false;
    private $has_packed = false;
    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
     */
    private $jstype = 0;
    private $has_jstype = false;
    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool lazy = 5 [default = false];</code>
     */
    private $lazy = false;
    private $has_lazy = false;
    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool deprecated = 3 [default = false];</code>
     */
    private $deprecated = false;
    private $has_deprecated = false;
    /**
     * <pre>
     * For Google-internal migration only. Do not use.
     * </pre>
     *
     * <code>optional bool weak = 10 [default = false];</code>
     */
    private $weak = false;
    private $has_weak = false;
    /**
     * <pre>
     * The parser stores options it doesn't recognize here. See above.
     * </pre>
     *
     * <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
     */
    private $uninterpreted_option;
    private $has_uninterpreted_option = false;

    public function __construct() {
        \GPBMetadata\Google\Protobuf\Internal\Descriptor::initOnce();
        parent::__construct();
    }

    /**
     * <pre>
     * 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!
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
     */
    public function getCtype()
    {
        return $this->ctype;
    }

    /**
     * <pre>
     * 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!
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];</code>
     */
    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;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool packed = 2;</code>
     */
    public function getPacked()
    {
        return $this->packed;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool packed = 2;</code>
     */
    public function setPacked($var)
    {
        GPBUtil::checkBool($var);
        $this->packed = $var;
        $this->has_packed = true;
    }

    public function hasPacked()
    {
        return $this->has_packed;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
     */
    public function getJstype()
    {
        return $this->jstype;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];</code>
     */
    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;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool lazy = 5 [default = false];</code>
     */
    public function getLazy()
    {
        return $this->lazy;
    }

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

    public function hasLazy()
    {
        return $this->has_lazy;
    }

    /**
     * <pre>
     * 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.
     * </pre>
     *
     * <code>optional bool deprecated = 3 [default = false];</code>
     */
    public function getDeprecated()
    {
        return $this->deprecated;
    }

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

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

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

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

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

    /**
     * <pre>
     * The parser stores options it doesn't recognize here. See above.
     * </pre>
     *
     * <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
     */
    public function getUninterpretedOption()
    {
        return $this->uninterpreted_option;
    }

    /**
     * <pre>
     * The parser stores options it doesn't recognize here. See above.
     * </pre>
     *
     * <code>repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;</code>
     */
    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;
    }

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

}