CacheSim/src/CacheSim/Update.elm

module CacheSim.Update exposing (..)
import CacheSim.Model exposing (..)
import CacheSim.Hierarchy exposing (..)
import CacheSim.Raw exposing (..)
import CacheSim.IntMap exposing (..)
import CacheSim.AccessView exposing (..)

updateChangeRawModel : Int -> (RawCacheModel -> RawCacheModel) -> Model -> (Model, Cmd Msg)
updateChangeRawModel l f m =
    let
        newModel = { m | rawHierarchy = intMapUpdate l f m.rawHierarchy }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateCreateRawModel : Model -> (Model, Cmd Msg)
updateCreateRawModel m =
    let
        freshRawModel = { blockSize = "4", setCount = "4", setSize = "3" }
        newModel = { m | rawHierarchy = m.rawHierarchy ++ [ freshRawModel ] }
        cmd = Cmd.none
    in
        (newModel, cmd)
 
updateDeleteRawModel : Int -> Model -> (Model, Cmd Msg)
updateDeleteRawModel l m =
    let
        newModel = { m | rawHierarchy = intMapDelete l m.rawHierarchy }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateUseHierarchy : Maybe CacheModelHierarchy -> Model -> (Model, Cmd Msg)
updateUseHierarchy cmh m =
    let
        newModel = { m | hierarchy = Maybe.map freshCacheHierarchy cmh }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateAccess : List Int -> Model -> (Model, Cmd Msg)
updateAccess li m =
    let
        process c xs =
            case xs of
                [] -> Ok []
                (i::t) ->
                    case accessCacheHierarchy (i // 4) c of
                        Ok av -> 
                            let
                                newView = { blockAddr = i, accessEffects = av, position = Down 0, initialState = c }
                            in
                                Result.map ((::) newView)
                                    <| process (finalCacheHierarchy newView) t
                        Err s -> Err s

        accessResult = Maybe.andThen (\h -> Result.toMaybe <| process h li) m.hierarchy
        newModel = { m | accessView = accessResult }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateAccessViewCancel : Model -> (Model, Cmd Msg)
updateAccessViewCancel m =
    let
        newModel = { m | accessView = Nothing }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateAccessViewForward : Model -> (Model, Cmd Msg)
updateAccessViewForward m =
    let
        afterStep = Maybe.map (intMapUpdate 0 accessViewForward) m.accessView
        newAccessView =
            case afterStep of
                Just (result::xs) ->
                    case (result.position, xs) of
                        (End, []) -> Nothing
                        (End, nxs) -> Just nxs
                        _ -> Just (result::xs)
                as_ -> as_
        newModel = { m | accessView = newAccessView }
        cmd = Cmd.none
    in
        (newModel, cmd)

updateAccessViewBack : Model -> (Model, Cmd Msg)
updateAccessViewBack m =
    let
        afterStep = Maybe.map (intMapUpdate 0 accessViewBack) m.accessView
        newModel = { m | accessView = afterStep }
        cmd = Cmd.none
    in
        (newModel, cmd)