# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ClassFormatCompact { inner : Class }impl From < Class > for ClassFormatCompact { fn from ( original : Class ) -> Self { Self { inner : original } } }impl Into < Class > for ClassFormatCompact { fn into ( self ) -> Class { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for Class { type Formatted = ClassFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ClassFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ClassFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ClassFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ClassFormatCompact { inner : Class { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectIntersectionOfFormatCompact { inner : ObjectIntersectionOf }impl From < ObjectIntersectionOf > for ObjectIntersectionOfFormatCompact { fn from ( original : ObjectIntersectionOf ) -> Self { Self { inner : original } } }impl Into < ObjectIntersectionOf > for ObjectIntersectionOfFormatCompact { fn into ( self ) -> ObjectIntersectionOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectIntersectionOf { type Formatted = ObjectIntersectionOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectIntersectionOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectIntersectionOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectIntersectionOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectIntersectionOfFormatCompact { inner : ObjectIntersectionOf { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectUnionOfFormatCompact { inner : ObjectUnionOf }impl From < ObjectUnionOf > for ObjectUnionOfFormatCompact { fn from ( original : ObjectUnionOf ) -> Self { Self { inner : original } } }impl Into < ObjectUnionOf > for ObjectUnionOfFormatCompact { fn into ( self ) -> ObjectUnionOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectUnionOf { type Formatted = ObjectUnionOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectUnionOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectUnionOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectUnionOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectUnionOfFormatCompact { inner : ObjectUnionOf { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectComplementOfFormatCompact { inner : ObjectComplementOf }impl From < ObjectComplementOf > for ObjectComplementOfFormatCompact { fn from ( original : ObjectComplementOf ) -> Self { Self { inner : original } } }impl Into < ObjectComplementOf > for ObjectComplementOfFormatCompact { fn into ( self ) -> ObjectComplementOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectComplementOf { type Formatted = ObjectComplementOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectComplementOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectComplementOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( with = "serde_bytes" ) ] pub complement_of : & 'a Vec < u8 > , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { complement_of : & self . inner . complement_of , annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectComplementOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( with = "serde_bytes" ) ] complement_of : Vec < u8 > , # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectComplementOfFormatCompact { inner : ObjectComplementOf { complement_of : helper_instance . complement_of , annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectOneOfFormatCompact { inner : ObjectOneOf }impl From < ObjectOneOf > for ObjectOneOfFormatCompact { fn from ( original : ObjectOneOf ) -> Self { Self { inner : original } } }impl Into < ObjectOneOf > for ObjectOneOfFormatCompact { fn into ( self ) -> ObjectOneOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectOneOf { type Formatted = ObjectOneOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectOneOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectOneOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectOneOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectOneOfFormatCompact { inner : ObjectOneOf { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectSomeValuesFromFormatCompact { inner : ObjectSomeValuesFrom }impl From < ObjectSomeValuesFrom > for ObjectSomeValuesFromFormatCompact { fn from ( original : ObjectSomeValuesFrom ) -> Self { Self { inner : original } } }impl Into < ObjectSomeValuesFrom > for ObjectSomeValuesFromFormatCompact { fn into ( self ) -> ObjectSomeValuesFrom { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectSomeValuesFrom { type Formatted = ObjectSomeValuesFromFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectSomeValuesFromFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectSomeValuesFromFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectSomeValuesFromFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectSomeValuesFromFormatCompact { inner : ObjectSomeValuesFrom { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectAllValuesFromFormatCompact { inner : ObjectAllValuesFrom }impl From < ObjectAllValuesFrom > for ObjectAllValuesFromFormatCompact { fn from ( original : ObjectAllValuesFrom ) -> Self { Self { inner : original } } }impl Into < ObjectAllValuesFrom > for ObjectAllValuesFromFormatCompact { fn into ( self ) -> ObjectAllValuesFrom { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectAllValuesFrom { type Formatted = ObjectAllValuesFromFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectAllValuesFromFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectAllValuesFromFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectAllValuesFromFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectAllValuesFromFormatCompact { inner : ObjectAllValuesFrom { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectHasValueFormatCompact { inner : ObjectHasValue }impl From < ObjectHasValue > for ObjectHasValueFormatCompact { fn from ( original : ObjectHasValue ) -> Self { Self { inner : original } } }impl Into < ObjectHasValue > for ObjectHasValueFormatCompact { fn into ( self ) -> ObjectHasValue { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectHasValue { type Formatted = ObjectHasValueFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectHasValueFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectHasValueFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectHasValueFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectHasValueFormatCompact { inner : ObjectHasValue { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectHasSelfFormatCompact { inner : ObjectHasSelf }impl From < ObjectHasSelf > for ObjectHasSelfFormatCompact { fn from ( original : ObjectHasSelf ) -> Self { Self { inner : original } } }impl Into < ObjectHasSelf > for ObjectHasSelfFormatCompact { fn into ( self ) -> ObjectHasSelf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectHasSelf { type Formatted = ObjectHasSelfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectHasSelfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectHasSelfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectHasSelfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectHasSelfFormatCompact { inner : ObjectHasSelf { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectMinCardinalityFormatCompact { inner : ObjectMinCardinality }impl From < ObjectMinCardinality > for ObjectMinCardinalityFormatCompact { fn from ( original : ObjectMinCardinality ) -> Self { Self { inner : original } } }impl Into < ObjectMinCardinality > for ObjectMinCardinalityFormatCompact { fn into ( self ) -> ObjectMinCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectMinCardinality { type Formatted = ObjectMinCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectMinCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectMinCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectMinCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectMinCardinalityFormatCompact { inner : ObjectMinCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectMaxCardinalityFormatCompact { inner : ObjectMaxCardinality }impl From < ObjectMaxCardinality > for ObjectMaxCardinalityFormatCompact { fn from ( original : ObjectMaxCardinality ) -> Self { Self { inner : original } } }impl Into < ObjectMaxCardinality > for ObjectMaxCardinalityFormatCompact { fn into ( self ) -> ObjectMaxCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectMaxCardinality { type Formatted = ObjectMaxCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectMaxCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectMaxCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectMaxCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectMaxCardinalityFormatCompact { inner : ObjectMaxCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectExactCardinalityFormatCompact { inner : ObjectExactCardinality }impl From < ObjectExactCardinality > for ObjectExactCardinalityFormatCompact { fn from ( original : ObjectExactCardinality ) -> Self { Self { inner : original } } }impl Into < ObjectExactCardinality > for ObjectExactCardinalityFormatCompact { fn into ( self ) -> ObjectExactCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectExactCardinality { type Formatted = ObjectExactCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectExactCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectExactCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectExactCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectExactCardinalityFormatCompact { inner : ObjectExactCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataSomeValuesFromFormatCompact { inner : DataSomeValuesFrom }impl From < DataSomeValuesFrom > for DataSomeValuesFromFormatCompact { fn from ( original : DataSomeValuesFrom ) -> Self { Self { inner : original } } }impl Into < DataSomeValuesFrom > for DataSomeValuesFromFormatCompact { fn into ( self ) -> DataSomeValuesFrom { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataSomeValuesFrom { type Formatted = DataSomeValuesFromFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataSomeValuesFromFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataSomeValuesFromFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataSomeValuesFromFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataSomeValuesFromFormatCompact { inner : DataSomeValuesFrom { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataAllValuesFromFormatCompact { inner : DataAllValuesFrom }impl From < DataAllValuesFrom > for DataAllValuesFromFormatCompact { fn from ( original : DataAllValuesFrom ) -> Self { Self { inner : original } } }impl Into < DataAllValuesFrom > for DataAllValuesFromFormatCompact { fn into ( self ) -> DataAllValuesFrom { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataAllValuesFrom { type Formatted = DataAllValuesFromFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataAllValuesFromFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataAllValuesFromFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataAllValuesFromFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataAllValuesFromFormatCompact { inner : DataAllValuesFrom { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataHasValueFormatCompact { inner : DataHasValue }impl From < DataHasValue > for DataHasValueFormatCompact { fn from ( original : DataHasValue ) -> Self { Self { inner : original } } }impl Into < DataHasValue > for DataHasValueFormatCompact { fn into ( self ) -> DataHasValue { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataHasValue { type Formatted = DataHasValueFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataHasValueFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataHasValueFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataHasValueFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataHasValueFormatCompact { inner : DataHasValue { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataMinCardinalityFormatCompact { inner : DataMinCardinality }impl From < DataMinCardinality > for DataMinCardinalityFormatCompact { fn from ( original : DataMinCardinality ) -> Self { Self { inner : original } } }impl Into < DataMinCardinality > for DataMinCardinalityFormatCompact { fn into ( self ) -> DataMinCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataMinCardinality { type Formatted = DataMinCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataMinCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataMinCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataMinCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataMinCardinalityFormatCompact { inner : DataMinCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataMaxCardinalityFormatCompact { inner : DataMaxCardinality }impl From < DataMaxCardinality > for DataMaxCardinalityFormatCompact { fn from ( original : DataMaxCardinality ) -> Self { Self { inner : original } } }impl Into < DataMaxCardinality > for DataMaxCardinalityFormatCompact { fn into ( self ) -> DataMaxCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataMaxCardinality { type Formatted = DataMaxCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataMaxCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataMaxCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataMaxCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataMaxCardinalityFormatCompact { inner : DataMaxCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataExactCardinalityFormatCompact { inner : DataExactCardinality }impl From < DataExactCardinality > for DataExactCardinalityFormatCompact { fn from ( original : DataExactCardinality ) -> Self { Self { inner : original } } }impl Into < DataExactCardinality > for DataExactCardinalityFormatCompact { fn into ( self ) -> DataExactCardinality { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataExactCardinality { type Formatted = DataExactCardinalityFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataExactCardinalityFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataExactCardinalityFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_class_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_class_expression : & self . inner . super_class_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataExactCardinalityFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_class_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataExactCardinalityFormatCompact { inner : DataExactCardinality { annotations : helper_instance . annotations , super_class_expression : helper_instance . super_class_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectPropertyFormatCompact { inner : ObjectProperty }impl From < ObjectProperty > for ObjectPropertyFormatCompact { fn from ( original : ObjectProperty ) -> Self { Self { inner : original } } }impl Into < ObjectProperty > for ObjectPropertyFormatCompact { fn into ( self ) -> ObjectProperty { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectProperty { type Formatted = ObjectPropertyFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectPropertyFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectPropertyFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_object_property_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_object_property_expression : & self . inner . super_object_property_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectPropertyFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_object_property_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectPropertyFormatCompact { inner : ObjectProperty { annotations : helper_instance . annotations , super_object_property_expression : helper_instance . super_object_property_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct InverseObjectPropertyFormatCompact { inner : InverseObjectProperty }impl From < InverseObjectProperty > for InverseObjectPropertyFormatCompact { fn from ( original : InverseObjectProperty ) -> Self { Self { inner : original } } }impl Into < InverseObjectProperty > for InverseObjectPropertyFormatCompact { fn into ( self ) -> InverseObjectProperty { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for InverseObjectProperty { type Formatted = InverseObjectPropertyFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { InverseObjectPropertyFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for InverseObjectPropertyFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_object_property_expression : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_object_property_expression : & self . inner . super_object_property_expression , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for InverseObjectPropertyFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_object_property_expression : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( InverseObjectPropertyFormatCompact { inner : InverseObjectProperty { annotations : helper_instance . annotations , super_object_property_expression : helper_instance . super_object_property_expression } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataPropertyFormatCompact { inner : DataProperty }impl From < DataProperty > for DataPropertyFormatCompact { fn from ( original : DataProperty ) -> Self { Self { inner : original } } }impl Into < DataProperty > for DataPropertyFormatCompact { fn into ( self ) -> DataProperty { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataProperty { type Formatted = DataPropertyFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataPropertyFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataPropertyFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub super_data_property_expression : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub domain : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub range : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , super_data_property_expression : & self . inner . super_data_property_expression , domain : & self . inner . domain , range : & self . inner . range , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataPropertyFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] super_data_property_expression : Vec < Vec < u8 >> , # [ serde ( default ) ] domain : Option < Vec < u8 >> , # [ serde ( default ) ] range : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataPropertyFormatCompact { inner : DataProperty { annotations : helper_instance . annotations , super_data_property_expression : helper_instance . super_data_property_expression , domain : helper_instance . domain , range : helper_instance . range } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct AnnotationFormatCompact { inner : Annotation }impl From < Annotation > for AnnotationFormatCompact { fn from ( original : Annotation ) -> Self { Self { inner : original } } }impl Into < Annotation > for AnnotationFormatCompact { fn into ( self ) -> Annotation { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for Annotation { type Formatted = AnnotationFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { AnnotationFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for AnnotationFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] pub property : & 'a Vec < u8 > , # [ serde ( with = "serde_bytes" ) ] pub value : & 'a Vec < u8 > , } let ext = SerializeHelper { annotations : & self . inner . annotations , property : & self . inner . property , value : & self . inner . value , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for AnnotationFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] property : Vec < u8 > , # [ serde ( with = "serde_bytes" ) ] value : Vec < u8 > , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( AnnotationFormatCompact { inner : Annotation { annotations : helper_instance . annotations , property : helper_instance . property , value : helper_instance . value } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct IndividualFormatCompact { inner : Individual }impl From < Individual > for IndividualFormatCompact { fn from ( original : Individual ) -> Self { Self { inner : original } } }impl Into < Individual > for IndividualFormatCompact { fn into ( self ) -> Individual { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for Individual { type Formatted = IndividualFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { IndividualFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for IndividualFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub class_assertions : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub negative_class_assertions : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub object_property_assertions : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub negative_object_property_assertions : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub data_property_assertions : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub negative_data_property_assertions : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , class_assertions : & self . inner . class_assertions , negative_class_assertions : & self . inner . negative_class_assertions , object_property_assertions : & self . inner . object_property_assertions , negative_object_property_assertions : & self . inner . negative_object_property_assertions , data_property_assertions : & self . inner . data_property_assertions , negative_data_property_assertions : & self . inner . negative_data_property_assertions , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for IndividualFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] class_assertions : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] negative_class_assertions : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] object_property_assertions : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] negative_object_property_assertions : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] data_property_assertions : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] negative_data_property_assertions : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( IndividualFormatCompact { inner : Individual { annotations : helper_instance . annotations , class_assertions : helper_instance . class_assertions , negative_class_assertions : helper_instance . negative_class_assertions , object_property_assertions : helper_instance . object_property_assertions , negative_object_property_assertions : helper_instance . negative_object_property_assertions , data_property_assertions : helper_instance . data_property_assertions , negative_data_property_assertions : helper_instance . negative_data_property_assertions } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct AnnotationPropertyFormatCompact { inner : AnnotationProperty }impl From < AnnotationProperty > for AnnotationPropertyFormatCompact { fn from ( original : AnnotationProperty ) -> Self { Self { inner : original } } }impl Into < AnnotationProperty > for AnnotationPropertyFormatCompact { fn into ( self ) -> AnnotationProperty { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for AnnotationProperty { type Formatted = AnnotationPropertyFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { AnnotationPropertyFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for AnnotationPropertyFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for AnnotationPropertyFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( AnnotationPropertyFormatCompact { inner : AnnotationProperty { annotations : helper_instance . annotations } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ClassAssertionFormatCompact { inner : ClassAssertion }impl From < ClassAssertion > for ClassAssertionFormatCompact { fn from ( original : ClassAssertion ) -> Self { Self { inner : original } } }impl Into < ClassAssertion > for ClassAssertionFormatCompact { fn into ( self ) -> ClassAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ClassAssertion { type Formatted = ClassAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ClassAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ClassAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] pub class : & 'a Vec < u8 > , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , class : & self . inner . class , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ClassAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] class : Vec < u8 > , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ClassAssertionFormatCompact { inner : ClassAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , class : helper_instance . class } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct NegativeClassAssertionFormatCompact { inner : NegativeClassAssertion }impl From < NegativeClassAssertion > for NegativeClassAssertionFormatCompact { fn from ( original : NegativeClassAssertion ) -> Self { Self { inner : original } } }impl Into < NegativeClassAssertion > for NegativeClassAssertionFormatCompact { fn into ( self ) -> NegativeClassAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for NegativeClassAssertion { type Formatted = NegativeClassAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { NegativeClassAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for NegativeClassAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] pub class : & 'a Vec < u8 > , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , class : & self . inner . class , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for NegativeClassAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] class : Vec < u8 > , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( NegativeClassAssertionFormatCompact { inner : NegativeClassAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , class : helper_instance . class } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct ObjectPropertyAssertionFormatCompact { inner : ObjectPropertyAssertion }impl From < ObjectPropertyAssertion > for ObjectPropertyAssertionFormatCompact { fn from ( original : ObjectPropertyAssertion ) -> Self { Self { inner : original } } }impl Into < ObjectPropertyAssertion > for ObjectPropertyAssertionFormatCompact { fn into ( self ) -> ObjectPropertyAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for ObjectPropertyAssertion { type Formatted = ObjectPropertyAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { ObjectPropertyAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for ObjectPropertyAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub target : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , target : & self . inner . target , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for ObjectPropertyAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] target : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( ObjectPropertyAssertionFormatCompact { inner : ObjectPropertyAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , target : helper_instance . target } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct NegativeObjectPropertyAssertionFormatCompact { inner : NegativeObjectPropertyAssertion }impl From < NegativeObjectPropertyAssertion > for NegativeObjectPropertyAssertionFormatCompact { fn from ( original : NegativeObjectPropertyAssertion ) -> Self { Self { inner : original } } }impl Into < NegativeObjectPropertyAssertion > for NegativeObjectPropertyAssertionFormatCompact { fn into ( self ) -> NegativeObjectPropertyAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for NegativeObjectPropertyAssertion { type Formatted = NegativeObjectPropertyAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { NegativeObjectPropertyAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for NegativeObjectPropertyAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub target : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , target : & self . inner . target , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for NegativeObjectPropertyAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] target : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( NegativeObjectPropertyAssertionFormatCompact { inner : NegativeObjectPropertyAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , target : helper_instance . target } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataPropertyAssertionFormatCompact { inner : DataPropertyAssertion }impl From < DataPropertyAssertion > for DataPropertyAssertionFormatCompact { fn from ( original : DataPropertyAssertion ) -> Self { Self { inner : original } } }impl Into < DataPropertyAssertion > for DataPropertyAssertionFormatCompact { fn into ( self ) -> DataPropertyAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataPropertyAssertion { type Formatted = DataPropertyAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataPropertyAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataPropertyAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub target : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , target : & self . inner . target , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataPropertyAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] target : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataPropertyAssertionFormatCompact { inner : DataPropertyAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , target : helper_instance . target } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct NegativeDataPropertyAssertionFormatCompact { inner : NegativeDataPropertyAssertion }impl From < NegativeDataPropertyAssertion > for NegativeDataPropertyAssertionFormatCompact { fn from ( original : NegativeDataPropertyAssertion ) -> Self { Self { inner : original } } }impl Into < NegativeDataPropertyAssertion > for NegativeDataPropertyAssertionFormatCompact { fn into ( self ) -> NegativeDataPropertyAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for NegativeDataPropertyAssertion { type Formatted = NegativeDataPropertyAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { NegativeDataPropertyAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for NegativeDataPropertyAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub target : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , target : & self . inner . target , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for NegativeDataPropertyAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] target : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( NegativeDataPropertyAssertionFormatCompact { inner : NegativeDataPropertyAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , target : helper_instance . target } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct AnnotationAssertionFormatCompact { inner : AnnotationAssertion }impl From < AnnotationAssertion > for AnnotationAssertionFormatCompact { fn from ( original : AnnotationAssertion ) -> Self { Self { inner : original } } }impl Into < AnnotationAssertion > for AnnotationAssertionFormatCompact { fn into ( self ) -> AnnotationAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for AnnotationAssertion { type Formatted = AnnotationAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { AnnotationAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for AnnotationAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub value : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , value : & self . inner . value , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for AnnotationAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] value : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( AnnotationAssertionFormatCompact { inner : AnnotationAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , value : helper_instance . value } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct NegativeAnnotationAssertionFormatCompact { inner : NegativeAnnotationAssertion }impl From < NegativeAnnotationAssertion > for NegativeAnnotationAssertionFormatCompact { fn from ( original : NegativeAnnotationAssertion ) -> Self { Self { inner : original } } }impl Into < NegativeAnnotationAssertion > for NegativeAnnotationAssertionFormatCompact { fn into ( self ) -> NegativeAnnotationAssertion { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for NegativeAnnotationAssertion { type Formatted = NegativeAnnotationAssertionFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { NegativeAnnotationAssertionFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for NegativeAnnotationAssertionFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub subject : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub property : & 'a Option < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub value : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , subject : & self . inner . subject , property : & self . inner . property , value : & self . inner . value , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for NegativeAnnotationAssertionFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] subject : Option < Vec < u8 >> , # [ serde ( default ) ] property : Option < Vec < u8 >> , # [ serde ( default ) ] value : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( NegativeAnnotationAssertionFormatCompact { inner : NegativeAnnotationAssertion { annotations : helper_instance . annotations , subject : helper_instance . subject , property : helper_instance . property , value : helper_instance . value } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct LiteralFormatCompact { inner : Literal }impl From < Literal > for LiteralFormatCompact { fn from ( original : Literal ) -> Self { Self { inner : original } } }impl Into < Literal > for LiteralFormatCompact { fn into ( self ) -> Literal { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for Literal { type Formatted = LiteralFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { LiteralFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for LiteralFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub datatype : & 'a Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] pub value : & 'a Vec < u8 > , } let ext = SerializeHelper { datatype : & self . inner . datatype , value : & self . inner . value , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for LiteralFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default ) ] datatype : Option < Vec < u8 >> , # [ serde ( with = "serde_bytes" ) ] value : Vec < u8 > , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( LiteralFormatCompact { inner : Literal { datatype : helper_instance . datatype , value : helper_instance . value } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DatatypeFormatCompact { inner : Datatype }impl From < Datatype > for DatatypeFormatCompact { fn from ( original : Datatype ) -> Self { Self { inner : original } } }impl Into < Datatype > for DatatypeFormatCompact { fn into ( self ) -> Datatype { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for Datatype { type Formatted = DatatypeFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DatatypeFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DatatypeFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DatatypeFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DatatypeFormatCompact { inner : Datatype { annotations : helper_instance . annotations } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataIntersectionOfFormatCompact { inner : DataIntersectionOf }impl From < DataIntersectionOf > for DataIntersectionOfFormatCompact { fn from ( original : DataIntersectionOf ) -> Self { Self { inner : original } } }impl Into < DataIntersectionOf > for DataIntersectionOfFormatCompact { fn into ( self ) -> DataIntersectionOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataIntersectionOf { type Formatted = DataIntersectionOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataIntersectionOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataIntersectionOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub datatypes : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , datatypes : & self . inner . datatypes , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataIntersectionOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] datatypes : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataIntersectionOfFormatCompact { inner : DataIntersectionOf { annotations : helper_instance . annotations , datatypes : helper_instance . datatypes } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataUnionOfFormatCompact { inner : DataUnionOf }impl From < DataUnionOf > for DataUnionOfFormatCompact { fn from ( original : DataUnionOf ) -> Self { Self { inner : original } } }impl Into < DataUnionOf > for DataUnionOfFormatCompact { fn into ( self ) -> DataUnionOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataUnionOf { type Formatted = DataUnionOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataUnionOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataUnionOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub datatypes : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , datatypes : & self . inner . datatypes , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataUnionOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] datatypes : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataUnionOfFormatCompact { inner : DataUnionOf { annotations : helper_instance . annotations , datatypes : helper_instance . datatypes } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataComplementOfFormatCompact { inner : DataComplementOf }impl From < DataComplementOf > for DataComplementOfFormatCompact { fn from ( original : DataComplementOf ) -> Self { Self { inner : original } } }impl Into < DataComplementOf > for DataComplementOfFormatCompact { fn into ( self ) -> DataComplementOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataComplementOf { type Formatted = DataComplementOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataComplementOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataComplementOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Option::is_none" ) ] pub datatype : & 'a Option < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , datatype : & self . inner . datatype , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataComplementOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default ) ] datatype : Option < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataComplementOfFormatCompact { inner : DataComplementOf { annotations : helper_instance . annotations , datatype : helper_instance . datatype } } ) } }# [ cfg_attr ( feature = "wasm_bindgen" , wasm_bindgen ) ] # [ derive ( Debug , Clone , PartialEq , Default ) ] pub struct DataOneOfFormatCompact { inner : DataOneOf }impl From < DataOneOf > for DataOneOfFormatCompact { fn from ( original : DataOneOf ) -> Self { Self { inner : original } } }impl Into < DataOneOf > for DataOneOfFormatCompact { fn into ( self ) -> DataOneOf { self . inner } }# [ cfg ( feature = "std" ) ] impl < 'a > FormatCompact < 'a > for DataOneOf { type Formatted = DataOneOfFormatCompact ; fn to_compact_format ( self ) -> Self :: Formatted { DataOneOfFormatCompact :: from ( self ) } fn from_compact_format ( formatted : Self :: Formatted ) -> Self { formatted . into ( ) } }# [ cfg ( feature = "std" ) ] impl :: serde :: Serialize for DataOneOfFormatCompact { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : :: serde :: Serializer , { # [ derive ( Serialize ) ] # [ allow ( non_snake_case ) ] struct SerializeHelper < 'a > { # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub annotations : & 'a Vec < Vec < u8 >> , # [ serde ( skip_serializing_if = "Vec::is_empty" ) ] pub values : & 'a Vec < Vec < u8 >> , } let ext = SerializeHelper { annotations : & self . inner . annotations , values : & self . inner . values , } ; Ok ( ext . serialize ( serializer ) ? ) } }# [ cfg ( feature = "std" ) ] impl < 'de > Deserialize < 'de > for DataOneOfFormatCompact { fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < 'de > , { # [ derive ( Deserialize ) ] struct DeserializeHelper { # [ serde ( default , deserialize_with = "nullable_vec" ) ] annotations : Vec < Vec < u8 >> , # [ serde ( default , deserialize_with = "nullable_vec" ) ] values : Vec < Vec < u8 >> , } # [ allow ( dead_code ) ] fn nullable_vec < 'de , D > ( deserializer : D ) -> Result < Vec < Vec < u8 >> , D :: Error > where D : Deserializer < 'de > { let opt : Option < Vec < serde_bytes :: ByteBuf >> = Option :: deserialize ( deserializer ) ? ; let val = opt . unwrap_or_else ( Vec :: new ) . into_iter ( ) . map ( | n | ( * n ) . to_vec ( ) ) . collect ( ) ; Ok ( val ) } let helper_instance = DeserializeHelper :: deserialize ( deserializer ) ? ; Ok ( DataOneOfFormatCompact { inner : DataOneOf { annotations : helper_instance . annotations , values : helper_instance . values } } ) } }