Change in the type structure

docs/src/reference/internal.md

@@ -1,5 +1,12 @@
 # Internal types
 
+## Internal supertypes
+
+```@docs
+TimeStruct.TimeStructInnerIter
+TimeStruct.TimeStructOuterIter
+```
+
 ## Strategic period types ([`TwoLevelTree`](@ref))
 
 ### Single types
@@ -32,7 +39,7 @@ TimeStruct.StrategicPeriod
 
 ```@docs
 TimeStruct.SingleStrategicPeriodWrapper
-TimeStruct.StratPeriods
+TimeStruct.StratPers
 ```
 
 ## Representative period types
@@ -51,9 +58,9 @@ TimeStruct.StratNodeReprPeriod
 
 ```@docs
 TimeStruct.SingleReprPeriodWrapper
-TimeStruct.ReprPeriods
-TimeStruct.StratReprPeriods
-TimeStruct.StratNodeReprPeriods
+TimeStruct.ReprPers
+TimeStruct.StratReprPers
+TimeStruct.StratNodeReprPers
 ```
 
 ## Operational scenarios types
@@ -64,10 +71,10 @@ TimeStruct.StratNodeReprPeriods
 TimeStruct.AbstractOperationalScenario
 TimeStruct.SingleScenario
 TimeStruct.OperationalScenario
-TimeStruct.ReprOperationalScenario
-TimeStruct.StratOperationalScenario
-TimeStruct.StratReprOpscenario
-TimeStruct.StratNodeOperationalScenario
+TimeStruct.ReprOpScenario
+TimeStruct.StratOpScenario
+TimeStruct.StratReprOpScenario
+TimeStruct.StratNodeOpScenario
 TimeStruct.StratNodeReprOpScenario
 ```
 
@@ -78,7 +85,7 @@ TimeStruct.SingleScenarioWrapper
 TimeStruct.OpScens
 TimeStruct.RepOpScens
 TimeStruct.StratOpScens
-TimeStruct.StratReprOpscenarios
+TimeStruct.StratReprOpScens
 TimeStruct.StratNodeOpScens
 TimeStruct.StratNodeReprOpScens
 ```

src/calendar.jl

@@ -90,7 +90,7 @@ function Base.last(ts::CalendarTimes)
 end
 
 """
-    struct CalendarPeriod <: TimePeriod
+    struct CalendarPeriod{T} <: TimePeriod
 
 Time period for a single operational period. It is created through iterating through a
 [`CalendarTimes`](@ref) time structure with duration measured in hours (by default).

src/op_scenarios/core_types.jl

@@ -99,52 +99,50 @@ function Base.iterate(oscs::OperationalScenarios, state = (nothing, 1))
     return ScenarioPeriod(oscs, next[1], osc), (next[2], osc)
 end
 function Base.last(oscs::OperationalScenarios)
-    return ScenarioPeriod(
-        oscs.len,
-        oscs.probability[oscs.len],
-        _multiple_adj(oscs, oscs.len),
-        last(oscs.scenarios[oscs.len]),
-    )
+    per = last(oscs.scenarios[oscs.len])
+    return ScenarioPeriod(oscs, per, oscs.len)
 end
 
 """
