{-# LANGUAGE RecordWildCards #-}
module Modelling.ActivityDiagram.Instance (
  parseInstance
) where

import qualified Data.Map               as M (fromAscList, elems, lookup, fromList)
import qualified Data.Set               as S (unions, mapMonotonic, fromAscList, toAscList, map, filter, member)

import Modelling.ActivityDiagram.Datatype (
  AdConnection (AdConnection),
  AdNode (..),
  UMLActivityDiagram(..),
  )

import Control.Monad.Catch              (Exception, MonadThrow (throwM))
import Data.List (singleton)
import Data.List.Extra                  (nubOrd)
import Data.Map                         (Map)
import Data.Maybe (
  fromMaybe,
  fromJust,
  )
import Data.Set                         (Set)
import Data.Tuple.Extra                 (uncurry3)
import Language.Alloy.Call (
  getDoubleAs,
  getSingleAs,
  lookupSig,
  scoped,
  AlloyInstance,
  )

newtype ComponentName = ComponentName String
  deriving (ComponentName -> ComponentName -> Bool
(ComponentName -> ComponentName -> Bool)
-> (ComponentName -> ComponentName -> Bool) -> Eq ComponentName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ComponentName -> ComponentName -> Bool
== :: ComponentName -> ComponentName -> Bool
$c/= :: ComponentName -> ComponentName -> Bool
/= :: ComponentName -> ComponentName -> Bool
Eq, Eq ComponentName
Eq ComponentName
-> (ComponentName -> ComponentName -> Ordering)
-> (ComponentName -> ComponentName -> Bool)
-> (ComponentName -> ComponentName -> Bool)
-> (ComponentName -> ComponentName -> Bool)
-> (ComponentName -> ComponentName -> Bool)
-> (ComponentName -> ComponentName -> ComponentName)
-> (ComponentName -> ComponentName -> ComponentName)
-> Ord ComponentName
ComponentName -> ComponentName -> Bool
ComponentName -> ComponentName -> Ordering
ComponentName -> ComponentName -> ComponentName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ComponentName -> ComponentName -> Ordering
compare :: ComponentName -> ComponentName -> Ordering
$c< :: ComponentName -> ComponentName -> Bool
< :: ComponentName -> ComponentName -> Bool
$c<= :: ComponentName -> ComponentName -> Bool
<= :: ComponentName -> ComponentName -> Bool
$c> :: ComponentName -> ComponentName -> Bool
> :: ComponentName -> ComponentName -> Bool
$c>= :: ComponentName -> ComponentName -> Bool
>= :: ComponentName -> ComponentName -> Bool
$cmax :: ComponentName -> ComponentName -> ComponentName
max :: ComponentName -> ComponentName -> ComponentName
$cmin :: ComponentName -> ComponentName -> ComponentName
min :: ComponentName -> ComponentName -> ComponentName
Ord, ReadPrec [ComponentName]
ReadPrec ComponentName
Int -> ReadS ComponentName
ReadS [ComponentName]
(Int -> ReadS ComponentName)
-> ReadS [ComponentName]
-> ReadPrec ComponentName
-> ReadPrec [ComponentName]
-> Read ComponentName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ComponentName
readsPrec :: Int -> ReadS ComponentName
$creadList :: ReadS [ComponentName]
readList :: ReadS [ComponentName]
$creadPrec :: ReadPrec ComponentName
readPrec :: ReadPrec ComponentName
$creadListPrec :: ReadPrec [ComponentName]
readListPrec :: ReadPrec [ComponentName]
Read, Int -> ComponentName -> String -> String
[ComponentName] -> String -> String
ComponentName -> String
(Int -> ComponentName -> String -> String)
-> (ComponentName -> String)
-> ([ComponentName] -> String -> String)
-> Show ComponentName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ComponentName -> String -> String
showsPrec :: Int -> ComponentName -> String -> String
$cshow :: ComponentName -> String
show :: ComponentName -> String
$cshowList :: [ComponentName] -> String -> String
showList :: [ComponentName] -> String -> String
Show)

newtype GuardName = GuardName String
  deriving (GuardName -> GuardName -> Bool
(GuardName -> GuardName -> Bool)
-> (GuardName -> GuardName -> Bool) -> Eq GuardName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GuardName -> GuardName -> Bool
== :: GuardName -> GuardName -> Bool
$c/= :: GuardName -> GuardName -> Bool
/= :: GuardName -> GuardName -> Bool
Eq, Eq GuardName
Eq GuardName
-> (GuardName -> GuardName -> Ordering)
-> (GuardName -> GuardName -> Bool)
-> (GuardName -> GuardName -> Bool)
-> (GuardName -> GuardName -> Bool)
-> (GuardName -> GuardName -> Bool)
-> (GuardName -> GuardName -> GuardName)
-> (GuardName -> GuardName -> GuardName)
-> Ord GuardName
GuardName -> GuardName -> Bool
GuardName -> GuardName -> Ordering
GuardName -> GuardName -> GuardName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GuardName -> GuardName -> Ordering
compare :: GuardName -> GuardName -> Ordering
$c< :: GuardName -> GuardName -> Bool
< :: GuardName -> GuardName -> Bool
$c<= :: GuardName -> GuardName -> Bool
<= :: GuardName -> GuardName -> Bool
$c> :: GuardName -> GuardName -> Bool
> :: GuardName -> GuardName -> Bool
$c>= :: GuardName -> GuardName -> Bool
>= :: GuardName -> GuardName -> Bool
$cmax :: GuardName -> GuardName -> GuardName
max :: GuardName -> GuardName -> GuardName
$cmin :: GuardName -> GuardName -> GuardName
min :: GuardName -> GuardName -> GuardName
Ord, ReadPrec [GuardName]
ReadPrec GuardName
Int -> ReadS GuardName
ReadS [GuardName]
(Int -> ReadS GuardName)
-> ReadS [GuardName]
-> ReadPrec GuardName
-> ReadPrec [GuardName]
-> Read GuardName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GuardName
readsPrec :: Int -> ReadS GuardName
$creadList :: ReadS [GuardName]
readList :: ReadS [GuardName]
$creadPrec :: ReadPrec GuardName
readPrec :: ReadPrec GuardName
$creadListPrec :: ReadPrec [GuardName]
readListPrec :: ReadPrec [GuardName]
Read, Int -> GuardName -> String -> String
[GuardName] -> String -> String
GuardName -> String
(Int -> GuardName -> String -> String)
-> (GuardName -> String)
-> ([GuardName] -> String -> String)
-> Show GuardName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GuardName -> String -> String
showsPrec :: Int -> GuardName -> String -> String
$cshow :: GuardName -> String
show :: GuardName -> String
$cshowList :: [GuardName] -> String -> String
showList :: [GuardName] -> String -> String
Show)

newtype ActionNode = ActionNode String
  deriving (ActionNode -> ActionNode -> Bool
(ActionNode -> ActionNode -> Bool)
-> (ActionNode -> ActionNode -> Bool) -> Eq ActionNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActionNode -> ActionNode -> Bool
== :: ActionNode -> ActionNode -> Bool
$c/= :: ActionNode -> ActionNode -> Bool
/= :: ActionNode -> ActionNode -> Bool
Eq, Eq ActionNode
Eq ActionNode
-> (ActionNode -> ActionNode -> Ordering)
-> (ActionNode -> ActionNode -> Bool)
-> (ActionNode -> ActionNode -> Bool)
-> (ActionNode -> ActionNode -> Bool)
-> (ActionNode -> ActionNode -> Bool)
-> (ActionNode -> ActionNode -> ActionNode)
-> (ActionNode -> ActionNode -> ActionNode)
-> Ord ActionNode
ActionNode -> ActionNode -> Bool
ActionNode -> ActionNode -> Ordering
ActionNode -> ActionNode -> ActionNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ActionNode -> ActionNode -> Ordering
compare :: ActionNode -> ActionNode -> Ordering
$c< :: ActionNode -> ActionNode -> Bool
< :: ActionNode -> ActionNode -> Bool
$c<= :: ActionNode -> ActionNode -> Bool
<= :: ActionNode -> ActionNode -> Bool
$c> :: ActionNode -> ActionNode -> Bool
> :: ActionNode -> ActionNode -> Bool
$c>= :: ActionNode -> ActionNode -> Bool
>= :: ActionNode -> ActionNode -> Bool
$cmax :: ActionNode -> ActionNode -> ActionNode
max :: ActionNode -> ActionNode -> ActionNode
$cmin :: ActionNode -> ActionNode -> ActionNode
min :: ActionNode -> ActionNode -> ActionNode
Ord, ReadPrec [ActionNode]
ReadPrec ActionNode
Int -> ReadS ActionNode
ReadS [ActionNode]
(Int -> ReadS ActionNode)
-> ReadS [ActionNode]
-> ReadPrec ActionNode
-> ReadPrec [ActionNode]
-> Read ActionNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ActionNode
readsPrec :: Int -> ReadS ActionNode
$creadList :: ReadS [ActionNode]
readList :: ReadS [ActionNode]
$creadPrec :: ReadPrec ActionNode
readPrec :: ReadPrec ActionNode
$creadListPrec :: ReadPrec [ActionNode]
readListPrec :: ReadPrec [ActionNode]
Read, Int -> ActionNode -> String -> String
[ActionNode] -> String -> String
ActionNode -> String
(Int -> ActionNode -> String -> String)
-> (ActionNode -> String)
-> ([ActionNode] -> String -> String)
-> Show ActionNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ActionNode -> String -> String
showsPrec :: Int -> ActionNode -> String -> String
$cshow :: ActionNode -> String
show :: ActionNode -> String
$cshowList :: [ActionNode] -> String -> String
showList :: [ActionNode] -> String -> String
Show)

newtype ObjectNode = ObjectNode String
  deriving (ObjectNode -> ObjectNode -> Bool
(ObjectNode -> ObjectNode -> Bool)
-> (ObjectNode -> ObjectNode -> Bool) -> Eq ObjectNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectNode -> ObjectNode -> Bool
== :: ObjectNode -> ObjectNode -> Bool
$c/= :: ObjectNode -> ObjectNode -> Bool
/= :: ObjectNode -> ObjectNode -> Bool
Eq, Eq ObjectNode
Eq ObjectNode
-> (ObjectNode -> ObjectNode -> Ordering)
-> (ObjectNode -> ObjectNode -> Bool)
-> (ObjectNode -> ObjectNode -> Bool)
-> (ObjectNode -> ObjectNode -> Bool)
-> (ObjectNode -> ObjectNode -> Bool)
-> (ObjectNode -> ObjectNode -> ObjectNode)
-> (ObjectNode -> ObjectNode -> ObjectNode)
-> Ord ObjectNode
ObjectNode -> ObjectNode -> Bool
ObjectNode -> ObjectNode -> Ordering
ObjectNode -> ObjectNode -> ObjectNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectNode -> ObjectNode -> Ordering
compare :: ObjectNode -> ObjectNode -> Ordering
$c< :: ObjectNode -> ObjectNode -> Bool
< :: ObjectNode -> ObjectNode -> Bool
$c<= :: ObjectNode -> ObjectNode -> Bool
<= :: ObjectNode -> ObjectNode -> Bool
$c> :: ObjectNode -> ObjectNode -> Bool
> :: ObjectNode -> ObjectNode -> Bool
$c>= :: ObjectNode -> ObjectNode -> Bool
>= :: ObjectNode -> ObjectNode -> Bool
$cmax :: ObjectNode -> ObjectNode -> ObjectNode
max :: ObjectNode -> ObjectNode -> ObjectNode
$cmin :: ObjectNode -> ObjectNode -> ObjectNode
min :: ObjectNode -> ObjectNode -> ObjectNode
Ord, ReadPrec [ObjectNode]
ReadPrec ObjectNode
Int -> ReadS ObjectNode
ReadS [ObjectNode]
(Int -> ReadS ObjectNode)
-> ReadS [ObjectNode]
-> ReadPrec ObjectNode
-> ReadPrec [ObjectNode]
-> Read ObjectNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectNode
readsPrec :: Int -> ReadS ObjectNode
$creadList :: ReadS [ObjectNode]
readList :: ReadS [ObjectNode]
$creadPrec :: ReadPrec ObjectNode
readPrec :: ReadPrec ObjectNode
$creadListPrec :: ReadPrec [ObjectNode]
readListPrec :: ReadPrec [ObjectNode]
Read, Int -> ObjectNode -> String -> String
[ObjectNode] -> String -> String
ObjectNode -> String
(Int -> ObjectNode -> String -> String)
-> (ObjectNode -> String)
-> ([ObjectNode] -> String -> String)
-> Show ObjectNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ObjectNode -> String -> String
showsPrec :: Int -> ObjectNode -> String -> String
$cshow :: ObjectNode -> String
show :: ObjectNode -> String
$cshowList :: [ObjectNode] -> String -> String
showList :: [ObjectNode] -> String -> String
Show)

newtype DecisionNode = DecisionNode String
  deriving (DecisionNode -> DecisionNode -> Bool
(DecisionNode -> DecisionNode -> Bool)
-> (DecisionNode -> DecisionNode -> Bool) -> Eq DecisionNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecisionNode -> DecisionNode -> Bool
== :: DecisionNode -> DecisionNode -> Bool
$c/= :: DecisionNode -> DecisionNode -> Bool
/= :: DecisionNode -> DecisionNode -> Bool
Eq, Eq DecisionNode
Eq DecisionNode
-> (DecisionNode -> DecisionNode -> Ordering)
-> (DecisionNode -> DecisionNode -> Bool)
-> (DecisionNode -> DecisionNode -> Bool)
-> (DecisionNode -> DecisionNode -> Bool)
-> (DecisionNode -> DecisionNode -> Bool)
-> (DecisionNode -> DecisionNode -> DecisionNode)
-> (DecisionNode -> DecisionNode -> DecisionNode)
-> Ord DecisionNode
DecisionNode -> DecisionNode -> Bool
DecisionNode -> DecisionNode -> Ordering
DecisionNode -> DecisionNode -> DecisionNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DecisionNode -> DecisionNode -> Ordering
compare :: DecisionNode -> DecisionNode -> Ordering
$c< :: DecisionNode -> DecisionNode -> Bool
< :: DecisionNode -> DecisionNode -> Bool
$c<= :: DecisionNode -> DecisionNode -> Bool
<= :: DecisionNode -> DecisionNode -> Bool
$c> :: DecisionNode -> DecisionNode -> Bool
> :: DecisionNode -> DecisionNode -> Bool
$c>= :: DecisionNode -> DecisionNode -> Bool
>= :: DecisionNode -> DecisionNode -> Bool
$cmax :: DecisionNode -> DecisionNode -> DecisionNode
max :: DecisionNode -> DecisionNode -> DecisionNode
$cmin :: DecisionNode -> DecisionNode -> DecisionNode
min :: DecisionNode -> DecisionNode -> DecisionNode
Ord, ReadPrec [DecisionNode]
ReadPrec DecisionNode
Int -> ReadS DecisionNode
ReadS [DecisionNode]
(Int -> ReadS DecisionNode)
-> ReadS [DecisionNode]
-> ReadPrec DecisionNode
-> ReadPrec [DecisionNode]
-> Read DecisionNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DecisionNode
readsPrec :: Int -> ReadS DecisionNode
$creadList :: ReadS [DecisionNode]
readList :: ReadS [DecisionNode]
$creadPrec :: ReadPrec DecisionNode
readPrec :: ReadPrec DecisionNode
$creadListPrec :: ReadPrec [DecisionNode]
readListPrec :: ReadPrec [DecisionNode]
Read, Int -> DecisionNode -> String -> String
[DecisionNode] -> String -> String
DecisionNode -> String
(Int -> DecisionNode -> String -> String)
-> (DecisionNode -> String)
-> ([DecisionNode] -> String -> String)
-> Show DecisionNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DecisionNode -> String -> String
showsPrec :: Int -> DecisionNode -> String -> String
$cshow :: DecisionNode -> String
show :: DecisionNode -> String
$cshowList :: [DecisionNode] -> String -> String
showList :: [DecisionNode] -> String -> String
Show)

newtype MergeNode = MergeNode String
  deriving (MergeNode -> MergeNode -> Bool
(MergeNode -> MergeNode -> Bool)
-> (MergeNode -> MergeNode -> Bool) -> Eq MergeNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeNode -> MergeNode -> Bool
== :: MergeNode -> MergeNode -> Bool
$c/= :: MergeNode -> MergeNode -> Bool
/= :: MergeNode -> MergeNode -> Bool
Eq, Eq MergeNode
Eq MergeNode
-> (MergeNode -> MergeNode -> Ordering)
-> (MergeNode -> MergeNode -> Bool)
-> (MergeNode -> MergeNode -> Bool)
-> (MergeNode -> MergeNode -> Bool)
-> (MergeNode -> MergeNode -> Bool)
-> (MergeNode -> MergeNode -> MergeNode)
-> (MergeNode -> MergeNode -> MergeNode)
-> Ord MergeNode
MergeNode -> MergeNode -> Bool
MergeNode -> MergeNode -> Ordering
MergeNode -> MergeNode -> MergeNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MergeNode -> MergeNode -> Ordering
compare :: MergeNode -> MergeNode -> Ordering
$c< :: MergeNode -> MergeNode -> Bool
< :: MergeNode -> MergeNode -> Bool
$c<= :: MergeNode -> MergeNode -> Bool
<= :: MergeNode -> MergeNode -> Bool
$c> :: MergeNode -> MergeNode -> Bool
> :: MergeNode -> MergeNode -> Bool
$c>= :: MergeNode -> MergeNode -> Bool
>= :: MergeNode -> MergeNode -> Bool
$cmax :: MergeNode -> MergeNode -> MergeNode
max :: MergeNode -> MergeNode -> MergeNode
$cmin :: MergeNode -> MergeNode -> MergeNode
min :: MergeNode -> MergeNode -> MergeNode
Ord, ReadPrec [MergeNode]
ReadPrec MergeNode
Int -> ReadS MergeNode
ReadS [MergeNode]
(Int -> ReadS MergeNode)
-> ReadS [MergeNode]
-> ReadPrec MergeNode
-> ReadPrec [MergeNode]
-> Read MergeNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MergeNode
readsPrec :: Int -> ReadS MergeNode
$creadList :: ReadS [MergeNode]
readList :: ReadS [MergeNode]
$creadPrec :: ReadPrec MergeNode
readPrec :: ReadPrec MergeNode
$creadListPrec :: ReadPrec [MergeNode]
readListPrec :: ReadPrec [MergeNode]
Read, Int -> MergeNode -> String -> String
[MergeNode] -> String -> String
MergeNode -> String
(Int -> MergeNode -> String -> String)
-> (MergeNode -> String)
-> ([MergeNode] -> String -> String)
-> Show MergeNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MergeNode -> String -> String
showsPrec :: Int -> MergeNode -> String -> String
$cshow :: MergeNode -> String
show :: MergeNode -> String
$cshowList :: [MergeNode] -> String -> String
showList :: [MergeNode] -> String -> String
Show)

newtype ForkNode = ForkNode String
  deriving (ForkNode -> ForkNode -> Bool
(ForkNode -> ForkNode -> Bool)
-> (ForkNode -> ForkNode -> Bool) -> Eq ForkNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForkNode -> ForkNode -> Bool
== :: ForkNode -> ForkNode -> Bool
$c/= :: ForkNode -> ForkNode -> Bool
/= :: ForkNode -> ForkNode -> Bool
Eq, Eq ForkNode
Eq ForkNode
-> (ForkNode -> ForkNode -> Ordering)
-> (ForkNode -> ForkNode -> Bool)
-> (ForkNode -> ForkNode -> Bool)
-> (ForkNode -> ForkNode -> Bool)
-> (ForkNode -> ForkNode -> Bool)
-> (ForkNode -> ForkNode -> ForkNode)
-> (ForkNode -> ForkNode -> ForkNode)
-> Ord ForkNode
ForkNode -> ForkNode -> Bool
ForkNode -> ForkNode -> Ordering
ForkNode -> ForkNode -> ForkNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ForkNode -> ForkNode -> Ordering
compare :: ForkNode -> ForkNode -> Ordering
$c< :: ForkNode -> ForkNode -> Bool
< :: ForkNode -> ForkNode -> Bool
$c<= :: ForkNode -> ForkNode -> Bool
<= :: ForkNode -> ForkNode -> Bool
$c> :: ForkNode -> ForkNode -> Bool
> :: ForkNode -> ForkNode -> Bool
$c>= :: ForkNode -> ForkNode -> Bool
>= :: ForkNode -> ForkNode -> Bool
$cmax :: ForkNode -> ForkNode -> ForkNode
max :: ForkNode -> ForkNode -> ForkNode
$cmin :: ForkNode -> ForkNode -> ForkNode
min :: ForkNode -> ForkNode -> ForkNode
Ord, ReadPrec [ForkNode]
ReadPrec ForkNode
Int -> ReadS ForkNode
ReadS [ForkNode]
(Int -> ReadS ForkNode)
-> ReadS [ForkNode]
-> ReadPrec ForkNode
-> ReadPrec [ForkNode]
-> Read ForkNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ForkNode
readsPrec :: Int -> ReadS ForkNode
$creadList :: ReadS [ForkNode]
readList :: ReadS [ForkNode]
$creadPrec :: ReadPrec ForkNode
readPrec :: ReadPrec ForkNode
$creadListPrec :: ReadPrec [ForkNode]
readListPrec :: ReadPrec [ForkNode]
Read, Int -> ForkNode -> String -> String
[ForkNode] -> String -> String
ForkNode -> String
(Int -> ForkNode -> String -> String)
-> (ForkNode -> String)
-> ([ForkNode] -> String -> String)
-> Show ForkNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ForkNode -> String -> String
showsPrec :: Int -> ForkNode -> String -> String
$cshow :: ForkNode -> String
show :: ForkNode -> String
$cshowList :: [ForkNode] -> String -> String
showList :: [ForkNode] -> String -> String
Show)

newtype JoinNode = JoinNode String
  deriving (JoinNode -> JoinNode -> Bool
(JoinNode -> JoinNode -> Bool)
-> (JoinNode -> JoinNode -> Bool) -> Eq JoinNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinNode -> JoinNode -> Bool
== :: JoinNode -> JoinNode -> Bool
$c/= :: JoinNode -> JoinNode -> Bool
/= :: JoinNode -> JoinNode -> Bool
Eq, Eq JoinNode
Eq JoinNode
-> (JoinNode -> JoinNode -> Ordering)
-> (JoinNode -> JoinNode -> Bool)
-> (JoinNode -> JoinNode -> Bool)
-> (JoinNode -> JoinNode -> Bool)
-> (JoinNode -> JoinNode -> Bool)
-> (JoinNode -> JoinNode -> JoinNode)
-> (JoinNode -> JoinNode -> JoinNode)
-> Ord JoinNode
JoinNode -> JoinNode -> Bool
JoinNode -> JoinNode -> Ordering
JoinNode -> JoinNode -> JoinNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: JoinNode -> JoinNode -> Ordering
compare :: JoinNode -> JoinNode -> Ordering
$c< :: JoinNode -> JoinNode -> Bool
< :: JoinNode -> JoinNode -> Bool
$c<= :: JoinNode -> JoinNode -> Bool
<= :: JoinNode -> JoinNode -> Bool
$c> :: JoinNode -> JoinNode -> Bool
> :: JoinNode -> JoinNode -> Bool
$c>= :: JoinNode -> JoinNode -> Bool
>= :: JoinNode -> JoinNode -> Bool
$cmax :: JoinNode -> JoinNode -> JoinNode
max :: JoinNode -> JoinNode -> JoinNode
$cmin :: JoinNode -> JoinNode -> JoinNode
min :: JoinNode -> JoinNode -> JoinNode
Ord, ReadPrec [JoinNode]
ReadPrec JoinNode
Int -> ReadS JoinNode
ReadS [JoinNode]
(Int -> ReadS JoinNode)
-> ReadS [JoinNode]
-> ReadPrec JoinNode
-> ReadPrec [JoinNode]
-> Read JoinNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoinNode
readsPrec :: Int -> ReadS JoinNode
$creadList :: ReadS [JoinNode]
readList :: ReadS [JoinNode]
$creadPrec :: ReadPrec JoinNode
readPrec :: ReadPrec JoinNode
$creadListPrec :: ReadPrec [JoinNode]
readListPrec :: ReadPrec [JoinNode]
Read, Int -> JoinNode -> String -> String
[JoinNode] -> String -> String
JoinNode -> String
(Int -> JoinNode -> String -> String)
-> (JoinNode -> String)
-> ([JoinNode] -> String -> String)
-> Show JoinNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> JoinNode -> String -> String
showsPrec :: Int -> JoinNode -> String -> String
$cshow :: JoinNode -> String
show :: JoinNode -> String
$cshowList :: [JoinNode] -> String -> String
showList :: [JoinNode] -> String -> String
Show)

newtype ActivityFinalNode = ActivityFinalNode String
  deriving (ActivityFinalNode -> ActivityFinalNode -> Bool
(ActivityFinalNode -> ActivityFinalNode -> Bool)
-> (ActivityFinalNode -> ActivityFinalNode -> Bool)
-> Eq ActivityFinalNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActivityFinalNode -> ActivityFinalNode -> Bool
== :: ActivityFinalNode -> ActivityFinalNode -> Bool
$c/= :: ActivityFinalNode -> ActivityFinalNode -> Bool
/= :: ActivityFinalNode -> ActivityFinalNode -> Bool
Eq, Eq ActivityFinalNode
Eq ActivityFinalNode
-> (ActivityFinalNode -> ActivityFinalNode -> Ordering)
-> (ActivityFinalNode -> ActivityFinalNode -> Bool)
-> (ActivityFinalNode -> ActivityFinalNode -> Bool)
-> (ActivityFinalNode -> ActivityFinalNode -> Bool)
-> (ActivityFinalNode -> ActivityFinalNode -> Bool)
-> (ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode)
-> (ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode)
-> Ord ActivityFinalNode
ActivityFinalNode -> ActivityFinalNode -> Bool
ActivityFinalNode -> ActivityFinalNode -> Ordering
ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ActivityFinalNode -> ActivityFinalNode -> Ordering
compare :: ActivityFinalNode -> ActivityFinalNode -> Ordering
$c< :: ActivityFinalNode -> ActivityFinalNode -> Bool
< :: ActivityFinalNode -> ActivityFinalNode -> Bool
$c<= :: ActivityFinalNode -> ActivityFinalNode -> Bool
<= :: ActivityFinalNode -> ActivityFinalNode -> Bool
$c> :: ActivityFinalNode -> ActivityFinalNode -> Bool
> :: ActivityFinalNode -> ActivityFinalNode -> Bool
$c>= :: ActivityFinalNode -> ActivityFinalNode -> Bool
>= :: ActivityFinalNode -> ActivityFinalNode -> Bool
$cmax :: ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode
max :: ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode
$cmin :: ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode
min :: ActivityFinalNode -> ActivityFinalNode -> ActivityFinalNode
Ord, ReadPrec [ActivityFinalNode]
ReadPrec ActivityFinalNode
Int -> ReadS ActivityFinalNode
ReadS [ActivityFinalNode]
(Int -> ReadS ActivityFinalNode)
-> ReadS [ActivityFinalNode]
-> ReadPrec ActivityFinalNode
-> ReadPrec [ActivityFinalNode]
-> Read ActivityFinalNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ActivityFinalNode
readsPrec :: Int -> ReadS ActivityFinalNode
$creadList :: ReadS [ActivityFinalNode]
readList :: ReadS [ActivityFinalNode]
$creadPrec :: ReadPrec ActivityFinalNode
readPrec :: ReadPrec ActivityFinalNode
$creadListPrec :: ReadPrec [ActivityFinalNode]
readListPrec :: ReadPrec [ActivityFinalNode]
Read, Int -> ActivityFinalNode -> String -> String
[ActivityFinalNode] -> String -> String
ActivityFinalNode -> String
(Int -> ActivityFinalNode -> String -> String)
-> (ActivityFinalNode -> String)
-> ([ActivityFinalNode] -> String -> String)
-> Show ActivityFinalNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ActivityFinalNode -> String -> String
showsPrec :: Int -> ActivityFinalNode -> String -> String
$cshow :: ActivityFinalNode -> String
show :: ActivityFinalNode -> String
$cshowList :: [ActivityFinalNode] -> String -> String
showList :: [ActivityFinalNode] -> String -> String
Show)

newtype FlowFinalNode = FlowFinalNode String
  deriving (FlowFinalNode -> FlowFinalNode -> Bool
(FlowFinalNode -> FlowFinalNode -> Bool)
-> (FlowFinalNode -> FlowFinalNode -> Bool) -> Eq FlowFinalNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FlowFinalNode -> FlowFinalNode -> Bool
== :: FlowFinalNode -> FlowFinalNode -> Bool
$c/= :: FlowFinalNode -> FlowFinalNode -> Bool
/= :: FlowFinalNode -> FlowFinalNode -> Bool
Eq, Eq FlowFinalNode
Eq FlowFinalNode
-> (FlowFinalNode -> FlowFinalNode -> Ordering)
-> (FlowFinalNode -> FlowFinalNode -> Bool)
-> (FlowFinalNode -> FlowFinalNode -> Bool)
-> (FlowFinalNode -> FlowFinalNode -> Bool)
-> (FlowFinalNode -> FlowFinalNode -> Bool)
-> (FlowFinalNode -> FlowFinalNode -> FlowFinalNode)
-> (FlowFinalNode -> FlowFinalNode -> FlowFinalNode)
-> Ord FlowFinalNode
FlowFinalNode -> FlowFinalNode -> Bool
FlowFinalNode -> FlowFinalNode -> Ordering
FlowFinalNode -> FlowFinalNode -> FlowFinalNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FlowFinalNode -> FlowFinalNode -> Ordering
compare :: FlowFinalNode -> FlowFinalNode -> Ordering
$c< :: FlowFinalNode -> FlowFinalNode -> Bool
< :: FlowFinalNode -> FlowFinalNode -> Bool
$c<= :: FlowFinalNode -> FlowFinalNode -> Bool
<= :: FlowFinalNode -> FlowFinalNode -> Bool
$c> :: FlowFinalNode -> FlowFinalNode -> Bool
> :: FlowFinalNode -> FlowFinalNode -> Bool
$c>= :: FlowFinalNode -> FlowFinalNode -> Bool
>= :: FlowFinalNode -> FlowFinalNode -> Bool
$cmax :: FlowFinalNode -> FlowFinalNode -> FlowFinalNode
max :: FlowFinalNode -> FlowFinalNode -> FlowFinalNode
$cmin :: FlowFinalNode -> FlowFinalNode -> FlowFinalNode
min :: FlowFinalNode -> FlowFinalNode -> FlowFinalNode
Ord, ReadPrec [FlowFinalNode]
ReadPrec FlowFinalNode
Int -> ReadS FlowFinalNode
ReadS [FlowFinalNode]
(Int -> ReadS FlowFinalNode)
-> ReadS [FlowFinalNode]
-> ReadPrec FlowFinalNode
-> ReadPrec [FlowFinalNode]
-> Read FlowFinalNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FlowFinalNode
readsPrec :: Int -> ReadS FlowFinalNode
$creadList :: ReadS [FlowFinalNode]
readList :: ReadS [FlowFinalNode]
$creadPrec :: ReadPrec FlowFinalNode
readPrec :: ReadPrec FlowFinalNode
$creadListPrec :: ReadPrec [FlowFinalNode]
readListPrec :: ReadPrec [FlowFinalNode]
Read, Int -> FlowFinalNode -> String -> String
[FlowFinalNode] -> String -> String
FlowFinalNode -> String
(Int -> FlowFinalNode -> String -> String)
-> (FlowFinalNode -> String)
-> ([FlowFinalNode] -> String -> String)
-> Show FlowFinalNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FlowFinalNode -> String -> String
showsPrec :: Int -> FlowFinalNode -> String -> String
$cshow :: FlowFinalNode -> String
show :: FlowFinalNode -> String
$cshowList :: [FlowFinalNode] -> String -> String
showList :: [FlowFinalNode] -> String -> String
Show)

newtype InitialNode = InitialNode String
  deriving (InitialNode -> InitialNode -> Bool
(InitialNode -> InitialNode -> Bool)
-> (InitialNode -> InitialNode -> Bool) -> Eq InitialNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitialNode -> InitialNode -> Bool
== :: InitialNode -> InitialNode -> Bool
$c/= :: InitialNode -> InitialNode -> Bool
/= :: InitialNode -> InitialNode -> Bool
Eq, Eq InitialNode
Eq InitialNode
-> (InitialNode -> InitialNode -> Ordering)
-> (InitialNode -> InitialNode -> Bool)
-> (InitialNode -> InitialNode -> Bool)
-> (InitialNode -> InitialNode -> Bool)
-> (InitialNode -> InitialNode -> Bool)
-> (InitialNode -> InitialNode -> InitialNode)
-> (InitialNode -> InitialNode -> InitialNode)
-> Ord InitialNode
InitialNode -> InitialNode -> Bool
InitialNode -> InitialNode -> Ordering
InitialNode -> InitialNode -> InitialNode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InitialNode -> InitialNode -> Ordering
compare :: InitialNode -> InitialNode -> Ordering
$c< :: InitialNode -> InitialNode -> Bool
< :: InitialNode -> InitialNode -> Bool
$c<= :: InitialNode -> InitialNode -> Bool
<= :: InitialNode -> InitialNode -> Bool
$c> :: InitialNode -> InitialNode -> Bool
> :: InitialNode -> InitialNode -> Bool
$c>= :: InitialNode -> InitialNode -> Bool
>= :: InitialNode -> InitialNode -> Bool
$cmax :: InitialNode -> InitialNode -> InitialNode
max :: InitialNode -> InitialNode -> InitialNode
$cmin :: InitialNode -> InitialNode -> InitialNode
min :: InitialNode -> InitialNode -> InitialNode
Ord, ReadPrec [InitialNode]
ReadPrec InitialNode
Int -> ReadS InitialNode
ReadS [InitialNode]
(Int -> ReadS InitialNode)
-> ReadS [InitialNode]
-> ReadPrec InitialNode
-> ReadPrec [InitialNode]
-> Read InitialNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InitialNode
readsPrec :: Int -> ReadS InitialNode
$creadList :: ReadS [InitialNode]
readList :: ReadS [InitialNode]
$creadPrec :: ReadPrec InitialNode
readPrec :: ReadPrec InitialNode
$creadListPrec :: ReadPrec [InitialNode]
readListPrec :: ReadPrec [InitialNode]
Read, Int -> InitialNode -> String -> String
[InitialNode] -> String -> String
InitialNode -> String
(Int -> InitialNode -> String -> String)
-> (InitialNode -> String)
-> ([InitialNode] -> String -> String)
-> Show InitialNode
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InitialNode -> String -> String
showsPrec :: Int -> InitialNode -> String -> String
$cshow :: InitialNode -> String
show :: InitialNode -> String
$cshowList :: [InitialNode] -> String -> String
showList :: [InitialNode] -> String -> String
Show)

newtype Trigger = Trigger String
  deriving (Trigger -> Trigger -> Bool
(Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool) -> Eq Trigger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Trigger -> Trigger -> Bool
== :: Trigger -> Trigger -> Bool
$c/= :: Trigger -> Trigger -> Bool
/= :: Trigger -> Trigger -> Bool
Eq, Eq Trigger
Eq Trigger
-> (Trigger -> Trigger -> Ordering)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Trigger)
-> (Trigger -> Trigger -> Trigger)
-> Ord Trigger
Trigger -> Trigger -> Bool
Trigger -> Trigger -> Ordering
Trigger -> Trigger -> Trigger
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Trigger -> Trigger -> Ordering
compare :: Trigger -> Trigger -> Ordering
$c< :: Trigger -> Trigger -> Bool
< :: Trigger -> Trigger -> Bool
$c<= :: Trigger -> Trigger -> Bool
<= :: Trigger -> Trigger -> Bool
$c> :: Trigger -> Trigger -> Bool
> :: Trigger -> Trigger -> Bool
$c>= :: Trigger -> Trigger -> Bool
>= :: Trigger -> Trigger -> Bool
$cmax :: Trigger -> Trigger -> Trigger
max :: Trigger -> Trigger -> Trigger
$cmin :: Trigger -> Trigger -> Trigger
min :: Trigger -> Trigger -> Trigger
Ord, ReadPrec [Trigger]
ReadPrec Trigger
Int -> ReadS Trigger
ReadS [Trigger]
(Int -> ReadS Trigger)
-> ReadS [Trigger]
-> ReadPrec Trigger
-> ReadPrec [Trigger]
-> Read Trigger
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Trigger
readsPrec :: Int -> ReadS Trigger
$creadList :: ReadS [Trigger]
readList :: ReadS [Trigger]
$creadPrec :: ReadPrec Trigger
readPrec :: ReadPrec Trigger
$creadListPrec :: ReadPrec [Trigger]
readListPrec :: ReadPrec [Trigger]
Read, Int -> Trigger -> String -> String
[Trigger] -> String -> String
Trigger -> String
(Int -> Trigger -> String -> String)
-> (Trigger -> String)
-> ([Trigger] -> String -> String)
-> Show Trigger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Trigger -> String -> String
showsPrec :: Int -> Trigger -> String -> String
$cshow :: Trigger -> String
show :: Trigger -> String
$cshowList :: [Trigger] -> String -> String
showList :: [Trigger] -> String -> String
Show)

