Renamed Varaible and abstracts - TODO test

Author: Affie

src/BigData/BigData.jl

@@ -1,16 +1,18 @@
 include("entities/AbstractDataStore.jl")
+#TODO Rename to AbstractDataEntries
 include("entities/AbstractBigDataEntries.jl")
 include("entities/InMemoryDataStore.jl")
 include("entities/FileDataStore.jl")
 
 include("services/AbstractDataStore.jl")
+#TODO Rename to AbstractDataEntries
 include("services/AbstractBigDataEntries.jl")
 include("services/InMemoryDataStore.jl")
 include("services/FileDataStore.jl")
 
 export AbstractDataStore
 
-export AbstractBigDataEntry, GeneralDataEntry, MongodbDataEntry, FileDataEntry
+export AbstractDataEntry, GeneralDataEntry, MongodbDataEntry, FileDataEntry
 export InMemoryDataStore, FileDataStore
 
 export getData, addData!, updateData!, deleteData!, listStoreEntries

src/BigData/entities/AbstractBigDataEntries.jl

@@ -1,9 +1,9 @@
 """
     $(TYPEDEF)
-GeneralBigDataEntry is a generic multipurpose data entry that creates a unique
+GeneralDataEntry is a generic multipurpose data entry that creates a unique
 reproducible key using userId_robotId_sessionId_variableId_key.
 """
-mutable struct GeneralDataEntry <: AbstractBigDataEntry
+mutable struct GeneralDataEntry <: AbstractDataEntry
     key::Symbol
     storeKey::Symbol # Could swap this to string, but using it as an index later, so better as a symbol I believe.
     createdTimestamp::DateTime