-	ScenarioPeriod{P} <: TimePeriod where {P<:TimePeriod}
+	struct ScenarioPeriod{P} <: TimePeriod where {P<:TimePeriod}
 
 Time period for a single operational period. It is created through iterating through a
 [`OperationalScenarios`](@ref) time structure. It is as well created as period within
 [`OperationalPeriod`](@ref) when the time structure includes [`OperationalScenarios`](@ref).
 """
 struct ScenarioPeriod{P} <: TimePeriod where {P<:TimePeriod}
     osc::Int
-    prob::Float64
-    multiple::Float64
     period::P
+    multiple::Float64
+    prob::Float64
 end
+_period(t::ScenarioPeriod) = t.period
 
-_oper(t::ScenarioPeriod) = _oper(t.period)
+_oper(t::ScenarioPeriod) = _oper(_period(t))
 _opscen(t::ScenarioPeriod) = t.osc
 
-isfirst(t::ScenarioPeriod) = isfirst(t.period)
-duration(t::ScenarioPeriod) = duration(t.period)
+isfirst(t::ScenarioPeriod) = isfirst(_period(t))
+duration(t::ScenarioPeriod) = duration(_period(t))
 multiple(t::ScenarioPeriod) = t.multiple
 probability(t::ScenarioPeriod) = t.prob
 
-Base.show(io::IO, t::ScenarioPeriod) = print(io, "sc$(t.osc)-$(t.period)")
+Base.show(io::IO, t::ScenarioPeriod) = print(io, "sc$(_opscen(t))-$(_period(t))")
 function Base.isless(t1::ScenarioPeriod, t2::ScenarioPeriod)
-    return t1.osc < t2.osc || (t1.osc == t2.osc && t1.period < t2.period)
+    return _opscen(t1) < _opscen(t2) ||
+           (_opscen(t1) == _opscen(t2) && _period(t1) < _period(t2))
 end
 
 # Convenience constructors for the type
 function ScenarioPeriod(osc::Int, prob::Number, multiple::Number, period)
     return ScenarioPeriod(
         osc,
-        Base.convert(Float64, prob),
-        Base.convert(Float64, multiple),
         period,
+        Base.convert(Float64, multiple),
+        Base.convert(Float64, prob),
     )
 end
 function ScenarioPeriod(oscs::OperationalScenarios, per::TimePeriod, osc::Int)
     prob = oscs.probability[osc]
     mult = _multiple_adj(oscs, osc)
-    return ScenarioPeriod(osc, prob, mult, per)
+    return ScenarioPeriod(osc, per, mult, prob)
 end

src/op_scenarios/opscenarios.jl

@@ -1,5 +1,5 @@
 """
-    AbstractOperationalScenario{T} <: TimeStructure{T}
+    abstract type AbstractOperationalScenario{T} <: TimeStructure{T}
 
 Abstract type used for time structures that represent an operational scenario.
 These periods are obtained when iterating through the operational scenarios of a time
@@ -26,7 +26,7 @@ ScenarioIndexable(::Type{<:AbstractOperationalScenario}) = HasScenarioIndex()
 ScenarioIndexable(::Type{<:TimePeriod}) = HasScenarioIndex()
 
 """
-    SingleScenario{T,SC<:TimeStructure{T}} <: AbstractRepresentativePeriod{T}
+    struct SingleScenario{T,SC<:TimeStructure{T}} <: AbstractRepresentativePeriod{T}
 
 A type representing a single operational scenario supporting iteration over its
 time periods. It is created when iterating through [`SingleScenarioWrapper`](@ref).
@@ -68,16 +68,18 @@ function Base.last( # TODO: Considering removing the function as the the structu
 end
 
 """
-    SingleScenarioWrapper{T,OP<:TimeStructure{T}} <: TimeStructure{T}
+    struct SingleScenarioWrapper{T,OP<:TimeStructure{T}} <: TimeStructInnerIter{T}
 
 Type for iterating through the individual operational scenarios of a time structure
 without [`OperationalScenarios`](@ref). It is automatically created through the function
 [`opscenarios`](@ref).
 """
-struct SingleScenarioWrapper{T,SC<:TimeStructure{T}} <: TimeStructure{T}
+struct SingleScenarioWrapper{T,SC<:TimeStructure{T}} <: TimeStructInnerIter{T}
     ts::SC
 end
 
+_oper_struct(oscs::SingleScenarioWrapper) = oscs.ts
+
 """
     opscenarios(ts::TimeStructure)
 
@@ -91,42 +93,39 @@ When the `TimeStructure` is a `TimeStructure`, `opscenarios` returns a
 opscenarios(ts::TimeStructure) = SingleScenarioWrapper(ts)
 
 # Add basic functions of iterators
-Base.length(ssw::SingleScenarioWrapper) = 1
+Base.length(oscs::SingleScenarioWrapper) = 1
 function Base.eltype(::Type{SingleScenarioWrapper{T,SC}}) where {T,SC}
     return SingleScenario{T,SC}
 end
