changelog shortlog graph tags branches changeset files revisions annotate raw help

Mercurial > demo / obj/src/lib.rs

changeset 7: 315fedf35bc7
parent: 8f59e2f1b8c4
child: d8f806f1d327
author: ellis <ellis@rwest.io>
date: Sun, 07 May 2023 18:06:13 -0400
permissions: -rw-r--r--
description: rust ffi macros, general stuff 
     1 //! obj/src/lib.rs --- Objective type library
     2 #![feature(associated_type_bounds)]
     3 mod err;
     4 pub use err::{Error, Result};
     5 mod types;
     6 pub use types::*;
     7 
     8 pub use bincode;
     9 pub use ron;
    10 use ron::extensions::Extensions;
    11 use serde::{de::DeserializeOwned, Deserialize, Serialize};
    12 pub use serde_json;
    13 use std::collections::{BTreeMap, HashMap};
    14 use std::io;
    15 
    16 /// common trait for all config modules. This trait provides functions
    17 /// for de/serializing to/from RON, updating fields, and formatting.
    18 pub trait Configure: Objective {
    19   fn update(&self) -> Result<()> {
    20     Ok(())
    21   }
    22 }
    23 
    24 /// Objective trait
    25 /// Define Object behaviors, implemented by Objects
    26 pub trait Objective {
    27   fn encode(&self) -> Result<Vec<u8>>
    28   where
    29     Self: Serialize,
    30   {
    31     Ok(bincode::serialize(self)?)
    32   }
    33 
    34   fn encode_into<W>(&self, writer: W) -> Result<()>
    35   where
    36     W: io::Write,
    37     Self: Serialize,
    38   {
    39     Ok(bincode::serialize_into(writer, self)?)
    40   }
    41 
    42   fn decode<'a>(bytes: &'a [u8]) -> Result<Self>
    43   where
    44     Self: Deserialize<'a>,
    45   {
    46     Ok(bincode::deserialize(bytes)?)
    47   }
    48 
    49   fn decode_from<R>(&self, rdr: R) -> Result<Self>
    50   where
    51     R: io::Read,
    52     Self: DeserializeOwned,
    53   {
    54     Ok(bincode::deserialize_from(rdr)?)
    55   }
    56 
    57   fn to_ron_writer<W>(&self, writer: W) -> Result<()>
    58   where
    59     W: io::Write,
    60     Self: Serialize,
    61   {
    62     Ok(ron::ser::to_writer_pretty(
    63       writer,
    64       &self,
    65       ron::ser::PrettyConfig::new()
    66         .indentor("  ".to_owned())
    67         .extensions(Extensions::all()),
    68     )?)
    69   }
    70 
    71   fn to_ron_string(&self) -> Result<String>
    72   where
    73     Self: Serialize,
    74   {
    75     Ok(ron::ser::to_string_pretty(
    76       &self,
    77       ron::ser::PrettyConfig::new().indentor("  ".to_owned()),
    78     )?)
    79   }
    80 
    81   fn from_ron_reader<R>(&self, mut rdr: R) -> Result<Self>
    82   where
    83     R: io::Read,
    84     Self: DeserializeOwned,
    85   {
    86     let mut bytes = Vec::new();
    87     rdr.read_to_end(&mut bytes)?;
    88     Ok(ron::de::from_bytes(&bytes)?)
    89   }
    90 
    91   fn from_ron_str<'a>(s: &'a str) -> Result<Self>
    92   where
    93     Self: Deserialize<'a>,
    94   {
    95     Ok(ron::de::from_bytes(s.as_bytes())?)
    96   }
    97 
    98   fn to_json_writer<W>(&self, writer: W) -> Result<()>
    99   where
   100     W: io::Write,
   101     Self: Serialize,
   102   {
   103     //    let formatter = serde_json::ser::PrettyFormatter::with_indent(b"  ");
   104     Ok(serde_json::ser::to_writer_pretty(writer, &self)?)
   105   }
   106 
   107   fn to_json_string(&self) -> Result<String>
   108   where
   109     Self: Serialize,
   110   {
   111     Ok(serde_json::ser::to_string_pretty(&self)?)
   112   }
   113 
   114   fn from_json_reader<R>(&self, mut rdr: R) -> Result<Self>
   115   where
   116     R: io::Read,
   117     Self: DeserializeOwned,
   118   {
   119     let mut bytes = Vec::new();
   120     rdr.read_to_end(&mut bytes)?;
   121     Ok(serde_json::de::from_slice(&bytes)?)
   122   }
   123 
   124   fn from_json_str<'a>(s: &'a str) -> Result<Self>
   125   where
   126     Self: Deserialize<'a>,
   127   {
   128     Ok(serde_json::de::from_slice(s.as_bytes())?)
   129   }
   130 }
   131 
   132 impl<T> Objective for Vec<T> {}
   133 impl<K, V> Objective for HashMap<K, V> {}
   134 impl<K, V> Objective for BTreeMap<K, V> {}