From 47e3f3f8c1834204816f14d4d8b24fc49e0607bc Mon Sep 17 00:00:00 2001 From: Antony Della Vecchia Date: Thu, 21 Nov 2024 17:21:23 +0100 Subject: [PATCH] broke everything --- src/Serialization/Groups.jl | 4 +- src/Serialization/containers.jl | 133 ++++++++++++++++++++++++++++--- src/Serialization/main.jl | 136 ++------------------------------ 3 files changed, 133 insertions(+), 140 deletions(-) diff --git a/src/Serialization/Groups.jl b/src/Serialization/Groups.jl index 434e7070a4ca..e4ee0faa2014 100644 --- a/src/Serialization/Groups.jl +++ b/src/Serialization/Groups.jl @@ -243,7 +243,7 @@ function save_object(s::SerializerState, G::FinGenAbGroup) end function load_object(s::DeserializerState, ::Type{FinGenAbGroup}) - return abelian_group(load_object(s, Matrix, ZZRingElem)) + return abelian_group(load_object(s, Matrix{ZZRingElem})) end # elems @@ -254,5 +254,5 @@ function save_object(s::SerializerState, g::FinGenAbGroupElem) end function load_object(s::DeserializerState, ::Type{FinGenAbGroupElem}, G::FinGenAbGroup) - return G(vec(load_object(s, Matrix, ZZRingElem))) + return G(vec(load_object(s, Matrix{ZZRingElem}))) end diff --git a/src/Serialization/containers.jl b/src/Serialization/containers.jl index f8e1a0863467..d71e8fd78ab3 100644 --- a/src/Serialization/containers.jl +++ b/src/Serialization/containers.jl @@ -16,6 +16,29 @@ function type_params(obj::S) where {T, S <:MatVecType{T}} return S, params[1] end +function save_type_params(s::SerializerState, T::Type{Vector{S}}, ::Nothing) where S + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_object(s, encode_type(S), :params) + end +end + +function save_type_params(s::SerializerState, T::Type, params::Vector) + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_data_array(s, :params) do + for param in params + save_type_params(s, param...) + end + end + end +end + +function load_type_params(s::DeserializerState, T::Type{<: Union{MatVecType, Set}}) + subtype, params = load_type_params(s, :params) + return T{subtype}, params +end + function save_object(s::SerializerState, x::Vector) save_data_array(s) do for elem in x @@ -119,6 +142,16 @@ function type_params(obj::T) where T <: Tuple for i in 1:n] end +function load_type_params(s::DeserializerState, T::Type{Tuple}) + subtype, params = load_node(s, :params) do _ + tuple_params = load_array_node(s) do _ + load_type_params(s) + end + return collect(zip(tuple_params...)) + end + return T{subtype...}, params +end + function save_object(s::SerializerState, obj::Tuple) save_data_array(s) do for entry in obj @@ -136,7 +169,7 @@ function load_object(s::DeserializerState, T::Type{<:Tuple}, params::Tuple) entries = load_array_node(s) do (i, entry) S = fieldtype(T, i) if serialize_with_id(S) - return load_ref(s) + return load_ref(s) else return load_object(s, S, params[i]) end @@ -152,6 +185,38 @@ function type_params(obj::T) where T <: NamedTuple return T, NamedTuple(map(x -> x.first => type_params(x.second), collect(pairs(obj)))) end + +# Named Tuples need to preserve order so they are handled seperate from Dict +function save_type_params(s::SerializerState, T::Type{<:NamedTuple}, params::Vector{<:Pair{Symbol, S}}) where S + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_data_dict(s, :params) do + save_data_array(s, :names) do + for param in params + save_object(s, param.first) + end + end + save_data_array(s, :tuple_params) do + for param in params + save_type_params(s, param.second...) + end + end + end + end +end + +function load_type_params(s::DeserializerState, T::Type{NamedTuple}) + subtype, params = load_node(s, :params) do obj + tuple_params = load_array_node(s, :tuple_params) do _ + load_type_params(s) + end + tuple_types, named_tuple_params = collect(zip(tuple_params...)) + names = load_object(s, Vector{Symbol}, :names) + return (tuple(names...), Tuple{tuple_types...}), named_tuple_params + end + return T{subtype...}, params +end + function save_object(s::SerializerState, obj::NamedTuple) save_object(s, values(obj)) end @@ -167,6 +232,62 @@ function type_params(obj::T) where T <: Dict return T, Dict(map(x -> x.first => type_params(x.second), collect(pairs(obj)))) end +function save_type_params(s::SerializerState, T::Type{<:Dict{S, U}}, params::Vector{<:Pair{S, V}}) where {U, V, S <: Union{Int, String}} + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_data_dict(s, :params) do + save_object(s, encode_type(S), :key_type) + isempty(params) && save_object(s, encode_type(U), :value_type) + for param in params + save_type_params(s, param.second..., Symbol(param.first)) + end + end + end +end + +function save_type_params(s::SerializerState, T::Type{<:Dict{Symbol, U}}, + params::Vector{<:Pair{Symbol, V}}) where {U, V} + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_data_dict(s, :params) do + save_object(s, encode_type(Symbol), :key_type) + isempty(params) && save_object(s, encode_type(U), :value_type) + for param in params + save_type_params(s, param.second..., Symbol(param.first)) + end + end + end +end + +function load_type_params(s::DeserializerState, T::Type{Dict}) + subtype, params = load_node(s, :params) do obj + S = load_node(s, :key_type) do _ + decode_type(s) + end + params_dict = Dict{S, Any}() + if S <: Union{String, Symbol, Int} + value_types = Type[] + for (k, _) in obj + k == :key_type && continue + if k == :value_type + load_node(s, k) do _ + push!(value_types, decode_type(s)) + end + continue + end + key = S == Int ? parse(Int, string(k)) : S(k) + params_dict[key] = load_type_params(s, k) + push!(value_types, params_dict[key][1]) + end + return (S, Union{value_types...}), params_dict + else + error{"not implented yet"} + end + end + + return Dict{subtype...}, params +end + function save_object(s::SerializerState, obj::Dict{S, T}) where {S <: Union{Symbol, String, Int}, T} save_data_dict(s) do for (k, v) in obj @@ -177,17 +298,9 @@ function save_object(s::SerializerState, obj::Dict{S, T}) where {S <: Union{Symb end end -#function save_object(s::SerializerState, obj::Dict) -# save_data_array(s) do -# for (k, v) in obj -# save_object(s, (k, v)) -# end -# end -#end - function load_object(s::DeserializerState, T::Type{<:Dict{S, U}}, - params::Dict{S, V}) where {S <: BasicKeyTypes, U, V} + params::Dict{S, V}) where {S <: Union{Symbol, String, Int}, U, V} dict = T() for k in keys(params) dict[k] = load_object(s, params[k]..., Symbol(k)) diff --git a/src/Serialization/main.jl b/src/Serialization/main.jl index fa737a46d2c6..a92be26bcfb0 100644 --- a/src/Serialization/main.jl +++ b/src/Serialization/main.jl @@ -201,74 +201,10 @@ function save_type_params(s::SerializerState, T::Type, params::Tuple{Type, S}) w end end -function save_type_params(s::SerializerState, T::Type{Vector{S}}, ::Nothing) where S - save_data_dict(s) do - save_object(s, encode_type(T), :name) - save_object(s, encode_type(S), :params) - end -end - -function save_type_params(s::SerializerState, T::Type, params::Vector) - save_data_dict(s) do - save_object(s, encode_type(T), :name) - save_data_array(s, :params) do - for param in params - save_type_params(s, param...) - end - end - end -end - function save_type_params(s::SerializerState, T::Type, params::S) where S <: Union{Dict, NamedTuple} save_type_params(s, T, collect(pairs(params))) end -# Named Tuples need to preserve order so they are handled seperate from Dict -function save_type_params(s::SerializerState, T::Type{<:NamedTuple}, params::Vector{<:Pair{Symbol, S}}) where S - save_data_dict(s) do - save_object(s, encode_type(T), :name) - save_data_dict(s, :params) do - save_data_array(s, :names) do - for param in params - save_object(s, param.first) - end - end - save_data_array(s, :tuple_params) do - for param in params - save_type_params(s, param.second...) - end - end - end - end -end - -function save_type_params(s::SerializerState, T::Type{<:Dict{S, U}}, params::Vector{<:Pair{S, V}}) where {U, V, S <: Union{Int, String}} - save_data_dict(s) do - save_object(s, encode_type(T), :name) - save_data_dict(s, :params) do - save_object(s, encode_type(S), :key_type) - isempty(params) && save_object(s, encode_type(U), :value_type) - for param in params - save_type_params(s, param.second..., Symbol(param.first)) - end - end - end -end - -# this function is exactly the same as above, it is here to distinguish from the function below -function save_type_params(s::SerializerState, T::Type{<:Dict{Symbol, U}}, params::Vector{<:Pair{Symbol, V}}) where {U, V} - save_data_dict(s) do - save_object(s, encode_type(T), :name) - save_data_dict(s, :params) do - save_object(s, encode_type(Symbol), :key_type) - isempty(params) && save_object(s, encode_type(U), :value_type) - for param in params - save_type_params(s, param.second..., Symbol(param.first)) - end - end - end -end - function save_type_params(s::SerializerState, T::Type, params::Vector{<:Pair{Symbol, S}}) where S save_data_dict(s) do @@ -312,73 +248,17 @@ function load_type_params(s::DeserializerState) end return T, nothing end - - !haskey(s, :params) && return T, load_typed_object(s) - - return load_type_params(s, T) -end - -function load_type_params(s::DeserializerState, T::Type{<: Union{MatVecType, Set}}) - subtype, params = load_type_params(s, :params) - return T{subtype}, params -end - -function load_type_params(s::DeserializerState, T::Type{Tuple}) - subtype, params = load_node(s, :params) do _ - tuple_params = load_array_node(s) do _ - load_type_params(s) - end - return collect(zip(tuple_params...)) - end - return T{subtype...}, params -end - -function load_type_params(s::DeserializerState, T::Type{NamedTuple}) - subtype, params = load_node(s, :params) do obj - tuple_params = load_array_node(s, :tuple_params) do _ - load_type_params(s) - end - tuple_types, named_tuple_params = collect(zip(tuple_params...)) - names = load_object(s, Vector{Symbol}, :names) - return (tuple(names...), Tuple{tuple_types...}), named_tuple_params - end - return T{subtype...}, params -end - -function load_type_params(s::DeserializerState, T::Type{Dict}) - subtype, params = load_node(s, :params) do obj - S = load_node(s, :key_type) do _ - decode_type(s) - end - params_dict = Dict{S, Any}() - if S <: Union{String, Symbol, Int} - value_types = Type[] - for (k, _) in obj - k == :key_type && continue - if k == :value_type - load_node(s, k) do _ - push!(value_types, decode_type(s)) - end - continue - end - key = S == Int ? parse(Int, string(k)) : S(k) - params_dict[key] = load_type_params(s, k) - push!(value_types, params_dict[key][1]) - end - return (S, Union{value_types...}), params_dict - else - error{"not implented yet"} - end + if haskey(s, :params) + return T, load_type_params(s, T) + else + return T, load_typed_object end - - return Dict{subtype...}, params end -function load_type_params(s::DeserializerState, T::Type) - subtype, params = load_node(s, :params) do obj - load_type_params(s) +function load_type_params(s::DeserializerState, T::Type) + load_node(s, :params) do obj + return load_type_params(s) end - return T, params end function load_typed_object(s::DeserializerState, key::Symbol; override_params::Any = nothing) @@ -400,7 +280,7 @@ function load_typed_object(s::DeserializerState; override_params::Any = nothing) params = override_params end else - s.obj isa String && !isnothing(tryparse(UUID, node)) && return load_ref(s) + s.obj isa String && !isnothing(tryparse(UUID, s.obj)) && return load_ref(s) T, params = load_type_params(s, type_key) end load_node(s, :data) do _