@@ -31,29 +31,24 @@ function GeneralDataEntry(dfg::G, var::V, key::Symbol;
     return GeneralDataEntry(key, _uniqueKey(dfg, var, key), mimeType=mimeType)
 end
 
-@deprecate GeneralBigDataEntry(args...; kwargs...) GeneralDataEntry(args...; kwargs...)
-
 """
     $(TYPEDEF)
-BigDataEntry in MongoDB.
+Data Entry in MongoDB.
 """
-struct MongodbDataEntry <: AbstractBigDataEntry
+struct MongodbDataEntry <: AbstractDataEntry
     key::Symbol
     oid::NTuple{12, UInt8} #mongodb object id
     #maybe other fields such as:
     #flags::Bool ready, valid, locked, permissions
     #MIMEType::String
 end
 
-@deprecate MongodbBigDataEntry(args...)  MongodbDataEntry(args...)
 
 """
     $(TYPEDEF)
-BigDataEntry in a file.
+Data Entry in a file.
 """
-struct FileDataEntry <: AbstractBigDataEntry
+struct FileDataEntry <: AbstractDataEntry
     key::Symbol
     filename::String
 end
-
-@deprecate FileBigDataEntry(args...)  FileDataEntry(args...)

src/BigData/entities/InMemoryDataStore.jl

@@ -2,7 +2,7 @@
     $(TYPEDEF)
 Simple in-memory data store with a specified data type and a specified key type.
 """
-struct InMemoryDataStore{T, E <: AbstractBigDataEntry} <: AbstractDataStore{T}
+struct InMemoryDataStore{T, E <: AbstractDataEntry} <: AbstractDataStore{T}
     data::Dict{Symbol, T}
     entries::Dict{Symbol, E}
 end
@@ -11,7 +11,7 @@ end
     $(SIGNATURES)
 Create an in-memory store using a specific data type.
 """
-function InMemoryDataStore{T, E}() where {T, E <: AbstractBigDataEntry}
+function InMemoryDataStore{T, E}() where {T, E <: AbstractDataEntry}
     return InMemoryDataStore{T, E}(Dict{Symbol, T}(), Dict{Symbol, E}())
 end
 

src/BigData/services/AbstractBigDataEntries.jl

@@ -20,9 +20,9 @@ end
     $(SIGNATURES)
 Add Big Data Entry to a DFG variable
 """
-function addDataEntry!(var::AbstractDFGVariable, bde::AbstractBigDataEntry)
-    haskey(var.bigData,bde.key) && error("BigData entry $(bde.key) already exists in variable")
-    var.bigData[bde.key] = bde
+function addDataEntry!(var::AbstractDFGVariable, bde::AbstractDataEntry)
+    haskey(var.dataDict, bde.key) && error("Data entry $(bde.key) already exists in variable")
+    var.dataDict[bde.key] = bde
     return bde
 end
 
@@ -32,11 +32,10 @@ end
 Add Big Data Entry to distributed factor graph.
 Should be extended if DFG variable is not returned by reference.
 """
-function addDataEntry!(dfg::AbstractDFG, label::Symbol, bde::AbstractBigDataEntry)
-    return addBigDataEntry!(getVariable(dfg, label), bde)
+function addDataEntry!(dfg::AbstractDFG, label::Symbol, bde::AbstractDataEntry)
+    return addDataEntry!(getVariable(dfg, label), bde)
 end
 
-@deprecate addBigDataEntry!(args...)  addDataEntry!(args...)
 
 """
 $(SIGNATURES)
@@ -73,24 +72,21 @@ end
 
 Does a data entry (element) exist at `key`.
 """
-hasDataEntry(var::DFGVariable, key::Symbol) = haskey(var.bigData, key)
-const hasBigDataEntry = hasDataEntry
+hasDataEntry(var::DFGVariable, key::Symbol) = haskey(var.dataDict, key)
 
 """
     $(SIGNATURES)
 Get big data entry
 """
 function getDataEntry(var::AbstractDFGVariable, key::Symbol)
-    !hasDataEntry(var, key) && (error("BigData entry $(key) does not exist in variable"); return nothing)
-    return var.bigData[key]
+    !hasDataEntry(var, key) && (error("Data entry $(key) does not exist in variable"); return nothing)
+    return var.dataDict[key]
 end
 
 function getDataEntry(dfg::AbstractDFG, label::Symbol, key::Symbol)
-    return getBigDataEntry(getVariable(dfg, label), key)
+    return getDataEntry(getVariable(dfg, label), key)
 end
 
-@deprecate getBigDataEntry(args...) getDataEntry(args...)
-
 """
 $SIGNATURES
 Get both the entry and raw data element from datastore returning as a tuple.
@@ -147,7 +143,6 @@ const fetchDataEntryElement = getDataEntryBlob
 const fetchData = getDataEntryBlob
 
 #
-@deprecate getDataEntryElement(args...) getDataEntryBlob(args...)
 
 """
     $(SIGNATURES)
@@ -156,18 +151,16 @@ Update big data entry
 DevNote
 - DF, unclear if `update` verb is applicable in this case, see #404
 """
-function updateDataEntry!(var::AbstractDFGVariable,  bde::AbstractBigDataEntry)
-    !haskey(var.bigData,bde.key) && (@warn "$(bde.key) does not exist in variable, adding")
-    var.bigData[bde.key] = bde
+function updateDataEntry!(var::AbstractDFGVariable,  bde::AbstractDataEntry)
+    !haskey(var.dataDict, bde.key) && (@warn "$(bde.key) does not exist in variable, adding")
+    var.dataDict[bde.key] = bde
     return bde
 end
-function updateDataEntry!(dfg::AbstractDFG, label::Symbol,  bde::AbstractBigDataEntry)
+function updateDataEntry!(dfg::AbstractDFG, label::Symbol,  bde::AbstractDataEntry)
     # !isVariable(dfg, label) && return nothing
     return updateDataEntry!(getVariable(dfg, label), bde)
 end
 
-@deprecate updateBigDataEntry!(args...) updateDataEntry!(args...)
-
 """
     $(SIGNATURES)
 Delete big data entry from the factor graph.
@@ -179,7 +172,7 @@ Notes:
 function deleteDataEntry!(var::AbstractDFGVariable, key::Symbol)
     bde = getDataEntry(var, key)
     bde == nothing && return nothing
-    delete!(var.bigData, key)
+    delete!(var.dataDict, key)
     return var
 end
 function deleteDataEntry!(dfg::AbstractDFG, label::Symbol, key::Symbol)
@@ -188,40 +181,35 @@ function deleteDataEntry!(dfg::AbstractDFG, label::Symbol, key::Symbol)
     return deleteDataEntry!(getVariable(dfg, label), key)
 end
 
-function deleteDataEntry!(var::AbstractDFGVariable, entry::AbstractBigDataEntry)
+function deleteDataEntry!(var::AbstractDFGVariable, entry::AbstractDataEntry)
     #users responsibility to delete big data in db before deleting entry
     return deleteDataEntry!(var, entry.key)
 end
 
-@deprecate deleteBigDataEntry!(args...) deleteDataEntry!(args...)
-
 """
     $(SIGNATURES)
-Get big data entries, Vector{AbstractBigDataEntry}
+Get big data entries, Vector{AbstractDataEntry}
 """
 function getDataEntries(var::AbstractDFGVariable)
-    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
-    collect(values(var.bigData))
+    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractDataEntry}}?
+    collect(values(var.dataDict))
 end
 function getDataEntries(dfg::AbstractDFG, label::Symbol)
     !isVariable(dfg, label) && return nothing
