Standardize abstract types and other cleanup

Author: Affie

.gitignore

@@ -7,3 +7,4 @@ docs/build
 Manifest.toml
 dev
 test/sandbox.jl
+lcov.info

src/Common.jl

@@ -3,10 +3,10 @@
 _getmodule(t::T) where {T} = T.name.module
 _getname(t::T) where {T} = T.name.name
 
-function convertPackedType(t::Union{T, Type{T}}) where {T <: AbstractFactorObservation}
+function convertPackedType(t::Union{T, Type{T}}) where {T <: AbstractObservation}
     return getfield(_getmodule(t), Symbol("Packed$(_getname(t))"))
 end
-function convertStructType(::Type{PT}) where {PT <: AbstractPackedFactorObservation}
+function convertStructType(::Type{PT}) where {PT <: AbstractPackedObservation}
     # see #668 for expanded reasoning.  PT may be ::UnionAll if the type is of template type.
     ptt = PT isa DataType ? PT.name.name : PT
     moduleName = PT isa DataType ? PT.name.module : Main
@@ -64,7 +64,7 @@ Related
 
 ls, lsf
 """
-function sortDFG(vars::Vector{<:DFGNode}; by = getTimestamp, kwargs...)
+function sortDFG(vars::Vector{<:AbstractGraphNode}; by = getTimestamp, kwargs...)
     return sort(vars; by = by, kwargs...)
 end
 sortDFG(vars::Vector{Symbol}; lt = natural_lt, kwargs...) = sort(vars; lt = lt, kwargs...)

src/DataBlobs/services/BlobEntry.jl

@@ -65,7 +65,7 @@ Get data entry
 
 Also see: [`addBlobentry!`](@ref), [`getBlob`](@ref), [`listBlobentries`](@ref)
 """
-function getBlobentry(var::AbstractDFGVariable, key::Symbol)
+function getBlobentry(var::AbstractGraphVariable, key::Symbol)
     if !hasBlobentry(var, key)
         throw(LabelNotFoundError("Blobentry", key, collect(keys(var.dataDict))))
     end
@@ -85,7 +85,7 @@ Finds and returns the first blob entry that matches the filter.
 
 Also see: [`getBlobentry`](@ref)
 """
-function getfirstBlobentry(var::AbstractDFGVariable, blobId::UUID)
+function getfirstBlobentry(var::AbstractGraphVariable, blobId::UUID)
     for (k, v) in var.dataDict
         if blobId == v.blobId
             return v
@@ -98,7 +98,7 @@ function getfirstBlobentry(dfg::AbstractDFG, label::Symbol, blobId::UUID)
     return getfirstBlobentry(getVariable(dfg, label), blobId)
 end
 
-function getfirstBlobentry(var::AbstractDFGVariable, key::Regex)
+function getfirstBlobentry(var::AbstractGraphVariable, key::Regex)
     for (k, v) in var.dataDict
         if occursin(key, string(v.label))
             return v
@@ -152,7 +152,7 @@ Should be extended if DFG variable is not returned by reference.
 
 Also see: [`getBlobentry`](@ref), [`addBlob!`](@ref), [`mergeBlobentries!`](@ref)
 """
-function addBlobentry!(var::AbstractDFGVariable, entry::Blobentry)
+function addBlobentry!(var::AbstractGraphVariable, entry::Blobentry)
     # see https://github.com/JuliaRobotics/DistributedFactorGraphs.jl/issues/985
     # blobId::Union{UUID,Nothing} = (isnothing(entry.blobId) ? entry.id : entry.blobId),
     # blobSize::Int = (hasfield(Blobentry, :size) ? entry.size : -1)
@@ -182,7 +182,7 @@ Update a Blobentry in the factor graph.
 If the Blobentry does not exist, it will be added.
 Notes:
 """
-function mergeBlobentry!(var::AbstractDFGVariable, bde::Blobentry)
+function mergeBlobentry!(var::AbstractGraphVariable, bde::Blobentry)
     if !haskey(var.dataDict, bde.label)
         addBlobentry!(var, bde)
     else
@@ -203,7 +203,7 @@ Note this doesn't remove it from any data stores.
 Notes:
 - users responsibility to delete data in db before deleting entry
 """
-function deleteBlobentry!(var::AbstractDFGVariable, key::Symbol)
+function deleteBlobentry!(var::AbstractGraphVariable, key::Symbol)
     pop!(var.dataDict, key)
     return 1
 end
@@ -226,7 +226,7 @@ function deleteBlobentry!(dfg::AbstractDFG, label::Symbol, key::Symbol)
     return deleteBlobentry!(getVariable(dfg, label), key)
 end
 