-function Base.iterate(ssw::SingleScenarioWrapper, state = nothing)
+function Base.iterate(oscs::SingleScenarioWrapper, state = nothing)
     !isnothing(state) && return nothing
-    return SingleScenario(ssw.ts), 1
+    return SingleScenario(_oper_struct(oscs)), 1
 end
 
 """
-    OperationalScenario{T,OP<:TimeStructure{T}} <: AbstractOperationalScenario{T}
+    struct OperationalScenario{T,OP<:TimeStructure{T}} <: AbstractOperationalScenario{T}
 
 A type representing a single operational scenario supporting iteration over its
 time periods. It is created when iterating through [`OpScens`](@ref).
 """
 struct OperationalScenario{T,OP<:TimeStructure{T}} <: AbstractOperationalScenario{T}
     scen::Int
-    mult_sc::Float64
+    mult_scen::Float64
     probability::Float64
     operational::OP
 end
 
 _opscen(osc::OperationalScenario) = osc.scen
 
 probability(osc::OperationalScenario) = osc.probability
-mult_scen(osc::OperationalScenario) = osc.mult_sc
+mult_scen(osc::OperationalScenario) = osc.mult_scen
 
 Base.show(io::IO, osc::OperationalScenario) = print(io, "sc-$(osc.scen)")
 
 # Provide a constructor to simplify the design
-function ScenarioPeriod(
-    osc::OperationalScenario,
-    per::P,
-) where {P<:Union{TimePeriod,TimeStructure}}
+function ScenarioPeriod(osc::OperationalScenario, per::TimePeriod)
     mult = mult_scen(osc) * multiple(per)
-    return ScenarioPeriod(_opscen(osc), probability(osc), mult, per)
+    return ScenarioPeriod(_opscen(osc), per, mult, probability(osc))
 end
 
 # Add basic functions of iterators
@@ -151,17 +150,17 @@ function Base.eachindex(osc::OperationalScenario)
 end
 
 """
-    OpScens{T,OP}
+    struct OpScens{T,OP} <: TimeStructInnerIter{T}
 
 Type for iterating through the individual operational scenarios of a
 [`OperationalScenarios`](@ref) time structure. It is automatically created through the
 function [`opscenarios`](@ref).
 """
-struct OpScens{T,OP}
+struct OpScens{T,OP} <: TimeStructInnerIter{T}
     ts::OperationalScenarios{T,OP}
 end
 
-_oper_it(oscs::OpScens) = oscs.ts
+_oper_struct(oscs::OpScens) = oscs.ts
 
 """
 When the `TimeStructure` is an [`OperationalScenarios`](@ref), `opscenarios` returns the
@@ -173,14 +172,14 @@ opscenarios(oscs::OperationalScenarios) = OpScens(oscs)
 function OperationalScenario(oscs::OpScens, per::Int)
     return OperationalScenario(
         per,
-        _multiple_adj(oscs.ts, per),
-        oscs.ts.probability[per],
-        oscs.ts.scenarios[per],
+        _multiple_adj(_oper_struct(oscs), per),
+        _oper_struct(oscs).probability[per],
+        _oper_struct(oscs).scenarios[per],
     )
 end
 
 # Add basic functions of iterators
-Base.length(oscs::OpScens) = oscs.ts.len
+Base.length(oscs::OpScens) = _oper_struct(oscs).len
 function Base.eltype(_::Type{OpScens{T,OP}}) where {T,OP<:TimeStructure{T}}
     return OperationalScenario{T,OP}
 end
@@ -194,6 +193,6 @@ function Base.getindex(oscs::OpScens, index::Int)
     return OperationalScenario(oscs, index)
 end
 function Base.eachindex(oscs::OpScens)
-    return eachindex(oscs.ts.scenarios)
+    return eachindex(_oper_struct(oscs).scenarios)
 end
 Base.last(oscs::OpScens) = OperationalScenario(oscs, length(oscs))