//! The Vino Codec crate contains the serialization and deserialization functions
//! and structures for communicating in and out of Vino Components.
//!
//! ### JSON
//!
//! Serializes to a [serde_json::Value] which can be printed as a JSON string.
//!
//! #### `json::serialize`
//!
//! ```
//! use vino_codec::{json, Error};
//! use serde::{Serialize, Deserialize};
//!
//! pub fn main() -> Result<(), Error> {
//!
//!   #[derive(Serialize, Deserialize)]
//!   struct Point {
//!     x: i32,
//!     y: i32,
//!   }
//!
//!   let point = Point { x: 200, y: 193 };
//!
//!   let value = json::serialize(&point)?;
//!   println!("{:?}", value);
//!
//!   assert_eq!(value, r#"{"x":200,"y":193}"#);
//!   Ok(())
//! }
//! ```
//!
//! #### `json::deserialize`
//!
//! ```
//! use vino_codec::{json, Error};
//! use serde::{Serialize, Deserialize};
//!
//! pub fn main() -> Result<(), Error> {
//!   #[derive(Serialize, Deserialize, Debug, PartialEq)]
//!   struct Point {
//!     x: i32,
//!     y: i32,
//!   }
//!
//!   let json = r#"{"x":200,"y":193}"#;
//!
//!   let instance: Point = json::deserialize(&json)?;
//!
//!   assert_eq!(instance, Point { x: 200, y: 193 });
//!   Ok(())
//! }
//!
//! ```
//!
//! ### MessagePack
//!
//! Serializes to a MessagePack [Vec<u8>].
//!
//! #### `messagepack::serialize`
//!
//! ```
//! use vino_codec::{messagepack, Error};
//! use serde::{Serialize, Deserialize};
//!
//! pub fn main() -> Result<(), Error> {
//!   #[derive(Serialize, Deserialize)]
//!   struct Point {
//!     x: i32,
//!     y: i32,
//!   }
//!
//!   let point = Point { x: 200, y: 193 };
//!
//!   let value = messagepack::serialize(&point)?;
//!   println!("{:?}", value);
//!
//!   let expected: Vec<u8> = vec![146, 204, 200, 204, 193];
//!   assert_eq!(value, expected);
//!   Ok(())
//! }
//! ```
//!
//! #### `messagepack::deserialize`
//!
//! ```
//! use vino_codec::{messagepack, Error};
//! use serde::{Serialize, Deserialize};
//!
//! pub fn main() -> Result<(), Error> {
//!   #[derive(Serialize, Deserialize, Debug, PartialEq)]
//!   struct Point {
//!     x: i32,
//!     y: i32,
//!   }
//!
//!   let slice = vec![146, 204, 200, 204, 193];
//!
//!   let instance: Point = messagepack::deserialize(&slice)?;
//!
//!   assert_eq!(instance, Point { x: 200, y: 193 });
//!   Ok(())
//! }
//! ```
//!
//! ### Raw
//!
//! The [raw] module uses [serde_value] as an intermediary format to pass around.
//!
//! ```
//! use vino_codec::{raw, Error};
//! use serde::{Serialize, Deserialize};
//!
//! pub fn main() -> Result<(), Error> {
//!   #[derive(Serialize, Deserialize, Debug, PartialEq)]
//!   struct Point {
//!     x: i32,
//!     y: i32,
//!   }
//!
//!   let point = Point { x: 200, y: 193 };
//!
//!   let value = raw::serialize(&point)?;
//!   let instance: Point = raw::deserialize(value)?;
//!
//!   assert_eq!(instance, Point { x: 200, y: 193 });
//!   Ok(())
//! }
//!```
//!

// !!START_LINTS
// Vino lints
// Do not change anything between the START_LINTS and END_LINTS line.
// This is automatically generated. Add exceptions after this section.
#![deny(
  clippy::expect_used,
  clippy::explicit_deref_methods,
  clippy::option_if_let_else,
  clippy::await_holding_lock,
  clippy::cloned_instead_of_copied,
  clippy::explicit_into_iter_loop,
  clippy::flat_map_option,
  clippy::fn_params_excessive_bools,
  clippy::implicit_clone,
  clippy::inefficient_to_string,
  clippy::large_types_passed_by_value,
  clippy::manual_ok_or,
  clippy::map_flatten,
  clippy::map_unwrap_or,
  clippy::must_use_candidate,
  clippy::needless_for_each,
  clippy::needless_pass_by_value,
  clippy::option_option,
  clippy::redundant_else,
  clippy::semicolon_if_nothing_returned,
  clippy::too_many_lines,
  clippy::trivially_copy_pass_by_ref,
  clippy::unnested_or_patterns,
  clippy::future_not_send,
  clippy::useless_let_if_seq,
  clippy::str_to_string,
  clippy::inherent_to_string,
  clippy::let_and_return,
  clippy::string_to_string,
  clippy::try_err,
  clippy::if_then_some_else_none,
  bad_style,
  clashing_extern_declarations,
  const_err,
  dead_code,
  deprecated,
  explicit_outlives_requirements,
  improper_ctypes,
  invalid_value,
  missing_copy_implementations,
  missing_debug_implementations,
  mutable_transmutes,
  no_mangle_generic_items,
  non_shorthand_field_patterns,
  overflowing_literals,
  path_statements,
  patterns_in_fns_without_body,
  private_in_public,
  trivial_bounds,
  trivial_casts,
  trivial_numeric_casts,
  type_alias_bounds,
  unconditional_recursion,
  unreachable_pub,
  unsafe_code,
  unstable_features,
  unused,
  unused_allocation,
  unused_comparisons,
  unused_import_braces,
  unused_parens,
  unused_qualifications,
  while_true,
  missing_docs
)]
// !!END_LINTS
// Add exceptions here
#![allow()]

/// The crate's error module.
pub mod error;

/// JSON serialization/deserialization.
#[cfg(feature = "json")]
pub mod json;

/// MessagePack serialization/deserialization.
#[cfg(feature = "messagepack")]
pub mod messagepack;

/// Serialization/deserialization implementations to raw [serde_value]s.
pub mod raw;

/// The crate's Result type.
pub(crate) type Result<T> = std::result::Result<T, error::CodecError>;

/// The crate's Error type.
pub type Error = error::CodecError;