Fix test with small data tipes

Author: Affie

attic/InMemoryDataStore.jl

@@ -0,0 +1,61 @@
+"""
+    $(TYPEDEF)
+Simple in-memory data store with a specified data type and a specified key type.
+"""
+struct InMemoryDataStore{T, E <: AbstractDataEntry} <: AbstractDataStore{T}
+    data::Dict{Symbol, T}
+    entries::Dict{Symbol, E}
+end
+
+"""
+    $(SIGNATURES)
+Create an in-memory store using a specific data type.
+"""
+function InMemoryDataStore{T, E}() where {T, E <: AbstractDataEntry}
+    return InMemoryDataStore{T, E}(Dict{Symbol, T}(), Dict{Symbol, E}())
+end
+
+"""
+    $(SIGNATURES)
+Create an in-memory store using binary data (UInt8) as a type.
+"""
+function InMemoryDataStore()
+    return InMemoryDataStore{Vector{UInt8}, GeneralDataEntry}()
+end
+
+
+##==============================================================================
+## InMemoryDataStore CRUD
+##==============================================================================
+function getDataBlob(store::InMemoryDataStore{T, E}, entry::E)::Union{T, Nothing} where {T, E <: AbstractDataEntry}
+    !haskey(store.data, entry.storeKey) && return nothing
+    return store.data[entry.storeKey]
+end
+
+function addDataBlob!(store::InMemoryDataStore{T, E}, entry::E, data::T)::T where {T, E <: AbstractDataEntry}
+    haskey(store.entries, entry.storeKey) && @warn "Key '$(entry.storeKey)' already exists in the data store, overwriting!"
+    store.entries[entry.storeKey] = entry
+    # Update timestamp
+    entry.lastUpdatedTimestamp = now()
+    return store.data[entry.storeKey] = data
+end
+
+function updateDataBlob!(store::InMemoryDataStore{T, E}, entry::E, data::T)::Union{T, Nothing} where {T, E <: AbstractDataEntry}
+    !haskey(store.entries, entry.storeKey) && (@error "Key '$(entry.storeKey)' doesn't exist in the data store!"; return nothing)
+    store.entries[entry.storeKey] = entry
+    # Update timestamp
+    entry.lastUpdatedTimestamp = now()
+    return store.data[entry.storeKey] = data
+end
+
+function deleteDataBlob!(store::InMemoryDataStore{T, E}, entry::E)::T where {T, E <: AbstractDataEntry}
+    data = getDataBlob(store, entry)
+    data == nothing && return nothing
+    delete!(store.data, entry.storeKey)
+    delete!(store.entries, entry.storeKey)
+    return data
+end
+
+function listDataBlobs(store::InMemoryDataStore{T, E})::Vector{E} where {T, E <: AbstractDataEntry}
+    return collect(values(store.entries))
+end

src/DistributedFactorGraphs.jl

@@ -123,6 +123,8 @@ export getSolverData
 
 export getVariableType
 
+# Small Data CRUD
+export SmallDataTypes, getSmallData, addSmallData!, updateSmallData!, deleteSmallData!, clearSmallData!
 export getSmallData, setSmallData!
 
 

src/entities/DFGVariable.jl

@@ -217,7 +217,7 @@ getEstimateFields(::MeanMaxPPE) = [:suggested, :max, :mean]
 ## DFG Variables
 ##==============================================================================
 
-const SmallDataType = Union{Int, Float64, String, Bool, Vector{Int}, Vector{Float64}, Vector{String}, Vector{Bool}}
+const SmallDataTypes = Union{Int, Float64, String, Bool, Vector{Int}, Vector{Float64}, Vector{String}, Vector{Bool}}
 
 ##------------------------------------------------------------------------------
 ## DFGVariable lv2
@@ -250,7 +250,7 @@ struct DFGVariable{T<:InferenceVariable} <: AbstractDFGVariable
     solverDataDict::Dict{Symbol, VariableNodeData{T}}
     """Dictionary of small data associated with this variable.
     Accessors: [`getSmallData`](@ref), [`setSmallData!`](@ref)"""
-    smallData::Dict{String, SmallDataType}
+    smallData::Dict{Symbol, SmallDataTypes}
     """Dictionary of large data associated with this variable.
     Accessors: [`addDataEntry!`](@ref), [`getDataEntry`](@ref), [`updateDataEntry!`](@ref), and [`deleteDataEntry!`](@ref)"""
     dataDict::Dict{Symbol, AbstractDataEntry}