data Node =
  Action ActionNode
  | Object ObjectNode
  | Decision DecisionNode
  | Merge MergeNode
  | Fork ForkNode
  | Join JoinNode
  | ActivityFinal ActivityFinalNode
  | FlowFinal FlowFinalNode
  | Initial InitialNode
  deriving (Node -> Node -> Bool
(Node -> Node -> Bool) -> (Node -> Node -> Bool) -> Eq Node
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Node -> Node -> Bool
== :: Node -> Node -> Bool
$c/= :: Node -> Node -> Bool
/= :: Node -> Node -> Bool
Eq, Eq Node
Eq Node
-> (Node -> Node -> Ordering)
-> (Node -> Node -> Bool)
-> (Node -> Node -> Bool)
-> (Node -> Node -> Bool)
-> (Node -> Node -> Bool)
-> (Node -> Node -> Node)
-> (Node -> Node -> Node)
-> Ord Node
Node -> Node -> Bool
Node -> Node -> Ordering
Node -> Node -> Node
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Node -> Node -> Ordering
compare :: Node -> Node -> Ordering
$c< :: Node -> Node -> Bool
< :: Node -> Node -> Bool
$c<= :: Node -> Node -> Bool
<= :: Node -> Node -> Bool
$c> :: Node -> Node -> Bool
> :: Node -> Node -> Bool
$c>= :: Node -> Node -> Bool
>= :: Node -> Node -> Bool
$cmax :: Node -> Node -> Node
max :: Node -> Node -> Node
$cmin :: Node -> Node -> Node
min :: Node -> Node -> Node
Ord, Int -> Node -> String -> String
[Node] -> String -> String
Node -> String
(Int -> Node -> String -> String)
-> (Node -> String) -> ([Node] -> String -> String) -> Show Node
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Node -> String -> String
showsPrec :: Int -> Node -> String -> String
$cshow :: Node -> String
show :: Node -> String
$cshowList :: [Node] -> String -> String
showList :: [Node] -> String -> String
Show)

