gf_metadata/

axes.rs

// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by protoc --rs_out=...
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `axes.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;

///  An axis in the GF Axis Registry
// @@protoc_insertion_point(message:AxisProto)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AxisProto {
    // message fields
    ///  Axis tag
    // @@protoc_insertion_point(field:AxisProto.tag)
    pub tag: ::std::option::Option<::std::string::String>,
    ///  Display name for axis, e.g. "Optical size" for 'opsz'
    ///  Like 'Name' in
    ///  https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxistag_opsz
    // @@protoc_insertion_point(field:AxisProto.display_name)
    pub display_name: ::std::option::Option<::std::string::String>,
    ///  Lower bound for the axis
    // @@protoc_insertion_point(field:AxisProto.min_value)
    pub min_value: ::std::option::Option<f32>,
    ///  The default position to use and to prefer for exemplars
    // @@protoc_insertion_point(field:AxisProto.default_value)
    pub default_value: ::std::option::Option<f32>,
    ///  Upper bound for the axis
    // @@protoc_insertion_point(field:AxisProto.max_value)
    pub max_value: ::std::option::Option<f32>,
    ///  Input values for this axis must aligned to 10^precision
    // @@protoc_insertion_point(field:AxisProto.precision)
    pub precision: ::std::option::Option<i32>,
    ///  Fallback positions along the axis
    // @@protoc_insertion_point(field:AxisProto.fallback)
    pub fallback: ::std::vec::Vec<FallbackProto>,
    ///  Short descriptive paragraph
    // @@protoc_insertion_point(field:AxisProto.description)
    pub description: ::std::option::Option<::std::string::String>,
    ///  Whether only the fallback positions should be used, for example, an axis
    ///  might have only three relevant positions: the min, the middle, and the max.
    // @@protoc_insertion_point(field:AxisProto.fallback_only)
    pub fallback_only: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:AxisProto.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a AxisProto {
    fn default() -> &'a AxisProto {
        <AxisProto as ::protobuf::Message>::default_instance()
    }
}

impl AxisProto {
    pub fn new() -> AxisProto {
        ::std::default::Default::default()
    }

    // optional string tag = 1;

    pub fn tag(&self) -> &str {
        match self.tag.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_tag(&mut self) {
        self.tag = ::std::option::Option::None;
    }

    pub fn has_tag(&self) -> bool {
        self.tag.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tag(&mut self, v: ::std::string::String) {
        self.tag = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tag(&mut self) -> &mut ::std::string::String {
        if self.tag.is_none() {
            self.tag = ::std::option::Option::Some(::std::string::String::new());
        }
        self.tag.as_mut().unwrap()
    }

    // Take field
    pub fn take_tag(&mut self) -> ::std::string::String {
        self.tag.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string display_name = 7;

    pub fn display_name(&self) -> &str {
        match self.display_name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_display_name(&mut self) {
        self.display_name = ::std::option::Option::None;
    }

    pub fn has_display_name(&self) -> bool {
        self.display_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_display_name(&mut self, v: ::std::string::String) {
        self.display_name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_display_name(&mut self) -> &mut ::std::string::String {
        if self.display_name.is_none() {
            self.display_name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.display_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_display_name(&mut self) -> ::std::string::String {
        self.display_name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional float min_value = 2;

    pub fn min_value(&self) -> f32 {
        self.min_value.unwrap_or(0.)
    }

    pub fn clear_min_value(&mut self) {
        self.min_value = ::std::option::Option::None;
    }

    pub fn has_min_value(&self) -> bool {
        self.min_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_min_value(&mut self, v: f32) {
        self.min_value = ::std::option::Option::Some(v);
    }

    // optional float default_value = 3;

    pub fn default_value(&self) -> f32 {
        self.default_value.unwrap_or(0.)
    }

    pub fn clear_default_value(&mut self) {
        self.default_value = ::std::option::Option::None;
    }

    pub fn has_default_value(&self) -> bool {
        self.default_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_default_value(&mut self, v: f32) {
        self.default_value = ::std::option::Option::Some(v);
    }

    // optional float max_value = 4;

    pub fn max_value(&self) -> f32 {
        self.max_value.unwrap_or(0.)
    }

    pub fn clear_max_value(&mut self) {
        self.max_value = ::std::option::Option::None;
    }

    pub fn has_max_value(&self) -> bool {
        self.max_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_max_value(&mut self, v: f32) {
        self.max_value = ::std::option::Option::Some(v);
    }

    // optional int32 precision = 5;

    pub fn precision(&self) -> i32 {
        self.precision.unwrap_or(0)
    }

    pub fn clear_precision(&mut self) {
        self.precision = ::std::option::Option::None;
    }

    pub fn has_precision(&self) -> bool {
        self.precision.is_some()
    }

    // Param is passed by value, moved
    pub fn set_precision(&mut self, v: i32) {
        self.precision = ::std::option::Option::Some(v);
    }

    // optional string description = 8;

    pub fn description(&self) -> &str {
        match self.description.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_description(&mut self) {
        self.description = ::std::option::Option::None;
    }

    pub fn has_description(&self) -> bool {
        self.description.is_some()
    }

    // Param is passed by value, moved
    pub fn set_description(&mut self, v: ::std::string::String) {
        self.description = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_description(&mut self) -> &mut ::std::string::String {
        if self.description.is_none() {
            self.description = ::std::option::Option::Some(::std::string::String::new());
        }
        self.description.as_mut().unwrap()
    }

    // Take field
    pub fn take_description(&mut self) -> ::std::string::String {
        self.description.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bool fallback_only = 9;

    pub fn fallback_only(&self) -> bool {
        self.fallback_only.unwrap_or(false)
    }

    pub fn clear_fallback_only(&mut self) {
        self.fallback_only = ::std::option::Option::None;
    }

    pub fn has_fallback_only(&self) -> bool {
        self.fallback_only.is_some()
    }

    // Param is passed by value, moved
    pub fn set_fallback_only(&mut self, v: bool) {
        self.fallback_only = ::std::option::Option::Some(v);
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(9);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tag",
            |m: &AxisProto| { &m.tag },
            |m: &mut AxisProto| { &mut m.tag },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "display_name",
            |m: &AxisProto| { &m.display_name },
            |m: &mut AxisProto| { &mut m.display_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "min_value",
            |m: &AxisProto| { &m.min_value },
            |m: &mut AxisProto| { &mut m.min_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "default_value",
            |m: &AxisProto| { &m.default_value },
            |m: &mut AxisProto| { &mut m.default_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "max_value",
            |m: &AxisProto| { &m.max_value },
            |m: &mut AxisProto| { &mut m.max_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "precision",
            |m: &AxisProto| { &m.precision },
            |m: &mut AxisProto| { &mut m.precision },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "fallback",
            |m: &AxisProto| { &m.fallback },
            |m: &mut AxisProto| { &mut m.fallback },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "description",
            |m: &AxisProto| { &m.description },
            |m: &mut AxisProto| { &mut m.description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "fallback_only",
            |m: &AxisProto| { &m.fallback_only },
            |m: &mut AxisProto| { &mut m.fallback_only },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AxisProto>(
            "AxisProto",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AxisProto {
    const NAME: &'static str = "AxisProto";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.tag = ::std::option::Option::Some(is.read_string()?);
                },
                58 => {
                    self.display_name = ::std::option::Option::Some(is.read_string()?);
                },
                21 => {
                    self.min_value = ::std::option::Option::Some(is.read_float()?);
                },
                29 => {
                    self.default_value = ::std::option::Option::Some(is.read_float()?);
                },
                37 => {
                    self.max_value = ::std::option::Option::Some(is.read_float()?);
                },
                40 => {
                    self.precision = ::std::option::Option::Some(is.read_int32()?);
                },
                50 => {
                    self.fallback.push(is.read_message()?);
                },
                66 => {
                    self.description = ::std::option::Option::Some(is.read_string()?);
                },
                72 => {
                    self.fallback_only = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.tag.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.display_name.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.min_value {
            my_size += 1 + 4;
        }
        if let Some(v) = self.default_value {
            my_size += 1 + 4;
        }
        if let Some(v) = self.max_value {
            my_size += 1 + 4;
        }
        if let Some(v) = self.precision {
            my_size += ::protobuf::rt::int32_size(5, v);
        }
        for value in &self.fallback {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.description.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.fallback_only {
            my_size += 1 + 1;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.tag.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.display_name.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.min_value {
            os.write_float(2, v)?;
        }
        if let Some(v) = self.default_value {
            os.write_float(3, v)?;
        }
        if let Some(v) = self.max_value {
            os.write_float(4, v)?;
        }
        if let Some(v) = self.precision {
            os.write_int32(5, v)?;
        }
        for v in &self.fallback {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        if let Some(v) = self.description.as_ref() {
            os.write_string(8, v)?;
        }
        if let Some(v) = self.fallback_only {
            os.write_bool(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> AxisProto {
        AxisProto::new()
    }

    fn clear(&mut self) {
        self.tag = ::std::option::Option::None;
        self.display_name = ::std::option::Option::None;
        self.min_value = ::std::option::Option::None;
        self.default_value = ::std::option::Option::None;
        self.max_value = ::std::option::Option::None;
        self.precision = ::std::option::Option::None;
        self.fallback.clear();
        self.description = ::std::option::Option::None;
        self.fallback_only = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AxisProto {
        static instance: AxisProto = AxisProto {
            tag: ::std::option::Option::None,
            display_name: ::std::option::Option::None,
            min_value: ::std::option::Option::None,
            default_value: ::std::option::Option::None,
            max_value: ::std::option::Option::None,
            precision: ::std::option::Option::None,
            fallback: ::std::vec::Vec::new(),
            description: ::std::option::Option::None,
            fallback_only: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AxisProto {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AxisProto").unwrap()).clone()
    }
}

impl ::std::fmt::Display for AxisProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for AxisProto {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:FallbackProto)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FallbackProto {
    // message fields
    // @@protoc_insertion_point(field:FallbackProto.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:FallbackProto.value)
    pub value: ::std::option::Option<f32>,
    // @@protoc_insertion_point(field:FallbackProto.display_name)
    pub display_name: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:FallbackProto.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a FallbackProto {
    fn default() -> &'a FallbackProto {
        <FallbackProto as ::protobuf::Message>::default_instance()
    }
}

impl FallbackProto {
    pub fn new() -> FallbackProto {
        ::std::default::Default::default()
    }

    // optional string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional float value = 2;

    pub fn value(&self) -> f32 {
        self.value.unwrap_or(0.)
    }

    pub fn clear_value(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: f32) {
        self.value = ::std::option::Option::Some(v);
    }

    // optional string display_name = 3;

    pub fn display_name(&self) -> &str {
        match self.display_name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_display_name(&mut self) {
        self.display_name = ::std::option::Option::None;
    }

    pub fn has_display_name(&self) -> bool {
        self.display_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_display_name(&mut self, v: ::std::string::String) {
        self.display_name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_display_name(&mut self) -> &mut ::std::string::String {
        if self.display_name.is_none() {
            self.display_name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.display_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_display_name(&mut self) -> ::std::string::String {
        self.display_name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &FallbackProto| { &m.name },
            |m: &mut FallbackProto| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "value",
            |m: &FallbackProto| { &m.value },
            |m: &mut FallbackProto| { &mut m.value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "display_name",
            |m: &FallbackProto| { &m.display_name },
            |m: &mut FallbackProto| { &mut m.display_name },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FallbackProto>(
            "FallbackProto",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for FallbackProto {
    const NAME: &'static str = "FallbackProto";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                21 => {
                    self.value = ::std::option::Option::Some(is.read_float()?);
                },
                26 => {
                    self.display_name = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.value {
            my_size += 1 + 4;
        }
        if let Some(v) = self.display_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.value {
            os.write_float(2, v)?;
        }
        if let Some(v) = self.display_name.as_ref() {
            os.write_string(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> FallbackProto {
        FallbackProto::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.display_name = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FallbackProto {
        static instance: FallbackProto = FallbackProto {
            name: ::std::option::Option::None,
            value: ::std::option::Option::None,
            display_name: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FallbackProto {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("FallbackProto").unwrap()).clone()
    }
}

impl ::std::fmt::Display for FallbackProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for FallbackProto {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\naxes.proto\"\xb0\x02\n\tAxisProto\x12\x10\n\x03tag\x18\x01\x20\x01(\
    \tR\x03tag\x12!\n\x0cdisplay_name\x18\x07\x20\x01(\tR\x0bdisplayName\x12\
    \x1b\n\tmin_value\x18\x02\x20\x01(\x02R\x08minValue\x12#\n\rdefault_valu\
    e\x18\x03\x20\x01(\x02R\x0cdefaultValue\x12\x1b\n\tmax_value\x18\x04\x20\
    \x01(\x02R\x08maxValue\x12\x1c\n\tprecision\x18\x05\x20\x01(\x05R\tpreci\
    sion\x12*\n\x08fallback\x18\x06\x20\x03(\x0b2\x0e.FallbackProtoR\x08fall\
    back\x12\x20\n\x0bdescription\x18\x08\x20\x01(\tR\x0bdescription\x12#\n\
    \rfallback_only\x18\t\x20\x01(\x08R\x0cfallbackOnly\"\\\n\rFallbackProto\
    \x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x14\n\x05value\x18\
    \x02\x20\x01(\x02R\x05value\x12!\n\x0cdisplay_name\x18\x03\x20\x01(\tR\
    \x0bdisplayNameJ\xec\x0b\n\x06\x12\x04\0\0*\x01\n#\n\x01\x0c\x12\x03\0\0\
    \x12\"\x19\x20GF\x20Axis\x20Registry\x20Protos\n\n-\n\x02\x04\0\x12\x04\
    \x04\0$\x01\x1a!\x20An\x20axis\x20in\x20the\x20GF\x20Axis\x20Registry\n\
    \n\n\n\x03\x04\0\x01\x12\x03\x04\x08\x11\n\x17\n\x04\x04\0\x02\0\x12\x03\
    \x06\x02\x1a\x1a\n\x20Axis\x20tag\n\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\
    \x06\x02\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x06\x0b\x11\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03\x06\x12\x15\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\
    \x06\x18\x19\n\xa1\x01\n\x04\x04\0\x02\x01\x12\x03\x0b\x02#\x1a\x93\x01\
    \x20Display\x20name\x20for\x20axis,\x20e.g.\x20\"Optical\x20size\"\x20fo\
    r\x20'opsz'\n\x20Like\x20'Name'\x20in\n\x20https://docs.microsoft.com/en\
    -us/typography/opentype/spec/dvaraxistag_opsz\n\n\x0c\n\x05\x04\0\x02\
    \x01\x04\x12\x03\x0b\x02\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x0b\x0b\
    \x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x0b\x12\x1e\n\x0c\n\x05\x04\0\
    \x02\x01\x03\x12\x03\x0b!\"\n'\n\x04\x04\0\x02\x02\x12\x03\x0e\x02\x1f\
    \x1a\x1a\x20Lower\x20bound\x20for\x20the\x20axis\n\n\x0c\n\x05\x04\0\x02\
    \x02\x04\x12\x03\x0e\x02\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x0e\x0b\
    \x10\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x0e\x11\x1a\n\x0c\n\x05\x04\0\
    \x02\x02\x03\x12\x03\x0e\x1d\x1e\nF\n\x04\x04\0\x02\x03\x12\x03\x11\x02#\
    \x1a9\x20The\x20default\x20position\x20to\x20use\x20and\x20to\x20prefer\
    \x20for\x20exemplars\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03\x11\x02\n\n\
    \x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x11\x0b\x10\n\x0c\n\x05\x04\0\x02\
    \x03\x01\x12\x03\x11\x11\x1e\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x11!\
    \"\n'\n\x04\x04\0\x02\x04\x12\x03\x14\x02\x1f\x1a\x1a\x20Upper\x20bound\
    \x20for\x20the\x20axis\n\n\x0c\n\x05\x04\0\x02\x04\x04\x12\x03\x14\x02\n\
    \n\x0c\n\x05\x04\0\x02\x04\x05\x12\x03\x14\x0b\x10\n\x0c\n\x05\x04\0\x02\
    \x04\x01\x12\x03\x14\x11\x1a\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\x14\
    \x1d\x1e\nF\n\x04\x04\0\x02\x05\x12\x03\x17\x02\x1f\x1a9\x20Input\x20val\
    ues\x20for\x20this\x20axis\x20must\x20aligned\x20to\x2010^precision\n\n\
    \x0c\n\x05\x04\0\x02\x05\x04\x12\x03\x17\x02\n\n\x0c\n\x05\x04\0\x02\x05\
    \x05\x12\x03\x17\x0b\x10\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03\x17\x11\
    \x1a\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03\x17\x1d\x1e\n0\n\x04\x04\0\
    \x02\x06\x12\x03\x1a\x02&\x1a#\x20Fallback\x20positions\x20along\x20the\
    \x20axis\n\n\x0c\n\x05\x04\0\x02\x06\x04\x12\x03\x1a\x02\n\n\x0c\n\x05\
    \x04\0\x02\x06\x06\x12\x03\x1a\x0b\x18\n\x0c\n\x05\x04\0\x02\x06\x01\x12\
    \x03\x1a\x19!\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03\x1a$%\n*\n\x04\x04\0\
    \x02\x07\x12\x03\x1d\x02\"\x1a\x1d\x20Short\x20descriptive\x20paragraph\
    \n\n\x0c\n\x05\x04\0\x02\x07\x04\x12\x03\x1d\x02\n\n\x0c\n\x05\x04\0\x02\
    \x07\x05\x12\x03\x1d\x0b\x11\n\x0c\n\x05\x04\0\x02\x07\x01\x12\x03\x1d\
    \x12\x1d\n\x0c\n\x05\x04\0\x02\x07\x03\x12\x03\x1d\x20!\n\xa5\x01\n\x04\
    \x04\0\x02\x08\x12\x03!\x02\"\x1a\x97\x01\x20Whether\x20only\x20the\x20f\
    allback\x20positions\x20should\x20be\x20used,\x20for\x20example,\x20an\
    \x20axis\n\x20might\x20have\x20only\x20three\x20relevant\x20positions:\
    \x20the\x20min,\x20the\x20middle,\x20and\x20the\x20max.\n\n\x0c\n\x05\
    \x04\0\x02\x08\x04\x12\x03!\x02\n\n\x0c\n\x05\x04\0\x02\x08\x05\x12\x03!\
    \x0b\x0f\n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03!\x10\x1d\n\x0c\n\x05\x04\
    \0\x02\x08\x03\x12\x03!\x20!\n\n\n\x02\x04\x01\x12\x04&\0*\x01\n\n\n\x03\
    \x04\x01\x01\x12\x03&\x08\x15\n\x0b\n\x04\x04\x01\x02\0\x12\x03'\x02\x1b\
    \n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03'\x02\n\n\x0c\n\x05\x04\x01\x02\0\
    \x05\x12\x03'\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03'\x12\x16\n\
    \x0c\n\x05\x04\x01\x02\0\x03\x12\x03'\x19\x1a\n\x0b\n\x04\x04\x01\x02\
    \x01\x12\x03(\x02\x1b\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03(\x02\n\n\
    \x0c\n\x05\x04\x01\x02\x01\x05\x12\x03(\x0b\x10\n\x0c\n\x05\x04\x01\x02\
    \x01\x01\x12\x03(\x11\x16\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03(\x19\
    \x1a\n\x0b\n\x04\x04\x01\x02\x02\x12\x03)\x02#\n\x0c\n\x05\x04\x01\x02\
    \x02\x04\x12\x03)\x02\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03)\x0b\x11\
    \n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03)\x12\x1e\n\x0c\n\x05\x04\x01\
    \x02\x02\x03\x12\x03)!\"\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(0);
            let mut messages = ::std::vec::Vec::with_capacity(2);
            messages.push(AxisProto::generated_message_descriptor_data());
            messages.push(FallbackProto::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}