rspeele / rezoom Goto Github PK

open System
open Rezoom
open Rezoom.Execution

type OrgId = OrgId of Guid
    with static member MakeOrgId () = OrgId (Guid.NewGuid())

type UserId = UserId of Guid
    with static member MakeUserId () = UserId (Guid.NewGuid())

let org1Id = OrgId.MakeOrgId()
let org2Id = OrgId.MakeOrgId()

let orgs = dict [ org1Id, "Org 1"
                  org2Id, "Org 2" ]

let users = dict [ UserId.MakeUserId(), ("User 1", org1Id )
                   UserId.MakeUserId(), ("User 2", org1Id )
                   UserId.MakeUserId(), ("User 3", org1Id )
                   UserId.MakeUserId(), ("User 4", org1Id )
                   UserId.MakeUserId(), ("User 5", org1Id )
                   UserId.MakeUserId(), ("User 6", org2Id )
                   UserId.MakeUserId(), ("User 7", org2Id )
                   UserId.MakeUserId(), ("User 8", org2Id )
                   UserId.MakeUserId(), ("User 9", org2Id )
                   UserId.MakeUserId(), ("User 10", org2Id ) ]

let getOrg id = orgs.[id]
let getUser id = users.[id]

let getOrgs ids = ids |> Seq.map getOrg
let getUsers ids = ids |> Seq.map getUser

type StepBatch<'a, 'b>(runBatch: 'a seq -> 'b seq) =
    let userIds = ResizeArray<'a>()
    let batchResults = lazy (runBatch userIds |> Seq.toArray) 
    
    member this.AddToBatch(i) =
        let index = userIds.Count
        userIds.Add(i)
        fun () -> batchResults.Value.[index]
        
let getCache<'a> () = 
    { new CacheInfo() with
        override this.Category = box typeof<'a>
        override this.Identity = box "ignorefornow"
        override this.Cacheable = true
        override this.DependencyMask = BitMask.Zero
        override this.InvalidationMask = BitMask.Zero
    }

//can't do this

//type Errand<'a, 'b>(arg : UserId, factory: unit->StepBatch<'a, 'b>) =
//    inherit SynchronousErrand<'b>()
//    
//    override this.CacheInfo = getCache<StepBatch<'a, 'b>> ()
//    override this.CacheArgument = box arg
//    
//    override this.Prepare(context : ServiceContext) =
//        let batch = context.GetService<UserStepBatch>(factory)
//        batch.AddToBatch arg
//
//type UserErrand(arg: UserId) = 
//    inherit Errand<UserId, string*OrgId>(arg, fun () -> StepBatch<UserId, string*OrgId>(getUsers) )
//
//type OrgErrand(arg: OrgId) = 
//    inherit Errand<OrgId, string>(arg, fun () -> StepBatch<OrgId, string>(getOrgs))
//
// Can create as many of these as I want trivially now!

//have to do this instead

type UserStepBatch() = inherit StepBatch<UserId, string*OrgId>(getUsers)
type OrgStepBatch() = inherit StepBatch<OrgId, string>(getOrgs)
    
type UserErrand(arg : UserId) =
    inherit SynchronousErrand<string*OrgId>()
    
    override this.CacheInfo = getCache<UserStepBatch> ()
    override this.CacheArgument = box arg
    
    override this.Prepare(context : ServiceContext) =
        let batch = context.GetService<StepLocal<UserStepBatch>, UserStepBatch>()
        batch.AddToBatch arg
        
type OrgErrand(arg : OrgId) =
    inherit SynchronousErrand<string>()
    
    override this.CacheInfo = getCache<OrgStepBatch> ()
    override this.CacheArgument = box arg
    
    override this.Prepare(context : ServiceContext) =
        // Get the batch for this execution step.
        let batch = context.GetService<StepLocal<OrgStepBatch>, OrgStepBatch>()
        // Add ourselves to the batch, return the result getter.
        batch.AddToBatch arg