data Nodes = Nodes {
  Nodes -> Set ActionNode
actionNodes  :: Set ActionNode,
  Nodes -> Set ObjectNode
objectNodes  :: Set ObjectNode,
  Nodes -> Set DecisionNode
decisionNodes  :: Set DecisionNode,
  Nodes -> Set MergeNode
mergeNodes  :: Set MergeNode,
  Nodes -> Set ForkNode
forkNodes  :: Set ForkNode,
  Nodes -> Set JoinNode
joinNodes  :: Set JoinNode,
  Nodes -> Set ActivityFinalNode
activityFinalNodes :: Set ActivityFinalNode,
  Nodes -> Set FlowFinalNode
flowFinalNodes :: Set FlowFinalNode,
  Nodes -> Set InitialNode
initialNodes :: Set InitialNode
} deriving Int -> Nodes -> String -> String
[Nodes] -> String -> String
Nodes -> String
(Int -> Nodes -> String -> String)
-> (Nodes -> String) -> ([Nodes] -> String -> String) -> Show Nodes
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Nodes -> String -> String
showsPrec :: Int -> Nodes -> String -> String
$cshow :: Nodes -> String
show :: Nodes -> String
$cshowList :: [Nodes] -> String -> String
showList :: [Nodes] -> String -> String
Show

