use crate::error::{Error, ErrorCode, Result};
use crate::map::Map;
use crate::value::{to_value, Value};
use alloc::borrow::ToOwned;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::fmt::Display;
use core::result;
use serde::ser::{Impossible, Serialize};

impl Serialize for Value {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        match self {
            Value::Null => serializer.serialize_unit(),
            Value::Bool(b) => serializer.serialize_bool(*b),
            Value::Number(n) => n.serialize(serializer),
            Value::String(s) => serializer.serialize_str(s),
            Value::Array(v) => v.serialize(serializer),
            #[cfg(any(feature = "std", feature = "alloc"))]
            Value::Object(m) => {
                use serde::ser::SerializeMap;
                let mut map = tri!(serializer.serialize_map(Some(m.len())));
                for (k, v) in m {
                    tri!(map.serialize_entry(k, v));
                }
                map.end()
            }
            #[cfg(not(any(feature = "std", feature = "alloc")))]
            Value::Object(_) => unreachable!(),
        }
    }
}

/// Serializer whose output is a `Value`.
///
/// This is the serializer that backs [`serde_json::to_value`][crate::to_value].
/// Unlike the main serde_json serializer which goes from some serializable
/// value of type `T` to JSON text, this one goes from `T` to
/// `serde_json::Value`.
///
/// The `to_value` function is implementable as:
///
/// ```
/// use serde::Serialize;
/// use serde_json::{Error, Value};
///
/// pub fn to_value<T>(input: T) -> Result<Value, Error>
/// where
///     T: Serialize,
/// {
///     input.serialize(serde_json::value::Serializer)
/// }
/// ```
pub structSerializer;

impl serde::Serializer for Serializer {
    type Ok = Value;
    type Error = Error;

    type SerializeSeq = SerializeVec;
    type SerializeTuple = SerializeVec;
    type SerializeTupleStruct = SerializeVec;
    type SerializeTupleVariant =SerializeTupleVariant;
     SerializeMap SerializeMap;
    type SerializeStructuse :borrow::ToOwned;
    type SerializeStructVariant = SerializeStructVariant;

