Changing get_index and creating PriorityValue structure

src/WildcardArrays.jl

@@ -1,33 +1,14 @@
 module WildcardArrays
 
-using OrderedCollections
 import Base: show, size, ndims, eltype
 
-struct WildcardArray{T,N} <: AbstractArray{T,N}
-    data::OrderedDict{NTuple{N,Int},T} # this would be the ordered map
-    dims::NTuple{N,Int}
-    default::T
-end
-
-WildcardArray(s::String, values::Vector{T}; default=0.0, startindex=0) where T = parse(s, values, default=default, startindex=startindex)
-
-Base.size(wa::WildcardArray) = wa.dims
-Base.ndims(wa::WildcardArray) = length(wa.dims)
-function Base.show(io::IO, m::MIME"text/plain", wa::WildcardArray{T,N}) where {T,N}
-    println("WildcardArray{$T,$N}")
-    [println("$(kk) => $(vv)") for (kk,vv) in zip(keys(wa.data), values(wa.data))]
-end 
-Base.show(wa::WildcardArray) = Base.show(stdout, MIME("text/plain"), wa) 
-Base.eltype(::WildcardArray{T,N}) where {T,N} = T
-
-dict(wa::WildcardArray) = wa.data
-
-include("./getindex.jl")
+include("./types.jl") # WildcardArray and PriorityValue
+include("./getindex.jl") # implementing get_index for WildcardArray
 
 export 
-    WildcardArray,
-    dict
-include("./parse.jl")
+    WildcardArray
+
+include("./parse.jl") 
 
 end
 

src/getindex.jl

@@ -1,27 +1,29 @@
 function Base.getindex(wa::WildcardArray{T,N}, i::Vararg{Int,N})::T where {T,N}
-    keys_obj = dict(wa) |> keys |> collect
-    # println(keys_obj)
-    # println(eltype(wa))
+    dict_wildcard = dict(wa) 
 
     if any(x -> x <= 0, i) || any(i[index] > size(wa)[index] for index in 1:N)
         error("Indices must be integers larger than zero and less than or equal to the entries of the vector $(size(wa))")
     end
 
-    index = 0
+    priority = 0
+    index = Vector{Int}(undef, N)
 
     for kk in Iterators.product([[0, index] for index in i]...)
-        temp_index = findfirst(x -> isequal(x, kk), keys_obj)
+        if haskey(dict_wildcard, kk)
+            tmp_priority = dict_wildcard[kk].priority
+        else
+            tmp_priority = -Inf
+        end
 
-        if !isnothing(temp_index)
-            if temp_index > index
-                index = temp_index
-            end
+        if tmp_priority > priority 
+            index = kk 
+            priority = tmp_priority
         end
     end
 
-    if index == 0
+    if priority == 0
         return wa.default
     end
 
-    return dict(wa)[keys_obj[index]]    # put implementation here
+    return dict_wildcard[index].value    # put implementation here
 end

src/parse.jl

@@ -14,18 +14,18 @@ function parse(s::String, values::Vector{Vector{String}}; default=0.0, startinde
     regex, collection_regex, num_colons, dic_colons = _create_regex(name_of_transition, s) 
 
     index=Vector{NTuple{N,Int}}()
-    vv=Vector{T}()
+    vv=Vector{PriorityValue{T}}()
 
-    for (m, col) in zip(eachmatch(regex, s), num_colons)
+    for (ii, (m, col)) in enumerate(zip(eachmatch(regex, s), num_colons))
         tmp_str = "$(name_of_transition)" * m.match * "\n$(name_of_transition):"
         fields = match(collection_regex[dic_colons[col]], tmp_str).captures # choosing the right regex. dic_colons[col] contains the index of the correct regex 
+
         deleteat!(fields, 1) # remove the first element which is the name_of_transition 
         fields = map(x->strip(x, ['\n', '\r', ' ']), fields)
-
         param = fields[end]
         if col == N
             push!(index, Tuple(dd[kk] for (dd,kk) in zip(dictionaries, fields[1:end-1])))
-            push!(vv, Base.parse(T, param))
+            push!(vv, PriorityValue(ii, Base.parse(T, param)))
 
         elseif col == N-1
             param = string.(split(param))
@@ -35,11 +35,11 @@ function parse(s::String, values::Vector{Vector{String}}; default=0.0, startinde
                 param = [string(1/length(values[end])) for _ in values[end]]
             end
 
-            for (ii,val) in enumerate(param)
+            for (jj,val) in enumerate(param)
                 tt = deepcopy(tmp_fields)
 
-                push!(index, Tuple(push!(tt, ii)))
-                push!(vv, Base.parse(T,val))
+                push!(index, Tuple(push!(tt, jj)))
+                push!(vv, PriorityValue(ii, Base.parse(T, val)))
             end
 
         elseif col == N-2
@@ -57,18 +57,19 @@ function parse(s::String, values::Vector{Vector{String}}; default=0.0, startinde
             for (jj,line) in enumerate(param)
                 tt_1 = deepcopy(tmp_fields)
                 push!(tt_1, jj)
-                for (ii,entry) in enumerate(string.(split(line)))
+                for (ℓ,val) in enumerate(string.(split(line)))
                         tt_2 = deepcopy(tt_1)
-                        push!(index, Tuple(push!(tt_2, ii)))
-                        push!(vv, Base.parse(T,entry))
+
+                        push!(index, Tuple(push!(tt_2, ℓ)))
+                        push!(vv, PriorityValue(ii, Base.parse(T, val)))
                 end 
             end
         else
             error("Unable to parse this string")
         end
     end
 
-    data = OrderedDict(tuple => fvalue for (tuple, fvalue) in zip(index,vv))
+    data = Dict(tuple => fvalue for (tuple, fvalue) in zip(index,vv))
 
     return WildcardArray(data, Tuple(length(vp) for vp in values), default) 
 end

src/types.jl

@@ -0,0 +1,23 @@
+struct PriorityValue{T}
+    priority::Int
+    value::T
+end
+
+struct WildcardArray{T,N} <: AbstractArray{T,N}
+    data::Dict{NTuple{N,Int},PriorityValue{T}}
+    dims::NTuple{N,Int}
+    default::T
+end
+
+WildcardArray(s::String, values::Vector{T}; default=0.0, startindex=0) where T = parse(s, values, default=default, startindex=startindex)
+
+Base.size(wa::WildcardArray) = wa.dims
+Base.ndims(wa::WildcardArray) = length(wa.dims)
+Base.eltype(::WildcardArray{T,N}) where {T,N} = T
+
+function Base.show(io::IO, m::MIME"text/plain", wa::WildcardArray{T,N}) where {T,N}
+    println("WildcardArray{$T,$N}")
+    [println("$(kk) => $(vv)") for (kk,vv) in zip(keys(wa.data), values(wa.data))]
+end 
+
+dict(wa::WildcardArray) = wa.data