toSet :: Nodes -> Set Node
toSet :: Nodes -> Set Node
toSet Nodes
ns = [Set Node] -> Set Node
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
S.unions [
  ActionNode -> Node
Action (ActionNode -> Node) -> Set ActionNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set ActionNode
actionNodes Nodes
ns,
  ObjectNode -> Node
Object (ObjectNode -> Node) -> Set ObjectNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set ObjectNode
objectNodes Nodes
ns,
  DecisionNode -> Node
Decision (DecisionNode -> Node) -> Set DecisionNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set DecisionNode
decisionNodes Nodes
ns,
  MergeNode -> Node
Merge (MergeNode -> Node) -> Set MergeNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set MergeNode
mergeNodes Nodes
ns,
  ForkNode -> Node
Fork (ForkNode -> Node) -> Set ForkNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set ForkNode
forkNodes Nodes
ns,
  JoinNode -> Node
Join (JoinNode -> Node) -> Set JoinNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set JoinNode
joinNodes Nodes
ns,
  ActivityFinalNode -> Node
ActivityFinal (ActivityFinalNode -> Node) -> Set ActivityFinalNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set ActivityFinalNode
activityFinalNodes Nodes
ns,
  FlowFinalNode -> Node
FlowFinal (FlowFinalNode -> Node) -> Set FlowFinalNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set FlowFinalNode
flowFinalNodes Nodes
ns,
  InitialNode -> Node
Initial (InitialNode -> Node) -> Set InitialNode -> Set Node
forall a b. (a -> b) -> Set a -> Set b
`S.mapMonotonic` Nodes -> Set InitialNode
initialNodes Nodes
ns
  ]