-function deleteBlobentry!(var::AbstractDFGVariable, entry::Blobentry)
+function deleteBlobentry!(var::AbstractGraphVariable, entry::Blobentry)
     #users responsibility to delete data in db before deleting entry
     return deleteBlobentry!(var, entry.label)
 end
@@ -240,7 +240,8 @@ end
 
 Does a blob entry exist with `blobLabel`.
 """
-hasBlobentry(var::AbstractDFGVariable, blobLabel::Symbol) = haskey(var.dataDict, blobLabel)
+hasBlobentry(var::AbstractGraphVariable, blobLabel::Symbol) =
+    haskey(var.dataDict, blobLabel)
 
 function hasBlobentry(var::VariableDFG, label::Symbol)
     return label in getproperty.(var.blobEntries, :label)
@@ -251,7 +252,7 @@ end
 
 Get blob entries, Vector{Blobentry}
 """
-function getBlobentries(var::AbstractDFGVariable)
+function getBlobentries(var::AbstractGraphVariable)
     #or should we return the iterator, Base.ValueIterator{Dict{Symbol,Blobentry}}?
     return collect(values(var.dataDict))
 end
@@ -311,7 +312,7 @@ end
     $(SIGNATURES)
 List the blob entries associated with a particular variable.
 """
-function listBlobentries(var::AbstractDFGVariable)
+function listBlobentries(var::AbstractGraphVariable)
     return collect(keys(var.dataDict))
 end
 

src/DataBlobs/services/BlobStores.jl

@@ -7,6 +7,8 @@ Get the data blob for the specified blobstore or dfg.
 
 Related
 [`getBlobentry`](@ref)
+Implement 
+`getBlob(store::AbstractBlobstore, blobId::UUID)`
 
 $(METHODLIST)
 """
@@ -17,67 +19,31 @@ Adds a blob to the blob store or dfg with the blobId.
 
 Related
 [`addBlobentry!`](@ref)
-
+Implement
+`addBlob!(store::AbstractBlobstore, blobId::UUID, data)`
 $(METHODLIST)
 """
 function addBlob! end
 
-"""
-Update a blob to the blob store or dfg with the given entry.
-Related
-[`mergeBlobentry!`](@ref)
-
-$(METHODLIST)
-
-DevNotes
-- TODO TBD update verb on data since data blobs and entries are restricted to immutable only.
-"""
-function updateBlob! end
-
 """
 Delete a blob from the blob store or dfg with the given entry.
 
 Related
 [`deleteBlobentry!`](@ref)
-
+Implement
+`deleteBlob!(store::AbstractBlobstore, blobId::UUID)`
 $(METHODLIST)
 """
 function deleteBlob! end
 
 """
     $(SIGNATURES)
-List all ids in the blob store.
+List all `blobId`s in the blob store.
+Implement
+`listBlobs(store::AbstractBlobstore)`
 """
 function listBlobs end
 
-##==============================================================================
-## AbstractBlobstore CRUD Interface
-##==============================================================================
-
-function getBlob(store::AbstractBlobstore, ::UUID)
-    return error("$(typeof(store)) doesn't override 'getBlob'.")
-end
-
-function addBlob!(store::AbstractBlobstore{T}, ::UUID, ::T) where {T}
-    return error("$(typeof(store)) doesn't override 'addBlob!'.")
-end
-
-function updateBlob!(store::AbstractBlobstore{T}, ::UUID, ::T) where {T}
-    return error("$(typeof(store)) doesn't override 'updateBlob!'.")
-end
-
-function deleteBlob!(store::AbstractBlobstore, ::UUID)
-    return error("$(typeof(store)) doesn't override 'deleteBlob!'.")
-end
-
-function listBlobs(store::AbstractBlobstore)
-    return error("$(typeof(store)) doesn't override 'listBlobs'.")
-end
-
-function hasBlob(store::AbstractBlobstore, ::UUID)
-    return error("$(typeof(store)) doesn't override 'hasBlob'.")
-end
-
 ##==============================================================================
 ## AbstractBlobstore derived CRUD for Blob 
 ##==============================================================================

src/Deprecated.jl

@@ -9,14 +9,18 @@ export AbstractRelativeMinimize,
     InferenceType,
     PackedSamplableBelief
 
+#TODO: maybe just remove these
+export NoSolverParams
+
 const AbstractPrior = PriorObservation
 const AbstractRelative = RelativeObservation
+const AbstractParams = AbstractDFGParams
 
 abstract type AbstractRelativeMinimize <: RelativeObservation end
 abstract type AbstractManifoldMinimize <: RelativeObservation end
 
 const InferenceVariable = VariableStateType{Any}
-const InferenceType = AbstractPackedFactorObservation
+const InferenceType = AbstractPackedObservation
 
 const PackedSamplableBelief = PackedBelief
 
@@ -149,14 +153,36 @@ function cloneSolveKey!(dfg::AbstractDFG, dest::Symbol, src::Symbol; kw...)
     return cloneSolveKey!(dfg, dest, dfg, src; kw...)
 end
 
+export getData, addData!, updateData!, deleteData!
+
+#TODO not a good function, as it's not complete.
+# """
+#     $(SIGNATURES)
+# Convenience function to get all the metadata of a DFG
+# """
+# export getDFGInfo
+function getDFGInfo(dfg::AbstractDFG)
+    return (
+        description = getDescription(dfg),
+        agentLabel = getAgentLabel(dfg),
+        graphLabel = getGraphLabel(dfg),
+        agentMetadata = getAgentMetadata(dfg),
+        graphMetadata = getGraphMetadata(dfg),
+        solverParams = getSolverParams(dfg),
+    )
+end
+
+export DFGVariable
+const DFGVariable = VariableCompute
+
 ## ================================================================================
 ## Deprecated in v0.27
 ##=================================================================================
 export AbstractFactor
