use std::fmt;
use std::ops::{Deref, DerefMut};
use crate::error::Error;
use crate::view::JsonView;
use serde::de::Error as DeError;
use serde::ser::Error as SerError;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::value::RawValue;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AsJshiftView<T>(pub T);
impl<T> AsJshiftView<T> {
#[inline]
pub const fn new(value: T) -> Self {
Self(value)
}
#[inline]
pub fn into_inner(self) -> T {
self.0
}
#[inline]
pub fn get(&self) -> &T {
&self.0
}
#[inline]
pub fn get_mut(&mut self) -> &mut T {
&mut self.0
}
#[inline]
pub fn from_raw_value(raw: &RawValue) -> Result<Self, Error>
where
T: JsonView,
{
Ok(Self(T::read_from(raw.get().as_bytes())?))
}
}
impl<T> From<T> for AsJshiftView<T> {
#[inline]
fn from(value: T) -> Self {
Self(value)
}
}
impl<T> Deref for AsJshiftView<T> {
type Target = T;
#[inline]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T> DerefMut for AsJshiftView<T> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<T: fmt::Display> fmt::Display for AsJshiftView<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl<'de, T: JsonView> Deserialize<'de> for AsJshiftView<T> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let raw = <&'de RawValue>::deserialize(deserializer)?;
let t = T::read_from(raw.get().as_bytes()).map_err(|e| D::Error::custom(e.to_string()))?;
Ok(AsJshiftView(t))
}
}
impl<T: JsonView> Serialize for AsJshiftView<T> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serialize_view(&self.0, serializer)
}
}
fn serialize_view<T: JsonView, S: Serializer>(view: &T, serializer: S) -> Result<S::Ok, S::Error> {
let bytes = view
.to_schema_bytes()
.map_err(|e| S::Error::custom(e.to_string()))?;
let s = String::from_utf8(bytes).map_err(|e| S::Error::custom(e.to_string()))?;
let raw = RawValue::from_string(s).map_err(|e| S::Error::custom(e.to_string()))?;
raw.serialize(serializer)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AsJshiftViewOwned<T>(pub T);
impl<T> AsJshiftViewOwned<T> {
#[inline]
pub const fn new(value: T) -> Self {
Self(value)
}
#[inline]
pub fn into_inner(self) -> T {
self.0
}
#[inline]
pub fn into_borrowed(self) -> AsJshiftView<T> {
AsJshiftView(self.0)
}
}
impl<T> From<T> for AsJshiftViewOwned<T> {
#[inline]
fn from(value: T) -> Self {
Self(value)
}
}
impl<T> From<AsJshiftView<T>> for AsJshiftViewOwned<T> {
#[inline]
fn from(value: AsJshiftView<T>) -> Self {
Self(value.0)
}
}
impl<T> Deref for AsJshiftViewOwned<T> {
type Target = T;
#[inline]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T> DerefMut for AsJshiftViewOwned<T> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<'de, T: JsonView> Deserialize<'de> for AsJshiftViewOwned<T> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let raw = Box::<RawValue>::deserialize(deserializer)?;
let t = T::read_from(raw.get().as_bytes()).map_err(|e| D::Error::custom(e.to_string()))?;
Ok(AsJshiftViewOwned(t))
}
}
impl<T: JsonView> Serialize for AsJshiftViewOwned<T> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serialize_view(&self.0, serializer)
}
}
pub fn from_value<T: JsonView>(value: &serde_json::Value) -> Result<T, Error> {
let bytes = serde_json::to_vec(value).map_err(|_| Error::InvalidJsonSyntax {
pos: 0,
msg: "serde_json failed to serialize Value for jshift",
})?;
T::read_from(&bytes)
}
pub fn to_value<T: JsonView>(view: &T) -> Result<serde_json::Value, Error> {
let bytes = view.to_schema_bytes()?;
serde_json::from_slice(&bytes).map_err(|_| Error::InvalidJsonSyntax {
pos: 0,
msg: "serde_json failed to parse jshift schema bytes",
})
}
#[inline]
pub fn from_str_view<T: JsonView>(s: &str) -> Result<T, Error> {
T::read_from(s.as_bytes())
}
#[inline]
pub fn from_slice_view<T: JsonView>(json: &[u8]) -> Result<T, Error> {
T::read_from(json)
}
#[inline]
pub fn from_raw_value<T: JsonView>(raw: &RawValue) -> Result<T, Error> {
T::read_from(raw.get().as_bytes())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{find_value, parse_path, upsert_at_path, FromJsonSlice, ToJsonBytes};
struct IdOnly {
id: u64,
}
impl JsonView for IdOnly {
fn read_from(json: &[u8]) -> Result<Self, Error> {
let slice = find_value(json, &parse_path("id"))?;
Ok(Self {
id: u64::from_json_slice(slice).ok_or(Error::TypeMismatch {
expected: "u64",
found: "bad",
})?,
})
}
fn write_into(&self, json: &mut Vec<u8>) -> Result<(), Error> {
upsert_at_path(json, &parse_path("id"), &self.id.to_json_bytes())
}
fn project_plan() -> crate::ProjectPlan {
crate::ProjectPlan::from_paths(&["id"]).unwrap()
}
}
#[test]
fn as_jshift_view_roundtrip_json() {
let raw = r#"{"id":7,"noise":true}"#;
let v: AsJshiftView<IdOnly> = serde_json::from_str(raw).unwrap();
assert_eq!(v.id, 7); let out = serde_json::to_string(&v).unwrap();
assert!(out.contains("\"id\":7"));
assert!(!out.contains("noise"));
}
#[test]
fn from_str_and_slice_use_borrowed_raw() {
let raw = r#"{"id":7,"noise":true}"#;
let v: AsJshiftView<IdOnly> = serde_json::from_str(raw).unwrap();
assert_eq!(v.id, 7);
let v2: AsJshiftView<IdOnly> = serde_json::from_slice(raw.as_bytes()).unwrap();
assert_eq!(v2.id, 7);
let rv: &RawValue = serde_json::from_str(raw).unwrap();
let rv_addr = rv.get().as_ptr() as usize;
let start = raw.as_ptr() as usize;
let end = start + raw.len();
assert!(
rv_addr >= start && rv_addr < end,
"RawValue text should borrow from input string"
);
let v3 = AsJshiftView::<IdOnly>::from_raw_value(rv).unwrap();
assert_eq!(v3.id, 7);
}
#[test]
fn owned_form_from_reader_path() {
use std::io::Cursor;
let raw = br#"{"id":42,"x":1}"#;
let cur = Cursor::new(raw);
let v: AsJshiftViewOwned<IdOnly> = serde_json::from_reader(cur).unwrap();
assert_eq!(v.id, 42);
assert_eq!(v.into_borrowed().id, 42);
}
#[test]
fn from_to_value_boundary() {
let val = serde_json::json!({"id": 3, "x": 1});
let t: IdOnly = from_value(&val).unwrap();
assert_eq!(t.id, 3);
let back = to_value(&t).unwrap();
assert_eq!(back["id"], 3);
assert!(back.get("x").is_none());
}
#[test]
fn from_slice_view_direct() {
let t = from_slice_view::<IdOnly>(br#"{"id":11}"#).unwrap();
assert_eq!(t.id, 11);
}
#[test]
fn into_inner_and_from() {
let v = AsJshiftView::from(IdOnly { id: 1 });
assert_eq!(v.into_inner().id, 1);
}
}