parseInstance
  :: MonadThrow m
  => AlloyInstance
  -> m UMLActivityDiagram
parseInstance :: forall (m :: * -> *).
MonadThrow m =>
AlloyInstance -> m UMLActivityDiagram
parseInstance AlloyInstance
alloyInstance = do
  let scope :: String
scope = String
"this"
  Set ActionNode
actionNodes <- String -> String -> (String -> ActionNode) -> m (Set ActionNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"ActionNodes" String -> ActionNode
ActionNode
  Set ObjectNode
objectNodes <- String -> String -> (String -> ObjectNode) -> m (Set ObjectNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scopeString
"ObjectNodes" String -> ObjectNode
ObjectNode
  Set DecisionNode
decisionNodes <- String
-> String -> (String -> DecisionNode) -> m (Set DecisionNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"DecisionNodes" String -> DecisionNode
DecisionNode
  Set MergeNode
mergeNodes <- String -> String -> (String -> MergeNode) -> m (Set MergeNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"MergeNodes" String -> MergeNode
MergeNode
  Set ForkNode
forkNodes <- String -> String -> (String -> ForkNode) -> m (Set ForkNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"ForkNodes" String -> ForkNode
ForkNode
  Set JoinNode
joinNodes <- String -> String -> (String -> JoinNode) -> m (Set JoinNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"JoinNodes" String -> JoinNode
JoinNode
  Set ActivityFinalNode
activityFinalNodes <- String
-> String
-> (String -> ActivityFinalNode)
-> m (Set ActivityFinalNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"ActivityFinalNodes" String -> ActivityFinalNode
ActivityFinalNode
  Set FlowFinalNode
flowFinalNodes <- String
-> String -> (String -> FlowFinalNode) -> m (Set FlowFinalNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scopeString
"FlowFinalNodes" String -> FlowFinalNode
FlowFinalNode
  Set InitialNode
initialNodes <- String -> String -> (String -> InitialNode) -> m (Set InitialNode)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope String
"InitialNodes" String -> InitialNode
InitialNode
  let nodes' :: Nodes
nodes' = Nodes {Set InitialNode
Set FlowFinalNode
Set ActivityFinalNode
Set JoinNode
Set ForkNode
Set MergeNode
Set DecisionNode
Set ObjectNode
Set ActionNode
actionNodes :: Set ActionNode
objectNodes :: Set ObjectNode
decisionNodes :: Set DecisionNode
mergeNodes :: Set MergeNode
forkNodes :: Set ForkNode
joinNodes :: Set JoinNode
activityFinalNodes :: Set ActivityFinalNode
flowFinalNodes :: Set FlowFinalNode
initialNodes :: Set InitialNode
actionNodes :: Set ActionNode
objectNodes :: Set ObjectNode
decisionNodes :: Set DecisionNode
mergeNodes :: Set MergeNode
forkNodes :: Set ForkNode
joinNodes :: Set JoinNode
activityFinalNodes :: Set ActivityFinalNode
flowFinalNodes :: Set FlowFinalNode
initialNodes :: Set InitialNode
..}
  Map Node ComponentName
componentNames <- [(Node, ComponentName)] -> Map Node ComponentName
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Node, ComponentName)] -> Map Node ComponentName)
-> (Set (Node, ComponentName) -> [(Node, ComponentName)])
-> Set (Node, ComponentName)
-> Map Node ComponentName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (Node, ComponentName) -> [(Node, ComponentName)]
forall a. Set a -> [a]
S.toAscList
    (Set (Node, ComponentName) -> Map Node ComponentName)
-> m (Set (Node, ComponentName)) -> m (Map Node ComponentName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> AlloyInstance
-> Nodes
-> String
-> (String -> ComponentName)
-> m (Set (Node, ComponentName))
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String
-> AlloyInstance
-> Nodes
-> String
-> (String -> a)
-> m (Set (Node, a))
getNames String
scope AlloyInstance
alloyInstance Nodes
nodes' String
"ActionObjectNodes" String -> ComponentName
ComponentName
  let components :: Set (Node, Int)
components = Set Node -> Set (Node, Int)
enumerateComponents (Set Node -> Set (Node, Int)) -> Set Node -> Set (Node, Int)
forall a b. (a -> b) -> a -> b
$ Nodes -> Set Node
toSet Nodes
nodes'
      names :: Map ComponentName String
names = [(ComponentName, String)] -> Map ComponentName String
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
        ([(ComponentName, String)] -> Map ComponentName String)
-> [(ComponentName, String)] -> Map ComponentName String
forall a b. (a -> b) -> a -> b
$ [ComponentName] -> [String] -> [(ComponentName, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip ([ComponentName] -> [ComponentName]
forall a. Ord a => [a] -> [a]
nubOrd ([ComponentName] -> [ComponentName])
-> [ComponentName] -> [ComponentName]
forall a b. (a -> b) -> a -> b
$ Map Node ComponentName -> [ComponentName]
forall k a. Map k a -> [a]
M.elems Map Node ComponentName
componentNames) ([String] -> [(ComponentName, String)])
-> [String] -> [(ComponentName, String)]
forall a b. (a -> b) -> a -> b
$ (Char -> String) -> String -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Char -> String
forall a. a -> [a]
singleton [Char
'A'..]
      getName :: Node -> String
getName Node
x = String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
"" (Maybe String -> String) -> Maybe String -> String
forall a b. (a -> b) -> a -> b
$ Node -> Map Node ComponentName -> Maybe ComponentName
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Node
x Map Node ComponentName
componentNames Maybe ComponentName
-> (ComponentName -> Maybe String) -> Maybe String
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ComponentName -> Map ComponentName String -> Maybe String
forall k a. Ord k => k -> Map k a -> Maybe a
`M.lookup` Map ComponentName String
names)
  Set (Node, Node, String)
conns <- String -> AlloyInstance -> Nodes -> m (Set (Node, Node, String))
forall (m :: * -> *).
MonadThrow m =>
String -> AlloyInstance -> Nodes -> m (Set (Node, Node, String))
getConnections String
scope AlloyInstance
alloyInstance Nodes
nodes'
  let labelOf :: Node -> Int
labelOf = Set (Node, Int) -> Node -> Int
getLabelOf Set (Node, Int)
components
      conns' :: Set (Int, Int, String)
conns' = ((Node, Node, String) -> (Int, Int, String))
-> Set (Node, Node, String) -> Set (Int, Int, String)
forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map (\(Node
x, Node
y, String
z) -> (Node -> Int
labelOf Node
x, Node -> Int
labelOf Node
y, String
z)) Set (Node, Node, String)
conns
      activityDiagram :: UMLActivityDiagram
activityDiagram = (Node -> String)
-> Set (Node, Int) -> Set (Int, Int, String) -> UMLActivityDiagram
setToActivityDiagram Node -> String
getName Set (Node, Int)
components Set (Int, Int, String)
conns'
  UMLActivityDiagram -> m UMLActivityDiagram
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return UMLActivityDiagram
activityDiagram
  where
    getAs
      :: (MonadThrow m, Ord a)
      => String
      -> String
      -> (String -> a)
      -> m (Set a)
    getAs :: forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> String -> (String -> a) -> m (Set a)
getAs String
scope = String -> AlloyInstance -> String -> (String -> a) -> m (Set a)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> AlloyInstance -> String -> (String -> a) -> m (Set a)
getX String
scope AlloyInstance
alloyInstance


enumerateComponents :: Set Node -> Set (Node, Int)
enumerateComponents :: Set Node -> Set (Node, Int)
enumerateComponents Set Node
s = [(Node, Int)] -> Set (Node, Int)
forall a. Eq a => [a] -> Set a
S.fromAscList ([(Node, Int)] -> Set (Node, Int))
-> [(Node, Int)] -> Set (Node, Int)
forall a b. (a -> b) -> a -> b
$ [Node] -> [Int] -> [(Node, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip (Set Node -> [Node]
forall a. Set a -> [a]
S.toAscList Set Node
s) [Int
1..]

getLabelOf :: Set (Node, Int) -> Node -> Int
getLabelOf :: Set (Node, Int) -> Node -> Int
getLabelOf Set (Node, Int)
s Node
n = Maybe Int -> Int
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Node -> Map Node Int -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Node
n ([(Node, Int)] -> Map Node Int
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Node, Int)] -> Map Node Int) -> [(Node, Int)] -> Map Node Int
forall a b. (a -> b) -> a -> b
$ Set (Node, Int) -> [(Node, Int)]
forall a. Set a -> [a]
S.toAscList Set (Node, Int)
s)

setToActivityDiagram
  :: (Node -> String)
  -> Set (Node, Int)
  -> Set (Int, Int, String)
  -> UMLActivityDiagram
setToActivityDiagram :: (Node -> String)
-> Set (Node, Int) -> Set (Int, Int, String) -> UMLActivityDiagram
setToActivityDiagram Node -> String
getName Set (Node, Int)
components Set (Int, Int, String)
conns = UMLActivityDiagram {
  nodes :: [AdNode]
nodes = ((Node, Int) -> AdNode) -> [(Node, Int)] -> [AdNode]
forall a b. (a -> b) -> [a] -> [b]
map ((Node -> String) -> (Node, Int) -> AdNode
convertToAdNode Node -> String
getName) (Set (Node, Int) -> [(Node, Int)]
forall a. Set a -> [a]
S.toAscList Set (Node, Int)
components),
  connections :: [AdConnection]
connections = ((Int, Int, String) -> AdConnection)
-> [(Int, Int, String)] -> [AdConnection]
forall a b. (a -> b) -> [a] -> [b]
map ((Int -> Int -> String -> AdConnection)
-> (Int, Int, String) -> AdConnection
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
uncurry3 Int -> Int -> String -> AdConnection
AdConnection) ([(Int, Int, String)] -> [AdConnection])
-> [(Int, Int, String)] -> [AdConnection]
forall a b. (a -> b) -> a -> b
$ Set (Int, Int, String) -> [(Int, Int, String)]
forall a. Set a -> [a]
S.toAscList Set (Int, Int, String)
conns
}

convertToAdNode :: (Node -> String) -> (Node, Int) -> AdNode
convertToAdNode :: (Node -> String) -> (Node, Int) -> AdNode
convertToAdNode Node -> String
getName (Node, Int)
tuple = case Node
node of
  Action {} -> AdActionNode {
    label :: Int
label = Int
l,
    name :: String
name = Node -> String
getName Node
node
    }
  Object {} -> AdObjectNode {
    label :: Int
label = Int
l,
    name :: String
name = Node -> String
getName Node
node
    }
  Decision {} -> AdDecisionNode {label :: Int
label = Int
l}
  Merge {} -> AdMergeNode {label :: Int
label = Int
l}
  Fork {} -> AdForkNode {label :: Int
label = Int
l}
  Join {} -> AdJoinNode {label :: Int
label = Int
l}
  ActivityFinal {} -> AdActivityFinalNode {label :: Int
label = Int
l}
  FlowFinal {} -> AdFlowFinalNode {label :: Int
label = Int
l}
  Initial {} -> AdInitialNode {label :: Int
label = Int
l}
  where
    node :: Node
node = (Node, Int) -> Node
forall a b. (a, b) -> a
fst (Node, Int)
tuple
    l :: Int
l = (Node, Int) -> Int
forall a b. (a, b) -> b
snd (Node, Int)
tuple


toX :: (String -> a) -> String -> Int -> a
toX :: forall a. (String -> a) -> String -> Int -> a
toX String -> a
f String
x = String -> a
f (String -> a) -> (Int -> String) -> Int -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
x String -> String -> String
forall a. [a] -> [a] -> [a]
++) (String -> String) -> (Int -> String) -> Int -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
'$'Char -> String -> String
forall a. a -> [a] -> [a]
:) (String -> String) -> (Int -> String) -> Int -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show

returnX :: Monad m => (String -> a) -> String -> Int -> m a
returnX :: forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> a
x String
y = a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> (Int -> a) -> Int -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> a) -> String -> Int -> a
forall a. (String -> a) -> String -> Int -> a
toX String -> a
x String
y

getX
  :: (MonadThrow m, Ord a)
  => String
  -> AlloyInstance
  -> String
  -> (String -> a)
  -> m (Set a)
getX :: forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> AlloyInstance -> String -> (String -> a) -> m (Set a)
getX String
scope AlloyInstance
alloyInstance String
n String -> a
f =
  Signature -> AlloyInstance -> m AlloySig
forall (m :: * -> *).
MonadThrow m =>
Signature -> AlloyInstance -> m AlloySig
lookupSig (String -> String -> Signature
scoped String
scope String
n) AlloyInstance
alloyInstance
  m AlloySig -> (AlloySig -> m (Set a)) -> m (Set a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> (String -> Int -> m a) -> AlloySig -> m (Set a)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> (String -> Int -> m a) -> AlloySig -> m (Set a)
getSingleAs String
"" ((String -> a) -> String -> Int -> m a
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> a
f)

getNames
  :: (MonadThrow m, Ord a)
  => String
  -> AlloyInstance
  -> Nodes
  -> String
  -> (String -> a)
  -> m (Set (Node, a))
getNames :: forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String
-> AlloyInstance
-> Nodes
-> String
-> (String -> a)
-> m (Set (Node, a))
getNames String
scope AlloyInstance
alloyInstance Nodes
ns String
n String -> a
f = do
  AlloySig
named <- Signature -> AlloyInstance -> m AlloySig
forall (m :: * -> *).
MonadThrow m =>
Signature -> AlloyInstance -> m AlloySig
lookupSig (String -> String -> Signature
scoped String
scope String
n) AlloyInstance
alloyInstance
  String
-> (String -> Int -> m Node)
-> (String -> Int -> m a)
-> AlloySig
-> m (Set (Node, a))
forall (m :: * -> *) a b.
(MonadThrow m, Ord a, Ord b) =>
String
-> (String -> Int -> m a)
-> (String -> Int -> m b)
-> AlloySig
-> m (Set (a, b))
getDoubleAs String
"name" (Nodes -> String -> Int -> m Node
forall (m :: * -> *).
MonadThrow m =>
Nodes -> String -> Int -> m Node
toNode Nodes
ns) ((String -> a) -> String -> Int -> m a
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> a
f) AlloySig
named

getConnections
  :: MonadThrow m
  => String
  -> AlloyInstance
  -> Nodes
  -> m (Set (Node, Node, String))
getConnections :: forall (m :: * -> *).
MonadThrow m =>
String -> AlloyInstance -> Nodes -> m (Set (Node, Node, String))
getConnections String
scope AlloyInstance
alloyInstance Nodes
ns = do
  AlloySig
guardNames  <- Signature -> AlloyInstance -> m AlloySig
forall (m :: * -> *).
MonadThrow m =>
Signature -> AlloyInstance -> m AlloySig
lookupSig (String -> String -> Signature
scoped String
scope String
"GuardNames") AlloyInstance
alloyInstance
  Set GuardName
triggers <-  String
-> (String -> Int -> m GuardName) -> AlloySig -> m (Set GuardName)
forall (m :: * -> *) a.
(MonadThrow m, Ord a) =>
String -> (String -> Int -> m a) -> AlloySig -> m (Set a)
getSingleAs String
"" ((String -> GuardName) -> String -> Int -> m GuardName
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> GuardName
GuardName) AlloySig
guardNames
  AlloySig
activityEdges  <- Signature -> AlloyInstance -> m AlloySig
forall (m :: * -> *).
MonadThrow m =>
Signature -> AlloyInstance -> m AlloySig
lookupSig (String -> String -> Signature
scoped String
scope String
"ActivityEdges") AlloyInstance
alloyInstance
  Set (Trigger, Node)
from <- String
-> (String -> Int -> m Trigger)
-> (String -> Int -> m Node)
-> AlloySig
-> m (Set (Trigger, Node))
forall (m :: * -> *) a b.
(MonadThrow m, Ord a, Ord b) =>
String
-> (String -> Int -> m a)
-> (String -> Int -> m b)
-> AlloySig
-> m (Set (a, b))
getDoubleAs
    String
"from"
    ((String -> Trigger) -> String -> Int -> m Trigger
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> Trigger
Trigger)
    (Nodes -> String -> Int -> m Node
forall (m :: * -> *).
MonadThrow m =>
Nodes -> String -> Int -> m Node
toNode Nodes
ns)
    AlloySig
activityEdges
  Map Trigger Node
to <- [(Trigger, Node)] -> Map Trigger Node
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Trigger, Node)] -> Map Trigger Node)
-> (Set (Trigger, Node) -> [(Trigger, Node)])
-> Set (Trigger, Node)
-> Map Trigger Node
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (Trigger, Node) -> [(Trigger, Node)]
forall a. Set a -> [a]
S.toAscList
    (Set (Trigger, Node) -> Map Trigger Node)