-    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
+    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractDataEntry}}?
     getDataEntries(getVariable(dfg, label))
 end
 
-@deprecate getBigDataEntries(args...) getDataEntries(args...)
-
 
 """
     $(SIGNATURES)
 listDataEntries
 """
 function listDataEntries(var::AbstractDFGVariable)
-    collect(keys(var.bigData))
+    collect(keys(var.dataDict))
 end
+
 function listDataEntries(dfg::AbstractDFG, label::Symbol)
     !isVariable(dfg, label) && return nothing
     listDataEntries(getVariable(dfg, label))
 end
-
-@deprecate getBigDataKeys(args...) listDataEntries(args...)

src/BigData/services/AbstractDataStore.jl

@@ -2,7 +2,7 @@
     $(SIGNATURES)
 Get the data for the specified entry, returns the data or Nothing.
 """
-function getDataBlob(store::D, entry::E)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractBigDataEntry}
+function getDataBlob(store::D, entry::E)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractDataEntry}
     error("$(typeof(store)) doesn't override 'getDataBlob'.")
 end
 
@@ -11,7 +11,7 @@ end
 Adds the data to the store with the given entry. The function will warn if the entry already
 exists and will overwrite it.
 """
-function addDataBlob!(store::D, entry::E, data::T)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractBigDataEntry}
+function addDataBlob!(store::D, entry::E, data::T)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractDataEntry}
     error("$(typeof(store)) doesn't override 'addDataBlob!'.")
 end
 
@@ -20,7 +20,7 @@ end
 Update the data in the store. The function will error and return nothing if
 the entry does not exist.
 """
-function updateDataBlob!(store::D, entry::E, data::T)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractBigDataEntry}
+function updateDataBlob!(store::D, entry::E, data::T)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractDataEntry}
     error("$(typeof(store)) doesn't override 'updateDataBlob!'.")
 end
 
@@ -29,7 +29,7 @@ end
 Delete the data in the store for the given entry. The function will error and return nothing if
 the entry does not exist.
 """
-function deleteDataBlob!(store::D, entry::E)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractBigDataEntry}
+function deleteDataBlob!(store::D, entry::E)::Union{Nothing, T} where {T, D <: AbstractDataStore{T}, E <: AbstractDataEntry}
     error("$(typeof(store)) doesn't override 'deleteDataBlob!'.")
 end
 
