// This file is generated by rust-protobuf 2.8.0. Do not edit
// @generated

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

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `fts.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

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

#[derive(PartialEq,Clone,Default)]
pub struct FullTextIndexDef {
    // message fields
    pub index_id: i64,
    pub col_id: i64,
    pub parser_type: ::std::string::String,
    pub index_fields: ::protobuf::RepeatedField<FullTextIndexFieldDef>,
    pub initial_field_layout: FtsFieldLayout,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 index_id = 1;


    pub fn get_index_id(&self) -> i64 {
        self.index_id
    }
    pub fn clear_index_id(&mut self) {
        self.index_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_index_id(&mut self, v: i64) {
        self.index_id = v;
    }

    // int64 col_id = 2;


    pub fn get_col_id(&self) -> i64 {
        self.col_id
    }
    pub fn clear_col_id(&mut self) {
        self.col_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_col_id(&mut self, v: i64) {
        self.col_id = v;
    }

    // string parser_type = 10;


    pub fn get_parser_type(&self) -> &str {
        &self.parser_type
    }
    pub fn clear_parser_type(&mut self) {
        self.parser_type.clear();
    }

    // Param is passed by value, moved
    pub fn set_parser_type(&mut self, v: ::std::string::String) {
        self.parser_type = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_parser_type(&mut self) -> &mut ::std::string::String {
        &mut self.parser_type
    }

    // Take field
    pub fn take_parser_type(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.parser_type, ::std::string::String::new())
    }

    // repeated .enginepb.FullTextIndexFieldDef index_fields = 20;


    pub fn get_index_fields(&self) -> &[FullTextIndexFieldDef] {
        &self.index_fields
    }
    pub fn clear_index_fields(&mut self) {
        self.index_fields.clear();
    }

    // Param is passed by value, moved
    pub fn set_index_fields(&mut self, v: ::protobuf::RepeatedField<FullTextIndexFieldDef>) {
        self.index_fields = v;
    }

    // Mutable pointer to the field.
    pub fn mut_index_fields(&mut self) -> &mut ::protobuf::RepeatedField<FullTextIndexFieldDef> {
        &mut self.index_fields
    }

    // Take field
    pub fn take_index_fields(&mut self) -> ::protobuf::RepeatedField<FullTextIndexFieldDef> {
        ::std::mem::replace(&mut self.index_fields, ::protobuf::RepeatedField::new())
    }

    // .enginepb.FtsFieldLayout initial_field_layout = 21;


    pub fn get_initial_field_layout(&self) -> FtsFieldLayout {
        self.initial_field_layout
    }
    pub fn clear_initial_field_layout(&mut self) {
        self.initial_field_layout = FtsFieldLayout::FtsFieldLayoutUnspecified;
    }

    // Param is passed by value, moved
    pub fn set_initial_field_layout(&mut self, v: FtsFieldLayout) {
        self.initial_field_layout = v;
    }
}

impl ::protobuf::Message for FullTextIndexDef {
    fn is_initialized(&self) -> bool {
        for v in &self.index_fields {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index_id = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.col_id = tmp;
                },
                10 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parser_type)?;
                },
                20 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.index_fields)?;
                },
                21 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.initial_field_layout, 21, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.index_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.index_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.col_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.col_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.parser_type.is_empty() {
            my_size += ::protobuf::rt::string_size(10, &self.parser_type);
        }
        for value in &self.index_fields {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.initial_field_layout != FtsFieldLayout::FtsFieldLayoutUnspecified {
            my_size += ::protobuf::rt::enum_size(21, self.initial_field_layout);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.index_id != 0 {
            os.write_int64(1, self.index_id)?;
        }
        if self.col_id != 0 {
            os.write_int64(2, self.col_id)?;
        }
        if !self.parser_type.is_empty() {
            os.write_string(10, &self.parser_type)?;
        }
        for v in &self.index_fields {
            os.write_tag(20, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.initial_field_layout != FtsFieldLayout::FtsFieldLayoutUnspecified {
            os.write_enum(21, self.initial_field_layout.value())?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "index_id",
                    |m: &FullTextIndexDef| { &m.index_id },
                    |m: &mut FullTextIndexDef| { &mut m.index_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "col_id",
                    |m: &FullTextIndexDef| { &m.col_id },
                    |m: &mut FullTextIndexDef| { &mut m.col_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "parser_type",
                    |m: &FullTextIndexDef| { &m.parser_type },
                    |m: &mut FullTextIndexDef| { &mut m.parser_type },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FullTextIndexFieldDef>>(
                    "index_fields",
                    |m: &FullTextIndexDef| { &m.index_fields },
                    |m: &mut FullTextIndexDef| { &mut m.index_fields },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FtsFieldLayout>>(
                    "initial_field_layout",
                    |m: &FullTextIndexDef| { &m.initial_field_layout },
                    |m: &mut FullTextIndexDef| { &mut m.initial_field_layout },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<FullTextIndexDef>(
                    "FullTextIndexDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FullTextIndexDef {
        static mut instance: ::protobuf::lazy::Lazy<FullTextIndexDef> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FullTextIndexDef,
        };
        unsafe {
            instance.get(FullTextIndexDef::new)
        }
    }
}

impl ::protobuf::Clear for FullTextIndexDef {
    fn clear(&mut self) {
        self.index_id = 0;
        self.col_id = 0;
        self.parser_type.clear();
        self.index_fields.clear();
        self.initial_field_layout = FtsFieldLayout::FtsFieldLayoutUnspecified;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for FullTextIndexDef {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", buf);
        ::protobuf::PbPrint::fmt(&self.col_id, "col_id", buf);
        ::protobuf::PbPrint::fmt(&self.parser_type, "parser_type", buf);
        ::protobuf::PbPrint::fmt(&self.index_fields, "index_fields", buf);
        ::protobuf::PbPrint::fmt(&self.initial_field_layout, "initial_field_layout", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for FullTextIndexDef {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.col_id, "col_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.parser_type, "parser_type", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_fields, "index_fields", &mut s);
        ::protobuf::PbPrint::fmt(&self.initial_field_layout, "initial_field_layout", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for FullTextIndexDef {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FullTextIndexFieldDef {
    // message fields
    pub col_id: i64,
    pub index_field_option: ::protobuf::SingularPtrField<FullTextIndexFieldOption>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 col_id = 1;


    pub fn get_col_id(&self) -> i64 {
        self.col_id
    }
    pub fn clear_col_id(&mut self) {
        self.col_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_col_id(&mut self, v: i64) {
        self.col_id = v;
    }

    // .enginepb.FullTextIndexFieldOption index_field_option = 2;


    pub fn get_index_field_option(&self) -> &FullTextIndexFieldOption {
        self.index_field_option.as_ref().unwrap_or_else(|| FullTextIndexFieldOption::default_instance())
    }
    pub fn clear_index_field_option(&mut self) {
        self.index_field_option.clear();
    }

    pub fn has_index_field_option(&self) -> bool {
        self.index_field_option.is_some()
    }

    // Param is passed by value, moved
    pub fn set_index_field_option(&mut self, v: FullTextIndexFieldOption) {
        self.index_field_option = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_index_field_option(&mut self) -> &mut FullTextIndexFieldOption {
        if self.index_field_option.is_none() {
            self.index_field_option.set_default();
        }
        self.index_field_option.as_mut().unwrap()
    }

    // Take field
    pub fn take_index_field_option(&mut self) -> FullTextIndexFieldOption {
        self.index_field_option.take().unwrap_or_else(|| FullTextIndexFieldOption::new())
    }
}

impl ::protobuf::Message for FullTextIndexFieldDef {
    fn is_initialized(&self) -> bool {
        for v in &self.index_field_option {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.col_id = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.index_field_option)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.col_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.col_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.index_field_option.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.col_id != 0 {
            os.write_int64(1, self.col_id)?;
        }
        if let Some(ref v) = self.index_field_option.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "col_id",
                    |m: &FullTextIndexFieldDef| { &m.col_id },
                    |m: &mut FullTextIndexFieldDef| { &mut m.col_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FullTextIndexFieldOption>>(
                    "index_field_option",
                    |m: &FullTextIndexFieldDef| { &m.index_field_option },
                    |m: &mut FullTextIndexFieldDef| { &mut m.index_field_option },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<FullTextIndexFieldDef>(
                    "FullTextIndexFieldDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FullTextIndexFieldDef {
        static mut instance: ::protobuf::lazy::Lazy<FullTextIndexFieldDef> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FullTextIndexFieldDef,
        };
        unsafe {
            instance.get(FullTextIndexFieldDef::new)
        }
    }
}

impl ::protobuf::Clear for FullTextIndexFieldDef {
    fn clear(&mut self) {
        self.col_id = 0;
        self.index_field_option.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for FullTextIndexFieldDef {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.col_id, "col_id", buf);
        ::protobuf::PbPrint::fmt(&self.index_field_option, "index_field_option", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for FullTextIndexFieldDef {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.col_id, "col_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_field_option, "index_field_option", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for FullTextIndexFieldDef {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FullTextIndexFieldOption {
    // message fields
    pub analyzer_type: FullTextAnalyzerType,
    pub enable_bm25: bool,
    // message oneof groups
    pub extra_option: ::std::option::Option<FullTextIndexFieldOption_oneof_extra_option>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq)]
pub enum FullTextIndexFieldOption_oneof_extra_option {
    Ngram(NgramOption),
    PathHierarchy(PathHierarchyOption),
}

impl ::protobuf::PbPrint for FullTextIndexFieldOption_oneof_extra_option {
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        match self {
            FullTextIndexFieldOption_oneof_extra_option::Ngram(v) => ::protobuf::PbPrint::fmt(v, name, buf),
            FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(v) => ::protobuf::PbPrint::fmt(v, name, buf),
        }
    }
}

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

    // .enginepb.FullTextAnalyzerType analyzer_type = 1;


    pub fn get_analyzer_type(&self) -> FullTextAnalyzerType {
        self.analyzer_type
    }
    pub fn clear_analyzer_type(&mut self) {
        self.analyzer_type = FullTextAnalyzerType::FtsAnalyzerUnspecified;
    }

    // Param is passed by value, moved
    pub fn set_analyzer_type(&mut self, v: FullTextAnalyzerType) {
        self.analyzer_type = v;
    }

    // bool enable_bm25 = 2;


    pub fn get_enable_bm25(&self) -> bool {
        self.enable_bm25
    }
    pub fn clear_enable_bm25(&mut self) {
        self.enable_bm25 = false;
    }

    // Param is passed by value, moved
    pub fn set_enable_bm25(&mut self, v: bool) {
        self.enable_bm25 = v;
    }

    // .enginepb.NgramOption ngram = 3;


    pub fn get_ngram(&self) -> &NgramOption {
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(ref v)) => v,
            _ => NgramOption::default_instance(),
        }
    }
    pub fn clear_ngram(&mut self) {
        self.extra_option = ::std::option::Option::None;
    }

    pub fn has_ngram(&self) -> bool {
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_ngram(&mut self, v: NgramOption) {
        self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(v))
    }

    // Mutable pointer to the field.
    pub fn mut_ngram(&mut self) -> &mut NgramOption {
        if let ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(_)) = self.extra_option {
        } else {
            self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(NgramOption::new()));
        }
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_ngram(&mut self) -> NgramOption {
        if self.has_ngram() {
            match self.extra_option.take() {
                ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(v)) => v,
                _ => panic!(),
            }
        } else {
            NgramOption::new()
        }
    }

    // .enginepb.PathHierarchyOption path_hierarchy = 4;


    pub fn get_path_hierarchy(&self) -> &PathHierarchyOption {
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(ref v)) => v,
            _ => PathHierarchyOption::default_instance(),
        }
    }
    pub fn clear_path_hierarchy(&mut self) {
        self.extra_option = ::std::option::Option::None;
    }

    pub fn has_path_hierarchy(&self) -> bool {
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_path_hierarchy(&mut self, v: PathHierarchyOption) {
        self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(v))
    }

    // Mutable pointer to the field.
    pub fn mut_path_hierarchy(&mut self) -> &mut PathHierarchyOption {
        if let ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(_)) = self.extra_option {
        } else {
            self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(PathHierarchyOption::new()));
        }
        match self.extra_option {
            ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_path_hierarchy(&mut self) -> PathHierarchyOption {
        if self.has_path_hierarchy() {
            match self.extra_option.take() {
                ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(v)) => v,
                _ => panic!(),
            }
        } else {
            PathHierarchyOption::new()
        }
    }
}

impl ::protobuf::Message for FullTextIndexFieldOption {
    fn is_initialized(&self) -> bool {
        if let Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(ref v)) = self.extra_option {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(ref v)) = self.extra_option {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.analyzer_type, 1, &mut self.unknown_fields)?
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.enable_bm25 = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::Ngram(is.read_message()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.extra_option = ::std::option::Option::Some(FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.analyzer_type != FullTextAnalyzerType::FtsAnalyzerUnspecified {
            my_size += ::protobuf::rt::enum_size(1, self.analyzer_type);
        }
        if self.enable_bm25 != false {
            my_size += 2;
        }
        if let ::std::option::Option::Some(ref v) = self.extra_option {
            match v {
                &FullTextIndexFieldOption_oneof_extra_option::Ngram(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.analyzer_type != FullTextAnalyzerType::FtsAnalyzerUnspecified {
            os.write_enum(1, self.analyzer_type.value())?;
        }
        if self.enable_bm25 != false {
            os.write_bool(2, self.enable_bm25)?;
        }
        if let ::std::option::Option::Some(ref v) = self.extra_option {
            match v {
                &FullTextIndexFieldOption_oneof_extra_option::Ngram(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &FullTextIndexFieldOption_oneof_extra_option::PathHierarchy(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FullTextAnalyzerType>>(
                    "analyzer_type",
                    |m: &FullTextIndexFieldOption| { &m.analyzer_type },
                    |m: &mut FullTextIndexFieldOption| { &mut m.analyzer_type },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "enable_bm25",
                    |m: &FullTextIndexFieldOption| { &m.enable_bm25 },
                    |m: &mut FullTextIndexFieldOption| { &mut m.enable_bm25 },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, NgramOption>(
                    "ngram",
                    FullTextIndexFieldOption::has_ngram,
                    FullTextIndexFieldOption::get_ngram,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, PathHierarchyOption>(
                    "path_hierarchy",
                    FullTextIndexFieldOption::has_path_hierarchy,
                    FullTextIndexFieldOption::get_path_hierarchy,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<FullTextIndexFieldOption>(
                    "FullTextIndexFieldOption",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FullTextIndexFieldOption {
        static mut instance: ::protobuf::lazy::Lazy<FullTextIndexFieldOption> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FullTextIndexFieldOption,
        };
        unsafe {
            instance.get(FullTextIndexFieldOption::new)
        }
    }
}

impl ::protobuf::Clear for FullTextIndexFieldOption {
    fn clear(&mut self) {
        self.analyzer_type = FullTextAnalyzerType::FtsAnalyzerUnspecified;
        self.enable_bm25 = false;
        self.extra_option = ::std::option::Option::None;
        self.extra_option = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for FullTextIndexFieldOption {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.analyzer_type, "analyzer_type", buf);
        ::protobuf::PbPrint::fmt(&self.enable_bm25, "enable_bm25", buf);
        ::protobuf::PbPrint::fmt(&self.extra_option, "extra_option", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for FullTextIndexFieldOption {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.analyzer_type, "analyzer_type", &mut s);
        ::protobuf::PbPrint::fmt(&self.enable_bm25, "enable_bm25", &mut s);
        ::protobuf::PbPrint::fmt(&self.extra_option, "extra_option", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for FullTextIndexFieldOption {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct NgramOption {
    // message fields
    pub min_gram: u64,
    pub max_gram: u64,
    pub granularity: ::std::string::String,
    pub lower_case: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 min_gram = 1;


    pub fn get_min_gram(&self) -> u64 {
        self.min_gram
    }
    pub fn clear_min_gram(&mut self) {
        self.min_gram = 0;
    }

    // Param is passed by value, moved
    pub fn set_min_gram(&mut self, v: u64) {
        self.min_gram = v;
    }

    // uint64 max_gram = 2;


    pub fn get_max_gram(&self) -> u64 {
        self.max_gram
    }
    pub fn clear_max_gram(&mut self) {
        self.max_gram = 0;
    }

    // Param is passed by value, moved
    pub fn set_max_gram(&mut self, v: u64) {
        self.max_gram = v;
    }

    // string granularity = 3;


    pub fn get_granularity(&self) -> &str {
        &self.granularity
    }
    pub fn clear_granularity(&mut self) {
        self.granularity.clear();
    }

    // Param is passed by value, moved
    pub fn set_granularity(&mut self, v: ::std::string::String) {
        self.granularity = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_granularity(&mut self) -> &mut ::std::string::String {
        &mut self.granularity
    }

    // Take field
    pub fn take_granularity(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.granularity, ::std::string::String::new())
    }

    // bool lower_case = 4;


    pub fn get_lower_case(&self) -> bool {
        self.lower_case
    }
    pub fn clear_lower_case(&mut self) {
        self.lower_case = false;
    }

    // Param is passed by value, moved
    pub fn set_lower_case(&mut self, v: bool) {
        self.lower_case = v;
    }
}

impl ::protobuf::Message for NgramOption {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.min_gram = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.max_gram = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.granularity)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.lower_case = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.min_gram != 0 {
            my_size += ::protobuf::rt::value_size(1, self.min_gram, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.max_gram != 0 {
            my_size += ::protobuf::rt::value_size(2, self.max_gram, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.granularity.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.granularity);
        }
        if self.lower_case != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.min_gram != 0 {
            os.write_uint64(1, self.min_gram)?;
        }
        if self.max_gram != 0 {
            os.write_uint64(2, self.max_gram)?;
        }
        if !self.granularity.is_empty() {
            os.write_string(3, &self.granularity)?;
        }
        if self.lower_case != false {
            os.write_bool(4, self.lower_case)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "min_gram",
                    |m: &NgramOption| { &m.min_gram },
                    |m: &mut NgramOption| { &mut m.min_gram },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "max_gram",
                    |m: &NgramOption| { &m.max_gram },
                    |m: &mut NgramOption| { &mut m.max_gram },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "granularity",
                    |m: &NgramOption| { &m.granularity },
                    |m: &mut NgramOption| { &mut m.granularity },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "lower_case",
                    |m: &NgramOption| { &m.lower_case },
                    |m: &mut NgramOption| { &mut m.lower_case },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<NgramOption>(
                    "NgramOption",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NgramOption {
        static mut instance: ::protobuf::lazy::Lazy<NgramOption> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const NgramOption,
        };
        unsafe {
            instance.get(NgramOption::new)
        }
    }
}

impl ::protobuf::Clear for NgramOption {
    fn clear(&mut self) {
        self.min_gram = 0;
        self.max_gram = 0;
        self.granularity.clear();
        self.lower_case = false;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for NgramOption {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.min_gram, "min_gram", buf);
        ::protobuf::PbPrint::fmt(&self.max_gram, "max_gram", buf);
        ::protobuf::PbPrint::fmt(&self.granularity, "granularity", buf);
        ::protobuf::PbPrint::fmt(&self.lower_case, "lower_case", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for NgramOption {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.min_gram, "min_gram", &mut s);
        ::protobuf::PbPrint::fmt(&self.max_gram, "max_gram", &mut s);
        ::protobuf::PbPrint::fmt(&self.granularity, "granularity", &mut s);
        ::protobuf::PbPrint::fmt(&self.lower_case, "lower_case", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for NgramOption {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PathHierarchyOption {
    // message fields
    pub delimiter: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string delimiter = 1;


    pub fn get_delimiter(&self) -> &str {
        &self.delimiter
    }
    pub fn clear_delimiter(&mut self) {
        self.delimiter.clear();
    }

    // Param is passed by value, moved
    pub fn set_delimiter(&mut self, v: ::std::string::String) {
        self.delimiter = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_delimiter(&mut self) -> &mut ::std::string::String {
        &mut self.delimiter
    }

    // Take field
    pub fn take_delimiter(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.delimiter, ::std::string::String::new())
    }
}

impl ::protobuf::Message for PathHierarchyOption {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.delimiter)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.delimiter.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.delimiter);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.delimiter.is_empty() {
            os.write_string(1, &self.delimiter)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "delimiter",
                    |m: &PathHierarchyOption| { &m.delimiter },
                    |m: &mut PathHierarchyOption| { &mut m.delimiter },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<PathHierarchyOption>(
                    "PathHierarchyOption",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PathHierarchyOption {
        static mut instance: ::protobuf::lazy::Lazy<PathHierarchyOption> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PathHierarchyOption,
        };
        unsafe {
            instance.get(PathHierarchyOption::new)
        }
    }
}

impl ::protobuf::Clear for PathHierarchyOption {
    fn clear(&mut self) {
        self.delimiter.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for PathHierarchyOption {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.delimiter, "delimiter", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for PathHierarchyOption {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.delimiter, "delimiter", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for PathHierarchyOption {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PackedFileIndexBlock {
    // message fields
    pub data_block_start_keys: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    pub data_block_offsets: ::std::vec::Vec<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated bytes data_block_start_keys = 1;


    pub fn get_data_block_start_keys(&self) -> &[::std::vec::Vec<u8>] {
        &self.data_block_start_keys
    }
    pub fn clear_data_block_start_keys(&mut self) {
        self.data_block_start_keys.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_block_start_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
        self.data_block_start_keys = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_block_start_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.data_block_start_keys
    }

    // Take field
    pub fn take_data_block_start_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.data_block_start_keys, ::protobuf::RepeatedField::new())
    }

    // repeated uint32 data_block_offsets = 2;


    pub fn get_data_block_offsets(&self) -> &[u32] {
        &self.data_block_offsets
    }
    pub fn clear_data_block_offsets(&mut self) {
        self.data_block_offsets.clear();
    }

    // Param is passed by value, moved
    pub fn set_data_block_offsets(&mut self, v: ::std::vec::Vec<u32>) {
        self.data_block_offsets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_data_block_offsets(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.data_block_offsets
    }

    // Take field
    pub fn take_data_block_offsets(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.data_block_offsets, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for PackedFileIndexBlock {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.data_block_start_keys)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.data_block_offsets)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.data_block_start_keys {
            my_size += ::protobuf::rt::bytes_size(1, &value);
        };
        for value in &self.data_block_offsets {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.data_block_start_keys {
            os.write_bytes(1, &v)?;
        };
        for v in &self.data_block_offsets {
            os.write_uint32(2, *v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "data_block_start_keys",
                    |m: &PackedFileIndexBlock| { &m.data_block_start_keys },
                    |m: &mut PackedFileIndexBlock| { &mut m.data_block_start_keys },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "data_block_offsets",
                    |m: &PackedFileIndexBlock| { &m.data_block_offsets },
                    |m: &mut PackedFileIndexBlock| { &mut m.data_block_offsets },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<PackedFileIndexBlock>(
                    "PackedFileIndexBlock",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PackedFileIndexBlock {
        static mut instance: ::protobuf::lazy::Lazy<PackedFileIndexBlock> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PackedFileIndexBlock,
        };
        unsafe {
            instance.get(PackedFileIndexBlock::new)
        }
    }
}

impl ::protobuf::Clear for PackedFileIndexBlock {
    fn clear(&mut self) {
        self.data_block_start_keys.clear();
        self.data_block_offsets.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for PackedFileIndexBlock {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.data_block_start_keys, "data_block_start_keys", buf);
        ::protobuf::PbPrint::fmt(&self.data_block_offsets, "data_block_offsets", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for PackedFileIndexBlock {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.data_block_start_keys, "data_block_start_keys", &mut s);
        ::protobuf::PbPrint::fmt(&self.data_block_offsets, "data_block_offsets", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for PackedFileIndexBlock {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PackedFilePropBlock {
    // message fields
    pub smallest_lp_key: ::std::vec::Vec<u8>,
    pub largest_lp_key: ::std::vec::Vec<u8>,
    pub total_lps: u32,
    pub total_index_bytes: u32,
    pub total_keys_bytes: u32,
    pub smallest_key: ::std::vec::Vec<u8>,
    pub biggest_key: ::std::vec::Vec<u8>,
    pub table_ids: ::std::vec::Vec<i64>,
    pub pk_total: u64,
    pub pk_live_unique: u64,
    pub smallest_table_index: ::protobuf::SingularPtrField<TableIndexId>,
    pub largest_table_index: ::protobuf::SingularPtrField<TableIndexId>,
    pub snap_version: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes smallest_lp_key = 1;


    pub fn get_smallest_lp_key(&self) -> &[u8] {
        &self.smallest_lp_key
    }
    pub fn clear_smallest_lp_key(&mut self) {
        self.smallest_lp_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_smallest_lp_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.smallest_lp_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_smallest_lp_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.smallest_lp_key
    }

    // Take field
    pub fn take_smallest_lp_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.smallest_lp_key, ::std::vec::Vec::new())
    }

    // bytes largest_lp_key = 2;


    pub fn get_largest_lp_key(&self) -> &[u8] {
        &self.largest_lp_key
    }
    pub fn clear_largest_lp_key(&mut self) {
        self.largest_lp_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_largest_lp_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.largest_lp_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_largest_lp_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.largest_lp_key
    }

    // Take field
    pub fn take_largest_lp_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.largest_lp_key, ::std::vec::Vec::new())
    }

    // uint32 total_lps = 3;


    pub fn get_total_lps(&self) -> u32 {
        self.total_lps
    }
    pub fn clear_total_lps(&mut self) {
        self.total_lps = 0;
    }

    // Param is passed by value, moved
    pub fn set_total_lps(&mut self, v: u32) {
        self.total_lps = v;
    }

    // uint32 total_index_bytes = 4;


    pub fn get_total_index_bytes(&self) -> u32 {
        self.total_index_bytes
    }
    pub fn clear_total_index_bytes(&mut self) {
        self.total_index_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_total_index_bytes(&mut self, v: u32) {
        self.total_index_bytes = v;
    }

    // uint32 total_keys_bytes = 5;


    pub fn get_total_keys_bytes(&self) -> u32 {
        self.total_keys_bytes
    }
    pub fn clear_total_keys_bytes(&mut self) {
        self.total_keys_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_total_keys_bytes(&mut self, v: u32) {
        self.total_keys_bytes = v;
    }

    // bytes smallest_key = 6;


    pub fn get_smallest_key(&self) -> &[u8] {
        &self.smallest_key
    }
    pub fn clear_smallest_key(&mut self) {
        self.smallest_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_smallest_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.smallest_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_smallest_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.smallest_key
    }

    // Take field
    pub fn take_smallest_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.smallest_key, ::std::vec::Vec::new())
    }

    // bytes biggest_key = 7;


    pub fn get_biggest_key(&self) -> &[u8] {
        &self.biggest_key
    }
    pub fn clear_biggest_key(&mut self) {
        self.biggest_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_biggest_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.biggest_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_biggest_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.biggest_key
    }

    // Take field
    pub fn take_biggest_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.biggest_key, ::std::vec::Vec::new())
    }

    // repeated int64 table_ids = 8;


    pub fn get_table_ids(&self) -> &[i64] {
        &self.table_ids
    }
    pub fn clear_table_ids(&mut self) {
        self.table_ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_ids(&mut self, v: ::std::vec::Vec<i64>) {
        self.table_ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_table_ids(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.table_ids
    }

    // Take field
    pub fn take_table_ids(&mut self) -> ::std::vec::Vec<i64> {
        ::std::mem::replace(&mut self.table_ids, ::std::vec::Vec::new())
    }

    // uint64 pk_total = 9;


    pub fn get_pk_total(&self) -> u64 {
        self.pk_total
    }
    pub fn clear_pk_total(&mut self) {
        self.pk_total = 0;
    }

    // Param is passed by value, moved
    pub fn set_pk_total(&mut self, v: u64) {
        self.pk_total = v;
    }

    // uint64 pk_live_unique = 10;


    pub fn get_pk_live_unique(&self) -> u64 {
        self.pk_live_unique
    }
    pub fn clear_pk_live_unique(&mut self) {
        self.pk_live_unique = 0;
    }

    // Param is passed by value, moved
    pub fn set_pk_live_unique(&mut self, v: u64) {
        self.pk_live_unique = v;
    }

    // .enginepb.TableIndexId smallest_table_index = 11;


    pub fn get_smallest_table_index(&self) -> &TableIndexId {
        self.smallest_table_index.as_ref().unwrap_or_else(|| TableIndexId::default_instance())
    }
    pub fn clear_smallest_table_index(&mut self) {
        self.smallest_table_index.clear();
    }

    pub fn has_smallest_table_index(&self) -> bool {
        self.smallest_table_index.is_some()
    }

    // Param is passed by value, moved
    pub fn set_smallest_table_index(&mut self, v: TableIndexId) {
        self.smallest_table_index = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_smallest_table_index(&mut self) -> &mut TableIndexId {
        if self.smallest_table_index.is_none() {
            self.smallest_table_index.set_default();
        }
        self.smallest_table_index.as_mut().unwrap()
    }

    // Take field
    pub fn take_smallest_table_index(&mut self) -> TableIndexId {
        self.smallest_table_index.take().unwrap_or_else(|| TableIndexId::new())
    }

    // .enginepb.TableIndexId largest_table_index = 12;


    pub fn get_largest_table_index(&self) -> &TableIndexId {
        self.largest_table_index.as_ref().unwrap_or_else(|| TableIndexId::default_instance())
    }
    pub fn clear_largest_table_index(&mut self) {
        self.largest_table_index.clear();
    }

    pub fn has_largest_table_index(&self) -> bool {
        self.largest_table_index.is_some()
    }

    // Param is passed by value, moved
    pub fn set_largest_table_index(&mut self, v: TableIndexId) {
        self.largest_table_index = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_largest_table_index(&mut self) -> &mut TableIndexId {
        if self.largest_table_index.is_none() {
            self.largest_table_index.set_default();
        }
        self.largest_table_index.as_mut().unwrap()
    }

    // Take field
    pub fn take_largest_table_index(&mut self) -> TableIndexId {
        self.largest_table_index.take().unwrap_or_else(|| TableIndexId::new())
    }

    // uint64 snap_version = 13;


    pub fn get_snap_version(&self) -> u64 {
        self.snap_version
    }
    pub fn clear_snap_version(&mut self) {
        self.snap_version = 0;
    }

    // Param is passed by value, moved
    pub fn set_snap_version(&mut self, v: u64) {
        self.snap_version = v;
    }
}

impl ::protobuf::Message for PackedFilePropBlock {
    fn is_initialized(&self) -> bool {
        for v in &self.smallest_table_index {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.largest_table_index {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.smallest_lp_key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.largest_lp_key)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.total_lps = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.total_index_bytes = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.total_keys_bytes = tmp;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.smallest_key)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.biggest_key)?;
                },
                8 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.table_ids)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.pk_total = tmp;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.pk_live_unique = tmp;
                },
                11 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.smallest_table_index)?;
                },
                12 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.largest_table_index)?;
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.snap_version = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.smallest_lp_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.smallest_lp_key);
        }
        if !self.largest_lp_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.largest_lp_key);
        }
        if self.total_lps != 0 {
            my_size += ::protobuf::rt::value_size(3, self.total_lps, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.total_index_bytes != 0 {
            my_size += ::protobuf::rt::value_size(4, self.total_index_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.total_keys_bytes != 0 {
            my_size += ::protobuf::rt::value_size(5, self.total_keys_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.smallest_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.smallest_key);
        }
        if !self.biggest_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(7, &self.biggest_key);
        }
        for value in &self.table_ids {
            my_size += ::protobuf::rt::value_size(8, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if self.pk_total != 0 {
            my_size += ::protobuf::rt::value_size(9, self.pk_total, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.pk_live_unique != 0 {
            my_size += ::protobuf::rt::value_size(10, self.pk_live_unique, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.smallest_table_index.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.largest_table_index.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.snap_version != 0 {
            my_size += ::protobuf::rt::value_size(13, self.snap_version, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.smallest_lp_key.is_empty() {
            os.write_bytes(1, &self.smallest_lp_key)?;
        }
        if !self.largest_lp_key.is_empty() {
            os.write_bytes(2, &self.largest_lp_key)?;
        }
        if self.total_lps != 0 {
            os.write_uint32(3, self.total_lps)?;
        }
        if self.total_index_bytes != 0 {
            os.write_uint32(4, self.total_index_bytes)?;
        }
        if self.total_keys_bytes != 0 {
            os.write_uint32(5, self.total_keys_bytes)?;
        }
        if !self.smallest_key.is_empty() {
            os.write_bytes(6, &self.smallest_key)?;
        }
        if !self.biggest_key.is_empty() {
            os.write_bytes(7, &self.biggest_key)?;
        }
        for v in &self.table_ids {
            os.write_int64(8, *v)?;
        };
        if self.pk_total != 0 {
            os.write_uint64(9, self.pk_total)?;
        }
        if self.pk_live_unique != 0 {
            os.write_uint64(10, self.pk_live_unique)?;
        }
        if let Some(ref v) = self.smallest_table_index.as_ref() {
            os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.largest_table_index.as_ref() {
            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.snap_version != 0 {
            os.write_uint64(13, self.snap_version)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "smallest_lp_key",
                    |m: &PackedFilePropBlock| { &m.smallest_lp_key },
                    |m: &mut PackedFilePropBlock| { &mut m.smallest_lp_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "largest_lp_key",
                    |m: &PackedFilePropBlock| { &m.largest_lp_key },
                    |m: &mut PackedFilePropBlock| { &mut m.largest_lp_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "total_lps",
                    |m: &PackedFilePropBlock| { &m.total_lps },
                    |m: &mut PackedFilePropBlock| { &mut m.total_lps },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "total_index_bytes",
                    |m: &PackedFilePropBlock| { &m.total_index_bytes },
                    |m: &mut PackedFilePropBlock| { &mut m.total_index_bytes },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "total_keys_bytes",
                    |m: &PackedFilePropBlock| { &m.total_keys_bytes },
                    |m: &mut PackedFilePropBlock| { &mut m.total_keys_bytes },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "smallest_key",
                    |m: &PackedFilePropBlock| { &m.smallest_key },
                    |m: &mut PackedFilePropBlock| { &mut m.smallest_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "biggest_key",
                    |m: &PackedFilePropBlock| { &m.biggest_key },
                    |m: &mut PackedFilePropBlock| { &mut m.biggest_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "table_ids",
                    |m: &PackedFilePropBlock| { &m.table_ids },
                    |m: &mut PackedFilePropBlock| { &mut m.table_ids },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "pk_total",
                    |m: &PackedFilePropBlock| { &m.pk_total },
                    |m: &mut PackedFilePropBlock| { &mut m.pk_total },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "pk_live_unique",
                    |m: &PackedFilePropBlock| { &m.pk_live_unique },
                    |m: &mut PackedFilePropBlock| { &mut m.pk_live_unique },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TableIndexId>>(
                    "smallest_table_index",
                    |m: &PackedFilePropBlock| { &m.smallest_table_index },
                    |m: &mut PackedFilePropBlock| { &mut m.smallest_table_index },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TableIndexId>>(
                    "largest_table_index",
                    |m: &PackedFilePropBlock| { &m.largest_table_index },
                    |m: &mut PackedFilePropBlock| { &mut m.largest_table_index },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "snap_version",
                    |m: &PackedFilePropBlock| { &m.snap_version },
                    |m: &mut PackedFilePropBlock| { &mut m.snap_version },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<PackedFilePropBlock>(
                    "PackedFilePropBlock",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PackedFilePropBlock {
        static mut instance: ::protobuf::lazy::Lazy<PackedFilePropBlock> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PackedFilePropBlock,
        };
        unsafe {
            instance.get(PackedFilePropBlock::new)
        }
    }
}

impl ::protobuf::Clear for PackedFilePropBlock {
    fn clear(&mut self) {
        self.smallest_lp_key.clear();
        self.largest_lp_key.clear();
        self.total_lps = 0;
        self.total_index_bytes = 0;
        self.total_keys_bytes = 0;
        self.smallest_key.clear();
        self.biggest_key.clear();
        self.table_ids.clear();
        self.pk_total = 0;
        self.pk_live_unique = 0;
        self.smallest_table_index.clear();
        self.largest_table_index.clear();
        self.snap_version = 0;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for PackedFilePropBlock {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.smallest_lp_key, "smallest_lp_key", buf);
        ::protobuf::PbPrint::fmt(&self.largest_lp_key, "largest_lp_key", buf);
        ::protobuf::PbPrint::fmt(&self.total_lps, "total_lps", buf);
        ::protobuf::PbPrint::fmt(&self.total_index_bytes, "total_index_bytes", buf);
        ::protobuf::PbPrint::fmt(&self.total_keys_bytes, "total_keys_bytes", buf);
        ::protobuf::PbPrint::fmt(&self.smallest_key, "smallest_key", buf);
        ::protobuf::PbPrint::fmt(&self.biggest_key, "biggest_key", buf);
        ::protobuf::PbPrint::fmt(&self.table_ids, "table_ids", buf);
        ::protobuf::PbPrint::fmt(&self.pk_total, "pk_total", buf);
        ::protobuf::PbPrint::fmt(&self.pk_live_unique, "pk_live_unique", buf);
        ::protobuf::PbPrint::fmt(&self.smallest_table_index, "smallest_table_index", buf);
        ::protobuf::PbPrint::fmt(&self.largest_table_index, "largest_table_index", buf);
        ::protobuf::PbPrint::fmt(&self.snap_version, "snap_version", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for PackedFilePropBlock {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.smallest_lp_key, "smallest_lp_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.largest_lp_key, "largest_lp_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.total_lps, "total_lps", &mut s);
        ::protobuf::PbPrint::fmt(&self.total_index_bytes, "total_index_bytes", &mut s);
        ::protobuf::PbPrint::fmt(&self.total_keys_bytes, "total_keys_bytes", &mut s);
        ::protobuf::PbPrint::fmt(&self.smallest_key, "smallest_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.biggest_key, "biggest_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.table_ids, "table_ids", &mut s);
        ::protobuf::PbPrint::fmt(&self.pk_total, "pk_total", &mut s);
        ::protobuf::PbPrint::fmt(&self.pk_live_unique, "pk_live_unique", &mut s);
        ::protobuf::PbPrint::fmt(&self.smallest_table_index, "smallest_table_index", &mut s);
        ::protobuf::PbPrint::fmt(&self.largest_table_index, "largest_table_index", &mut s);
        ::protobuf::PbPrint::fmt(&self.snap_version, "snap_version", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for PackedFilePropBlock {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PackedFileLpProps {
    // message fields
    pub n_pk: u32,
    pub is_int_handle: bool,
    pub table_id: i64,
    pub index_id: i64,
    pub tantivy_layout: ::protobuf::SingularPtrField<TantivyIndexLayout>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint32 n_pk = 1;


    pub fn get_n_pk(&self) -> u32 {
        self.n_pk
    }
    pub fn clear_n_pk(&mut self) {
        self.n_pk = 0;
    }

    // Param is passed by value, moved
    pub fn set_n_pk(&mut self, v: u32) {
        self.n_pk = v;
    }

    // bool is_int_handle = 2;


    pub fn get_is_int_handle(&self) -> bool {
        self.is_int_handle
    }
    pub fn clear_is_int_handle(&mut self) {
        self.is_int_handle = false;
    }

    // Param is passed by value, moved
    pub fn set_is_int_handle(&mut self, v: bool) {
        self.is_int_handle = v;
    }

    // int64 table_id = 3;


    pub fn get_table_id(&self) -> i64 {
        self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_table_id(&mut self, v: i64) {
        self.table_id = v;
    }

    // int64 index_id = 4;


    pub fn get_index_id(&self) -> i64 {
        self.index_id
    }
    pub fn clear_index_id(&mut self) {
        self.index_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_index_id(&mut self, v: i64) {
        self.index_id = v;
    }

    // .enginepb.TantivyIndexLayout tantivy_layout = 5;


    pub fn get_tantivy_layout(&self) -> &TantivyIndexLayout {
        self.tantivy_layout.as_ref().unwrap_or_else(|| TantivyIndexLayout::default_instance())
    }
    pub fn clear_tantivy_layout(&mut self) {
        self.tantivy_layout.clear();
    }

    pub fn has_tantivy_layout(&self) -> bool {
        self.tantivy_layout.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tantivy_layout(&mut self, v: TantivyIndexLayout) {
        self.tantivy_layout = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tantivy_layout(&mut self) -> &mut TantivyIndexLayout {
        if self.tantivy_layout.is_none() {
            self.tantivy_layout.set_default();
        }
        self.tantivy_layout.as_mut().unwrap()
    }

    // Take field
    pub fn take_tantivy_layout(&mut self) -> TantivyIndexLayout {
        self.tantivy_layout.take().unwrap_or_else(|| TantivyIndexLayout::new())
    }
}

impl ::protobuf::Message for PackedFileLpProps {
    fn is_initialized(&self) -> bool {
        for v in &self.tantivy_layout {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.n_pk = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_int_handle = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.table_id = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index_id = tmp;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tantivy_layout)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.n_pk != 0 {
            my_size += ::protobuf::rt::value_size(1, self.n_pk, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.is_int_handle != false {
            my_size += 2;
        }
        if self.table_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.table_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.index_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.index_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.tantivy_layout.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.n_pk != 0 {
            os.write_uint32(1, self.n_pk)?;
        }
        if self.is_int_handle != false {
            os.write_bool(2, self.is_int_handle)?;
        }
        if self.table_id != 0 {
            os.write_int64(3, self.table_id)?;
        }
        if self.index_id != 0 {
            os.write_int64(4, self.index_id)?;
        }
        if let Some(ref v) = self.tantivy_layout.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "n_pk",
                    |m: &PackedFileLpProps| { &m.n_pk },
                    |m: &mut PackedFileLpProps| { &mut m.n_pk },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "is_int_handle",
                    |m: &PackedFileLpProps| { &m.is_int_handle },
                    |m: &mut PackedFileLpProps| { &mut m.is_int_handle },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "table_id",
                    |m: &PackedFileLpProps| { &m.table_id },
                    |m: &mut PackedFileLpProps| { &mut m.table_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "index_id",
                    |m: &PackedFileLpProps| { &m.index_id },
                    |m: &mut PackedFileLpProps| { &mut m.index_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TantivyIndexLayout>>(
                    "tantivy_layout",
                    |m: &PackedFileLpProps| { &m.tantivy_layout },
                    |m: &mut PackedFileLpProps| { &mut m.tantivy_layout },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<PackedFileLpProps>(
                    "PackedFileLpProps",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PackedFileLpProps {
        static mut instance: ::protobuf::lazy::Lazy<PackedFileLpProps> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PackedFileLpProps,
        };
        unsafe {
            instance.get(PackedFileLpProps::new)
        }
    }
}

impl ::protobuf::Clear for PackedFileLpProps {
    fn clear(&mut self) {
        self.n_pk = 0;
        self.is_int_handle = false;
        self.table_id = 0;
        self.index_id = 0;
        self.tantivy_layout.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for PackedFileLpProps {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.n_pk, "n_pk", buf);
        ::protobuf::PbPrint::fmt(&self.is_int_handle, "is_int_handle", buf);
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", buf);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", buf);
        ::protobuf::PbPrint::fmt(&self.tantivy_layout, "tantivy_layout", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for PackedFileLpProps {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.n_pk, "n_pk", &mut s);
        ::protobuf::PbPrint::fmt(&self.is_int_handle, "is_int_handle", &mut s);
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.tantivy_layout, "tantivy_layout", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for PackedFileLpProps {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TableIndexId {
    // message fields
    pub table_id: i64,
    pub index_id: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 table_id = 1;


    pub fn get_table_id(&self) -> i64 {
        self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_table_id(&mut self, v: i64) {
        self.table_id = v;
    }

    // int64 index_id = 2;


    pub fn get_index_id(&self) -> i64 {
        self.index_id
    }
    pub fn clear_index_id(&mut self) {
        self.index_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_index_id(&mut self, v: i64) {
        self.index_id = v;
    }
}

impl ::protobuf::Message for TableIndexId {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.table_id = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index_id = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.table_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.table_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.index_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.index_id, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.table_id != 0 {
            os.write_int64(1, self.table_id)?;
        }
        if self.index_id != 0 {
            os.write_int64(2, self.index_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "table_id",
                    |m: &TableIndexId| { &m.table_id },
                    |m: &mut TableIndexId| { &mut m.table_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "index_id",
                    |m: &TableIndexId| { &m.index_id },
                    |m: &mut TableIndexId| { &mut m.index_id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<TableIndexId>(
                    "TableIndexId",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TableIndexId {
        static mut instance: ::protobuf::lazy::Lazy<TableIndexId> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TableIndexId,
        };
        unsafe {
            instance.get(TableIndexId::new)
        }
    }
}

impl ::protobuf::Clear for TableIndexId {
    fn clear(&mut self) {
        self.table_id = 0;
        self.index_id = 0;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for TableIndexId {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", buf);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for TableIndexId {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for TableIndexId {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FtsTrackedIndexMeta {
    // message fields
    pub table_id: i64,
    pub index_id: i64,
    pub field_layout: FtsFieldLayout,
    pub index_fields: ::protobuf::RepeatedField<FullTextIndexFieldDef>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 table_id = 1;


    pub fn get_table_id(&self) -> i64 {
        self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_table_id(&mut self, v: i64) {
        self.table_id = v;
    }

    // int64 index_id = 2;


    pub fn get_index_id(&self) -> i64 {
        self.index_id
    }
    pub fn clear_index_id(&mut self) {
        self.index_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_index_id(&mut self, v: i64) {
        self.index_id = v;
    }

    // .enginepb.FtsFieldLayout field_layout = 3;


    pub fn get_field_layout(&self) -> FtsFieldLayout {
        self.field_layout
    }
    pub fn clear_field_layout(&mut self) {
        self.field_layout = FtsFieldLayout::FtsFieldLayoutUnspecified;
    }

    // Param is passed by value, moved
    pub fn set_field_layout(&mut self, v: FtsFieldLayout) {
        self.field_layout = v;
    }

    // repeated .enginepb.FullTextIndexFieldDef index_fields = 4;


    pub fn get_index_fields(&self) -> &[FullTextIndexFieldDef] {
        &self.index_fields
    }
    pub fn clear_index_fields(&mut self) {
        self.index_fields.clear();
    }

    // Param is passed by value, moved
    pub fn set_index_fields(&mut self, v: ::protobuf::RepeatedField<FullTextIndexFieldDef>) {
        self.index_fields = v;
    }

    // Mutable pointer to the field.
    pub fn mut_index_fields(&mut self) -> &mut ::protobuf::RepeatedField<FullTextIndexFieldDef> {
        &mut self.index_fields
    }

    // Take field
    pub fn take_index_fields(&mut self) -> ::protobuf::RepeatedField<FullTextIndexFieldDef> {
        ::std::mem::replace(&mut self.index_fields, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for FtsTrackedIndexMeta {
    fn is_initialized(&self) -> bool {
        for v in &self.index_fields {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.table_id = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index_id = tmp;
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_layout, 3, &mut self.unknown_fields)?
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.index_fields)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.table_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.table_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.index_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.index_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.field_layout != FtsFieldLayout::FtsFieldLayoutUnspecified {
            my_size += ::protobuf::rt::enum_size(3, self.field_layout);
        }
        for value in &self.index_fields {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.table_id != 0 {
            os.write_int64(1, self.table_id)?;
        }
        if self.index_id != 0 {
            os.write_int64(2, self.index_id)?;
        }
        if self.field_layout != FtsFieldLayout::FtsFieldLayoutUnspecified {
            os.write_enum(3, self.field_layout.value())?;
        }
        for v in &self.index_fields {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "table_id",
                    |m: &FtsTrackedIndexMeta| { &m.table_id },
                    |m: &mut FtsTrackedIndexMeta| { &mut m.table_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "index_id",
                    |m: &FtsTrackedIndexMeta| { &m.index_id },
                    |m: &mut FtsTrackedIndexMeta| { &mut m.index_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FtsFieldLayout>>(
                    "field_layout",
                    |m: &FtsTrackedIndexMeta| { &m.field_layout },
                    |m: &mut FtsTrackedIndexMeta| { &mut m.field_layout },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FullTextIndexFieldDef>>(
                    "index_fields",
                    |m: &FtsTrackedIndexMeta| { &m.index_fields },
                    |m: &mut FtsTrackedIndexMeta| { &mut m.index_fields },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<FtsTrackedIndexMeta>(
                    "FtsTrackedIndexMeta",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FtsTrackedIndexMeta {
        static mut instance: ::protobuf::lazy::Lazy<FtsTrackedIndexMeta> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FtsTrackedIndexMeta,
        };
        unsafe {
            instance.get(FtsTrackedIndexMeta::new)
        }
    }
}

impl ::protobuf::Clear for FtsTrackedIndexMeta {
    fn clear(&mut self) {
        self.table_id = 0;
        self.index_id = 0;
        self.field_layout = FtsFieldLayout::FtsFieldLayoutUnspecified;
        self.index_fields.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for FtsTrackedIndexMeta {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", buf);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", buf);
        ::protobuf::PbPrint::fmt(&self.field_layout, "field_layout", buf);
        ::protobuf::PbPrint::fmt(&self.index_fields, "index_fields", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for FtsTrackedIndexMeta {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.field_layout, "field_layout", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_fields, "index_fields", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for FtsTrackedIndexMeta {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct OffsetSize {
    // message fields
    pub offset: u64,
    pub size: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 offset = 1;


    pub fn get_offset(&self) -> u64 {
        self.offset
    }
    pub fn clear_offset(&mut self) {
        self.offset = 0;
    }

    // Param is passed by value, moved
    pub fn set_offset(&mut self, v: u64) {
        self.offset = v;
    }

    // uint64 size = 2;


    pub fn get_size(&self) -> u64 {
        self.size
    }
    pub fn clear_size(&mut self) {
        self.size = 0;
    }

    // Param is passed by value, moved
    pub fn set_size(&mut self, v: u64) {
        self.size = v;
    }
}

impl ::protobuf::Message for OffsetSize {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.offset = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.size = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.offset != 0 {
            my_size += ::protobuf::rt::value_size(1, self.offset, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.size, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.offset != 0 {
            os.write_uint64(1, self.offset)?;
        }
        if self.size != 0 {
            os.write_uint64(2, self.size)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "offset",
                    |m: &OffsetSize| { &m.offset },
                    |m: &mut OffsetSize| { &mut m.offset },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "size",
                    |m: &OffsetSize| { &m.size },
                    |m: &mut OffsetSize| { &mut m.size },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<OffsetSize>(
                    "OffsetSize",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static OffsetSize {
        static mut instance: ::protobuf::lazy::Lazy<OffsetSize> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const OffsetSize,
        };
        unsafe {
            instance.get(OffsetSize::new)
        }
    }
}

impl ::protobuf::Clear for OffsetSize {
    fn clear(&mut self) {
        self.offset = 0;
        self.size = 0;
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for OffsetSize {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.offset, "offset", buf);
        ::protobuf::PbPrint::fmt(&self.size, "size", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for OffsetSize {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.offset, "offset", &mut s);
        ::protobuf::PbPrint::fmt(&self.size, "size", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for OffsetSize {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TantivyIndexLayout {
    // message fields
    pub meta: ::protobuf::SingularPtrField<OffsetSize>,
    pub managed: ::protobuf::SingularPtrField<OffsetSize>,
    pub term: ::protobuf::SingularPtrField<OffsetSize>,
    pub idx: ::protobuf::SingularPtrField<OffsetSize>,
    pub pos: ::protobuf::SingularPtrField<OffsetSize>,
    pub store: ::protobuf::SingularPtrField<OffsetSize>,
    pub fast: ::protobuf::SingularPtrField<OffsetSize>,
    pub fieldnorm: ::protobuf::SingularPtrField<OffsetSize>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .enginepb.OffsetSize meta = 1;


    pub fn get_meta(&self) -> &OffsetSize {
        self.meta.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_meta(&mut self) {
        self.meta.clear();
    }

    pub fn has_meta(&self) -> bool {
        self.meta.is_some()
    }

    // Param is passed by value, moved
    pub fn set_meta(&mut self, v: OffsetSize) {
        self.meta = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_meta(&mut self) -> &mut OffsetSize {
        if self.meta.is_none() {
            self.meta.set_default();
        }
        self.meta.as_mut().unwrap()
    }

    // Take field
    pub fn take_meta(&mut self) -> OffsetSize {
        self.meta.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize managed = 2;


    pub fn get_managed(&self) -> &OffsetSize {
        self.managed.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_managed(&mut self) {
        self.managed.clear();
    }

    pub fn has_managed(&self) -> bool {
        self.managed.is_some()
    }

    // Param is passed by value, moved
    pub fn set_managed(&mut self, v: OffsetSize) {
        self.managed = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_managed(&mut self) -> &mut OffsetSize {
        if self.managed.is_none() {
            self.managed.set_default();
        }
        self.managed.as_mut().unwrap()
    }

    // Take field
    pub fn take_managed(&mut self) -> OffsetSize {
        self.managed.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize term = 3;


    pub fn get_term(&self) -> &OffsetSize {
        self.term.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_term(&mut self) {
        self.term.clear();
    }

    pub fn has_term(&self) -> bool {
        self.term.is_some()
    }

    // Param is passed by value, moved
    pub fn set_term(&mut self, v: OffsetSize) {
        self.term = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_term(&mut self) -> &mut OffsetSize {
        if self.term.is_none() {
            self.term.set_default();
        }
        self.term.as_mut().unwrap()
    }

    // Take field
    pub fn take_term(&mut self) -> OffsetSize {
        self.term.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize idx = 4;


    pub fn get_idx(&self) -> &OffsetSize {
        self.idx.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_idx(&mut self) {
        self.idx.clear();
    }

    pub fn has_idx(&self) -> bool {
        self.idx.is_some()
    }

    // Param is passed by value, moved
    pub fn set_idx(&mut self, v: OffsetSize) {
        self.idx = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_idx(&mut self) -> &mut OffsetSize {
        if self.idx.is_none() {
            self.idx.set_default();
        }
        self.idx.as_mut().unwrap()
    }

    // Take field
    pub fn take_idx(&mut self) -> OffsetSize {
        self.idx.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize pos = 5;


    pub fn get_pos(&self) -> &OffsetSize {
        self.pos.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_pos(&mut self) {
        self.pos.clear();
    }

    pub fn has_pos(&self) -> bool {
        self.pos.is_some()
    }

    // Param is passed by value, moved
    pub fn set_pos(&mut self, v: OffsetSize) {
        self.pos = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_pos(&mut self) -> &mut OffsetSize {
        if self.pos.is_none() {
            self.pos.set_default();
        }
        self.pos.as_mut().unwrap()
    }

    // Take field
    pub fn take_pos(&mut self) -> OffsetSize {
        self.pos.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize store = 6;


    pub fn get_store(&self) -> &OffsetSize {
        self.store.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_store(&mut self) {
        self.store.clear();
    }

    pub fn has_store(&self) -> bool {
        self.store.is_some()
    }

    // Param is passed by value, moved
    pub fn set_store(&mut self, v: OffsetSize) {
        self.store = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_store(&mut self) -> &mut OffsetSize {
        if self.store.is_none() {
            self.store.set_default();
        }
        self.store.as_mut().unwrap()
    }

    // Take field
    pub fn take_store(&mut self) -> OffsetSize {
        self.store.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize fast = 7;


    pub fn get_fast(&self) -> &OffsetSize {
        self.fast.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_fast(&mut self) {
        self.fast.clear();
    }

    pub fn has_fast(&self) -> bool {
        self.fast.is_some()
    }

    // Param is passed by value, moved
    pub fn set_fast(&mut self, v: OffsetSize) {
        self.fast = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_fast(&mut self) -> &mut OffsetSize {
        if self.fast.is_none() {
            self.fast.set_default();
        }
        self.fast.as_mut().unwrap()
    }

    // Take field
    pub fn take_fast(&mut self) -> OffsetSize {
        self.fast.take().unwrap_or_else(|| OffsetSize::new())
    }

    // .enginepb.OffsetSize fieldnorm = 8;


    pub fn get_fieldnorm(&self) -> &OffsetSize {
        self.fieldnorm.as_ref().unwrap_or_else(|| OffsetSize::default_instance())
    }
    pub fn clear_fieldnorm(&mut self) {
        self.fieldnorm.clear();
    }

    pub fn has_fieldnorm(&self) -> bool {
        self.fieldnorm.is_some()
    }

    // Param is passed by value, moved
    pub fn set_fieldnorm(&mut self, v: OffsetSize) {
        self.fieldnorm = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_fieldnorm(&mut self) -> &mut OffsetSize {
        if self.fieldnorm.is_none() {
            self.fieldnorm.set_default();
        }
        self.fieldnorm.as_mut().unwrap()
    }

    // Take field
    pub fn take_fieldnorm(&mut self) -> OffsetSize {
        self.fieldnorm.take().unwrap_or_else(|| OffsetSize::new())
    }
}

impl ::protobuf::Message for TantivyIndexLayout {
    fn is_initialized(&self) -> bool {
        for v in &self.meta {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.managed {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.term {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.idx {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.pos {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.store {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.fast {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.fieldnorm {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.meta)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.managed)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.term)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.idx)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pos)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.store)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fast)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fieldnorm)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.meta.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.managed.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.term.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.idx.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.pos.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.store.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.fast.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.fieldnorm.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.meta.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.managed.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.term.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.idx.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.pos.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.store.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.fast.as_ref() {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.fieldnorm.as_ref() {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "meta",
                    |m: &TantivyIndexLayout| { &m.meta },
                    |m: &mut TantivyIndexLayout| { &mut m.meta },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "managed",
                    |m: &TantivyIndexLayout| { &m.managed },
                    |m: &mut TantivyIndexLayout| { &mut m.managed },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "term",
                    |m: &TantivyIndexLayout| { &m.term },
                    |m: &mut TantivyIndexLayout| { &mut m.term },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "idx",
                    |m: &TantivyIndexLayout| { &m.idx },
                    |m: &mut TantivyIndexLayout| { &mut m.idx },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "pos",
                    |m: &TantivyIndexLayout| { &m.pos },
                    |m: &mut TantivyIndexLayout| { &mut m.pos },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "store",
                    |m: &TantivyIndexLayout| { &m.store },
                    |m: &mut TantivyIndexLayout| { &mut m.store },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "fast",
                    |m: &TantivyIndexLayout| { &m.fast },
                    |m: &mut TantivyIndexLayout| { &mut m.fast },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OffsetSize>>(
                    "fieldnorm",
                    |m: &TantivyIndexLayout| { &m.fieldnorm },
                    |m: &mut TantivyIndexLayout| { &mut m.fieldnorm },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<TantivyIndexLayout>(
                    "TantivyIndexLayout",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TantivyIndexLayout {
        static mut instance: ::protobuf::lazy::Lazy<TantivyIndexLayout> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TantivyIndexLayout,
        };
        unsafe {
            instance.get(TantivyIndexLayout::new)
        }
    }
}

impl ::protobuf::Clear for TantivyIndexLayout {
    fn clear(&mut self) {
        self.meta.clear();
        self.managed.clear();
        self.term.clear();
        self.idx.clear();
        self.pos.clear();
        self.store.clear();
        self.fast.clear();
        self.fieldnorm.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for TantivyIndexLayout {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.meta, "meta", buf);
        ::protobuf::PbPrint::fmt(&self.managed, "managed", buf);
        ::protobuf::PbPrint::fmt(&self.term, "term", buf);
        ::protobuf::PbPrint::fmt(&self.idx, "idx", buf);
        ::protobuf::PbPrint::fmt(&self.pos, "pos", buf);
        ::protobuf::PbPrint::fmt(&self.store, "store", buf);
        ::protobuf::PbPrint::fmt(&self.fast, "fast", buf);
        ::protobuf::PbPrint::fmt(&self.fieldnorm, "fieldnorm", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for TantivyIndexLayout {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.meta, "meta", &mut s);
        ::protobuf::PbPrint::fmt(&self.managed, "managed", &mut s);
        ::protobuf::PbPrint::fmt(&self.term, "term", &mut s);
        ::protobuf::PbPrint::fmt(&self.idx, "idx", &mut s);
        ::protobuf::PbPrint::fmt(&self.pos, "pos", &mut s);
        ::protobuf::PbPrint::fmt(&self.store, "store", &mut s);
        ::protobuf::PbPrint::fmt(&self.fast, "fast", &mut s);
        ::protobuf::PbPrint::fmt(&self.fieldnorm, "fieldnorm", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for TantivyIndexLayout {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DedFileIBlock {
    // message fields
    pub hblock_start_key: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    pub hblock_offsets: ::std::vec::Vec<u64>,
    pub hblock_start_docid: ::std::vec::Vec<u32>,
    pub hblock_handle_rank_stride: u32,
    pub hblock_handle_rank: ::std::vec::Vec<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated bytes hblock_start_key = 1;


    pub fn get_hblock_start_key(&self) -> &[::std::vec::Vec<u8>] {
        &self.hblock_start_key
    }
    pub fn clear_hblock_start_key(&mut self) {
        self.hblock_start_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_hblock_start_key(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
        self.hblock_start_key = v;
    }

    // Mutable pointer to the field.
    pub fn mut_hblock_start_key(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.hblock_start_key
    }

    // Take field
    pub fn take_hblock_start_key(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.hblock_start_key, ::protobuf::RepeatedField::new())
    }

    // repeated uint64 hblock_offsets = 2;


    pub fn get_hblock_offsets(&self) -> &[u64] {
        &self.hblock_offsets
    }
    pub fn clear_hblock_offsets(&mut self) {
        self.hblock_offsets.clear();
    }

    // Param is passed by value, moved
    pub fn set_hblock_offsets(&mut self, v: ::std::vec::Vec<u64>) {
        self.hblock_offsets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_hblock_offsets(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.hblock_offsets
    }

    // Take field
    pub fn take_hblock_offsets(&mut self) -> ::std::vec::Vec<u64> {
        ::std::mem::replace(&mut self.hblock_offsets, ::std::vec::Vec::new())
    }

    // repeated uint32 hblock_start_docid = 3;


    pub fn get_hblock_start_docid(&self) -> &[u32] {
        &self.hblock_start_docid
    }
    pub fn clear_hblock_start_docid(&mut self) {
        self.hblock_start_docid.clear();
    }

    // Param is passed by value, moved
    pub fn set_hblock_start_docid(&mut self, v: ::std::vec::Vec<u32>) {
        self.hblock_start_docid = v;
    }

    // Mutable pointer to the field.
    pub fn mut_hblock_start_docid(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.hblock_start_docid
    }

    // Take field
    pub fn take_hblock_start_docid(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.hblock_start_docid, ::std::vec::Vec::new())
    }

    // uint32 hblock_handle_rank_stride = 4;


    pub fn get_hblock_handle_rank_stride(&self) -> u32 {
        self.hblock_handle_rank_stride
    }
    pub fn clear_hblock_handle_rank_stride(&mut self) {
        self.hblock_handle_rank_stride = 0;
    }

    // Param is passed by value, moved
    pub fn set_hblock_handle_rank_stride(&mut self, v: u32) {
        self.hblock_handle_rank_stride = v;
    }

    // repeated uint32 hblock_handle_rank = 5;


    pub fn get_hblock_handle_rank(&self) -> &[u32] {
        &self.hblock_handle_rank
    }
    pub fn clear_hblock_handle_rank(&mut self) {
        self.hblock_handle_rank.clear();
    }

    // Param is passed by value, moved
    pub fn set_hblock_handle_rank(&mut self, v: ::std::vec::Vec<u32>) {
        self.hblock_handle_rank = v;
    }

    // Mutable pointer to the field.
    pub fn mut_hblock_handle_rank(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.hblock_handle_rank
    }

    // Take field
    pub fn take_hblock_handle_rank(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.hblock_handle_rank, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for DedFileIBlock {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.hblock_start_key)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.hblock_offsets)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.hblock_start_docid)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.hblock_handle_rank_stride = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.hblock_handle_rank)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.hblock_start_key {
            my_size += ::protobuf::rt::bytes_size(1, &value);
        };
        for value in &self.hblock_offsets {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in &self.hblock_start_docid {
            my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if self.hblock_handle_rank_stride != 0 {
            my_size += ::protobuf::rt::value_size(4, self.hblock_handle_rank_stride, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.hblock_handle_rank {
            my_size += ::protobuf::rt::value_size(5, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.hblock_start_key {
            os.write_bytes(1, &v)?;
        };
        for v in &self.hblock_offsets {
            os.write_uint64(2, *v)?;
        };
        for v in &self.hblock_start_docid {
            os.write_uint32(3, *v)?;
        };
        if self.hblock_handle_rank_stride != 0 {
            os.write_uint32(4, self.hblock_handle_rank_stride)?;
        }
        for v in &self.hblock_handle_rank {
            os.write_uint32(5, *v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "hblock_start_key",
                    |m: &DedFileIBlock| { &m.hblock_start_key },
                    |m: &mut DedFileIBlock| { &mut m.hblock_start_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "hblock_offsets",
                    |m: &DedFileIBlock| { &m.hblock_offsets },
                    |m: &mut DedFileIBlock| { &mut m.hblock_offsets },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "hblock_start_docid",
                    |m: &DedFileIBlock| { &m.hblock_start_docid },
                    |m: &mut DedFileIBlock| { &mut m.hblock_start_docid },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "hblock_handle_rank_stride",
                    |m: &DedFileIBlock| { &m.hblock_handle_rank_stride },
                    |m: &mut DedFileIBlock| { &mut m.hblock_handle_rank_stride },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "hblock_handle_rank",
                    |m: &DedFileIBlock| { &m.hblock_handle_rank },
                    |m: &mut DedFileIBlock| { &mut m.hblock_handle_rank },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DedFileIBlock>(
                    "DedFileIBlock",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DedFileIBlock {
        static mut instance: ::protobuf::lazy::Lazy<DedFileIBlock> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const DedFileIBlock,
        };
        unsafe {
            instance.get(DedFileIBlock::new)
        }
    }
}

impl ::protobuf::Clear for DedFileIBlock {
    fn clear(&mut self) {
        self.hblock_start_key.clear();
        self.hblock_offsets.clear();
        self.hblock_start_docid.clear();
        self.hblock_handle_rank_stride = 0;
        self.hblock_handle_rank.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for DedFileIBlock {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.hblock_start_key, "hblock_start_key", buf);
        ::protobuf::PbPrint::fmt(&self.hblock_offsets, "hblock_offsets", buf);
        ::protobuf::PbPrint::fmt(&self.hblock_start_docid, "hblock_start_docid", buf);
        ::protobuf::PbPrint::fmt(&self.hblock_handle_rank_stride, "hblock_handle_rank_stride", buf);
        ::protobuf::PbPrint::fmt(&self.hblock_handle_rank, "hblock_handle_rank", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for DedFileIBlock {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.hblock_start_key, "hblock_start_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.hblock_offsets, "hblock_offsets", &mut s);
        ::protobuf::PbPrint::fmt(&self.hblock_start_docid, "hblock_start_docid", &mut s);
        ::protobuf::PbPrint::fmt(&self.hblock_handle_rank_stride, "hblock_handle_rank_stride", &mut s);
        ::protobuf::PbPrint::fmt(&self.hblock_handle_rank, "hblock_handle_rank", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for DedFileIBlock {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DedFilePropBlock {
    // message fields
    pub lp_key: ::std::vec::Vec<u8>,
    pub is_int_handle: bool,
    pub table_id: i64,
    pub index_id: i64,
    pub snap_version: u64,
    pub pk_total: u64,
    pub pk_live_unique: u64,
    pub smallest_key: ::std::vec::Vec<u8>,
    pub biggest_key: ::std::vec::Vec<u8>,
    pub tantivy_layout: ::protobuf::SingularPtrField<TantivyIndexLayout>,
    pub idx_sub_offsets: ::std::vec::Vec<u64>,
    pub pos_sub_offsets: ::std::vec::Vec<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes lp_key = 1;


    pub fn get_lp_key(&self) -> &[u8] {
        &self.lp_key
    }
    pub fn clear_lp_key(&mut self) {
        self.lp_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_lp_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.lp_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_lp_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.lp_key
    }

    // Take field
    pub fn take_lp_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.lp_key, ::std::vec::Vec::new())
    }

    // bool is_int_handle = 2;


    pub fn get_is_int_handle(&self) -> bool {
        self.is_int_handle
    }
    pub fn clear_is_int_handle(&mut self) {
        self.is_int_handle = false;
    }

    // Param is passed by value, moved
    pub fn set_is_int_handle(&mut self, v: bool) {
        self.is_int_handle = v;
    }

    // int64 table_id = 3;


    pub fn get_table_id(&self) -> i64 {
        self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_table_id(&mut self, v: i64) {
        self.table_id = v;
    }

    // int64 index_id = 4;


    pub fn get_index_id(&self) -> i64 {
        self.index_id
    }
    pub fn clear_index_id(&mut self) {
        self.index_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_index_id(&mut self, v: i64) {
        self.index_id = v;
    }

    // uint64 snap_version = 5;


    pub fn get_snap_version(&self) -> u64 {
        self.snap_version
    }
    pub fn clear_snap_version(&mut self) {
        self.snap_version = 0;
    }

    // Param is passed by value, moved
    pub fn set_snap_version(&mut self, v: u64) {
        self.snap_version = v;
    }

    // uint64 pk_total = 10;


    pub fn get_pk_total(&self) -> u64 {
        self.pk_total
    }
    pub fn clear_pk_total(&mut self) {
        self.pk_total = 0;
    }

    // Param is passed by value, moved
    pub fn set_pk_total(&mut self, v: u64) {
        self.pk_total = v;
    }

    // uint64 pk_live_unique = 11;


    pub fn get_pk_live_unique(&self) -> u64 {
        self.pk_live_unique
    }
    pub fn clear_pk_live_unique(&mut self) {
        self.pk_live_unique = 0;
    }

    // Param is passed by value, moved
    pub fn set_pk_live_unique(&mut self, v: u64) {
        self.pk_live_unique = v;
    }

    // bytes smallest_key = 20;


    pub fn get_smallest_key(&self) -> &[u8] {
        &self.smallest_key
    }
    pub fn clear_smallest_key(&mut self) {
        self.smallest_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_smallest_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.smallest_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_smallest_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.smallest_key
    }

    // Take field
    pub fn take_smallest_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.smallest_key, ::std::vec::Vec::new())
    }

    // bytes biggest_key = 21;


    pub fn get_biggest_key(&self) -> &[u8] {
        &self.biggest_key
    }
    pub fn clear_biggest_key(&mut self) {
        self.biggest_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_biggest_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.biggest_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_biggest_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.biggest_key
    }

    // Take field
    pub fn take_biggest_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.biggest_key, ::std::vec::Vec::new())
    }

    // .enginepb.TantivyIndexLayout tantivy_layout = 30;


    pub fn get_tantivy_layout(&self) -> &TantivyIndexLayout {
        self.tantivy_layout.as_ref().unwrap_or_else(|| TantivyIndexLayout::default_instance())
    }
    pub fn clear_tantivy_layout(&mut self) {
        self.tantivy_layout.clear();
    }

    pub fn has_tantivy_layout(&self) -> bool {
        self.tantivy_layout.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tantivy_layout(&mut self, v: TantivyIndexLayout) {
        self.tantivy_layout = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tantivy_layout(&mut self) -> &mut TantivyIndexLayout {
        if self.tantivy_layout.is_none() {
            self.tantivy_layout.set_default();
        }
        self.tantivy_layout.as_mut().unwrap()
    }

    // Take field
    pub fn take_tantivy_layout(&mut self) -> TantivyIndexLayout {
        self.tantivy_layout.take().unwrap_or_else(|| TantivyIndexLayout::new())
    }

    // repeated uint64 idx_sub_offsets = 31;


    pub fn get_idx_sub_offsets(&self) -> &[u64] {
        &self.idx_sub_offsets
    }
    pub fn clear_idx_sub_offsets(&mut self) {
        self.idx_sub_offsets.clear();
    }

    // Param is passed by value, moved
    pub fn set_idx_sub_offsets(&mut self, v: ::std::vec::Vec<u64>) {
        self.idx_sub_offsets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_idx_sub_offsets(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.idx_sub_offsets
    }

    // Take field
    pub fn take_idx_sub_offsets(&mut self) -> ::std::vec::Vec<u64> {
        ::std::mem::replace(&mut self.idx_sub_offsets, ::std::vec::Vec::new())
    }

    // repeated uint64 pos_sub_offsets = 32;


    pub fn get_pos_sub_offsets(&self) -> &[u64] {
        &self.pos_sub_offsets
    }
    pub fn clear_pos_sub_offsets(&mut self) {
        self.pos_sub_offsets.clear();
    }

    // Param is passed by value, moved
    pub fn set_pos_sub_offsets(&mut self, v: ::std::vec::Vec<u64>) {
        self.pos_sub_offsets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_pos_sub_offsets(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.pos_sub_offsets
    }

    // Take field
    pub fn take_pos_sub_offsets(&mut self) -> ::std::vec::Vec<u64> {
        ::std::mem::replace(&mut self.pos_sub_offsets, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for DedFilePropBlock {
    fn is_initialized(&self) -> bool {
        for v in &self.tantivy_layout {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.lp_key)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_int_handle = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.table_id = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index_id = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.snap_version = tmp;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.pk_total = tmp;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.pk_live_unique = tmp;
                },
                20 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.smallest_key)?;
                },
                21 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.biggest_key)?;
                },
                30 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tantivy_layout)?;
                },
                31 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.idx_sub_offsets)?;
                },
                32 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.pos_sub_offsets)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.lp_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.lp_key);
        }
        if self.is_int_handle != false {
            my_size += 2;
        }
        if self.table_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.table_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.index_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.index_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.snap_version != 0 {
            my_size += ::protobuf::rt::value_size(5, self.snap_version, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.pk_total != 0 {
            my_size += ::protobuf::rt::value_size(10, self.pk_total, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.pk_live_unique != 0 {
            my_size += ::protobuf::rt::value_size(11, self.pk_live_unique, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.smallest_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(20, &self.smallest_key);
        }
        if !self.biggest_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(21, &self.biggest_key);
        }
        if let Some(ref v) = self.tantivy_layout.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.idx_sub_offsets {
            my_size += ::protobuf::rt::value_size(31, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in &self.pos_sub_offsets {
            my_size += ::protobuf::rt::value_size(32, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.lp_key.is_empty() {
            os.write_bytes(1, &self.lp_key)?;
        }
        if self.is_int_handle != false {
            os.write_bool(2, self.is_int_handle)?;
        }
        if self.table_id != 0 {
            os.write_int64(3, self.table_id)?;
        }
        if self.index_id != 0 {
            os.write_int64(4, self.index_id)?;
        }
        if self.snap_version != 0 {
            os.write_uint64(5, self.snap_version)?;
        }
        if self.pk_total != 0 {
            os.write_uint64(10, self.pk_total)?;
        }
        if self.pk_live_unique != 0 {
            os.write_uint64(11, self.pk_live_unique)?;
        }
        if !self.smallest_key.is_empty() {
            os.write_bytes(20, &self.smallest_key)?;
        }
        if !self.biggest_key.is_empty() {
            os.write_bytes(21, &self.biggest_key)?;
        }
        if let Some(ref v) = self.tantivy_layout.as_ref() {
            os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.idx_sub_offsets {
            os.write_uint64(31, *v)?;
        };
        for v in &self.pos_sub_offsets {
            os.write_uint64(32, *v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn ::std::any::Any {
        self as &dyn ::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
        self as &mut dyn ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "lp_key",
                    |m: &DedFilePropBlock| { &m.lp_key },
                    |m: &mut DedFilePropBlock| { &mut m.lp_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "is_int_handle",
                    |m: &DedFilePropBlock| { &m.is_int_handle },
                    |m: &mut DedFilePropBlock| { &mut m.is_int_handle },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "table_id",
                    |m: &DedFilePropBlock| { &m.table_id },
                    |m: &mut DedFilePropBlock| { &mut m.table_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "index_id",
                    |m: &DedFilePropBlock| { &m.index_id },
                    |m: &mut DedFilePropBlock| { &mut m.index_id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "snap_version",
                    |m: &DedFilePropBlock| { &m.snap_version },
                    |m: &mut DedFilePropBlock| { &mut m.snap_version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "pk_total",
                    |m: &DedFilePropBlock| { &m.pk_total },
                    |m: &mut DedFilePropBlock| { &mut m.pk_total },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "pk_live_unique",
                    |m: &DedFilePropBlock| { &m.pk_live_unique },
                    |m: &mut DedFilePropBlock| { &mut m.pk_live_unique },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "smallest_key",
                    |m: &DedFilePropBlock| { &m.smallest_key },
                    |m: &mut DedFilePropBlock| { &mut m.smallest_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "biggest_key",
                    |m: &DedFilePropBlock| { &m.biggest_key },
                    |m: &mut DedFilePropBlock| { &mut m.biggest_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TantivyIndexLayout>>(
                    "tantivy_layout",
                    |m: &DedFilePropBlock| { &m.tantivy_layout },
                    |m: &mut DedFilePropBlock| { &mut m.tantivy_layout },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "idx_sub_offsets",
                    |m: &DedFilePropBlock| { &m.idx_sub_offsets },
                    |m: &mut DedFilePropBlock| { &mut m.idx_sub_offsets },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "pos_sub_offsets",
                    |m: &DedFilePropBlock| { &m.pos_sub_offsets },
                    |m: &mut DedFilePropBlock| { &mut m.pos_sub_offsets },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DedFilePropBlock>(
                    "DedFilePropBlock",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DedFilePropBlock {
        static mut instance: ::protobuf::lazy::Lazy<DedFilePropBlock> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const DedFilePropBlock,
        };
        unsafe {
            instance.get(DedFilePropBlock::new)
        }
    }
}

impl ::protobuf::Clear for DedFilePropBlock {
    fn clear(&mut self) {
        self.lp_key.clear();
        self.is_int_handle = false;
        self.table_id = 0;
        self.index_id = 0;
        self.snap_version = 0;
        self.pk_total = 0;
        self.pk_live_unique = 0;
        self.smallest_key.clear();
        self.biggest_key.clear();
        self.tantivy_layout.clear();
        self.idx_sub_offsets.clear();
        self.pos_sub_offsets.clear();
        self.unknown_fields.clear();
    }
}

impl ::protobuf::PbPrint for DedFilePropBlock {
    #[allow(unused_variables)]
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        ::protobuf::push_message_start(name, buf);
        let old_len = buf.len();
        ::protobuf::PbPrint::fmt(&self.lp_key, "lp_key", buf);
        ::protobuf::PbPrint::fmt(&self.is_int_handle, "is_int_handle", buf);
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", buf);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", buf);
        ::protobuf::PbPrint::fmt(&self.snap_version, "snap_version", buf);
        ::protobuf::PbPrint::fmt(&self.pk_total, "pk_total", buf);
        ::protobuf::PbPrint::fmt(&self.pk_live_unique, "pk_live_unique", buf);
        ::protobuf::PbPrint::fmt(&self.smallest_key, "smallest_key", buf);
        ::protobuf::PbPrint::fmt(&self.biggest_key, "biggest_key", buf);
        ::protobuf::PbPrint::fmt(&self.tantivy_layout, "tantivy_layout", buf);
        ::protobuf::PbPrint::fmt(&self.idx_sub_offsets, "idx_sub_offsets", buf);
        ::protobuf::PbPrint::fmt(&self.pos_sub_offsets, "pos_sub_offsets", buf);
        if old_len < buf.len() {
          buf.push(' ');
        }
        buf.push('}');
    }
}
impl ::std::fmt::Debug for DedFilePropBlock {
    #[allow(unused_variables)]
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        let mut s = ::std::string::String::new();
        ::protobuf::PbPrint::fmt(&self.lp_key, "lp_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.is_int_handle, "is_int_handle", &mut s);
        ::protobuf::PbPrint::fmt(&self.table_id, "table_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.index_id, "index_id", &mut s);
        ::protobuf::PbPrint::fmt(&self.snap_version, "snap_version", &mut s);
        ::protobuf::PbPrint::fmt(&self.pk_total, "pk_total", &mut s);
        ::protobuf::PbPrint::fmt(&self.pk_live_unique, "pk_live_unique", &mut s);
        ::protobuf::PbPrint::fmt(&self.smallest_key, "smallest_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.biggest_key, "biggest_key", &mut s);
        ::protobuf::PbPrint::fmt(&self.tantivy_layout, "tantivy_layout", &mut s);
        ::protobuf::PbPrint::fmt(&self.idx_sub_offsets, "idx_sub_offsets", &mut s);
        ::protobuf::PbPrint::fmt(&self.pos_sub_offsets, "pos_sub_offsets", &mut s);
        write!(f, "{}", s)
    }
}

impl ::protobuf::reflect::ProtobufValue for DedFilePropBlock {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum FullTextAnalyzerType {
    FtsAnalyzerUnspecified = 0,
    FtsAnalyzerExactValueV1 = 1,
    FtsAnalyzerStandardV1 = 2,
    FtsAnalyzerMultilingualV1 = 3,
    FtsAnalyzerNgramV1 = 4,
    FtsAnalyzerPathHierarchyV1 = 5,
}

impl ::protobuf::ProtobufEnum for FullTextAnalyzerType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<FullTextAnalyzerType> {
        match value {
            0 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerUnspecified),
            1 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerExactValueV1),
            2 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerStandardV1),
            3 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerMultilingualV1),
            4 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerNgramV1),
            5 => ::std::option::Option::Some(FullTextAnalyzerType::FtsAnalyzerPathHierarchyV1),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [FullTextAnalyzerType] = &[
            FullTextAnalyzerType::FtsAnalyzerUnspecified,
            FullTextAnalyzerType::FtsAnalyzerExactValueV1,
            FullTextAnalyzerType::FtsAnalyzerStandardV1,
            FullTextAnalyzerType::FtsAnalyzerMultilingualV1,
            FullTextAnalyzerType::FtsAnalyzerNgramV1,
            FullTextAnalyzerType::FtsAnalyzerPathHierarchyV1,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FullTextAnalyzerType", file_descriptor_proto())
            })
        }
    }
}

impl ::std::marker::Copy for FullTextAnalyzerType {
}

impl ::protobuf::PbPrint for FullTextAnalyzerType {
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        use std::fmt::Write;
        if *self == FullTextAnalyzerType::default() {
            return;
        }
        ::protobuf::push_field_start(name, buf);
        write!(buf, "{:?}", self).unwrap();
    }
}

impl ::std::default::Default for FullTextAnalyzerType {
    fn default() -> Self {
        FullTextAnalyzerType::FtsAnalyzerUnspecified
    }
}

impl ::protobuf::reflect::ProtobufValue for FullTextAnalyzerType {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum FtsFieldLayout {
    FtsFieldLayoutUnspecified = 0,
    FtsFieldLayoutLegacyBody = 1,
    FtsFieldLayoutIndexFieldOrdinalString = 2,
}

impl ::protobuf::ProtobufEnum for FtsFieldLayout {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<FtsFieldLayout> {
        match value {
            0 => ::std::option::Option::Some(FtsFieldLayout::FtsFieldLayoutUnspecified),
            1 => ::std::option::Option::Some(FtsFieldLayout::FtsFieldLayoutLegacyBody),
            2 => ::std::option::Option::Some(FtsFieldLayout::FtsFieldLayoutIndexFieldOrdinalString),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [FtsFieldLayout] = &[
            FtsFieldLayout::FtsFieldLayoutUnspecified,
            FtsFieldLayout::FtsFieldLayoutLegacyBody,
            FtsFieldLayout::FtsFieldLayoutIndexFieldOrdinalString,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FtsFieldLayout", file_descriptor_proto())
            })
        }
    }
}

impl ::std::marker::Copy for FtsFieldLayout {
}

impl ::protobuf::PbPrint for FtsFieldLayout {
    fn fmt(&self, name: &str, buf: &mut ::std::string::String) {
        use std::fmt::Write;
        if *self == FtsFieldLayout::default() {
            return;
        }
        ::protobuf::push_field_start(name, buf);
        write!(buf, "{:?}", self).unwrap();
    }
}

impl ::std::default::Default for FtsFieldLayout {
    fn default() -> Self {
        FtsFieldLayout::FtsFieldLayoutUnspecified
    }
}

impl ::protobuf::reflect::ProtobufValue for FtsFieldLayout {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef<'_> {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\tfts.proto\x12\x08enginepb\"\xc4\x01\n\x10FullTextIndexDef\x12\x12\n\
    \x08index_id\x18\x01\x20\x01(\x03B\0\x12\x10\n\x06col_id\x18\x02\x20\x01\
    (\x03B\0\x12\x15\n\x0bparser_type\x18\n\x20\x01(\tB\0\x127\n\x0cindex_fi\
    elds\x18\x14\x20\x03(\x0b2\x1f.enginepb.FullTextIndexFieldDefB\0\x128\n\
    \x14initial_field_layout\x18\x15\x20\x01(\x0e2\x18.enginepb.FtsFieldLayo\
    utB\0:\0\"m\n\x15FullTextIndexFieldDef\x12\x10\n\x06col_id\x18\x01\x20\
    \x01(\x03B\0\x12@\n\x12index_field_option\x18\x02\x20\x01(\x0b2\".engine\
    pb.FullTextIndexFieldOptionB\0:\0\"\xe1\x01\n\x18FullTextIndexFieldOptio\
    n\x127\n\ranalyzer_type\x18\x01\x20\x01(\x0e2\x1e.enginepb.FullTextAnaly\
    zerTypeB\0\x12\x15\n\x0benable_bm25\x18\x02\x20\x01(\x08B\0\x12(\n\x05ng\
    ram\x18\x03\x20\x01(\x0b2\x15.enginepb.NgramOptionH\0B\0\x129\n\x0epath_\
    hierarchy\x18\x04\x20\x01(\x0b2\x1d.enginepb.PathHierarchyOptionH\0B\0B\
    \x0e\n\x0cextra_option:\0\"d\n\x0bNgramOption\x12\x12\n\x08min_gram\x18\
    \x01\x20\x01(\x04B\0\x12\x12\n\x08max_gram\x18\x02\x20\x01(\x04B\0\x12\
    \x15\n\x0bgranularity\x18\x03\x20\x01(\tB\0\x12\x14\n\nlower_case\x18\
    \x04\x20\x01(\x08B\0:\0\",\n\x13PathHierarchyOption\x12\x13\n\tdelimiter\
    \x18\x01\x20\x01(\tB\0:\0\"W\n\x14PackedFileIndexBlock\x12\x1f\n\x15data\
    _block_start_keys\x18\x01\x20\x03(\x0cB\0\x12\x1c\n\x12data_block_offset\
    s\x18\x02\x20\x03(\rB\0:\0\"\x93\x03\n\x13PackedFilePropBlock\x12\x19\n\
    \x0fsmallest_lp_key\x18\x01\x20\x01(\x0cB\0\x12\x18\n\x0elargest_lp_key\
    \x18\x02\x20\x01(\x0cB\0\x12\x13\n\ttotal_lps\x18\x03\x20\x01(\rB\0\x12\
    \x1b\n\x11total_index_bytes\x18\x04\x20\x01(\rB\0\x12\x1a\n\x10total_key\
    s_bytes\x18\x05\x20\x01(\rB\0\x12\x16\n\x0csmallest_key\x18\x06\x20\x01(\
    \x0cB\0\x12\x15\n\x0bbiggest_key\x18\x07\x20\x01(\x0cB\0\x12\x13\n\ttabl\
    e_ids\x18\x08\x20\x03(\x03B\0\x12\x12\n\x08pk_total\x18\t\x20\x01(\x04B\
    \0\x12\x18\n\x0epk_live_unique\x18\n\x20\x01(\x04B\0\x126\n\x14smallest_\
    table_index\x18\x0b\x20\x01(\x0b2\x16.enginepb.TableIndexIdB\0\x125\n\
    \x13largest_table_index\x18\x0c\x20\x01(\x0b2\x16.enginepb.TableIndexIdB\
    \0\x12\x16\n\x0csnap_version\x18\r\x20\x01(\x04B\0:\0\"\x9e\x01\n\x11Pac\
    kedFileLpProps\x12\x0e\n\x04n_pk\x18\x01\x20\x01(\rB\0\x12\x17\n\ris_int\
    _handle\x18\x02\x20\x01(\x08B\0\x12\x12\n\x08table_id\x18\x03\x20\x01(\
    \x03B\0\x12\x12\n\x08index_id\x18\x04\x20\x01(\x03B\0\x126\n\x0etantivy_\
    layout\x18\x05\x20\x01(\x0b2\x1c.enginepb.TantivyIndexLayoutB\0:\0\"8\n\
    \x0cTableIndexId\x12\x12\n\x08table_id\x18\x01\x20\x01(\x03B\0\x12\x12\n\
    \x08index_id\x18\x02\x20\x01(\x03B\0:\0\"\xaa\x01\n\x13FtsTrackedIndexMe\
    ta\x12\x12\n\x08table_id\x18\x01\x20\x01(\x03B\0\x12\x12\n\x08index_id\
    \x18\x02\x20\x01(\x03B\0\x120\n\x0cfield_layout\x18\x03\x20\x01(\x0e2\
    \x18.enginepb.FtsFieldLayoutB\0\x127\n\x0cindex_fields\x18\x04\x20\x03(\
    \x0b2\x1f.enginepb.FullTextIndexFieldDefB\0:\0\"0\n\nOffsetSize\x12\x10\
    \n\x06offset\x18\x01\x20\x01(\x04B\0\x12\x0e\n\x04size\x18\x02\x20\x01(\
    \x04B\0:\0\"\xcd\x02\n\x12TantivyIndexLayout\x12$\n\x04meta\x18\x01\x20\
    \x01(\x0b2\x14.enginepb.OffsetSizeB\0\x12'\n\x07managed\x18\x02\x20\x01(\
    \x0b2\x14.enginepb.OffsetSizeB\0\x12$\n\x04term\x18\x03\x20\x01(\x0b2\
    \x14.enginepb.OffsetSizeB\0\x12#\n\x03idx\x18\x04\x20\x01(\x0b2\x14.engi\
    nepb.OffsetSizeB\0\x12#\n\x03pos\x18\x05\x20\x01(\x0b2\x14.enginepb.Offs\
    etSizeB\0\x12%\n\x05store\x18\x06\x20\x01(\x0b2\x14.enginepb.OffsetSizeB\
    \0\x12$\n\x04fast\x18\x07\x20\x01(\x0b2\x14.enginepb.OffsetSizeB\0\x12)\
    \n\tfieldnorm\x18\x08\x20\x01(\x0b2\x14.enginepb.OffsetSizeB\0:\0\"\xa8\
    \x01\n\rDedFileIBlock\x12\x1a\n\x10hblock_start_key\x18\x01\x20\x03(\x0c\
    B\0\x12\x18\n\x0ehblock_offsets\x18\x02\x20\x03(\x04B\0\x12\x1c\n\x12hbl\
    ock_start_docid\x18\x03\x20\x03(\rB\0\x12#\n\x19hblock_handle_rank_strid\
    e\x18\x04\x20\x01(\rB\0\x12\x1c\n\x12hblock_handle_rank\x18\x05\x20\x03(\
    \rB\0:\0\"\xca\x02\n\x10DedFilePropBlock\x12\x10\n\x06lp_key\x18\x01\x20\
    \x01(\x0cB\0\x12\x17\n\ris_int_handle\x18\x02\x20\x01(\x08B\0\x12\x12\n\
    \x08table_id\x18\x03\x20\x01(\x03B\0\x12\x12\n\x08index_id\x18\x04\x20\
    \x01(\x03B\0\x12\x16\n\x0csnap_version\x18\x05\x20\x01(\x04B\0\x12\x12\n\
    \x08pk_total\x18\n\x20\x01(\x04B\0\x12\x18\n\x0epk_live_unique\x18\x0b\
    \x20\x01(\x04B\0\x12\x16\n\x0csmallest_key\x18\x14\x20\x01(\x0cB\0\x12\
    \x15\n\x0bbiggest_key\x18\x15\x20\x01(\x0cB\0\x126\n\x0etantivy_layout\
    \x18\x1e\x20\x01(\x0b2\x1c.enginepb.TantivyIndexLayoutB\0\x12\x19\n\x0fi\
    dx_sub_offsets\x18\x1f\x20\x03(\x04B\0\x12\x19\n\x0fpos_sub_offsets\x18\
    \x20\x20\x03(\x04B\0:\0*\xd6\x01\n\x14FullTextAnalyzerType\x12\x1c\n\x18\
    FTS_ANALYZER_UNSPECIFIED\x10\0\x12\x1f\n\x1bFTS_ANALYZER_EXACT_VALUE_V1\
    \x10\x01\x12\x1c\n\x18FTS_ANALYZER_STANDARD_V1\x10\x02\x12\x20\n\x1cFTS_\
    ANALYZER_MULTILINGUAL_V1\x10\x03\x12\x19\n\x15FTS_ANALYZER_NGRAM_V1\x10\
    \x04\x12\"\n\x1eFTS_ANALYZER_PATH_HIERARCHY_V1\x10\x05\x1a\0*\x87\x01\n\
    \x0eFtsFieldLayout\x12\x20\n\x1cFTS_FIELD_LAYOUT_UNSPECIFIED\x10\0\x12\
    \x20\n\x1cFTS_FIELD_LAYOUT_LEGACY_BODY\x10\x01\x12/\n+FTS_FIELD_LAYOUT_I\
    NDEX_FIELD_ORDINAL_STRING\x10\x02\x1a\0B\0b\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
    lock: ::protobuf::lazy::ONCE_INIT,
    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}