-> m (Set (Trigger, Node)) -> m (Map Trigger Node)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> (String -> Int -> m Trigger)
-> (String -> Int -> m Node)
-> AlloySig
-> m (Set (Trigger, Node))
forall (m :: * -> *) a b.
(MonadThrow m, Ord a, Ord b) =>
String
-> (String -> Int -> m a)
-> (String -> Int -> m b)
-> AlloySig
-> m (Set (a, b))
getDoubleAs String
"to" ((String -> Trigger) -> String -> Int -> m Trigger
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> Trigger
Trigger) (Nodes -> String -> Int -> m Node
forall (m :: * -> *).
MonadThrow m =>
Nodes -> String -> Int -> m Node
toNode Nodes
ns) AlloySig
activityEdges
  Map Trigger GuardName
label <- [(Trigger, GuardName)] -> Map Trigger GuardName
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Trigger, GuardName)] -> Map Trigger GuardName)
-> (Set (Trigger, GuardName) -> [(Trigger, GuardName)])
-> Set (Trigger, GuardName)
-> Map Trigger GuardName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (Trigger, GuardName) -> [(Trigger, GuardName)]
forall a. Set a -> [a]
S.toAscList (Set (Trigger, GuardName) -> [(Trigger, GuardName)])
-> (Set (Trigger, GuardName) -> Set (Trigger, GuardName))
-> Set (Trigger, GuardName)
-> [(Trigger, GuardName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Trigger, GuardName) -> GuardName)
-> Set GuardName
-> Set (Trigger, GuardName)
-> Set (Trigger, GuardName)
forall {b} {a}. Ord b => (a -> b) -> Set b -> Set a -> Set a
only (Trigger, GuardName) -> GuardName
forall a b. (a, b) -> b
snd Set GuardName
triggers
    (Set (Trigger, GuardName) -> Map Trigger GuardName)