@@ -272,7 +272,7 @@ function DFGVariable(label::Symbol, softtype::T;
             tags::Set{Symbol}=Set{Symbol}(),
             estimateDict::Dict{Symbol, <: AbstractPointParametricEst}=Dict{Symbol, MeanMaxPPE}(),
             solverDataDict::Dict{Symbol, VariableNodeData{T}}=Dict{Symbol, VariableNodeData{T}}(),
-            smallData::Dict{String, SmallDataType}=Dict{String, SmallDataType}(),
+            smallData::Dict{String, SmallDataTypes}=Dict{String, SmallDataTypes}(),
             dataDict::Dict{Symbol, AbstractDataEntry}=Dict{Symbol,AbstractDataEntry}(),
             solvable::Int=1) where {T <: InferenceVariable}
 
@@ -289,7 +289,7 @@ function DFGVariable(label::Symbol,
             nstime::Nanosecond = Nanosecond(0),
             tags::Set{Symbol}=Set{Symbol}(),
             estimateDict::Dict{Symbol, <: AbstractPointParametricEst}=Dict{Symbol, MeanMaxPPE}(),
-            smallData::Dict{String, SmallDataType}=Dict{String, SmallDataType}(),
+            smallData::Dict{String, SmallDataTypes}=Dict{String, SmallDataTypes}(),
             dataDict::Dict{Symbol, AbstractDataEntry}=Dict{Symbol,AbstractDataEntry}(),
             solvable::Int=1) where {T <: InferenceVariable}
     if timestamp isa DateTime

src/services/DFGVariable.jl

@@ -273,14 +273,14 @@ setSolverData!(v::DFGVariable, data::VariableNodeData, key::Symbol=:default) = v
     $(SIGNATURES)
 Get the small data for a variable.
 """
-getSmallData(v::DFGVariable)::Dict{String, SmallDataType} = v.smallData
+getSmallData(v::DFGVariable)::Dict{Symbol, SmallDataTypes} = v.smallData
 
 """
     $(SIGNATURES)
 Set the small data for a variable.
 This will overwrite old smallData.
 """
-function setSmallData!(v::DFGVariable, smallData::Dict{String, SmallDataType})
+function setSmallData!(v::DFGVariable, smallData::Dict{Symbol, SmallDataTypes})
     empty!(v.smallData)
     merge!(v.smallData, smallData)
 end

src/services/Serialization.jl

@@ -39,7 +39,7 @@ function unpackVariable(dfg::G,
         tags = Symbol.(packedProps["tags"])
     end
     ppeDict = unpackPPEs ? JSON2.read(packedProps["ppeDict"], Dict{Symbol, MeanMaxPPE}) : Dict{Symbol, MeanMaxPPE}()
-    smallData = JSON2.read(packedProps["smallData"], Dict{String, SmallDataType})
+    smallData = JSON2.read(packedProps["smallData"], Dict{Symbol, SmallDataTypes})
 
     softtypeString = packedProps["softtype"]
     softtype = getTypeFromSerializationModule(dfg, Symbol(softtypeString))

test/interfaceTests.jl

@@ -56,7 +56,7 @@ end
     @test printFactor(fac1) == nothing
 
     @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe, :nstime]) == nothing
-    @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict(\"small\"=>\"data\")\ndataDict:\nDict{Symbol,AbstractDataEntry}()\nsolvable:\n0\n"
+    @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict{Symbol,Union{Bool, Float64, Int64, Array{Bool,1}, Array{Float64,1}, Array{Int64,1}, Array{String,1}, String}}(:small=>\"data\")\ndataDict:\nDict{Symbol,AbstractDataEntry}()\nsolvable:\n0\n"
 
     @test printVariable(iobuf, var1, short=true) == nothing
     @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel: a\ntags: Set([:VARIABLE, :POSE])\nsize marginal samples: (1, 1)\nkde bandwidths: [0.0]\nNo PPEs\n"

test/testBlocks.jl

@@ -238,7 +238,7 @@ function DFGVariableSCA()
 
     v1_lbl = :a
     v1_tags = Set([:VARIABLE, :POSE])
-    small = Dict("small"=>"data")
+    small = Dict{Symbol, SmallDataTypes}(:small=>"data")
     testTimestamp = now(localzone())
     # Constructors
     v1 = DFGVariable(v1_lbl, TestSofttype1(), tags=v1_tags, solvable=0, solverDataDict=Dict(:default=>VariableNodeData{TestSofttype1}()))
@@ -262,7 +262,7 @@ function DFGVariableSCA()
 
     @test getPPEDict(v1) == v1.ppeDict
 
-    @test getSmallData(v1) == Dict{String,String}()
+    @test getSmallData(v1) == Dict{Symbol,SmallDataTypes}()
 
     @test getSofttype(v1) == TestSofttype1()