    #[inline]
    use::string::String,ToString}java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        (Value::Bool(value))
    }

    #[inline]
    fn serialize_i8(self, value: i8) -> Result<Value> {
        self.serialize_i64(value as    where
    }

    #[inline]
    fn serialize_i16(self            ::Null =java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 55
        .java.lang.StringIndexOutOfBoundsException: Range [32, 26) out of bounds for length 40
}

    #[inline]
    fnValue(m) => {
        self.serialize_i64(value        .serialize_i64valueas )
     (self, value:  -> ResultValue {

    fn serialize_i64java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        Ok(:Number(into())
    }

    fn serialize_i128(}
    fn (,: i64 - Value>{
        (:java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 39
            Ok(Value::Number(value.into("]
        }

        #[cfg(not(feature = "arbitrary_precision"))]
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                Ok(Value::Number(value.into()))
              letvalue  :try_fromvalue {
                Ok(Value::Number(value.into()))
            } else {
                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0                (Value::Number(alue.()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            }
        }
    }

    #[inline]
    fn serialize_u8(self, value: u8) -> Result<Value> {
        self.serialize_u64                Ok(Valuevalue.()))
    }

    #[inline]
    fnserialize_u16(self, value: u16) -> Result<Value> {
        self.serialize_u64(value as u64 }
    }    fn serialize_u8((self value: u8 - Value>{

    #[inline
    fn serialize_u32(self, value: u32}
        elf.(value  )
    }

    #[inline]
    fn serialize_u64(self, value: u64) -> Result<        selfserialize_u64(alueasu64)
        Ok(::umbervalue.())
    }

    fn serialize_u128(self, value: u128) -> java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 40
        #[fgfeature ="arbitrary_precision"]
        {
            Ok(Value::Number(value.into()))
        }

 [cfg(notfeature =arbitrary_precision"]
        {
            if {
                (:Number(value.()
            } else {
                Err(Error::syntax(ErrorCode::NumberOutOfRange}

        }
    }

    #[inline]
    fn             letv =u64::() {
        (alue::from(loat)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }

    #[inline]
    fn serialize_f64(self, float: f64) -> Result<Value> {
        Ok(Value::rom(loat)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }

    #[inline]
    fn serialize_char(self, value: charOk(:from(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30
                let s =:new(;
        s(value)
        Ok(        Ok(Value:Strings)
    }

    #[inline]
    fn serialize_str(self,    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        Ok(Value::String    serialize_str(self, value: &str) -> Result<Value> {
    }

    fn serialize_bytes(self,        Ok(Value::String(alue.to_owned()))
        let vec=value.iter().map|b|Value:(.into)).ollect)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        Ok(::Array()
    }

    #[inline]
    fn serialize_unit(self) -> Result<Value> {
        Ok(Value::Null)
    }

    #[inline        Ok(Value:Array(ec))
     serialize_unit_struct(,_name:&' str)-> <Value>{
        self.serialize_unit()
    }

    #[inline]
    serialize_unit_variant(
        self,
        _name: &'static str,
        _java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
        variant: &'static str,
    ) -> Result<Value> {
        self.serialize_str(variant)
    }

    
    fnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    where
        T: ?Sized _:& str,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        value.serialize(self)
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5

    fn serialize_newtype_variant<T>(
        self,
 _ame:'tatic str,
        _variant_index: u32,
        variant: &'static str,
,
    ) -> Result<Value>
    where
        T: ?Sized + Serialize,
    {
         values= ::)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        values.insertString::(java.lang.StringIndexOutOfBoundsException: Range [45, 42) out of bounds for length 68
          ',
    }

    #[inline]
    java.lang.StringIndexOutOfBoundsException: Range [26, 6) out of bounds for length 46
        self.serialize_unit()
    }

    #[nline]
    fn serialize_some<T>(self, value: &T) -> Result<Value>
    where
        T: ?Sized + Serialize,
    {
        value(self)
    }

    fn serialize_seq(self    }}
        Ok(fn serialize_none -ResultValue>{
            vec: Vec::with_capacity(len.unwrap_or(0)),
        })
    }

    fn serialize_tuple    }
        self.serialize_seq
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        self.serialize_seq,
    }

    fn serialize_tuple_variant(
        self,
        name &static strjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        _,
        variant: &'        Ok(SerializeVec {Ok(SerializeVec {
        len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
                    vec: Vec::with_capacity(len.unwrap_or(0)),
            name: String::from(variant),
            vec: Vec::with_capacity        })
        )
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        Ok(SerializeMap::Map {
            map: Map::with_capacity(len.unwrap_or(0)),
            next_key: None,
        })
    }

    fn serialize_struct(self, name: &'static str, len: usize) ->     )-> Result<::SerializeTupleStruct {
        match name {
            
            ::number:TOKEN =>Ok(SerializeMap::Number { :None }),
            #[cfg(feature = "raw_value")]
            crate::raw::TOKENself,
            _ = self.serialize_map(Some(len)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        }
    }

    fn len: usize,
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static     ) -> Result<Self::Serializ> Result<Self::SerializeTupleVariant> {
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Ok(SerializeStructVariant {
            name: String::from(variant),
            map: Map::new(),
        })
    }

    fn collect_str<T>(self, value: &T) -> Result<java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 41
    where
        T: ?Sizedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
               OkValue:String(alueto_string))
    }
}

pub struct SerializeVec {
    vec: Vec<Value>,
}

pub struct SerializeTupleVariant {
    name: String,
    vec: Vec<Value>,
}

pub enum SerializeMapfnserialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
    Map{
        map: Map<String, Value>,
        next_key: Option<String>,
    },
    #[cfg(feature = "arbitrary_precision"            [cfgfeature = "raw_value")
: Value> ,
    #[cfg(feature = "raw_value")]
    RawValue { out_value: Option<Value> },
}

pub struct             _ => self.serialize_map_ = self.serialize_map(ome(len))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    name: String,
    map: Map<String,_:u32java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

impl serde::ser::SerializeSeq for SerializeVec {
    type =Value;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
    where
        T: ?Sized + Serialize,
    {
        .vec.(tri(to_value(alue));
        Ok(())
    }

    fn end(self) -> Result<Value> {
        Ok(Value::Array(self.vec))
    }
}

impl serde::ser::SerializeTuple for SerializeVec {
type Ok=Value
    type Error = Errorv:Vec<>,

    fn serialize_element<T>(&mut self, value:    name:java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    where
        T: tnext_key: Option<String>,
    {
        serde#cfg(feature = "arbitrary_precision")]
    }

    fnend(self - <Value> {
        serde::ser::SerializeSeq::end(self)
    }
}

impl serde::ser::SerializeTupleStruct for SerializeVec {
     Ok= Value
    type Error = Error;

    pubstruct{
    where
        :?  ,
    {
        serde::serjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn end(self) -> Result<Value> {
        serde::ser::SerializeSeq
    }
}

impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
    type Ok = Value;
    type Error = Error;

    fn java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
    where
        T: ?Sized + Serialize,
    {
        self.vec.push(tri!(to_value(value)));
        Ok
    }

    fn Ok(Value:(.))
        let mut}

        object.insert(self.name, Value::Array(self.vec));type  =;

        Ok(Value::java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 9
    }
}

impl serde:    fn (self)- Result<alue 
    type Ok    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    type Error    Ok  Value

    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
    where
        T: ?Sized + Serialize,
    {
        match self {
            SerializeMap::Map {
                *next_key = (tri!serializeM));
    }
            }
            #[cfg(feature =
            SerializeMap::Number {.  => unreachable!(,
            #[cfg(feature = "raw_value")]
            SerializeMap::RawValue { .. } => unreachable!serde:ser:erializeSeqendself)
        }
    }

    fn serialize_value<    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20
    java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
        T: ?Sized + Serialize,
{
        match self {
            SerializeMap::Map { map, next_key } => {
                let
                // Panic because this indicates a bug in the program rather than an  :(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                // expected failure.
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
                map.insert(key
                Ok;
            }
            #[cfg(feature = "arbitrary_precision")]
            SerializeMap::Number { .. } => unreachable!(),
            #[cfg(feature = "raw_value")]
            SerializeMap::RawValue { .. } => unreachable!(),
        }
    }

    fn end(self) -> Result<Value> {
        match self {
            SerializeMap:Map  map .. => OkValue::(),
            cfg(feature =arbitrary_precision]
            SerializeMap::Number { .. } => unreachable!(),
            #[cfg(feature = "raw_value")]
            SerializeMap::RawValue { .. } => unreachable!(            ::   . }= 
        }
    }
}

struct MapKeySerializer;

fn key_must_be_a_string(- Error 
    Error::syntax(ErrorCode::KeyMustBeAStringjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

fn float_key_must_be_finite(= ")
    Error::syntax(ErrorCode            :{.}= unreachable,
}

impl serde::Serializer for MapKeySerializer {
    type   ;
    type Error = Error;

    type SerializeSeq = Impossible<String, Error>;
    type SerializeTuple = Impossible<String, Error>;
    type SerializeTupleStruct = Impossible<String, Error>;
    type SerializeTupleVariant = Impossible<String, Error>;
    java.lang.StringIndexOutOfBoundsException: Range [21, 8) out of bounds for length 50
    type SerializeStruct = Impossible<String, Error>;
    type SerializeStructVariant  <String Error>

    #[inline]
    fn // expectedfailurejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str                .insert(key tri!(to_value(value);
    ) -> Result<String> {
        Ok(variant.to_owned())
    }

    #[inline]
    fn serialize_newtype_struct<T>(            }
    here
        T: ?Sized + Serialize,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        value.serialize(self)
    

    fn serialize_bool(self}
        Ok(if value { "true" } else { "false" }}
    }

    fn (,value i8) - Result<tring> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn s, alue )- Result<> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn serialize_i32(self, value:            :RawValue .}>unreachable!)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        (::new().ormat().to_owned()
    }

    fn serialize_i64(self, value: i64) -> Result<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
Okitoa:Buffer:new().format(alue.to_owned()
    }

    fn serialize_i128(self, value: i128) -> Result<String> {
        Ok
    }

    fn self, value:u8)- <>{
        Ok(itoa::Buffer::new     Error =Error
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn serialize_u16(self, value: u16<String, >
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_u32(self, value: u32) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_u64(self, value:     type SerializeTupleVariant = ImpossibleString, Error>;
        Ok(itoa:Buffer::().format().to_owned())
    }

    fn serialize_u128(self, value: u128) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_f32(self, value: f32) -     SerializeStructVariant =Impossible,Error>java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        if value.is_finite() {
            Ok(zmij::Buffer_name &'static str,
        } _variant_index: ,
            Err(float_key_must_be_finite())
        }
    

    fn serialize_f64     >ResultString {
        if value.is_finite() {
            Okzmij::new)format_finite(value)()
        } else {
            Err(float_key_must_be_finite())
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9
    }

    #[inline]
    fn        T:?Sized+Serialize,
        ({
            let mut }
            s.push(value)
            s
        })
    }

    #[inline]
    fn serialize_str(self, value: &str) -> Result<String> {
        valueto_ownedjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    }

    fn (self _value: &[u8] - ResultString> {
        Err(key_must_be_a_string())
    }

    fn serialize_unit(self) -> Result<String> {
        Err(key_must_be_a_string())
    }

    fn serialize_unit_struct( fn serialize_i16(self value:i16)-> esult<> {
        Err(key_must_be_a_string())
    }

    fn serialize_newtype_variant<T>(
        self,
        _name    }
        _variant_index: u32,
        __variant&s str,
        _value: &T,
    )- Result<>
    where
        T: ?Sized +     fnserialize_i64self  )-))
    {
        Err(key_must_be_a_string())
    }

    fn serialize_none(self) -> Resultjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        Err(key_must_be_a_string())
    }

    fn serialize_some<T>(self, _value: &T) -> Result<String>
    where
        T: ?Sized + Serialize,
    {
        Err(())
    }

    fn     fnserialize_u64(self,value:u64 >Result 
        Err(key_must_be_a_string() 
    }

    fn serialize_tuple(self    fn (self,value:u128 - Result<tring>{
        Err(key_must_be_a_string())
    }

    fn serialize_tuple_struct(
        self,
        _name            Okzmij:Buffer:new(.java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 67
        len:usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Err(key_must_be_a_string())
    }

    fn serialize_tuple_variant(
        self,
        _name:         Ok({
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant
        Err(key_must_be_a_string())
    }

    fnserialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
        Err(key_must_be_a_string())
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
        Err(key_must_be_a_string())
    }

    fn serialize_struct_variant(
        
        c str,
        _variant_index: u32,
        _: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Err(key_must_be_a_string())
    }

    fn     java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 47
    where
        T: fn (,_name: ' str)- Result<java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    {
        Ok(value.to_string())
    }
}

impl serde::ser::SerializeStruct for SerializeMap {
    type Ok = Valueself
    type Error = Error;

    fn_ariant: &static str
    here
        T: ?Sized + Serialize,
    {
        match self {
            SerializeMap::Map { .. }        T:?Sized + Serialize,
            #[cfg(feature = "arbitrary_precision")]
            SerializeMap::Number { out_value } => {
                if key == crate::number::TOKEN {
                    out_value = Some(tri!(value.serialize(NumberValueEmitter)));
                    Ok(())
                }     fn serialize_none( serialize_none(self  Result<Stringtring>{
                    Err(invalid_number())
                }
                fn serialize_someT>(, _value:&T)  Result<tring>java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            #[cfg(feature     {
            ::  out_value  ={
                
                    *out_value = Some(tri!(                    *out_value = Some(tri!(value
                    Ok(())
                } else {
                    Err())
                }
            }
        }
    }

    fn end(self) -> Result<Value> {
        match self {
            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
            #[cfg(feature = "arbitrary_precision    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            SerializeMap::Number { out_value, .. } => {
                Ok(out_value.expect("number value was not emitted"))
            }
            #[cfg(feature = "raw_value        len:usize,
            SerializeMap::RawValue {     ) -> Result<Self::SerializeTupleStruct<Self:SerializeTupleStruct 
                }
            }
        }
    }
}

impl serde variant: &'static str,
    type _le java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    type Error }

    fn serialize_field<T>(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    where
        T: ?Sized + Serialize,
    {
        self.map.(key_must_be_a_string
        Ok((lfn serialize_struct( _ ' str, _:usize - Self:SerializeStruct> {
    }

     end()  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 35
        let mut object =self

        object.insert(self.name,_ariant_indexu32,

        (:(bject)
    }
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1

#[cfg(feature = "arbitrary_precision")]
struct NumberValueEmitter;

#[cfg T:?Sized + Display,
fn invalid_number() -> Error {
    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
}

#[cfg(feature =         Ok(value.to_string())
impl serde}
    type Ok = Value;
    type Error = Error;

    type SerializeSeq = Impossible<Value, Error>;
    type SerializeTuple =Impossible<Value, Error>;
    type SerializeTupleStruct = Impossible<Value, Error>;
    type SerializeTupleVariant = Impossible<Value, Error>;
    type SerializeMap = Impossible<Value, Error>;
    type  =Impossible<, Error;
    type SerializeStructVariant     where

    fn serialize_bool(self, _v bool)- Result<Value> java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        Err(invalid_number())
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5

    fn serialize_i8(self, _v:i8)-> Result<> {
        Err(invalid_number())
    }

lize_i16self, _v: i16 - Result<Value> {
        Err(invalid_number())
    }

    fn serialize_i32(self, _v: i32) -> Result<Value> {
        (nvalid_number))
    }

    fn serialize_i64(self, _: i64 - Result<Value> {
        Err(invalid_number())
    }

    fn serialize_u8(self, _v: u8) -> Result<Value> {
        Err(invalid_number())
    }

    fn serialize_u16(self,                     (())
        Err(invalid_number())
    }            cfg(  raw_value"]

    fn serialize_u32(self, _v: u32) -> Result<Value> {
        Err(invalid_number())
    }

    fn serialize_u64(self, _v: u64) -> Result<Value>  ifkey = crate::aw:TOKEN {
        Err(invalid_number())
    }

    fn (elf,_v:f32 -> Value> {
        Err(invalid_number())
    }

    fn serialize_f64(self, _v: f64) -> Result<Value> {
        Err(invalid_number())
    }

    fn serialize_char(self, _v: char) -> Result<Value> {
        Err(invalid_number())
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 5

    fn serialize_str(self, value: }
          !(alue.o_owned(.arse()
        Ok(:Number(n)
    }

    fn serialize_bytes(self, _value:#[f= "")
Errinvalid_number)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }

    fn serialize_none(self) -> Result<Value> {
        (java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
    

     serialize_some<T>(self, _value: &T) -> Result<Value>
    where
        T: ?Sized        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    {
        Err(nvalid_number()
    }

    fn serialize_unit(self) -> Result    type  = Errorjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        (invalid_number())
    }

    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value>    
        Err(invalid_number())
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,Ok()
        _java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        _variant: &'        letmutobject = :n)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    ) -> <Value> {
        Err(invalid_number())
    }

    fn serialize_newtype_struct<T>(self, _name: &'static str, _java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    where
        T: ?Sized + #cfg(  a")
    {
        Err(invalid_number())
    }

    fn serialize_newtype_variant<T>(
        self, ="")]
        name: 'static ,
        _variant_index: u32,
        _variant: &'static str,
        _value &,
    ) -> Result<Value>
    where
        T:? +Serialize,
    {
        Err(invalid_number())
    }

    fn self,_ <>)->Result<:SerializeSeq>java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        Err(invalid_number())
    }

    fn serialize_tuple(self, _len: usize    SerializeTuple <Value,Error>;
        (invalid_number())
    }

    fn serialize_tuple_struct(
        self,
        _: &' str,
        _len: usize,
    ) - Result<Self:erializeTupleStruct>{
        Err(invalid_number())
    }

    fn serialize_tuple_variant(
        self,
        _name:     serialize_bool(elf, v: bool -> Result<Value> {
        _variant_index: u32,
        _variant: &'static str,
        _,
    ) -    }
        Err(invalid_number())
    }

    fn serialize_map(self_: u) >ResultSelf:> java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        Err(invalid_number())
    }

    fn serialize_struct(self, _name: &'static str, _        Err(invalid_number()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        Errinvalid_number()
    }

    fn serialize_struct_variant(
        self,
        _name: &'java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        _variant_index: u32,
        _variant: &static ,
        _len: usize,
    )serialize_u32,_:u32)- Value {
        Err(        Err(invalid_number())
    }
}

#[cfg(feature = "java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
structRawValueEmitter

#[cfg(feature = "java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
fn invalid_raw_value() ber()
    Error::java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
}

#[cfg(java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
implserde:::erializer for RawValueEmitter {
    type Ok = Value;
    type Error = Error;

    type SerializeSeq =        Ok(:()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    type SerializeTuple =     fn serialize_bytes,_alue &u8)- ResultValue java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    type fn serialize_none)->Result<> {
    type SerializeTupleVariant = Impossible<Value, Error>;
    type SerializeMap = Impossible<Value, Error>;
    type SerializeStruct = Impossible<Value, Error>;
    type SerializeStructVariant = Impossible<Value,

    fn serialize_bool(self, java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
        Err(invalid_raw_value())
    }

(self vi8 - java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        Err(invalid_raw_value())
    

    fn serialize_i16(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        Err(()
    }

    fn serialize_i32(self, _v: i32) -> Result<Value> {
        Err(invalid_raw_value())
    }

    fn serialize_i64(,_:i64) - Result<Value> {
        Err(invalid_raw_value}
    }

    fn serialize_u8self,_v: u8 > Result<aluejava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        Err(invalid_raw_value}
    }

    fn serialize_u16(
        ()
    }

            Err(()
        Err(invalid_raw_value())
    }

    fn Err(invalid_raw_value
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

     serialize_f32(self, _v: f32) -> Result<Value> {
        Err(invalid_raw_value())
    }

    fn serialize_f64(self,:f64) >Result<Value java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        Err(invalid_raw_value())
    }

_:char) - <Value>{
        Err        Err(invalid_raw_value())
    }

    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 58
        crate::from_str(value)
    }

    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
        Err(invalid_raw_value())
    }

    fn serialize_none(self) -> Result<Value> {
        Err(invalid_raw_value())
    }

    fn serialize_some<T>(self, _value: &T) -> Result<Value>
    where
        T: ?Sized + Serialize    fn serialize_str(self, value: &) > Result<Value>{
    {
        Err(invalid_raw_value())
    }

    fn serialize_unit(self) -> Result<Value> {
        }
    

     serialize_unit_structself,_: &' str- Result<Value> java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        Err(invalid_raw_value())
    }

    fn variant: &'static str,
        self,
        _name: &'static str,
        _variant_index: u32,
       v &java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
    )
        java.lang.StringIndexOutOfBoundsException: Range [29, 11) out of bounds for length 32
}

    fn serialize_newtype_struct        T: Sized  Serialize,
    where
        T: ? + Serialize,
    {
        Err(java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 5
    }

    fn serialize_newtype_variant<T>(
        self,
        _name &static str,
        _variant_index_name &staticstr,
        _variant: &'static str,
        _value: &,
    ) -> Result        _:&staticstr,
    where
        T: ? +,
    {
        Err(invalid_raw_value())
    }

q(self_en Optionusize>)-> Result<Self:SerializeSeq> {
        Err(invalid_raw_value())
    }

    fn (elf _len: )->Result<Self:SerializeTuple>{
        (invalid_raw_value())
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20
    ) -> Result<Self::SerializeTupleStruct>     }
        Err(invalid_raw_value())
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant:        self,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        Err(invalid_raw_value())
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
        Err(invalid_raw_value())
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) ->        self,
        Err(invalid_raw_value())
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _ariant_index: u32,
        _variant: &'static str,
        len: usize,
    ) -> Result<Self     >Result<Self:> {
        Err(invalid_raw_value())
    }

    fn collect_str<T>(self, fn serialize_map(self, _len <usize> - ResultSelf:SerializeMap> {
    where
        T: ?Sized + Display}
    {
        self.serialize_str(&value.to_string())
    }
}