-> m (Set (Trigger, GuardName)) -> m (Map Trigger GuardName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> (String -> Int -> m Trigger)
-> (String -> Int -> m GuardName)
-> AlloySig
-> m (Set (Trigger, GuardName))
forall (m :: * -> *) a b.
(MonadThrow m, Ord a, Ord b) =>
String
-> (String -> Int -> m a)
-> (String -> Int -> m b)
-> AlloySig
-> m (Set (a, b))
getDoubleAs
      String
"guard"
      ((String -> Trigger) -> String -> Int -> m Trigger
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> Trigger
Trigger)
      ((String -> GuardName) -> String -> Int -> m GuardName
forall (m :: * -> *) a.
Monad m =>
(String -> a) -> String -> Int -> m a
returnX String -> GuardName
GuardName)
      AlloySig
activityEdges
  let labelMap :: Map GuardName String
      labelMap :: Map GuardName String
labelMap = [(GuardName, String)] -> Map GuardName String
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(GuardName, String)] -> Map GuardName String)
-> ([String] -> [(GuardName, String)])
-> [String]
-> Map GuardName String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GuardName] -> [String] -> [(GuardName, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip (Set GuardName -> [GuardName]
forall a. Set a -> [a]
S.toAscList Set GuardName
triggers) ([String] -> Map GuardName String)
-> [String] -> Map GuardName String
forall a b. (a -> b) -> a -> b
$ (Char -> String) -> String -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Char -> String
forall a. a -> [a]
singleton [Char
'a'..]
  Set (Node, Node, String) -> m (Set (Node, Node, String))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Set (Node, Node, String) -> m (Set (Node, Node, String)))
-> Set (Node, Node, String) -> m (Set (Node, Node, String))
forall a b. (a -> b) -> a -> b
$ Map Trigger Node
-> Map Trigger GuardName
-> Map GuardName String
-> Set (Trigger, Node)
-> Set (Node, Node, String)
forall {a} {b} {k} {a}.
(Ord a, Ord b, Ord k, Ord a) =>
Map k b
-> Map k a -> Map a String -> Set (k, a) -> Set (a, b, String)
link Map Trigger Node
to Map Trigger GuardName
label Map GuardName String
labelMap Set (Trigger, Node)
from
  where
    only :: (a -> b) -> Set b -> Set a -> Set a
only a -> b
f Set b
xs = (a -> Bool) -> Set a -> Set a
forall a. (a -> Bool) -> Set a -> Set a
S.filter ((a -> Bool) -> Set a -> Set a) -> (a -> Bool) -> Set a -> Set a
forall a b. (a -> b) -> a -> b
$ (b -> Set b -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set b
xs) (b -> Bool) -> (a -> b) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f
    link :: Map k b
-> Map k a -> Map a String -> Set (k, a) -> Set (a, b, String)
link Map k b
to Map k a
lbs Map a String
lm = ((k, a) -> (a, b, String)) -> Set (k, a) -> Set (a, b, String)
forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map (((k, a) -> (a, b, String)) -> Set (k, a) -> Set (a, b, String))
-> ((k, a) -> (a, b, String)) -> Set (k, a) -> Set (a, b, String)
forall a b. (a -> b) -> a -> b
$ \(k
x, a
f) -> (
      a
f,
      Maybe b -> b
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe b -> b) -> Maybe b -> b
forall a b. (a -> b) -> a -> b
$ k -> Map k b -> Maybe b
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
x Map k b
to,
      String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
"" (Maybe String -> String) -> Maybe String -> String
forall a b. (a -> b) -> a -> b
$ k -> Map k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup k
x Map k a
lbs Maybe a -> (a -> Maybe String) -> Maybe String
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (a -> Map a String -> Maybe String
forall k a. Ord k => k -> Map k a -> Maybe a
`M.lookup` Map a String
lm)
      )