@@ -47,7 +47,7 @@ Copies all the entries from the source into the destination.
 Can specify which entries to copy with the `sourceEntries` parameter.
 Returns the list of copied entries.
 """
-function copyStore(sourceStore::D1, destStore::D2; sourceEntries=listEntries(sourceStore))::Vector{E} where {T, D1 <: AbstractDataStore{T}, D2 <: AbstractDataStore{T}, E <: AbstractBigDataEntry}
+function copyStore(sourceStore::D1, destStore::D2; sourceEntries=listEntries(sourceStore))::Vector{E} where {T, D1 <: AbstractDataStore{T}, D2 <: AbstractDataStore{T}, E <: AbstractDataEntry}
     # Quick check
     destEntries = listDataBlobs(destStore)
     typeof(sourceEntries) != typeof(destEntries) && error("Can't copy stores, source has entries of type $(typeof(sourceEntries)), destination has entries of type $(typeof(destEntries)).")

src/BigData/services/FileDataStore.jl

@@ -2,15 +2,15 @@
 ## FileDataStore Common
 ##==============================================================================
 searchdir(path,key) = filter(x->occursin(key,x), readdir(path))
-filename(store::FileDataStore, entry::E) where E <: AbstractBigDataEntry = "$(store.folder)/$(entry.storeKey).dat"
+filename(store::FileDataStore, entry::E) where E <: AbstractDataEntry = "$(store.folder)/$(entry.storeKey).dat"
 
-function readentry(store::FileDataStore, entry::AbstractBigDataEntry)
+function readentry(store::FileDataStore, entry::AbstractDataEntry)
     open(filename(store, entry)) do f
         return read(f)
     end
 end
 
-function writeentry(store::FileDataStore, entry::AbstractBigDataEntry, data::Vector{UInt8})
+function writeentry(store::FileDataStore, entry::AbstractDataEntry, data::Vector{UInt8})
     open(filename(store, entry), "w") do f
         write(f, data)
     end
@@ -20,20 +20,20 @@ end
 ## FileDataStore CRUD
 ##==============================================================================
 
-function getDataBlob(store::FileDataStore, entry::AbstractBigDataEntry)::Union{Vector{UInt8}, Nothing}
+function getDataBlob(store::FileDataStore, entry::AbstractDataEntry)::Union{Vector{UInt8}, Nothing}
     length(searchdir(store.folder, String(entry.storeKey)*".dat")) !=1 && (@warn "Could not find unique file for key '$(entry.storeKey)'."; return nothing)
     return readentry(store, entry)
 end
 
-function addDataBlob!(store::FileDataStore, entry::AbstractBigDataEntry, data::Vector{UInt8})::Vector{UInt8}
+function addDataBlob!(store::FileDataStore, entry::AbstractDataEntry, data::Vector{UInt8})::Vector{UInt8}
     length(searchdir(store.folder, String(entry.storeKey)*".dat")) !=0 && error("Key '$(entry.storeKey)' already exists.")
     writeentry(store, entry, data)
     # Update timestamp
     entry.lastUpdatedTimestamp = now()
     return getDataBlob(store, entry)
 end
 
-function updateDataBlob!(store::FileDataStore, entry::AbstractBigDataEntry, data::Vector{UInt8})::Union{Vector{UInt8}, Nothing}
+function updateDataBlob!(store::FileDataStore, entry::AbstractDataEntry, data::Vector{UInt8})::Union{Vector{UInt8}, Nothing}
     n_entries = length(searchdir(store.folder, String(entry.storeKey)*".dat"))
     if  n_entries > 1
         error("Could not find unique file for key '$(entry.storeKey)'.")
@@ -49,7 +49,7 @@ function updateDataBlob!(store::FileDataStore, entry::AbstractBigDataEntry, data
     end
 end
 
-function deleteDataBlob!(store::FileDataStore, entry::AbstractBigDataEntry)::Vector{UInt8}
+function deleteDataBlob!(store::FileDataStore, entry::AbstractDataEntry)::Vector{UInt8}
     data = getDataBlob(store, entry)
     data == nothing && return nothing
     rm(filename(store, entry))
@@ -58,6 +58,6 @@ end
 
 # TODO: Manifest file
 #
-# function listDataBlobs(store::FileDataStore)::Vector{E} where {E <: AbstractBigDataEntry}
+# function listDataBlobs(store::FileDataStore)::Vector{E} where {E <: AbstractDataEntry}
 #     return collect(values(store.entries))
 # end

src/BigData/services/InMemoryDataStore.jl

@@ -1,35 +1,35 @@
 ##==============================================================================
 ## InMemoryDataStore CRUD
 ##==============================================================================
-function getDataBlob(store::InMemoryDataStore{T, E}, entry::E)::Union{T, Nothing} where {T, E <: AbstractBigDataEntry}
+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 <: AbstractBigDataEntry}
+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 <: AbstractBigDataEntry}
+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 <: AbstractBigDataEntry}
+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 <: AbstractBigDataEntry}
+function listDataBlobs(store::InMemoryDataStore{T, E})::Vector{E} where {T, E <: AbstractDataEntry}
     return collect(values(store.entries))
 end

src/CloudGraphsDFG/CloudGraphsDFG.jl

@@ -39,7 +39,7 @@ import ...DistributedFactorGraphs:  setSolverParams!,
                                     _getDuplicatedEmptyDFG,
                                     toDot,
                                     toDotFile,
-                                    AbstractBigDataEntry,
+                                    AbstractDataEntry,
                                     isValidLabel,
                                     _invalidIds,#TODO Export from DFG
                                     _validLabelRegex, #TODO Export from DFG