Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #558 from AppFlowy-IO/fix/proto_compile

Browse Source 
Fix/proto compile
This commit is contained in:
Nathan.fooo 2022-06-16 09:00:07 +08:00 committed by GitHub
commit 16d9db440f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 115 additions and 5491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
frontend/rust-lib/dart-ffi/Flowy.toml
View File

@ -1,4 +1,4 @@
proto_crates = ["src/model"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/model"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
frontend/rust-lib/dart-notify/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
frontend/rust-lib/flowy-error/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/errors.rs",]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/errors.rs",]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
frontend/rust-lib/flowy-folder/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities", "src/event_map.rs", "src/dart_notification.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities", "src/event_map.rs", "src/dart_notification.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = ["src/event_map.rs"]

6
frontend/rust-lib/flowy-grid/Flowy.toml
View File

@ -1,9 +1,9 @@
proto_crates = [
proto_rust_file_input_dir = [
"src/event_map.rs",
"src/services/field/type_options",
"src/entities",
"src/dart_notification.rs"
]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = ["src/event_map.rs"]

4
frontend/rust-lib/flowy-grid/src/protobuf/mod.rs
View File

@ -1,4 +0,0 @@
#![cfg_attr(rustfmt, rustfmt::skip)]
// Auto-generated, do not edit
mod model;
pub use model::*;

505
frontend/rust-lib/flowy-grid/src/protobuf/model/cell_entities.rs
View File

@ -1,505 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `cell_entities.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct CreateSelectOptionPayload {
// message fields
pub field_identifier: ::protobuf::SingularPtrField<super::field_entities::FieldIdentifierPayload>,
pub option_name: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateSelectOptionPayload {
fn default() -> &'a CreateSelectOptionPayload {
<CreateSelectOptionPayload as ::protobuf::Message>::default_instance()
}
}
impl CreateSelectOptionPayload {
pub fn new() -> CreateSelectOptionPayload {
::std::default::Default::default()
}
// .FieldIdentifierPayload field_identifier = 1;
pub fn get_field_identifier(&self) -> &super::field_entities::FieldIdentifierPayload {
self.field_identifier.as_ref().unwrap_or_else(|| <super::field_entities::FieldIdentifierPayload as ::protobuf::Message>::default_instance())
}
pub fn clear_field_identifier(&mut self) {
self.field_identifier.clear();
}
pub fn has_field_identifier(&self) -> bool {
self.field_identifier.is_some()
}
// Param is passed by value, moved
pub fn set_field_identifier(&mut self, v: super::field_entities::FieldIdentifierPayload) {
self.field_identifier = ::protobuf::SingularPtrField::some(v);
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_field_identifier(&mut self) -> &mut super::field_entities::FieldIdentifierPayload {
if self.field_identifier.is_none() {
self.field_identifier.set_default();
}
self.field_identifier.as_mut().unwrap()
}
// Take field
pub fn take_field_identifier(&mut self) -> super::field_entities::FieldIdentifierPayload {
self.field_identifier.take().unwrap_or_else(|| super::field_entities::FieldIdentifierPayload::new())
}
// string option_name = 2;
pub fn get_option_name(&self) -> &str {
&self.option_name
}
pub fn clear_option_name(&mut self) {
self.option_name.clear();
}
// Param is passed by value, moved
pub fn set_option_name(&mut self, v: ::std::string::String) {
self.option_name = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_option_name(&mut self) -> &mut ::std::string::String {
&mut self.option_name
}
// Take field
pub fn take_option_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.option_name, ::std::string::String::new())
}
}
impl ::protobuf::Message for CreateSelectOptionPayload {
fn is_initialized(&self) -> bool {
for v in &self.field_identifier {
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.field_identifier)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.option_name)?;
},
_ => {
::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.field_identifier.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.option_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.option_name);
}
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.field_identifier.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 !self.option_name.is_empty() {
os.write_string(2, &self.option_name)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CreateSelectOptionPayload {
CreateSelectOptionPayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::field_entities::FieldIdentifierPayload>>(
"field_identifier",
|m: &CreateSelectOptionPayload| { &m.field_identifier },
|m: &mut CreateSelectOptionPayload| { &mut m.field_identifier },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"option_name",
|m: &CreateSelectOptionPayload| { &m.option_name },
|m: &mut CreateSelectOptionPayload| { &mut m.option_name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateSelectOptionPayload>(
"CreateSelectOptionPayload",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CreateSelectOptionPayload {
static instance: ::protobuf::rt::LazyV2<CreateSelectOptionPayload> = ::protobuf::rt::LazyV2::INIT;
instance.get(CreateSelectOptionPayload::new)
}
}
impl ::protobuf::Clear for CreateSelectOptionPayload {
fn clear(&mut self) {
self.field_identifier.clear();
self.option_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateSelectOptionPayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateSelectOptionPayload {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CellIdentifierPayload {
// message fields
pub grid_id: ::std::string::String,
pub field_id: ::std::string::String,
pub row_id: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CellIdentifierPayload {
fn default() -> &'a CellIdentifierPayload {
<CellIdentifierPayload as ::protobuf::Message>::default_instance()
}
}
impl CellIdentifierPayload {
pub fn new() -> CellIdentifierPayload {
::std::default::Default::default()
}
// string grid_id = 1;
pub fn get_grid_id(&self) -> &str {
&self.grid_id
}
pub fn clear_grid_id(&mut self) {
self.grid_id.clear();
}
// Param is passed by value, moved
pub fn set_grid_id(&mut self, v: ::std::string::String) {
self.grid_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_grid_id(&mut self) -> &mut ::std::string::String {
&mut self.grid_id
}
// Take field
pub fn take_grid_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.grid_id, ::std::string::String::new())
}
// string field_id = 2;
pub fn get_field_id(&self) -> &str {
&self.field_id
}
pub fn clear_field_id(&mut self) {
self.field_id.clear();
}
// Param is passed by value, moved
pub fn set_field_id(&mut self, v: ::std::string::String) {
self.field_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_field_id(&mut self) -> &mut ::std::string::String {
&mut self.field_id
}
// Take field
pub fn take_field_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.field_id, ::std::string::String::new())
}
// string row_id = 3;
pub fn get_row_id(&self) -> &str {
&self.row_id
}
pub fn clear_row_id(&mut self) {
self.row_id.clear();
}
// Param is passed by value, moved
pub fn set_row_id(&mut self, v: ::std::string::String) {
self.row_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_row_id(&mut self) -> &mut ::std::string::String {
&mut self.row_id
}
// Take field
pub fn take_row_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.row_id, ::std::string::String::new())
}
}
impl ::protobuf::Message for CellIdentifierPayload {
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.grid_id)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_id)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.row_id)?;
},
_ => {
::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.grid_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.grid_id);
}
if !self.field_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.field_id);
}
if !self.row_id.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.row_id);
}
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.grid_id.is_empty() {
os.write_string(1, &self.grid_id)?;
}
if !self.field_id.is_empty() {
os.write_string(2, &self.field_id)?;
}
if !self.row_id.is_empty() {
os.write_string(3, &self.row_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CellIdentifierPayload {
CellIdentifierPayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"grid_id",
|m: &CellIdentifierPayload| { &m.grid_id },
|m: &mut CellIdentifierPayload| { &mut m.grid_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"field_id",
|m: &CellIdentifierPayload| { &m.field_id },
|m: &mut CellIdentifierPayload| { &mut m.field_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"row_id",
|m: &CellIdentifierPayload| { &m.row_id },
|m: &mut CellIdentifierPayload| { &mut m.row_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CellIdentifierPayload>(
"CellIdentifierPayload",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CellIdentifierPayload {
static instance: ::protobuf::rt::LazyV2<CellIdentifierPayload> = ::protobuf::rt::LazyV2::INIT;
instance.get(CellIdentifierPayload::new)
}
}
impl ::protobuf::Clear for CellIdentifierPayload {
fn clear(&mut self) {
self.grid_id.clear();
self.field_id.clear();
self.row_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CellIdentifierPayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CellIdentifierPayload {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x13cell_entities.proto\x1a\x14field_entities.proto\"\x80\x01\n\x19Cre\
ateSelectOptionPayload\x12B\n\x10field_identifier\x18\x01\x20\x01(\x0b2\
\x17.FieldIdentifierPayloadR\x0ffieldIdentifier\x12\x1f\n\x0boption_name\
\x18\x02\x20\x01(\tR\noptionName\"b\n\x15CellIdentifierPayload\x12\x17\n\
\x07grid_id\x18\x01\x20\x01(\tR\x06gridId\x12\x19\n\x08field_id\x18\x02\
\x20\x01(\tR\x07fieldId\x12\x15\n\x06row_id\x18\x03\x20\x01(\tR\x05rowId\
b\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

193
frontend/rust-lib/flowy-grid/src/protobuf/model/checkbox_type_option.rs
View File

@ -1,193 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `checkbox_type_option.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct CheckboxTypeOption {
// message fields
pub is_selected: bool,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CheckboxTypeOption {
fn default() -> &'a CheckboxTypeOption {
<CheckboxTypeOption as ::protobuf::Message>::default_instance()
}
}
impl CheckboxTypeOption {
pub fn new() -> CheckboxTypeOption {
::std::default::Default::default()
}
// bool is_selected = 1;
pub fn get_is_selected(&self) -> bool {
self.is_selected
}
pub fn clear_is_selected(&mut self) {
self.is_selected = false;
}
// Param is passed by value, moved
pub fn set_is_selected(&mut self, v: bool) {
self.is_selected = v;
}
}
impl ::protobuf::Message for CheckboxTypeOption {
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_bool()?;
self.is_selected = 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.is_selected != 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.is_selected != false {
os.write_bool(1, self.is_selected)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CheckboxTypeOption {
CheckboxTypeOption::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"is_selected",
|m: &CheckboxTypeOption| { &m.is_selected },
|m: &mut CheckboxTypeOption| { &mut m.is_selected },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CheckboxTypeOption>(
"CheckboxTypeOption",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CheckboxTypeOption {
static instance: ::protobuf::rt::LazyV2<CheckboxTypeOption> = ::protobuf::rt::LazyV2::INIT;
instance.get(CheckboxTypeOption::new)
}
}
impl ::protobuf::Clear for CheckboxTypeOption {
fn clear(&mut self) {
self.is_selected = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CheckboxTypeOption {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CheckboxTypeOption {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x1acheckbox_type_option.proto\"5\n\x12CheckboxTypeOption\x12\x1f\n\
\x0bis_selected\x18\x01\x20\x01(\x08R\nisSelectedb\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

109
frontend/rust-lib/flowy-grid/src/protobuf/model/dart_notification.rs
View File

@ -1,109 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `dart_notification.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum GridNotification {
Unknown = 0,
DidCreateBlock = 11,
DidUpdateGridRow = 20,
DidUpdateGridField = 21,
DidUpdateRow = 30,
DidUpdateCell = 40,
DidUpdateField = 50,
}
impl ::protobuf::ProtobufEnum for GridNotification {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<GridNotification> {
match value {
0 => ::std::option::Option::Some(GridNotification::Unknown),
11 => ::std::option::Option::Some(GridNotification::DidCreateBlock),
20 => ::std::option::Option::Some(GridNotification::DidUpdateGridRow),
21 => ::std::option::Option::Some(GridNotification::DidUpdateGridField),
30 => ::std::option::Option::Some(GridNotification::DidUpdateRow),
40 => ::std::option::Option::Some(GridNotification::DidUpdateCell),
50 => ::std::option::Option::Some(GridNotification::DidUpdateField),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [GridNotification] = &[
GridNotification::Unknown,
GridNotification::DidCreateBlock,
GridNotification::DidUpdateGridRow,
GridNotification::DidUpdateGridField,
GridNotification::DidUpdateRow,
GridNotification::DidUpdateCell,
GridNotification::DidUpdateField,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<GridNotification>("GridNotification", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for GridNotification {
}
impl ::std::default::Default for GridNotification {
fn default() -> Self {
GridNotification::Unknown
}
}
impl ::protobuf::reflect::ProtobufValue for GridNotification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x17dart_notification.proto*\x9a\x01\n\x10GridNotification\x12\x0b\n\
\x07Unknown\x10\0\x12\x12\n\x0eDidCreateBlock\x10\x0b\x12\x14\n\x10DidUp\
dateGridRow\x10\x14\x12\x16\n\x12DidUpdateGridField\x10\x15\x12\x10\n\
\x0cDidUpdateRow\x10\x1e\x12\x11\n\rDidUpdateCell\x10(\x12\x12\n\x0eDidU\
pdateField\x102b\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

946
frontend/rust-lib/flowy-grid/src/protobuf/model/date_type_option.rs
View File

@ -1,946 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `date_type_option.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct DateTypeOption {
// message fields
pub date_format: DateFormat,
pub time_format: TimeFormat,
pub include_time: bool,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DateTypeOption {
fn default() -> &'a DateTypeOption {
<DateTypeOption as ::protobuf::Message>::default_instance()
}
}
impl DateTypeOption {
pub fn new() -> DateTypeOption {
::std::default::Default::default()
}
// .DateFormat date_format = 1;
pub fn get_date_format(&self) -> DateFormat {
self.date_format
}
pub fn clear_date_format(&mut self) {
self.date_format = DateFormat::Local;
}
// Param is passed by value, moved
pub fn set_date_format(&mut self, v: DateFormat) {
self.date_format = v;
}
// .TimeFormat time_format = 2;
pub fn get_time_format(&self) -> TimeFormat {
self.time_format
}
pub fn clear_time_format(&mut self) {
self.time_format = TimeFormat::TwelveHour;
}
// Param is passed by value, moved
pub fn set_time_format(&mut self, v: TimeFormat) {
self.time_format = v;
}
// bool include_time = 3;
pub fn get_include_time(&self) -> bool {
self.include_time
}
pub fn clear_include_time(&mut self) {
self.include_time = false;
}
// Param is passed by value, moved
pub fn set_include_time(&mut self, v: bool) {
self.include_time = v;
}
}
impl ::protobuf::Message for DateTypeOption {
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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.date_format, 1, &mut self.unknown_fields)?
},
2 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.time_format, 2, &mut self.unknown_fields)?
},
3 => {
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.include_time = 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.date_format != DateFormat::Local {
my_size += ::protobuf::rt::enum_size(1, self.date_format);
}
if self.time_format != TimeFormat::TwelveHour {
my_size += ::protobuf::rt::enum_size(2, self.time_format);
}
if self.include_time != 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.date_format != DateFormat::Local {
os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.date_format))?;
}
if self.time_format != TimeFormat::TwelveHour {
os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.time_format))?;
}
if self.include_time != false {
os.write_bool(3, self.include_time)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DateTypeOption {
DateTypeOption::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<DateFormat>>(
"date_format",
|m: &DateTypeOption| { &m.date_format },
|m: &mut DateTypeOption| { &mut m.date_format },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TimeFormat>>(
"time_format",
|m: &DateTypeOption| { &m.time_format },
|m: &mut DateTypeOption| { &mut m.time_format },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"include_time",
|m: &DateTypeOption| { &m.include_time },
|m: &mut DateTypeOption| { &mut m.include_time },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DateTypeOption>(
"DateTypeOption",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DateTypeOption {
static instance: ::protobuf::rt::LazyV2<DateTypeOption> = ::protobuf::rt::LazyV2::INIT;
instance.get(DateTypeOption::new)
}
}
impl ::protobuf::Clear for DateTypeOption {
fn clear(&mut self) {
self.date_format = DateFormat::Local;
self.time_format = TimeFormat::TwelveHour;
self.include_time = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DateTypeOption {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DateTypeOption {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DateCellData {
// message fields
pub date: ::std::string::String,
pub time: ::std::string::String,
pub timestamp: i64,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DateCellData {
fn default() -> &'a DateCellData {
<DateCellData as ::protobuf::Message>::default_instance()
}
}
impl DateCellData {
pub fn new() -> DateCellData {
::std::default::Default::default()
}
// string date = 1;
pub fn get_date(&self) -> &str {
&self.date
}
pub fn clear_date(&mut self) {
self.date.clear();
}
// Param is passed by value, moved
pub fn set_date(&mut self, v: ::std::string::String) {
self.date = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_date(&mut self) -> &mut ::std::string::String {
&mut self.date
}
// Take field
pub fn take_date(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.date, ::std::string::String::new())
}
// string time = 2;
pub fn get_time(&self) -> &str {
&self.time
}
pub fn clear_time(&mut self) {
self.time.clear();
}
// Param is passed by value, moved
pub fn set_time(&mut self, v: ::std::string::String) {
self.time = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_time(&mut self) -> &mut ::std::string::String {
&mut self.time
}
// Take field
pub fn take_time(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.time, ::std::string::String::new())
}
// int64 timestamp = 3;
pub fn get_timestamp(&self) -> i64 {
self.timestamp
}
pub fn clear_timestamp(&mut self) {
self.timestamp = 0;
}
// Param is passed by value, moved
pub fn set_timestamp(&mut self, v: i64) {
self.timestamp = v;
}
}
impl ::protobuf::Message for DateCellData {
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.date)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.time)?;
},
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.timestamp = 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.date.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.date);
}
if !self.time.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.time);
}
if self.timestamp != 0 {
my_size += ::protobuf::rt::value_size(3, self.timestamp, ::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.date.is_empty() {
os.write_string(1, &self.date)?;
}
if !self.time.is_empty() {
os.write_string(2, &self.time)?;
}
if self.timestamp != 0 {
os.write_int64(3, self.timestamp)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DateCellData {
DateCellData::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"date",
|m: &DateCellData| { &m.date },
|m: &mut DateCellData| { &mut m.date },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"time",
|m: &DateCellData| { &m.time },
|m: &mut DateCellData| { &mut m.time },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
"timestamp",
|m: &DateCellData| { &m.timestamp },
|m: &mut DateCellData| { &mut m.timestamp },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DateCellData>(
"DateCellData",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DateCellData {
static instance: ::protobuf::rt::LazyV2<DateCellData> = ::protobuf::rt::LazyV2::INIT;
instance.get(DateCellData::new)
}
}
impl ::protobuf::Clear for DateCellData {
fn clear(&mut self) {
self.date.clear();
self.time.clear();
self.timestamp = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DateCellData {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DateCellData {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DateChangesetPayload {
// message fields
pub cell_identifier: ::protobuf::SingularPtrField<super::cell_entities::CellIdentifierPayload>,
// message oneof groups
pub one_of_date: ::std::option::Option<DateChangesetPayload_oneof_one_of_date>,
pub one_of_time: ::std::option::Option<DateChangesetPayload_oneof_one_of_time>,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DateChangesetPayload {
fn default() -> &'a DateChangesetPayload {
<DateChangesetPayload as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum DateChangesetPayload_oneof_one_of_date {
date(::std::string::String),
}
#[derive(Clone,PartialEq,Debug)]
pub enum DateChangesetPayload_oneof_one_of_time {
time(::std::string::String),
}
impl DateChangesetPayload {
pub fn new() -> DateChangesetPayload {
::std::default::Default::default()
}
// .CellIdentifierPayload cell_identifier = 1;
pub fn get_cell_identifier(&self) -> &super::cell_entities::CellIdentifierPayload {
self.cell_identifier.as_ref().unwrap_or_else(|| <super::cell_entities::CellIdentifierPayload as ::protobuf::Message>::default_instance())
}
pub fn clear_cell_identifier(&mut self) {
self.cell_identifier.clear();
}
pub fn has_cell_identifier(&self) -> bool {
self.cell_identifier.is_some()
}
// Param is passed by value, moved
pub fn set_cell_identifier(&mut self, v: super::cell_entities::CellIdentifierPayload) {
self.cell_identifier = ::protobuf::SingularPtrField::some(v);
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_cell_identifier(&mut self) -> &mut super::cell_entities::CellIdentifierPayload {
if self.cell_identifier.is_none() {
self.cell_identifier.set_default();
}
self.cell_identifier.as_mut().unwrap()
}
// Take field
pub fn take_cell_identifier(&mut self) -> super::cell_entities::CellIdentifierPayload {
self.cell_identifier.take().unwrap_or_else(|| super::cell_entities::CellIdentifierPayload::new())
}
// string date = 2;
pub fn get_date(&self) -> &str {
match self.one_of_date {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(ref v)) => v,
_ => "",
}
}
pub fn clear_date(&mut self) {
self.one_of_date = ::std::option::Option::None;
}
pub fn has_date(&self) -> bool {
match self.one_of_date {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(..)) => true,
_ => false,
}
}
// Param is passed by value, moved
pub fn set_date(&mut self, v: ::std::string::String) {
self.one_of_date = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(v))
}
// Mutable pointer to the field.
pub fn mut_date(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(_)) = self.one_of_date {
} else {
self.one_of_date = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(::std::string::String::new()));
}
match self.one_of_date {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(ref mut v)) => v,
_ => panic!(),
}
}
// Take field
pub fn take_date(&mut self) -> ::std::string::String {
if self.has_date() {
match self.one_of_date.take() {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
// string time = 3;
pub fn get_time(&self) -> &str {
match self.one_of_time {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(ref v)) => v,
_ => "",
}
}
pub fn clear_time(&mut self) {
self.one_of_time = ::std::option::Option::None;
}
pub fn has_time(&self) -> bool {
match self.one_of_time {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(..)) => true,
_ => false,
}
}
// Param is passed by value, moved
pub fn set_time(&mut self, v: ::std::string::String) {
self.one_of_time = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(v))
}
// Mutable pointer to the field.
pub fn mut_time(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(_)) = self.one_of_time {
} else {
self.one_of_time = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(::std::string::String::new()));
}
match self.one_of_time {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(ref mut v)) => v,
_ => panic!(),
}
}
// Take field
pub fn take_time(&mut self) -> ::std::string::String {
if self.has_time() {
match self.one_of_time.take() {
::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
}
impl ::protobuf::Message for DateChangesetPayload {
fn is_initialized(&self) -> bool {
for v in &self.cell_identifier {
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.cell_identifier)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.one_of_date = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_date::date(is.read_string()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.one_of_time = ::std::option::Option::Some(DateChangesetPayload_oneof_one_of_time::time(is.read_string()?));
},
_ => {
::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.cell_identifier.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let ::std::option::Option::Some(ref v) = self.one_of_date {
match v {
&DateChangesetPayload_oneof_one_of_date::date(ref v) => {
my_size += ::protobuf::rt::string_size(2, &v);
},
};
}
if let ::std::option::Option::Some(ref v) = self.one_of_time {
match v {
&DateChangesetPayload_oneof_one_of_time::time(ref v) => {
my_size += ::protobuf::rt::string_size(3, &v);
},
};
}
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.cell_identifier.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 ::std::option::Option::Some(ref v) = self.one_of_date {
match v {
&DateChangesetPayload_oneof_one_of_date::date(ref v) => {
os.write_string(2, v)?;
},
};
}
if let ::std::option::Option::Some(ref v) = self.one_of_time {
match v {
&DateChangesetPayload_oneof_one_of_time::time(ref v) => {
os.write_string(3, 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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DateChangesetPayload {
DateChangesetPayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::cell_entities::CellIdentifierPayload>>(
"cell_identifier",
|m: &DateChangesetPayload| { &m.cell_identifier },
|m: &mut DateChangesetPayload| { &mut m.cell_identifier },
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"date",
DateChangesetPayload::has_date,
DateChangesetPayload::get_date,
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"time",
DateChangesetPayload::has_time,
DateChangesetPayload::get_time,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DateChangesetPayload>(
"DateChangesetPayload",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DateChangesetPayload {
static instance: ::protobuf::rt::LazyV2<DateChangesetPayload> = ::protobuf::rt::LazyV2::INIT;
instance.get(DateChangesetPayload::new)
}
}
impl ::protobuf::Clear for DateChangesetPayload {
fn clear(&mut self) {
self.cell_identifier.clear();
self.one_of_date = ::std::option::Option::None;
self.one_of_time = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DateChangesetPayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DateChangesetPayload {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum DateFormat {
Local = 0,
US = 1,
ISO = 2,
Friendly = 3,
}
impl ::protobuf::ProtobufEnum for DateFormat {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<DateFormat> {
match value {
0 => ::std::option::Option::Some(DateFormat::Local),
1 => ::std::option::Option::Some(DateFormat::US),
2 => ::std::option::Option::Some(DateFormat::ISO),
3 => ::std::option::Option::Some(DateFormat::Friendly),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [DateFormat] = &[
DateFormat::Local,
DateFormat::US,
DateFormat::ISO,
DateFormat::Friendly,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<DateFormat>("DateFormat", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for DateFormat {
}
impl ::std::default::Default for DateFormat {
fn default() -> Self {
DateFormat::Local
}
}
impl ::protobuf::reflect::ProtobufValue for DateFormat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TimeFormat {
TwelveHour = 0,
TwentyFourHour = 1,
}
impl ::protobuf::ProtobufEnum for TimeFormat {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<TimeFormat> {
match value {
0 => ::std::option::Option::Some(TimeFormat::TwelveHour),
1 => ::std::option::Option::Some(TimeFormat::TwentyFourHour),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [TimeFormat] = &[
TimeFormat::TwelveHour,
TimeFormat::TwentyFourHour,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<TimeFormat>("TimeFormat", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for TimeFormat {
}
impl ::std::default::Default for TimeFormat {
fn default() -> Self {
TimeFormat::TwelveHour
}
}
impl ::protobuf::reflect::ProtobufValue for TimeFormat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x16date_type_option.proto\x1a\x13cell_entities.proto\"\x8f\x01\n\x0eD\
ateTypeOption\x12,\n\x0bdate_format\x18\x01\x20\x01(\x0e2\x0b.DateFormat\
R\ndateFormat\x12,\n\x0btime_format\x18\x02\x20\x01(\x0e2\x0b.TimeFormat\
R\ntimeFormat\x12!\n\x0cinclude_time\x18\x03\x20\x01(\x08R\x0bincludeTim\
e\"T\n\x0cDateCellData\x12\x12\n\x04date\x18\x01\x20\x01(\tR\x04date\x12\
\x12\n\x04time\x18\x02\x20\x01(\tR\x04time\x12\x1c\n\ttimestamp\x18\x03\
\x20\x01(\x03R\ttimestamp\"\xa1\x01\n\x14DateChangesetPayload\x12?\n\x0f\
cell_identifier\x18\x01\x20\x01(\x0b2\x16.CellIdentifierPayloadR\x0ecell\
Identifier\x12\x14\n\x04date\x18\x02\x20\x01(\tH\0R\x04date\x12\x14\n\
\x04time\x18\x03\x20\x01(\tH\x01R\x04timeB\r\n\x0bone_of_dateB\r\n\x0bon\
e_of_time*6\n\nDateFormat\x12\t\n\x05Local\x10\0\x12\x06\n\x02US\x10\x01\
\x12\x07\n\x03ISO\x10\x02\x12\x0c\n\x08Friendly\x10\x03*0\n\nTimeFormat\
\x12\x0e\n\nTwelveHour\x10\0\x12\x12\n\x0eTwentyFourHour\x10\x01b\x06pro\
to3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

164
frontend/rust-lib/flowy-grid/src/protobuf/model/event_map.rs
View File

@ -1,164 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `event_map.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum GridEvent {
GetGridData = 0,
GetGridBlocks = 1,
GetFields = 10,
UpdateField = 11,
UpdateFieldTypeOption = 12,
InsertField = 13,
DeleteField = 14,
SwitchToField = 20,
DuplicateField = 21,
MoveItem = 22,
GetFieldTypeOption = 23,
CreateFieldTypeOption = 24,
NewSelectOption = 30,
GetSelectOptionCellData = 31,
UpdateSelectOption = 32,
CreateRow = 50,
GetRow = 51,
DeleteRow = 52,
DuplicateRow = 53,
GetCell = 70,
UpdateCell = 71,
UpdateSelectOptionCell = 72,
UpdateDateCell = 80,
}
impl ::protobuf::ProtobufEnum for GridEvent {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<GridEvent> {
match value {
0 => ::std::option::Option::Some(GridEvent::GetGridData),
1 => ::std::option::Option::Some(GridEvent::GetGridBlocks),
10 => ::std::option::Option::Some(GridEvent::GetFields),
11 => ::std::option::Option::Some(GridEvent::UpdateField),
12 => ::std::option::Option::Some(GridEvent::UpdateFieldTypeOption),
13 => ::std::option::Option::Some(GridEvent::InsertField),
14 => ::std::option::Option::Some(GridEvent::DeleteField),
20 => ::std::option::Option::Some(GridEvent::SwitchToField),
21 => ::std::option::Option::Some(GridEvent::DuplicateField),
22 => ::std::option::Option::Some(GridEvent::MoveItem),
23 => ::std::option::Option::Some(GridEvent::GetFieldTypeOption),
24 => ::std::option::Option::Some(GridEvent::CreateFieldTypeOption),
30 => ::std::option::Option::Some(GridEvent::NewSelectOption),
31 => ::std::option::Option::Some(GridEvent::GetSelectOptionCellData),
32 => ::std::option::Option::Some(GridEvent::UpdateSelectOption),
50 => ::std::option::Option::Some(GridEvent::CreateRow),
51 => ::std::option::Option::Some(GridEvent::GetRow),
52 => ::std::option::Option::Some(GridEvent::DeleteRow),
53 => ::std::option::Option::Some(GridEvent::DuplicateRow),
70 => ::std::option::Option::Some(GridEvent::GetCell),
71 => ::std::option::Option::Some(GridEvent::UpdateCell),
72 => ::std::option::Option::Some(GridEvent::UpdateSelectOptionCell),
80 => ::std::option::Option::Some(GridEvent::UpdateDateCell),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [GridEvent] = &[
GridEvent::GetGridData,
GridEvent::GetGridBlocks,
GridEvent::GetFields,
GridEvent::UpdateField,
GridEvent::UpdateFieldTypeOption,
GridEvent::InsertField,
GridEvent::DeleteField,
GridEvent::SwitchToField,
GridEvent::DuplicateField,
GridEvent::MoveItem,
GridEvent::GetFieldTypeOption,
GridEvent::CreateFieldTypeOption,
GridEvent::NewSelectOption,
GridEvent::GetSelectOptionCellData,
GridEvent::UpdateSelectOption,
GridEvent::CreateRow,
GridEvent::GetRow,
GridEvent::DeleteRow,
GridEvent::DuplicateRow,
GridEvent::GetCell,
GridEvent::UpdateCell,
GridEvent::UpdateSelectOptionCell,
GridEvent::UpdateDateCell,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<GridEvent>("GridEvent", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for GridEvent {
}
impl ::std::default::Default for GridEvent {
fn default() -> Self {
GridEvent::GetGridData
}
}
impl ::protobuf::reflect::ProtobufValue for GridEvent {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x0fevent_map.proto*\xc7\x03\n\tGridEvent\x12\x0f\n\x0bGetGridData\x10\
\0\x12\x11\n\rGetGridBlocks\x10\x01\x12\r\n\tGetFields\x10\n\x12\x0f\n\
\x0bUpdateField\x10\x0b\x12\x19\n\x15UpdateFieldTypeOption\x10\x0c\x12\
\x0f\n\x0bInsertField\x10\r\x12\x0f\n\x0bDeleteField\x10\x0e\x12\x11\n\r\
SwitchToField\x10\x14\x12\x12\n\x0eDuplicateField\x10\x15\x12\x0c\n\x08M\
oveItem\x10\x16\x12\x16\n\x12GetFieldTypeOption\x10\x17\x12\x19\n\x15Cre\
ateFieldTypeOption\x10\x18\x12\x13\n\x0fNewSelectOption\x10\x1e\x12\x1b\
\n\x17GetSelectOptionCellData\x10\x1f\x12\x16\n\x12UpdateSelectOption\
\x10\x20\x12\r\n\tCreateRow\x102\x12\n\n\x06GetRow\x103\x12\r\n\tDeleteR\
ow\x104\x12\x10\n\x0cDuplicateRow\x105\x12\x0b\n\x07GetCell\x10F\x12\x0e\
\n\nUpdateCell\x10G\x12\x1a\n\x16UpdateSelectOptionCell\x10H\x12\x12\n\
\x0eUpdateDateCell\x10Pb\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

243
frontend/rust-lib/flowy-grid/src/protobuf/model/field_entities.rs
View File

@ -1,243 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `field_entities.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct FieldIdentifierPayload {
// message fields
pub field_id: ::std::string::String,
pub grid_id: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a FieldIdentifierPayload {
fn default() -> &'a FieldIdentifierPayload {
<FieldIdentifierPayload as ::protobuf::Message>::default_instance()
}
}
impl FieldIdentifierPayload {
pub fn new() -> FieldIdentifierPayload {
::std::default::Default::default()
}
// string field_id = 1;
pub fn get_field_id(&self) -> &str {
&self.field_id
}
pub fn clear_field_id(&mut self) {
self.field_id.clear();
}
// Param is passed by value, moved
pub fn set_field_id(&mut self, v: ::std::string::String) {
self.field_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_field_id(&mut self) -> &mut ::std::string::String {
&mut self.field_id
}
// Take field
pub fn take_field_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.field_id, ::std::string::String::new())
}
// string grid_id = 2;
pub fn get_grid_id(&self) -> &str {
&self.grid_id
}
pub fn clear_grid_id(&mut self) {
self.grid_id.clear();
}
// Param is passed by value, moved
pub fn set_grid_id(&mut self, v: ::std::string::String) {
self.grid_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_grid_id(&mut self) -> &mut ::std::string::String {
&mut self.grid_id
}
// Take field
pub fn take_grid_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.grid_id, ::std::string::String::new())
}
}
impl ::protobuf::Message for FieldIdentifierPayload {
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.field_id)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.grid_id)?;
},
_ => {
::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.field_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.field_id);
}
if !self.grid_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.grid_id);
}
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.field_id.is_empty() {
os.write_string(1, &self.field_id)?;
}
if !self.grid_id.is_empty() {
os.write_string(2, &self.grid_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> FieldIdentifierPayload {
FieldIdentifierPayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"field_id",
|m: &FieldIdentifierPayload| { &m.field_id },
|m: &mut FieldIdentifierPayload| { &mut m.field_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"grid_id",
|m: &FieldIdentifierPayload| { &m.grid_id },
|m: &mut FieldIdentifierPayload| { &mut m.grid_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldIdentifierPayload>(
"FieldIdentifierPayload",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static FieldIdentifierPayload {
static instance: ::protobuf::rt::LazyV2<FieldIdentifierPayload> = ::protobuf::rt::LazyV2::INIT;
instance.get(FieldIdentifierPayload::new)
}
}
impl ::protobuf::Clear for FieldIdentifierPayload {
fn clear(&mut self) {
self.field_id.clear();
self.grid_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for FieldIdentifierPayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for FieldIdentifierPayload {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x14field_entities.proto\"L\n\x16FieldIdentifierPayload\x12\x19\n\x08f\
ield_id\x18\x01\x20\x01(\tR\x07fieldId\x12\x17\n\x07grid_id\x18\x02\x20\
\x01(\tR\x06gridIdb\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

207
frontend/rust-lib/flowy-grid/src/protobuf/model/format.rs
View File

@ -1,207 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `format.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum NumberFormat {
Number = 0,
USD = 1,
CanadianDollar = 2,
EUR = 4,
Pound = 5,
Yen = 6,
Ruble = 7,
Rupee = 8,
Won = 9,
Yuan = 10,
Real = 11,
Lira = 12,
Rupiah = 13,
Franc = 14,
HongKongDollar = 15,
NewZealandDollar = 16,
Krona = 17,
NorwegianKrone = 18,
MexicanPeso = 19,
Rand = 20,
NewTaiwanDollar = 21,
DanishKrone = 22,
Baht = 23,
Forint = 24,
Koruna = 25,
Shekel = 26,
ChileanPeso = 27,
PhilippinePeso = 28,
Dirham = 29,
ColombianPeso = 30,
Riyal = 31,
Ringgit = 32,
Leu = 33,
ArgentinePeso = 34,
UruguayanPeso = 35,
Percent = 36,
}
impl ::protobuf::ProtobufEnum for NumberFormat {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<NumberFormat> {
match value {
0 => ::std::option::Option::Some(NumberFormat::Number),
1 => ::std::option::Option::Some(NumberFormat::USD),
2 => ::std::option::Option::Some(NumberFormat::CanadianDollar),
4 => ::std::option::Option::Some(NumberFormat::EUR),
5 => ::std::option::Option::Some(NumberFormat::Pound),
6 => ::std::option::Option::Some(NumberFormat::Yen),
7 => ::std::option::Option::Some(NumberFormat::Ruble),
8 => ::std::option::Option::Some(NumberFormat::Rupee),
9 => ::std::option::Option::Some(NumberFormat::Won),
10 => ::std::option::Option::Some(NumberFormat::Yuan),
11 => ::std::option::Option::Some(NumberFormat::Real),
12 => ::std::option::Option::Some(NumberFormat::Lira),
13 => ::std::option::Option::Some(NumberFormat::Rupiah),
14 => ::std::option::Option::Some(NumberFormat::Franc),
15 => ::std::option::Option::Some(NumberFormat::HongKongDollar),
16 => ::std::option::Option::Some(NumberFormat::NewZealandDollar),
17 => ::std::option::Option::Some(NumberFormat::Krona),
18 => ::std::option::Option::Some(NumberFormat::NorwegianKrone),
19 => ::std::option::Option::Some(NumberFormat::MexicanPeso),
20 => ::std::option::Option::Some(NumberFormat::Rand),
21 => ::std::option::Option::Some(NumberFormat::NewTaiwanDollar),
22 => ::std::option::Option::Some(NumberFormat::DanishKrone),
23 => ::std::option::Option::Some(NumberFormat::Baht),
24 => ::std::option::Option::Some(NumberFormat::Forint),
25 => ::std::option::Option::Some(NumberFormat::Koruna),
26 => ::std::option::Option::Some(NumberFormat::Shekel),
27 => ::std::option::Option::Some(NumberFormat::ChileanPeso),
28 => ::std::option::Option::Some(NumberFormat::PhilippinePeso),
29 => ::std::option::Option::Some(NumberFormat::Dirham),
30 => ::std::option::Option::Some(NumberFormat::ColombianPeso),
31 => ::std::option::Option::Some(NumberFormat::Riyal),
32 => ::std::option::Option::Some(NumberFormat::Ringgit),
33 => ::std::option::Option::Some(NumberFormat::Leu),
34 => ::std::option::Option::Some(NumberFormat::ArgentinePeso),
35 => ::std::option::Option::Some(NumberFormat::UruguayanPeso),
36 => ::std::option::Option::Some(NumberFormat::Percent),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [NumberFormat] = &[
NumberFormat::Number,
NumberFormat::USD,
NumberFormat::CanadianDollar,
NumberFormat::EUR,
NumberFormat::Pound,
NumberFormat::Yen,
NumberFormat::Ruble,
NumberFormat::Rupee,
NumberFormat::Won,
NumberFormat::Yuan,
NumberFormat::Real,
NumberFormat::Lira,
NumberFormat::Rupiah,
NumberFormat::Franc,
NumberFormat::HongKongDollar,
NumberFormat::NewZealandDollar,
NumberFormat::Krona,
NumberFormat::NorwegianKrone,
NumberFormat::MexicanPeso,
NumberFormat::Rand,
NumberFormat::NewTaiwanDollar,
NumberFormat::DanishKrone,
NumberFormat::Baht,
NumberFormat::Forint,
NumberFormat::Koruna,
NumberFormat::Shekel,
NumberFormat::ChileanPeso,
NumberFormat::PhilippinePeso,
NumberFormat::Dirham,
NumberFormat::ColombianPeso,
NumberFormat::Riyal,
NumberFormat::Ringgit,
NumberFormat::Leu,
NumberFormat::ArgentinePeso,
NumberFormat::UruguayanPeso,
NumberFormat::Percent,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<NumberFormat>("NumberFormat", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for NumberFormat {
}
impl ::std::default::Default for NumberFormat {
fn default() -> Self {
NumberFormat::Number
}
}
impl ::protobuf::reflect::ProtobufValue for NumberFormat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x0cformat.proto*\xf8\x03\n\x0cNumberFormat\x12\n\n\x06Number\x10\0\
\x12\x07\n\x03USD\x10\x01\x12\x12\n\x0eCanadianDollar\x10\x02\x12\x07\n\
\x03EUR\x10\x04\x12\t\n\x05Pound\x10\x05\x12\x07\n\x03Yen\x10\x06\x12\t\
\n\x05Ruble\x10\x07\x12\t\n\x05Rupee\x10\x08\x12\x07\n\x03Won\x10\t\x12\
\x08\n\x04Yuan\x10\n\x12\x08\n\x04Real\x10\x0b\x12\x08\n\x04Lira\x10\x0c\
\x12\n\n\x06Rupiah\x10\r\x12\t\n\x05Franc\x10\x0e\x12\x12\n\x0eHongKongD\
ollar\x10\x0f\x12\x14\n\x10NewZealandDollar\x10\x10\x12\t\n\x05Krona\x10\
\x11\x12\x12\n\x0eNorwegianKrone\x10\x12\x12\x0f\n\x0bMexicanPeso\x10\
\x13\x12\x08\n\x04Rand\x10\x14\x12\x13\n\x0fNewTaiwanDollar\x10\x15\x12\
\x0f\n\x0bDanishKrone\x10\x16\x12\x08\n\x04Baht\x10\x17\x12\n\n\x06Forin\
t\x10\x18\x12\n\n\x06Koruna\x10\x19\x12\n\n\x06Shekel\x10\x1a\x12\x0f\n\
\x0bChileanPeso\x10\x1b\x12\x12\n\x0ePhilippinePeso\x10\x1c\x12\n\n\x06D\
irham\x10\x1d\x12\x11\n\rColombianPeso\x10\x1e\x12\t\n\x05Riyal\x10\x1f\
\x12\x0b\n\x07Ringgit\x10\x20\x12\x07\n\x03Leu\x10!\x12\x11\n\rArgentine\
Peso\x10\"\x12\x11\n\rUruguayanPeso\x10#\x12\x0b\n\x07Percent\x10$b\x06p\
roto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

38
frontend/rust-lib/flowy-grid/src/protobuf/model/mod.rs
View File

@ -1,38 +0,0 @@
#![cfg_attr(rustfmt, rustfmt::skip)]
// Auto-generated, do not edit
mod field_entities;
pub use field_entities::*;
mod number_type_option;
pub use number_type_option::*;
mod dart_notification;
pub use dart_notification::*;
mod selection_type_option;
pub use selection_type_option::*;
mod row_entities;
pub use row_entities::*;
mod cell_entities;
pub use cell_entities::*;
mod url_type_option;
pub use url_type_option::*;
mod checkbox_type_option;
pub use checkbox_type_option::*;
mod format;
pub use format::*;
mod event_map;
pub use event_map::*;
mod text_type_option;
pub use text_type_option::*;
mod date_type_option;
pub use date_type_option::*;

347
frontend/rust-lib/flowy-grid/src/protobuf/model/number_type_option.rs
View File

@ -1,347 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `number_type_option.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct NumberTypeOption {
// message fields
pub format: super::format::NumberFormat,
pub scale: u32,
pub symbol: ::std::string::String,
pub sign_positive: bool,
pub name: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a NumberTypeOption {
fn default() -> &'a NumberTypeOption {
<NumberTypeOption as ::protobuf::Message>::default_instance()
}
}
impl NumberTypeOption {
pub fn new() -> NumberTypeOption {
::std::default::Default::default()
}
// .NumberFormat format = 1;
pub fn get_format(&self) -> super::format::NumberFormat {
self.format
}
pub fn clear_format(&mut self) {
self.format = super::format::NumberFormat::Number;
}
// Param is passed by value, moved
pub fn set_format(&mut self, v: super::format::NumberFormat) {
self.format = v;
}
// uint32 scale = 2;
pub fn get_scale(&self) -> u32 {
self.scale
}
pub fn clear_scale(&mut self) {
self.scale = 0;
}
// Param is passed by value, moved
pub fn set_scale(&mut self, v: u32) {
self.scale = v;
}
// string symbol = 3;
pub fn get_symbol(&self) -> &str {
&self.symbol
}
pub fn clear_symbol(&mut self) {
self.symbol.clear();
}
// Param is passed by value, moved
pub fn set_symbol(&mut self, v: ::std::string::String) {
self.symbol = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_symbol(&mut self) -> &mut ::std::string::String {
&mut self.symbol
}
// Take field
pub fn take_symbol(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.symbol, ::std::string::String::new())
}
// bool sign_positive = 4;
pub fn get_sign_positive(&self) -> bool {
self.sign_positive
}
pub fn clear_sign_positive(&mut self) {
self.sign_positive = false;
}
// Param is passed by value, moved
pub fn set_sign_positive(&mut self, v: bool) {
self.sign_positive = v;
}
// string name = 5;
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
// Param is passed by value, moved
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
// Take field
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
}
impl ::protobuf::Message for NumberTypeOption {
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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.format, 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_uint32()?;
self.scale = tmp;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.symbol)?;
},
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.sign_positive = tmp;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
_ => {
::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.format != super::format::NumberFormat::Number {
my_size += ::protobuf::rt::enum_size(1, self.format);
}
if self.scale != 0 {
my_size += ::protobuf::rt::value_size(2, self.scale, ::protobuf::wire_format::WireTypeVarint);
}
if !self.symbol.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.symbol);
}
if self.sign_positive != false {
my_size += 2;
}
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.name);
}
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.format != super::format::NumberFormat::Number {
os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.format))?;
}
if self.scale != 0 {
os.write_uint32(2, self.scale)?;
}
if !self.symbol.is_empty() {
os.write_string(3, &self.symbol)?;
}
if self.sign_positive != false {
os.write_bool(4, self.sign_positive)?;
}
if !self.name.is_empty() {
os.write_string(5, &self.name)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> NumberTypeOption {
NumberTypeOption::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::format::NumberFormat>>(
"format",
|m: &NumberTypeOption| { &m.format },
|m: &mut NumberTypeOption| { &mut m.format },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"scale",
|m: &NumberTypeOption| { &m.scale },
|m: &mut NumberTypeOption| { &mut m.scale },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"symbol",
|m: &NumberTypeOption| { &m.symbol },
|m: &mut NumberTypeOption| { &mut m.symbol },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"sign_positive",
|m: &NumberTypeOption| { &m.sign_positive },
|m: &mut NumberTypeOption| { &mut m.sign_positive },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &NumberTypeOption| { &m.name },
|m: &mut NumberTypeOption| { &mut m.name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<NumberTypeOption>(
"NumberTypeOption",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static NumberTypeOption {
static instance: ::protobuf::rt::LazyV2<NumberTypeOption> = ::protobuf::rt::LazyV2::INIT;
instance.get(NumberTypeOption::new)
}
}
impl ::protobuf::Clear for NumberTypeOption {
fn clear(&mut self) {
self.format = super::format::NumberFormat::Number;
self.scale = 0;
self.symbol.clear();
self.sign_positive = false;
self.name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for NumberTypeOption {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NumberTypeOption {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x18number_type_option.proto\x1a\x0cformat.proto\"\xa0\x01\n\x10Number\
TypeOption\x12%\n\x06format\x18\x01\x20\x01(\x0e2\r.NumberFormatR\x06for\
mat\x12\x14\n\x05scale\x18\x02\x20\x01(\rR\x05scale\x12\x16\n\x06symbol\
\x18\x03\x20\x01(\tR\x06symbol\x12#\n\rsign_positive\x18\x04\x20\x01(\
\x08R\x0csignPositive\x12\x12\n\x04name\x18\x05\x20\x01(\tR\x04nameb\x06\
proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

243
frontend/rust-lib/flowy-grid/src/protobuf/model/row_entities.rs
View File

@ -1,243 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `row_entities.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct RowIdentifierPayload {
// message fields
pub grid_id: ::std::string::String,
pub row_id: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RowIdentifierPayload {
fn default() -> &'a RowIdentifierPayload {
<RowIdentifierPayload as ::protobuf::Message>::default_instance()
}
}
impl RowIdentifierPayload {
pub fn new() -> RowIdentifierPayload {
::std::default::Default::default()
}
// string grid_id = 1;
pub fn get_grid_id(&self) -> &str {
&self.grid_id
}
pub fn clear_grid_id(&mut self) {
self.grid_id.clear();
}
// Param is passed by value, moved
pub fn set_grid_id(&mut self, v: ::std::string::String) {
self.grid_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_grid_id(&mut self) -> &mut ::std::string::String {
&mut self.grid_id
}
// Take field
pub fn take_grid_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.grid_id, ::std::string::String::new())
}
// string row_id = 3;
pub fn get_row_id(&self) -> &str {
&self.row_id
}
pub fn clear_row_id(&mut self) {
self.row_id.clear();
}
// Param is passed by value, moved
pub fn set_row_id(&mut self, v: ::std::string::String) {
self.row_id = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_row_id(&mut self) -> &mut ::std::string::String {
&mut self.row_id
}
// Take field
pub fn take_row_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.row_id, ::std::string::String::new())
}
}
impl ::protobuf::Message for RowIdentifierPayload {
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.grid_id)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.row_id)?;
},
_ => {
::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.grid_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.grid_id);
}
if !self.row_id.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.row_id);
}
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.grid_id.is_empty() {
os.write_string(1, &self.grid_id)?;
}
if !self.row_id.is_empty() {
os.write_string(3, &self.row_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RowIdentifierPayload {
RowIdentifierPayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"grid_id",
|m: &RowIdentifierPayload| { &m.grid_id },
|m: &mut RowIdentifierPayload| { &mut m.grid_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"row_id",
|m: &RowIdentifierPayload| { &m.row_id },
|m: &mut RowIdentifierPayload| { &mut m.row_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<RowIdentifierPayload>(
"RowIdentifierPayload",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static RowIdentifierPayload {
static instance: ::protobuf::rt::LazyV2<RowIdentifierPayload> = ::protobuf::rt::LazyV2::INIT;
instance.get(RowIdentifierPayload::new)
}
}
impl ::protobuf::Clear for RowIdentifierPayload {
fn clear(&mut self) {
self.grid_id.clear();
self.row_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for RowIdentifierPayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RowIdentifierPayload {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x12row_entities.proto\"F\n\x14RowIdentifierPayload\x12\x17\n\x07grid_\
id\x18\x01\x20\x01(\tR\x06gridId\x12\x15\n\x06row_id\x18\x03\x20\x01(\tR\
\x05rowIdb\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

1764
frontend/rust-lib/flowy-grid/src/protobuf/model/selection_type_option.rs
View File

File diff suppressed because it is too large Load Diff

200
frontend/rust-lib/flowy-grid/src/protobuf/model/text_type_option.rs
View File

@ -1,200 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `text_type_option.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct RichTextTypeOption {
// message fields
pub data: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RichTextTypeOption {
fn default() -> &'a RichTextTypeOption {
<RichTextTypeOption as ::protobuf::Message>::default_instance()
}
}
impl RichTextTypeOption {
pub fn new() -> RichTextTypeOption {
::std::default::Default::default()
}
// string data = 1;
pub fn get_data(&self) -> &str {
&self.data
}
pub fn clear_data(&mut self) {
self.data.clear();
}
// Param is passed by value, moved
pub fn set_data(&mut self, v: ::std::string::String) {
self.data = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_data(&mut self) -> &mut ::std::string::String {
&mut self.data
}
// Take field
pub fn take_data(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.data, ::std::string::String::new())
}
}
impl ::protobuf::Message for RichTextTypeOption {
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.data)?;
},
_ => {
::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.data.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.data);
}
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.data.is_empty() {
os.write_string(1, &self.data)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RichTextTypeOption {
RichTextTypeOption::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"data",
|m: &RichTextTypeOption| { &m.data },
|m: &mut RichTextTypeOption| { &mut m.data },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<RichTextTypeOption>(
"RichTextTypeOption",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static RichTextTypeOption {
static instance: ::protobuf::rt::LazyV2<RichTextTypeOption> = ::protobuf::rt::LazyV2::INIT;
instance.get(RichTextTypeOption::new)
}
}
impl ::protobuf::Clear for RichTextTypeOption {
fn clear(&mut self) {
self.data.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for RichTextTypeOption {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RichTextTypeOption {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x16text_type_option.proto\"(\n\x12RichTextTypeOption\x12\x12\n\x04dat\
a\x18\x01\x20\x01(\tR\x04datab\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

403
frontend/rust-lib/flowy-grid/src/protobuf/model/url_type_option.rs
View File

@ -1,403 +0,0 @@
// This file is generated by rust-protobuf 2.25.2. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `url_type_option.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
#[derive(PartialEq,Clone,Default)]
pub struct URLTypeOption {
// message fields
pub data: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a URLTypeOption {
fn default() -> &'a URLTypeOption {
<URLTypeOption as ::protobuf::Message>::default_instance()
}
}
impl URLTypeOption {
pub fn new() -> URLTypeOption {
::std::default::Default::default()
}
// string data = 1;
pub fn get_data(&self) -> &str {
&self.data
}
pub fn clear_data(&mut self) {
self.data.clear();
}
// Param is passed by value, moved
pub fn set_data(&mut self, v: ::std::string::String) {
self.data = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_data(&mut self) -> &mut ::std::string::String {
&mut self.data
}
// Take field
pub fn take_data(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.data, ::std::string::String::new())
}
}
impl ::protobuf::Message for URLTypeOption {
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.data)?;
},
_ => {
::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.data.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.data);
}
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.data.is_empty() {
os.write_string(1, &self.data)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> URLTypeOption {
URLTypeOption::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"data",
|m: &URLTypeOption| { &m.data },
|m: &mut URLTypeOption| { &mut m.data },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<URLTypeOption>(
"URLTypeOption",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static URLTypeOption {
static instance: ::protobuf::rt::LazyV2<URLTypeOption> = ::protobuf::rt::LazyV2::INIT;
instance.get(URLTypeOption::new)
}
}
impl ::protobuf::Clear for URLTypeOption {
fn clear(&mut self) {
self.data.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for URLTypeOption {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for URLTypeOption {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct URLCellData {
// message fields
pub url: ::std::string::String,
pub content: ::std::string::String,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a URLCellData {
fn default() -> &'a URLCellData {
<URLCellData as ::protobuf::Message>::default_instance()
}
}
impl URLCellData {
pub fn new() -> URLCellData {
::std::default::Default::default()
}
// string url = 1;
pub fn get_url(&self) -> &str {
&self.url
}
pub fn clear_url(&mut self) {
self.url.clear();
}
// Param is passed by value, moved
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_url(&mut self) -> &mut ::std::string::String {
&mut self.url
}
// Take field
pub fn take_url(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.url, ::std::string::String::new())
}
// string content = 2;
pub fn get_content(&self) -> &str {
&self.content
}
pub fn clear_content(&mut self) {
self.content.clear();
}
// Param is passed by value, moved
pub fn set_content(&mut self, v: ::std::string::String) {
self.content = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_content(&mut self) -> &mut ::std::string::String {
&mut self.content
}
// Take field
pub fn take_content(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.content, ::std::string::String::new())
}
}
impl ::protobuf::Message for URLCellData {
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.url)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.content)?;
},
_ => {
::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.url.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.url);
}
if !self.content.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.content);
}
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.url.is_empty() {
os.write_string(1, &self.url)?;
}
if !self.content.is_empty() {
os.write_string(2, &self.content)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> URLCellData {
URLCellData::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"url",
|m: &URLCellData| { &m.url },
|m: &mut URLCellData| { &mut m.url },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"content",
|m: &URLCellData| { &m.content },
|m: &mut URLCellData| { &mut m.content },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<URLCellData>(
"URLCellData",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static URLCellData {
static instance: ::protobuf::rt::LazyV2<URLCellData> = ::protobuf::rt::LazyV2::INIT;
instance.get(URLCellData::new)
}
}
impl ::protobuf::Clear for URLCellData {
fn clear(&mut self) {
self.url.clear();
self.content.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for URLCellData {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for URLCellData {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x15url_type_option.proto\"#\n\rURLTypeOption\x12\x12\n\x04data\x18\
\x01\x20\x01(\tR\x04data\"9\n\x0bURLCellData\x12\x10\n\x03url\x18\x01\
\x20\x01(\tR\x03url\x12\x18\n\x07content\x18\x02\x20\x01(\tR\x07contentb\
\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}

6
frontend/rust-lib/flowy-net/Flowy.toml
View File

@ -1,4 +1,4 @@
proto_crates = ["src/event_map.rs", "src/entities"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/event_map.rs", "src/entities"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = ["src/event_map.rs"]

6
frontend/rust-lib/flowy-text-block/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/event_map.rs", "src/entities.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/event_map.rs", "src/entities.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = ["src/event_map.rs"]

6
frontend/rust-lib/flowy-user/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/event_map.rs", "src/dart_notification.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/event_map.rs", "src/dart_notification.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = ["src/event_map.rs"]

5
frontend/scripts/clean.sh
View File

@ -4,8 +4,11 @@
cd rust-lib
cargo clean
cd ../../shared-lib
cargo clean
CACHE_FILE=lib-infra/.cache
if [ -f "$CACHE_FILE" ]; then
if [ -d "$CACHE_FILE" ]; then
echo "Remove $CACHE_FILE"
rm -rf $CACHE_FILE
fi

8
frontend/scripts/makefile/tool.toml
View File

@ -7,7 +7,11 @@ script = [
cd ../../shared-lib
cargo clean
rm -rf lib-infra/.cache
CACHE_FILE=lib-infra/.cache
if [ -d "$CACHE_FILE" ]; then
echo "Remove $CACHE_FILE"
rm -rf $CACHE_FILE
fi
""",
]
script_runner = "@shell"
@ -19,8 +23,6 @@ script = [
cargo clean
cd ../../shared-lib
cargo clean
rmdir /s/q "lib-infra/.cache"
""",
]

6
shared-lib/flowy-error-code/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/code.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/code.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
shared-lib/flowy-folder-data-model/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities",]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities",]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
shared-lib/flowy-grid-data-model/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities/",]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities/",]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
shared-lib/flowy-sync/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

6
shared-lib/flowy-user-data-model/Flowy.toml
View File

@ -1,5 +1,5 @@
proto_crates = ["src/entities", "src/errors.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/entities", "src/errors.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []

25
shared-lib/lib-infra/src/code_gen/flowy_toml.rs
View File

@ -1,13 +1,12 @@
use crate::code_gen::util::path_buf_with_component;
use std::fs;
use std::path::{Path, PathBuf};
#[derive(serde::Deserialize, Clone, Debug)]
pub struct FlowyConfig {
pub proto_crates: Vec<String>,
pub event_files: Vec<String>,
pub proto_output_dir: String,
pub protobuf_crate_path: String,
pub proto_rust_file_input_dir: Vec<String>,
pub proto_file_output_dir: String,
pub protobuf_crate_output_dir: String,
}
impl FlowyConfig {
@ -20,22 +19,10 @@ impl FlowyConfig {
pub struct CrateConfig {
pub crate_path: PathBuf,
pub folder_name: String,
pub crate_folder: String,
pub flowy_config: FlowyConfig,
}
impl CrateConfig {
pub fn proto_paths(&self) -> Vec<PathBuf> {
let proto_paths = self
.flowy_config
.proto_crates
.iter()
.map(|name| path_buf_with_component(&self.crate_path, vec![name]))
.collect::<Vec<PathBuf>>();
proto_paths
}
}
pub fn parse_crate_config_from(entry: &walkdir::DirEntry) -> Option<CrateConfig> {
let mut config_path = entry.path().parent().unwrap().to_path_buf();
config_path.push("Flowy.toml");
@ -44,11 +31,11 @@ pub fn parse_crate_config_from(entry: &walkdir::DirEntry) -> Option<CrateConfig>
}
let crate_path = entry.path().parent().unwrap().to_path_buf();
let flowy_config = FlowyConfig::from_toml_file(config_path.as_path());
let folder_name = crate_path.file_stem().unwrap().to_str().unwrap().to_string();
let crate_folder = crate_path.file_stem().unwrap().to_str().unwrap().to_string();
Some(CrateConfig {
crate_path,
folder_name,
crate_folder,
flowy_config,
})
}

31
shared-lib/lib-infra/src/code_gen/protobuf_file/ast.rs
View File

@ -13,14 +13,14 @@ use std::{fs::File, io::Read, path::Path};
use syn::Item;
use walkdir::WalkDir;
pub fn parse_crate_protobuf(crate_paths: Vec<String>) -> Vec<ProtobufCrateContext> {
pub fn parse_protobuf_context_from(crate_paths: Vec<String>) -> Vec<ProtobufCrateContext> {
let crate_infos = parse_crate_info_from_path(crate_paths);
crate_infos
let contexts = crate_infos
.into_iter()
.map(|crate_info| {
let proto_output_dir = crate_info.proto_output_dir();
let proto_output_dir = crate_info.proto_file_output_dir();
let files = crate_info
.proto_paths
.proto_rust_file_paths()
.iter()
.map(|proto_crate_path| parse_files_protobuf(proto_crate_path, &proto_output_dir))
.flatten()
@ -28,7 +28,9 @@ pub fn parse_crate_protobuf(crate_paths: Vec<String>) -> Vec<ProtobufCrateContex
ProtobufCrateContext::from_crate_info(crate_info, files)
})
.collect::<Vec<ProtobufCrateContext>>()
.collect::<Vec<ProtobufCrateContext>>();
contexts
}
fn parse_files_protobuf(proto_crate_path: &Path, proto_output_dir: &Path) -> Vec<ProtoFile> {
@ -55,7 +57,7 @@ fn parse_files_protobuf(proto_crate_path: &Path, proto_output_dir: &Path) -> Vec
let structs = get_ast_structs(&ast);
let proto_file = format!("{}.proto", &file_name);
let proto_file_path = path_string_with_component(proto_output_dir, vec![&proto_file]);
let mut proto_file_content = parse_or_init_proto_file(proto_file_path.as_ref());
let mut proto_file_content = find_proto_syntax(proto_file_path.as_ref());
structs.iter().for_each(|s| {
let mut struct_template = StructTemplate::new();
@ -94,14 +96,6 @@ fn parse_files_protobuf(proto_crate_path: &Path, proto_output_dir: &Path) -> Vec
gen_proto_vec
}
pub fn parse_or_init_proto_file(path: &str) -> String {
let mut proto_file_content = String::new();
let imported_content = find_proto_file_import(path);
proto_file_content.push_str(imported_content.as_ref());
proto_file_content.push('\n');
proto_file_content
}
pub fn get_ast_structs(ast: &syn::File) -> Vec<Struct> {
// let mut content = format!("{:#?}", &ast);
// let mut file = File::create("./foo.txt").unwrap();
@ -157,14 +151,12 @@ lazy_static! {
static ref IMPORT_REGEX: Regex = Regex::new("(import\\s).*;").unwrap();
}
fn find_proto_file_import(path: &str) -> String {
let mut result = String::new();
fn find_proto_syntax(path: &str) -> String {
if !Path::new(path).exists() {
// log::error!("{} not exist", path);
result = String::from("syntax = \"proto3\";");
return result;
return String::from("syntax = \"proto3\";\\n");
}
let mut result = String::new();
let mut file = File::open(path).unwrap();
let mut content = String::new();
file.read_to_string(&mut content).unwrap();
@ -182,5 +174,6 @@ fn find_proto_file_import(path: &str) -> String {
}
});
result.push('\n');
result
}

31
shared-lib/lib-infra/src/code_gen/protobuf_file/mod.rs
View File

@ -27,9 +27,10 @@ pub fn gen(crate_name: &str) {
for proto_crate in proto_crates {
let mut proto_file_paths = vec![];
let mut file_names = vec![];
let proto_file_dir = &proto_crate.flowy_config.proto_output_dir;
let proto_file_output_dir = proto_crate.proto_file_output_dir().to_str().unwrap().to_string();
let protobuf_output_dir = proto_crate.protobuf_crate_path().to_str().unwrap().to_string();
for (path, file_name) in WalkDir::new(proto_file_dir)
for (path, file_name) in WalkDir::new(&proto_file_output_dir)
.into_iter()
.filter_map(|e| e.ok())
.map(|e| {
@ -51,31 +52,41 @@ pub fn gen(crate_name: &str) {
#[cfg(feature = "dart")]
generate_dart_protobuf_files(
crate_name,
proto_file_dir,
&proto_file_output_dir,
&proto_file_paths,
&file_names,
&protoc_bin_path,
);
// 3. generate the protobuf files(Rust)
generate_rust_protobuf_files(&protoc_bin_path, &proto_file_paths, proto_file_dir);
generate_rust_protobuf_files(
&protoc_bin_path,
&proto_file_paths,
&proto_file_output_dir,
&protobuf_output_dir,
);
}
}
fn generate_rust_protobuf_files(protoc_bin_path: &Path, proto_file_paths: &[String], proto_file_dir: &str) {
fn generate_rust_protobuf_files(
protoc_bin_path: &Path,
proto_file_paths: &[String],
proto_file_output_dir: &str,
protobuf_output_dir: &str,
) {
protoc_rust::Codegen::new()
.out_dir("./src/protobuf/model")
.out_dir(protobuf_output_dir)
.protoc_path(protoc_bin_path)
.inputs(proto_file_paths)
.include(proto_file_dir)
.include(proto_file_output_dir)
.run()
.expect("Running protoc failed.");
.expect("Running rust protoc failed.");
}
#[cfg(feature = "dart")]
fn generate_dart_protobuf_files(
name: &str,
proto_path: &str,
proto_file_output_dir: &str,
paths: &Vec<String>,
file_names: &Vec<String>,
protoc_bin_path: &PathBuf,
@ -104,7 +115,7 @@ fn generate_dart_protobuf_files(
let protoc_bin_path = protoc_bin_path.to_str().unwrap().to_owned();
paths.iter().for_each(|path| {
if cmd_lib::run_cmd! {
${protoc_bin_path} --dart_out=${output} --proto_path=${proto_path} ${path}
${protoc_bin_path} --dart_out=${output} --proto_path=${proto_file_output_dir} ${path}
}
.is_err()
{

13
shared-lib/lib-infra/src/code_gen/protobuf_file/proto_gen.rs
View File

@ -2,7 +2,7 @@
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use crate::code_gen::protobuf_file::ast::parse_crate_protobuf;
use crate::code_gen::protobuf_file::ast::parse_protobuf_context_from;
use crate::code_gen::protobuf_file::proto_info::ProtobufCrateContext;
use crate::code_gen::protobuf_file::ProtoFile;
use crate::code_gen::util::*;
@ -14,14 +14,9 @@ use std::{fs::OpenOptions, io::Write};
pub struct ProtoGenerator();
impl ProtoGenerator {
pub fn gen(crate_name: &str, crate_path: &str) -> Vec<ProtobufCrateContext> {
let crate_contexts = parse_crate_protobuf(vec![crate_path.to_owned()]);
let crate_contexts = parse_protobuf_context_from(vec![crate_path.to_owned()]);
write_proto_files(&crate_contexts);
write_rust_crate_mod_file(&crate_contexts);
for crate_info in &crate_contexts {
let _ = crate_info.protobuf_crate.create_output_dir();
let _ = crate_info.protobuf_crate.proto_output_dir();
crate_info.create_crate_mod_file();
}
let proto_cache = ProtoCache::from_crate_contexts(&crate_contexts);
let proto_cache_str = serde_json::to_string(&proto_cache).unwrap();
@ -55,7 +50,7 @@ impl ProtoGenerator {
fn write_proto_files(crate_contexts: &[ProtobufCrateContext]) {
for context in crate_contexts {
let dir = context.protobuf_crate.proto_output_dir();
let dir = context.protobuf_crate.proto_file_output_dir();
context.files.iter().for_each(|info| {
let proto_file = format!("{}.proto", &info.file_name);
let proto_file_path = path_string_with_component(&dir, vec![&proto_file]);
@ -80,7 +75,7 @@ fn write_rust_crate_mod_file(crate_contexts: &[ProtobufCrateContext]) {
mod_file_content.push_str("#![cfg_attr(rustfmt, rustfmt::skip)]\n");
mod_file_content.push_str("// Auto-generated, do not edit\n");
walk_dir(
context.protobuf_crate.proto_output_dir(),
context.protobuf_crate.proto_file_output_dir(),
|e| !e.file_type().is_dir(),
|_, name| {
let c = format!("\nmod {};\npub use {}::*;\n", &name, &name);

42
shared-lib/lib-infra/src/code_gen/protobuf_file/proto_info.rs
View File

@ -24,7 +24,7 @@ impl ProtobufCrateContext {
pub fn create_crate_mod_file(&self) {
// mod model;
// pub use model::*;
let mod_file_path = path_string_with_component(&self.protobuf_crate.protobuf_crate_name(), vec!["mod.rs"]);
let mod_file_path = path_string_with_component(&self.protobuf_crate.protobuf_crate_path(), vec!["mod.rs"]);
let mut content = "#![cfg_attr(rustfmt, rustfmt::skip)]\n".to_owned();
content.push_str("// Auto-generated, do not edit\n");
content.push_str("mod model;\npub use model::*;");
@ -46,57 +46,55 @@ impl ProtobufCrateContext {
#[allow(dead_code)]
pub fn flutter_mod_dir(&self, root: &str) -> String {
let crate_module_dir = format!("{}/{}", root, self.protobuf_crate.folder_name);
let crate_module_dir = format!("{}/{}", root, self.protobuf_crate.crate_folder);
crate_module_dir
}
#[allow(dead_code)]
pub fn flutter_mod_file(&self, root: &str) -> String {
let crate_module_dir = format!("{}/{}/protobuf.dart", root, self.protobuf_crate.folder_name);
let crate_module_dir = format!("{}/{}/protobuf.dart", root, self.protobuf_crate.crate_folder);
crate_module_dir
}
}
#[derive(Clone, Debug)]
pub struct ProtobufCrate {
pub folder_name: String,
pub proto_paths: Vec<PathBuf>,
pub crate_folder: String,
pub crate_path: PathBuf,
pub flowy_config: FlowyConfig,
flowy_config: FlowyConfig,
}
impl ProtobufCrate {
pub fn from_config(config: CrateConfig) -> Self {
let proto_paths = config.proto_paths();
ProtobufCrate {
folder_name: config.folder_name,
proto_paths,
crate_path: config.crate_path,
crate_folder: config.crate_folder,
flowy_config: config.flowy_config.clone(),
}
}
fn protobuf_crate_name(&self) -> PathBuf {
let crate_path = PathBuf::from(&self.flowy_config.protobuf_crate_path);
pub fn proto_rust_file_paths(&self) -> Vec<PathBuf> {
self.flowy_config
.proto_rust_file_input_dir
.iter()
.map(|name| path_buf_with_component(&self.crate_path, vec![name]))
.collect::<Vec<PathBuf>>()
}
pub fn protobuf_crate_path(&self) -> PathBuf {
let crate_path = PathBuf::from(&self.flowy_config.protobuf_crate_output_dir);
create_dir_if_not_exist(&crate_path);
crate_path
}
pub fn proto_output_dir(&self) -> PathBuf {
let output_dir = PathBuf::from(&self.flowy_config.proto_output_dir);
pub fn proto_file_output_dir(&self) -> PathBuf {
let output_dir = PathBuf::from(&self.flowy_config.proto_file_output_dir);
create_dir_if_not_exist(&output_dir);
output_dir
}
pub fn create_output_dir(&self) -> PathBuf {
let path = self.protobuf_crate_name();
let dir = path_buf_with_component(&path, vec!["model"]);
create_dir_if_not_exist(&dir);
dir
}
pub fn proto_model_mod_file(&self) -> String {
path_string_with_component(&self.create_output_dir(), vec!["mod.rs"])
path_string_with_component(&self.protobuf_crate_path(), vec!["mod.rs"])
}
}

1
shared-lib/lib-infra/src/code_gen/util.rs
View File

@ -104,6 +104,7 @@ pub fn path_string_with_component(path: &Path, components: Vec<&str>) -> String
path_buf_with_component(path, components).to_str().unwrap().to_string()
}
#[allow(dead_code)]
pub fn path_buf_with_component(path: &Path, components: Vec<&str>) -> PathBuf {
let mut path_buf = path.to_path_buf();
for component in components {

6
shared-lib/lib-ws/Flowy.toml
View File

@ -1,4 +1,4 @@
proto_crates = ["src/errors.rs", "src/msg.rs"]
proto_output_dir = "resources/proto"
protobuf_crate_path = "src/protobuf"
proto_rust_file_input_dir = ["src/errors.rs", "src/msg.rs"]
proto_file_output_dir = "resources/proto"
protobuf_crate_output_dir = "src/protobuf"
event_files = []