step to rename FactorOperationalMemory

Author: Affie

src/DistributedFactorGraphs.jl

@@ -173,7 +173,7 @@ export addBigDataEntry!, addDataEntry!, getBigDataEntry, updateBigDataEntry!, de
 ##------------------------------------------------------------------------------
 # Factor Data
 export GenericFunctionNodeData
-export InferenceType, PackedInferenceType, FunctorInferenceType, ConvolutionObject
+export InferenceType, PackedInferenceType, FunctorInferenceType, FactorOperationalMemory
 export FunctorSingleton, FunctorPairwise, FunctorPairwiseMinimize
 
 # accessors
@@ -225,7 +225,8 @@ export
 
 
 ## Deprecated exports should be listed in Deprecated.jl if possible, otherwise here
-
+#TODO remove export in DFG v0.8.0
+export ConvolutionObject
 
 ## needsahome.jl
 import Base: print

src/entities/DFGFactor.jl

@@ -7,15 +7,12 @@ abstract type PackedInferenceType end
 
 abstract type FunctorInferenceType <: Function end
 
-# DF suggestion1 (this is a first guess)  `ConvolutionObject` --> `FactorInsituObject`
-# DF second guess,  ConvolutionObject <: FactorInsituObject
-# JT Maybe second guess as intermediate step where ConvolutionObject is moved to IIF.
-# then it can be removed to CommonConvWrapper <: FactorInsituObject
-
-# DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
-# DF, IIF.CommonConvWrapper <: FactorOperationalMemory # FIXME
-# MAYBE rename "FactorOperationalMemory"
-abstract type ConvolutionObject <: Function end
+# NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
+# DF, IIF.CommonConvWrapper <: FactorOperationalMemory #
+abstract type FactorOperationalMemory <: Function end
+# TODO to be removed from DFG,
+# we can add to IIF or have IIF.CommonConvWrapper <: FactorOperationalMemory directly
+abstract type ConvolutionObject <: FactorOperationalMemory end
 
 abstract type FunctorSingleton <: FunctorInferenceType end
 abstract type FunctorPairwise <: FunctorInferenceType end
@@ -37,7 +34,7 @@ Designing (WIP)
 # in IIF.FunctorPairwiseMinimize <: InferenceType # DFG whatever, something, we'll figure it out
 # in Main/User, SomeFactor <: FunctorPairwiseMinimize
 """
-mutable struct GenericFunctionNodeData{T, S} #{T<:Union{PackedInferenceType, FunctorInferenceType, ConvolutionObject}, S<:Union{Symbol, AbstractString}}
+mutable struct GenericFunctionNodeData{T, S} #{T<:Union{PackedInferenceType, FunctorInferenceType, FactorOperationalMemory}, S<:Union{Symbol, AbstractString}}
     fncargvID::Vector{Symbol}
     eliminated::Bool
     potentialused::Bool
@@ -62,7 +59,7 @@ end
 const PackedFunctionNodeData{T} = GenericFunctionNodeData{T, <: AbstractString}
 PackedFunctionNodeData(x1, x2, x3, x4, x5::S, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T <: PackedInferenceType, S <: AbstractString} = GenericFunctionNodeData(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
 const FunctionNodeData{T} = GenericFunctionNodeData{T, Symbol}
-FunctionNodeData(x1, x2, x3, x4, x5::Symbol, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T <: Union{FunctorInferenceType, ConvolutionObject}}= GenericFunctionNodeData{T, Symbol}(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
+FunctionNodeData(x1, x2, x3, x4, x5::Symbol, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T <: Union{FunctorInferenceType, FactorOperationalMemory}}= GenericFunctionNodeData{T, Symbol}(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
 
 ##==============================================================================
 ## Factors
@@ -104,7 +101,7 @@ mutable struct DFGFactor{T, S} <: AbstractDFGFactor
     """Mutable parameters for the variable. We suggest using accessors to get to this data.
     Accessors: [`getSolvable`](@ref), [`setSolvable!`](@ref)"""
     _dfgNodeParams::DFGNodeParams
-    """Internal cache of the ordering of the neighbor variables. Rather use getNeighbors to get the list as this is an internal value.
+    """Internal cache of the ordering of the neighbor variables. Rather use getVariableOrder to get the list as this is an internal value.
     Accessors: [`getVariableOrder`](@ref)"""
     _variableOrderSymbols::Vector{Symbol}
 end

src/services/CompareUtils.jl

@@ -12,7 +12,7 @@ implement compare if needed.
 =#
 ==(a::InferenceVariable,b::InferenceVariable) = typeof(a) == typeof(b) && a.dims == b.dims && a.manifolds == b.manifolds
 
-==(a::ConvolutionObject, b::ConvolutionObject) = typeof(a) == typeof(b)
+==(a::FactorOperationalMemory, b::FactorOperationalMemory) = typeof(a) == typeof(b)
 
 ==(a::FunctorInferenceType, b::FunctorInferenceType) = typeof(a) == typeof(b)
 

test/testBlocks.jl

@@ -56,7 +56,7 @@ function Base.convert(::Type{TestFunctorSingleton}, d::PackedTestFunctorSingleto
     TestFunctorSingleton()
 end
 
-struct TestCCW{T} <: ConvolutionObject where {T<:FunctorInferenceType}
+struct TestCCW{T} <: FactorOperationalMemory where {T<:FunctorInferenceType}
     usrfnc!::T
 end
 Base.:(==)(a::TestCCW, b::TestCCW) = a.usrfnc! == b.usrfnc!
@@ -76,7 +76,7 @@ function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
                                 d.solveInProgress)
 end
 
-function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:ConvolutionObject}) where P <: PackedInferenceType
+function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:FactorOperationalMemory}) where P <: PackedInferenceType
   # mhstr = packmultihypo(d.fnc)  # this is where certainhypo error occurs
   return DFG.PackedFunctionNodeData(d.fncargvID,
                                     d.eliminated,