Removed dead code from old broadcasting stuff

Author: jonniedie

src/axis.jl

@@ -156,13 +156,6 @@ reindex(ax::ViewAxis, offset) = ViewAxis(viewindex(ax) .+ offset, indexmap(ax))
 @inline Base.getindex(::AbstractAxis{IdxMap}, s::Symbol) where IdxMap =
     ComponentIndex(getproperty(IdxMap, s))
 
-Base.iterate(ax::AbstractAxis, state=1) = state > lastindex(ax) ? nothing : (ax[state], state+1)
-
-Base.length(ax::AbstractAxis) = lastindex(ax) - firstindex(ax) + 1
-
-Base.UnitRange(ax::AbstractAxis) = firstindex(ax):lastindex(ax)
-Base.UnitRange{T}(ax::AbstractAxis) where {T} = T(firstindex(ax)):T(lastindex(ax))
-
 
 struct CombinedAxis{C,A} <: AbstractUnitRange{Int}
     component_axis::C

src/broadcasting.jl

@@ -18,13 +18,6 @@ Base.promote_shape(a::NTuple{N,AbstractUnitRange}, b::Tuple{Vararg{CombinedAxis}
 Base.promote_shape(a::Tuple{Vararg{CombinedAxis}}, b::Tuple{Vararg{CombinedAxis}}) = Base.promote_shape(_array_axis.(a), _array_axis.(b))
 Base.promote_shape(a::T, b::T) where {T<:Tuple{Vararg{CombinedAxis}}} = a
 
-# Need a special case here because `map` doesn't follow same rules as normal broadcasting. To be safe and avoid ambiguities,
-# we'll just handle the case where everything is a ComponentArray. Else it falls back to a plain Array output.
-function Base.map(f, xs::ComponentArray{<:Any, <:Any, <:Any, Axes}...) where Axes
-    return ComponentArray(map(f, getdata.(xs)...), getaxes(Axes))
-end
-
-
 # From https://github.com/JuliaArrays/OffsetArrays.jl/blob/master/src/OffsetArrays.jl
 Base.dataids(A::ComponentArray) = Base.dataids(parent(A))
 Broadcast.broadcast_unalias(dest::ComponentArray, src) = getdata(dest) === getdata(src) ? src : Broadcast.unalias(dest, src)

src/componentindex.jl

@@ -6,24 +6,9 @@ ComponentIndex(idx::Int) = ComponentIndex(idx, NullAxis())
 ComponentIndex(idx::Union{FlatIdx, Colon}) = ComponentIndex(idx, FlatAxis())
 ComponentIndex(vax::ViewAxis{Inds,IdxMap,Ax}) where {Inds,IdxMap,Ax} = ComponentIndex(Inds, vax.ax)
 
-value(idx::ComponentIndex) = idx.idx
-value(idx) = idx
-
 const FlatComponentIndex{Idx} = ComponentIndex{Idx, FlatAxis}
 const NullComponentIndex{Idx} = ComponentIndex{Idx, NullAxis}
 
-function Base.getindex(A::AbstractArray, ind::ComponentIndex, inds::ComponentIndex...)
-    inds = (ind, inds...)
-    return ComponentArray(A[(i.idx for i in inds)...], Tuple(i.ax for i in inds))
-end
-Base.getindex(A::ComponentArray, ind::ComponentIndex, inds::ComponentIndex...) = getindex(A, ind.idx, (i.idx for i in inds)...)
-Base.getindex(bc::Base.Broadcast.Broadcasted{Nothing}, idx::ComponentIndex) = bc[CartesianIndex(idx)]
-
-# Do we still need this?
-Base.getindex(ax::AbstractAxis, ind::ComponentIndex) = ax[ind.idx]
-
-Base.CartesianIndex(idx::Union{ComponentIndex, Integer, CartesianIndex}...) = CartesianIndex(value.(idx)...)
-
 
 """
     KeepIndex(idx)

src/similar_convert_copy.jl

@@ -80,30 +80,4 @@ Base.NamedTuple(x::ComponentVector) = _namedtuple(x)
 
 
 ## AbstractAxis conversion and promotion
-Base.convert(::Type{Ax}, ax::AbstractAxis) where {Ax<:AbstractAxis} = ax #Ax()
-# Base.convert(::Type{Axis}, ax::AbstractAxis) = ax #Ax()
-Base.convert(::Type{Ax}, ax::AbstractAxis) where {Ax<:VarAxes} = convert.(typeof.(getaxes(Ax)), (ax,))
-
-Base.promote_rule(AA::Type{<:Axis}, ::Type{NullAxis}) = AA
-Base.promote_rule(AA::Type{<:Axis}, ::Type{FlatAxis}) = AA
-Base.promote_rule(FA::Type{FlatAxis}, ::Type{NullAxis}) = FA
-Base.promote_rule(FA::Type{FlatAxis}, ::Type{FlatAxis}) = FA
-Base.promote_rule(NA::Type{NullAxis}, ::Type{NullAxis}) = NA
-function Base.promote_rule(A1::Type{<:VarAxes}, A2::Type{<:VarAxes})
-    # promote_type.(typeof.(getaxes(A1)), typeof.(getaxes(A2)))
-    ax = typeof(first.(promote.(getaxes(A1), getaxes(A2))))
-end
-
-broadcast_promote_type(::Type{FlatAxis}, ax2::Type{<:Axis}) = ax2
-broadcast_promote_type(ax1::Type{<:Axis}, ::Type{FlatAxis}) = ax1
-broadcast_promote_type(ax1::Type{FlatAxis}, ::Type{NullAxis}) = ax1
-broadcast_promote_type(::Type{NullAxis}, ax2::Type{FlatAxis}) = ax2
-broadcast_promote_type(::Type{<:Axis}, ::Type{<:Axis}) = FlatAxis
-broadcast_promote_type(ax1::Type{Ax}, ::Type{Ax}) where {Ax<:Axis} = ax1
-function broadcast_promote_type(A1::Type{<:VarAxes}, A2::Type{<:VarAxes})
-    ax = Tuple{broadcast_promote_typeof.(getaxes(A1), getaxes(A2))...}
-end
-
-broadcast_promote_typeof(ax1, ax2) = broadcast_promote_type(typeof(ax1), typeof(ax2))
-
-broadcast_promote(ax1, ax2) = broadcast_promote_typeof(ax1, ax2)()
+Base.convert(::Type{Ax}, ax::AbstractAxis) where {Ax<:AbstractAxis} = ax