-const AbstractFactor = AbstractFactorObservation
+const AbstractFactor = AbstractObservation
 
 export AbstractPackedFactor
-const AbstractPackedFactor = AbstractPackedFactorObservation
+const AbstractPackedFactor = AbstractPackedObservation
 
 export FactorOperationalMemory
 const FactorOperationalMemory = FactorSolverCache
@@ -214,8 +240,8 @@ const VariableNodeData = VariableState
 @deprecate hasBlobEntry(args...; kwargs...) hasBlobentry(args...; kwargs...)
 @deprecate getBlobEntry(args...; kwargs...) getBlobentry(args...; kwargs...)
 @deprecate getBlobEntryFirst(args...; kwargs...) getfirstBlobentry(args...; kwargs...)
-@deprecate getBlobentry(var::AbstractDFGVariable, blobId::UUID) getfirstBlobentry(
-    var::AbstractDFGVariable,
+@deprecate getBlobentry(var::AbstractGraphVariable, blobId::UUID) getfirstBlobentry(
+    var::AbstractGraphVariable,
     blobId::UUID,
 )
 @deprecate addBlobEntry!(args...; kwargs...) addBlobentry!(args...; kwargs...)
@@ -385,11 +411,7 @@ end
 
 ## factor refactor deprecations
 Base.@kwdef mutable struct GenericFunctionNodeData{
-    T <: Union{
-        <:AbstractPackedFactorObservation,
-        <:AbstractFactorObservation,
-        <:FactorSolverCache,
-    },
+    T <: Union{<:AbstractPackedObservation, <:AbstractObservation, <:FactorSolverCache},
 }
     eliminated::Bool = false
     potentialused::Bool = false
@@ -481,7 +503,7 @@ function decodePackedType(
 end
 
 export _packSolverData
-function _packSolverData(f::FactorCompute, fnctype::AbstractFactorObservation)
+function _packSolverData(f::FactorCompute, fnctype::AbstractObservation)
     #
     error("_packSolverData is deprecated, use seperate packing of observation #TODO")
     packtype = convertPackedType(fnctype)
@@ -501,20 +523,20 @@ end
 export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
 
 const PackedFunctionNodeData{T} =
-    GenericFunctionNodeData{T} where {T <: AbstractPackedFactorObservation}
+    GenericFunctionNodeData{T} where {T <: AbstractPackedObservation}
 function PackedFunctionNodeData(args...; kw...)
     error("PackedFunctionNodeData is obsolete")
     return PackedFunctionNodeData{typeof(args[4])}(args...; kw...)
 end
 
 const FunctionNodeData{T} = GenericFunctionNodeData{
     T,
-} where {T <: Union{<:AbstractFactorObservation, <:FactorSolverCache}}
+} where {T <: Union{<:AbstractObservation, <:FactorSolverCache}}
 FunctionNodeData(args...; kw...) = FunctionNodeData{typeof(args[4])}(args...; kw...)
 
 # this is the GenericFunctionNodeData for packed types
 #TODO deprecate FactorData in favor of FactorState (with no more distinction between packed and compute)
-const FactorData = PackedFunctionNodeData{AbstractPackedFactorObservation}
+const FactorData = PackedFunctionNodeData{AbstractPackedObservation}
 
 function FactorCompute(
     label::Symbol,