newtype ParsingActivityDiagramException
  = NodeHasUnknownNodeType String
  deriving Int -> ParsingActivityDiagramException -> String -> String
[ParsingActivityDiagramException] -> String -> String
ParsingActivityDiagramException -> String
(Int -> ParsingActivityDiagramException -> String -> String)
-> (ParsingActivityDiagramException -> String)
-> ([ParsingActivityDiagramException] -> String -> String)
-> Show ParsingActivityDiagramException
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ParsingActivityDiagramException -> String -> String
showsPrec :: Int -> ParsingActivityDiagramException -> String -> String
$cshow :: ParsingActivityDiagramException -> String
show :: ParsingActivityDiagramException -> String
$cshowList :: [ParsingActivityDiagramException] -> String -> String
showList :: [ParsingActivityDiagramException] -> String -> String
Show

instance Exception ParsingActivityDiagramException

toNode
  :: MonadThrow m
  => Nodes
  -> String
  -> Int
  -> m Node
toNode :: forall (m :: * -> *).
MonadThrow m =>
Nodes -> String -> Int -> m Node
toNode Nodes
ns String
x Int
i = (ActionNode -> Node)
-> (String -> ActionNode)
-> (Nodes -> Set ActionNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX ActionNode -> Node
Action String -> ActionNode
ActionNode Nodes -> Set ActionNode
actionNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (ObjectNode -> Node)
-> (String -> ObjectNode)
-> (Nodes -> Set ObjectNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX ObjectNode -> Node
Object String -> ObjectNode
ObjectNode Nodes -> Set ObjectNode
objectNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (DecisionNode -> Node)
-> (String -> DecisionNode)
-> (Nodes -> Set DecisionNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX DecisionNode -> Node
Decision String -> DecisionNode
DecisionNode Nodes -> Set DecisionNode
decisionNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (MergeNode -> Node)
-> (String -> MergeNode)
-> (Nodes -> Set MergeNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX MergeNode -> Node
Merge String -> MergeNode
MergeNode Nodes -> Set MergeNode
mergeNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (ForkNode -> Node)
-> (String -> ForkNode)
-> (Nodes -> Set ForkNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX ForkNode -> Node
Fork String -> ForkNode
ForkNode Nodes -> Set ForkNode
forkNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (JoinNode -> Node)
-> (String -> JoinNode)
-> (Nodes -> Set JoinNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX JoinNode -> Node
Join String -> JoinNode
JoinNode Nodes -> Set JoinNode
joinNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (ActivityFinalNode -> Node)
-> (String -> ActivityFinalNode)
-> (Nodes -> Set ActivityFinalNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX ActivityFinalNode -> Node
ActivityFinal String -> ActivityFinalNode
ActivityFinalNode Nodes -> Set ActivityFinalNode
activityFinalNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (FlowFinalNode -> Node)
-> (String -> FlowFinalNode)
-> (Nodes -> Set FlowFinalNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX FlowFinalNode -> Node
FlowFinal String -> FlowFinalNode
FlowFinalNode Nodes -> Set FlowFinalNode
flowFinalNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ (InitialNode -> Node)
-> (String -> InitialNode)
-> (Nodes -> Set InitialNode)
-> m Node
-> m Node
forall {t} {m :: * -> *} {a}.
(Ord t, Monad m) =>
(t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX InitialNode -> Node
Initial String -> InitialNode
InitialNode Nodes -> Set InitialNode
initialNodes
  (m Node -> m Node) -> m Node -> m Node
forall a b. (a -> b) -> a -> b
$ ParsingActivityDiagramException -> m Node
forall e a. Exception e => e -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (ParsingActivityDiagramException -> m Node)
-> ParsingActivityDiagramException -> m Node
forall a b. (a -> b) -> a -> b
$ String -> ParsingActivityDiagramException
NodeHasUnknownNodeType (String -> ParsingActivityDiagramException)
-> String -> ParsingActivityDiagramException
forall a b. (a -> b) -> a -> b
$ String
"x$" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i
  where
    ifX :: (t -> a) -> (String -> t) -> (Nodes -> Set t) -> m a -> m a
ifX t -> a
f String -> t
g Nodes -> Set t
which m a
h =
      let node :: t
node = (String -> t) -> String -> Int -> t
forall a. (String -> a) -> String -> Int -> a
toX String -> t
g String
x Int
i
      in if t
node t -> Set t -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Nodes -> Set t
which Nodes
ns
         then a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> a -> m a
forall a b. (a -> b) -> a -> b
$ t -> a
f t
node
         else m a
h