{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}

module Modelling.ActivityDiagram.FindAuxiliaryPetriNodes (
  FindAuxiliaryPetriNodesConfig (..),
  FindAuxiliaryPetriNodesInstance (..),
  FindAuxiliaryPetriNodesSolution (..),
  checkFindAuxiliaryPetriNodesConfig,
  defaultFindAuxiliaryPetriNodesConfig,
  defaultFindAuxiliaryPetriNodesInstance,
  findAuxiliaryPetriNodes,
  findAuxiliaryPetriNodesAlloy,
  findAuxiliaryPetriNodesEvaluation,
  findAuxiliaryPetriNodesInitial,
  findAuxiliaryPetriNodesSolution,
  findAuxiliaryPetriNodesTask,
) where

import qualified Modelling.PetriNet.Types as Petri (Net (nodes))

import qualified Data.Map as M (
  filter,
  filterWithKey,
  fromList,
  keys,
  size,
  )

import Capabilities.Alloy               (MonadAlloy, getInstances)
import Capabilities.PlantUml            (MonadPlantUml)
import Capabilities.WriteFile           (MonadWriteFile)
import Modelling.ActivityDiagram.Alloy (
  adConfigToAlloy,
  modulePetriNet,
  )
import Modelling.ActivityDiagram.Auxiliary.PetriValidation (
  validateBasePetriConfig,
  )
import Modelling.ActivityDiagram.Auxiliary.Util (finalNodesAdvice)
import Modelling.ActivityDiagram.Datatype (
  AdConnection (..),
  AdNode (..),
  UMLActivityDiagram (..),
  )
import Modelling.ActivityDiagram.PetriNet (
  PetriKey(..),
  convertToPetriNet,
  convertToSimple,
  isAuxiliaryPetriNode,
  )
import Modelling.ActivityDiagram.Shuffle (shuffleAdNames)
import Modelling.ActivityDiagram.Config (
  AdConfig (..),
  checkAdConfig,
  defaultAdConfig,
  )
import Modelling.ActivityDiagram.Instance (parseInstance)
import Modelling.ActivityDiagram.PlantUMLConverter (
  PlantUmlConfig (..),
  defaultPlantUmlConfig,
  drawAdToFile,
  )
import Modelling.Auxiliary.Common       (getFirstInstance)
import Modelling.Auxiliary.Output (
  addPretext,
  extra
  )
import Modelling.PetriNet.Types (
  checkPetriNodeCount,
  Net (..),
  PetriLike (..),
  PetriNode (..),
  SimpleNode,
  SimplePetriLike,
  isPlaceNode,
  isTransitionNode,
  )

import Control.Applicative (Alternative ((<|>)))
import Control.Monad.Catch              (MonadThrow)
import Control.OutputCapable.Blocks (
  ArticleToUse (DefiniteArticle),
  GenericOutputCapable (..),
  LangM,
  Language,
  OutputCapable,
  Rated,
  ($=<<),
  english,
  german,
  translate,
  translations,
  multipleChoice,
  )
import Control.Monad.Random (
  RandT,
  RandomGen,
  evalRandT,
  mkStdGen
  )
import Data.Map (Map)
import Data.String.Interpolate (i, iii)
import GHC.Generics (Generic)
import System.Random.Shuffle (shuffleM)

data FindAuxiliaryPetriNodesInstance = FindAuxiliaryPetriNodesInstance {
  FindAuxiliaryPetriNodesInstance -> UMLActivityDiagram
activityDiagram :: UMLActivityDiagram,
  FindAuxiliaryPetriNodesInstance -> SimplePetriLike PetriKey
matchingNet :: SimplePetriLike PetriKey,
  FindAuxiliaryPetriNodesInstance -> PlantUmlConfig
plantUMLConf :: PlantUmlConfig,
  FindAuxiliaryPetriNodesInstance -> Bool
showSolution :: Bool,
  FindAuxiliaryPetriNodesInstance -> Maybe (Map Language String)
addText :: Maybe (Map Language String)
} deriving ((forall x.
 FindAuxiliaryPetriNodesInstance
 -> Rep FindAuxiliaryPetriNodesInstance x)
-> (forall x.
    Rep FindAuxiliaryPetriNodesInstance x
    -> FindAuxiliaryPetriNodesInstance)
-> Generic FindAuxiliaryPetriNodesInstance
forall x.
Rep FindAuxiliaryPetriNodesInstance x
-> FindAuxiliaryPetriNodesInstance
forall x.
FindAuxiliaryPetriNodesInstance
-> Rep FindAuxiliaryPetriNodesInstance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
FindAuxiliaryPetriNodesInstance
-> Rep FindAuxiliaryPetriNodesInstance x
from :: forall x.
FindAuxiliaryPetriNodesInstance
-> Rep FindAuxiliaryPetriNodesInstance x
$cto :: forall x.
Rep FindAuxiliaryPetriNodesInstance x
-> FindAuxiliaryPetriNodesInstance
to :: forall x.
Rep FindAuxiliaryPetriNodesInstance x
-> FindAuxiliaryPetriNodesInstance
Generic, ReadPrec [FindAuxiliaryPetriNodesInstance]
ReadPrec FindAuxiliaryPetriNodesInstance
Int -> ReadS FindAuxiliaryPetriNodesInstance
ReadS [FindAuxiliaryPetriNodesInstance]
(Int -> ReadS FindAuxiliaryPetriNodesInstance)
-> ReadS [FindAuxiliaryPetriNodesInstance]
-> ReadPrec FindAuxiliaryPetriNodesInstance
-> ReadPrec [FindAuxiliaryPetriNodesInstance]
-> Read FindAuxiliaryPetriNodesInstance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FindAuxiliaryPetriNodesInstance
readsPrec :: Int -> ReadS FindAuxiliaryPetriNodesInstance
$creadList :: ReadS [FindAuxiliaryPetriNodesInstance]
readList :: ReadS [FindAuxiliaryPetriNodesInstance]
$creadPrec :: ReadPrec FindAuxiliaryPetriNodesInstance
readPrec :: ReadPrec FindAuxiliaryPetriNodesInstance
$creadListPrec :: ReadPrec [FindAuxiliaryPetriNodesInstance]
readListPrec :: ReadPrec [FindAuxiliaryPetriNodesInstance]
Read, Int -> FindAuxiliaryPetriNodesInstance -> ShowS
[FindAuxiliaryPetriNodesInstance] -> ShowS
FindAuxiliaryPetriNodesInstance -> String
(Int -> FindAuxiliaryPetriNodesInstance -> ShowS)
-> (FindAuxiliaryPetriNodesInstance -> String)
-> ([FindAuxiliaryPetriNodesInstance] -> ShowS)
-> Show FindAuxiliaryPetriNodesInstance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FindAuxiliaryPetriNodesInstance -> ShowS
showsPrec :: Int -> FindAuxiliaryPetriNodesInstance -> ShowS
$cshow :: FindAuxiliaryPetriNodesInstance -> String
show :: FindAuxiliaryPetriNodesInstance -> String
$cshowList :: [FindAuxiliaryPetriNodesInstance] -> ShowS
showList :: [FindAuxiliaryPetriNodesInstance] -> ShowS
Show)

data FindAuxiliaryPetriNodesConfig = FindAuxiliaryPetriNodesConfig {
  FindAuxiliaryPetriNodesConfig -> AdConfig
adConfig :: AdConfig,
  -- | generate only activity diagrams with a corresponding Petri net
  -- having a total count of nodes within the given bounds
  FindAuxiliaryPetriNodesConfig -> (Int, Maybe Int)
countOfPetriNodesBounds :: !(Int, Maybe Int),
  FindAuxiliaryPetriNodesConfig -> Maybe Integer
maxInstances :: Maybe Integer,
  FindAuxiliaryPetriNodesConfig -> Bool
hideNodeNames :: Bool,
  FindAuxiliaryPetriNodesConfig -> Bool
hideBranchConditions :: Bool,
  -- | Force presence or absence of new sink transitions for representing finals
  FindAuxiliaryPetriNodesConfig -> Maybe Bool
presenceOfSinkTransitionsForFinals :: Maybe Bool,
  FindAuxiliaryPetriNodesConfig -> Bool
printSolution :: Bool,
  FindAuxiliaryPetriNodesConfig -> Maybe (Map Language String)
extraText :: Maybe (Map Language String)
} deriving ((forall x.
 FindAuxiliaryPetriNodesConfig
 -> Rep FindAuxiliaryPetriNodesConfig x)
-> (forall x.
    Rep FindAuxiliaryPetriNodesConfig x
    -> FindAuxiliaryPetriNodesConfig)
-> Generic FindAuxiliaryPetriNodesConfig
forall x.
Rep FindAuxiliaryPetriNodesConfig x
-> FindAuxiliaryPetriNodesConfig
forall x.
FindAuxiliaryPetriNodesConfig
-> Rep FindAuxiliaryPetriNodesConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
FindAuxiliaryPetriNodesConfig
-> Rep FindAuxiliaryPetriNodesConfig x
from :: forall x.
FindAuxiliaryPetriNodesConfig
-> Rep FindAuxiliaryPetriNodesConfig x
$cto :: forall x.
Rep FindAuxiliaryPetriNodesConfig x
-> FindAuxiliaryPetriNodesConfig
to :: forall x.
Rep FindAuxiliaryPetriNodesConfig x
-> FindAuxiliaryPetriNodesConfig
Generic, ReadPrec [FindAuxiliaryPetriNodesConfig]
ReadPrec FindAuxiliaryPetriNodesConfig
Int -> ReadS FindAuxiliaryPetriNodesConfig
ReadS [FindAuxiliaryPetriNodesConfig]
(Int -> ReadS FindAuxiliaryPetriNodesConfig)
-> ReadS [FindAuxiliaryPetriNodesConfig]
-> ReadPrec FindAuxiliaryPetriNodesConfig
-> ReadPrec [FindAuxiliaryPetriNodesConfig]
-> Read FindAuxiliaryPetriNodesConfig
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FindAuxiliaryPetriNodesConfig
readsPrec :: Int -> ReadS FindAuxiliaryPetriNodesConfig
$creadList :: ReadS [FindAuxiliaryPetriNodesConfig]
readList :: ReadS [FindAuxiliaryPetriNodesConfig]
$creadPrec :: ReadPrec FindAuxiliaryPetriNodesConfig
readPrec :: ReadPrec FindAuxiliaryPetriNodesConfig
$creadListPrec :: ReadPrec [FindAuxiliaryPetriNodesConfig]
readListPrec :: ReadPrec [FindAuxiliaryPetriNodesConfig]
Read, Int -> FindAuxiliaryPetriNodesConfig -> ShowS
[FindAuxiliaryPetriNodesConfig] -> ShowS
FindAuxiliaryPetriNodesConfig -> String
(Int -> FindAuxiliaryPetriNodesConfig -> ShowS)
-> (FindAuxiliaryPetriNodesConfig -> String)
-> ([FindAuxiliaryPetriNodesConfig] -> ShowS)
-> Show FindAuxiliaryPetriNodesConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FindAuxiliaryPetriNodesConfig -> ShowS
showsPrec :: Int -> FindAuxiliaryPetriNodesConfig -> ShowS
$cshow :: FindAuxiliaryPetriNodesConfig -> String
show :: FindAuxiliaryPetriNodesConfig -> String
$cshowList :: [FindAuxiliaryPetriNodesConfig] -> ShowS
showList :: [FindAuxiliaryPetriNodesConfig] -> ShowS
Show)

defaultFindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig
defaultFindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig
defaultFindAuxiliaryPetriNodesConfig =
  FindAuxiliaryPetriNodesConfig {
    $sel:adConfig:FindAuxiliaryPetriNodesConfig :: AdConfig
adConfig = AdConfig
defaultAdConfig {activityFinalNodes :: Int
activityFinalNodes = Int
0, flowFinalNodes :: Int
flowFinalNodes = Int
2},
    $sel:countOfPetriNodesBounds:FindAuxiliaryPetriNodesConfig :: (Int, Maybe Int)
countOfPetriNodesBounds = (Int
0, Maybe Int
forall a. Maybe a
Nothing),
    $sel:maxInstances:FindAuxiliaryPetriNodesConfig :: Maybe Integer
maxInstances = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
50,
    $sel:hideNodeNames:FindAuxiliaryPetriNodesConfig :: Bool
hideNodeNames = Bool
False,
    $sel:hideBranchConditions:FindAuxiliaryPetriNodesConfig :: Bool
hideBranchConditions = Bool
False,
    $sel:presenceOfSinkTransitionsForFinals:FindAuxiliaryPetriNodesConfig :: Maybe Bool
presenceOfSinkTransitionsForFinals = Maybe Bool
forall a. Maybe a
Nothing,
    $sel:printSolution:FindAuxiliaryPetriNodesConfig :: Bool
printSolution = Bool
False,
    $sel:extraText:FindAuxiliaryPetriNodesConfig :: Maybe (Map Language String)
extraText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }

checkFindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe String
checkFindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe String
checkFindAuxiliaryPetriNodesConfig FindAuxiliaryPetriNodesConfig
conf =
  AdConfig -> Maybe String
checkAdConfig (FindAuxiliaryPetriNodesConfig -> AdConfig
adConfig FindAuxiliaryPetriNodesConfig
conf)
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FindAuxiliaryPetriNodesConfig -> Maybe String
findAuxiliaryPetriNodesConfig' FindAuxiliaryPetriNodesConfig
conf

findAuxiliaryPetriNodesConfig' :: FindAuxiliaryPetriNodesConfig -> Maybe String
findAuxiliaryPetriNodesConfig' :: FindAuxiliaryPetriNodesConfig -> Maybe String
findAuxiliaryPetriNodesConfig' FindAuxiliaryPetriNodesConfig {
    AdConfig
$sel:adConfig:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> AdConfig
adConfig :: AdConfig
adConfig,
    (Int, Maybe Int)
$sel:countOfPetriNodesBounds:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> (Int, Maybe Int)
countOfPetriNodesBounds :: (Int, Maybe Int)
countOfPetriNodesBounds,
    Maybe Integer
$sel:maxInstances:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe Integer
maxInstances :: Maybe Integer
maxInstances,
    Maybe Bool
$sel:presenceOfSinkTransitionsForFinals:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe Bool
presenceOfSinkTransitionsForFinals :: Maybe Bool
presenceOfSinkTransitionsForFinals
  } = AdConfig
-> (Int, Maybe Int) -> Maybe Integer -> Maybe Bool -> Maybe String
validateBasePetriConfig AdConfig
adConfig (Int, Maybe Int)
countOfPetriNodesBounds Maybe Integer
maxInstances Maybe Bool
presenceOfSinkTransitionsForFinals

findAuxiliaryPetriNodesAlloy :: FindAuxiliaryPetriNodesConfig -> String
findAuxiliaryPetriNodesAlloy :: FindAuxiliaryPetriNodesConfig -> String
findAuxiliaryPetriNodesAlloy FindAuxiliaryPetriNodesConfig {
  AdConfig
$sel:adConfig:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> AdConfig
adConfig :: AdConfig
adConfig,
  Maybe Bool
$sel:presenceOfSinkTransitionsForFinals:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe Bool
presenceOfSinkTransitionsForFinals :: Maybe Bool
presenceOfSinkTransitionsForFinals
}
  = String -> String -> AdConfig -> String
adConfigToAlloy String
modules String
predicates AdConfig
adConfig
  where
    activityFinalsExist :: Maybe Bool
activityFinalsExist = Bool -> Maybe Bool
forall a. a -> Maybe a
Just (AdConfig -> Int
activityFinalNodes AdConfig
adConfig Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0)
    modules :: String
modules = String
modulePetriNet
    predicates :: String
predicates =
          [i|
            not auxiliaryPetriNodeAbsent
            #{f activityFinalsExist "activityFinalsExist"}
            #{f (not <$> presenceOfSinkTransitionsForFinals) "avoidAddingSinksForFinals"}
          |]
    f :: Maybe Bool -> ShowS
f Maybe Bool
opt String
s =
          case Maybe Bool
opt of
            Just Bool
True -> String
s
            Just Bool
False -> [i| not #{s}|]
            Maybe Bool
Nothing -> String
""

data FindAuxiliaryPetriNodesSolution = FindAuxiliaryPetriNodesSolution {
  FindAuxiliaryPetriNodesSolution -> Int
countOfNonAuxiliaryNodes :: Int,
  FindAuxiliaryPetriNodesSolution -> Int
countOfAuxiliaryPlaces :: Int,
  FindAuxiliaryPetriNodesSolution -> Int
countOfAuxiliaryTransitions :: Int
} deriving ((forall x.
 FindAuxiliaryPetriNodesSolution
 -> Rep FindAuxiliaryPetriNodesSolution x)
-> (forall x.
    Rep FindAuxiliaryPetriNodesSolution x
    -> FindAuxiliaryPetriNodesSolution)
-> Generic FindAuxiliaryPetriNodesSolution
forall x.
Rep FindAuxiliaryPetriNodesSolution x
-> FindAuxiliaryPetriNodesSolution
forall x.
FindAuxiliaryPetriNodesSolution
-> Rep FindAuxiliaryPetriNodesSolution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
FindAuxiliaryPetriNodesSolution
-> Rep FindAuxiliaryPetriNodesSolution x
from :: forall x.
FindAuxiliaryPetriNodesSolution
-> Rep FindAuxiliaryPetriNodesSolution x
$cto :: forall x.
Rep FindAuxiliaryPetriNodesSolution x
-> FindAuxiliaryPetriNodesSolution
to :: forall x.
Rep FindAuxiliaryPetriNodesSolution x
-> FindAuxiliaryPetriNodesSolution
Generic, Int -> FindAuxiliaryPetriNodesSolution -> ShowS
[FindAuxiliaryPetriNodesSolution] -> ShowS
FindAuxiliaryPetriNodesSolution -> String
(Int -> FindAuxiliaryPetriNodesSolution -> ShowS)
-> (FindAuxiliaryPetriNodesSolution -> String)
-> ([FindAuxiliaryPetriNodesSolution] -> ShowS)
-> Show FindAuxiliaryPetriNodesSolution
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FindAuxiliaryPetriNodesSolution -> ShowS
showsPrec :: Int -> FindAuxiliaryPetriNodesSolution -> ShowS
$cshow :: FindAuxiliaryPetriNodesSolution -> String
show :: FindAuxiliaryPetriNodesSolution -> String
$cshowList :: [FindAuxiliaryPetriNodesSolution] -> ShowS
showList :: [FindAuxiliaryPetriNodesSolution] -> ShowS
Show, FindAuxiliaryPetriNodesSolution
-> FindAuxiliaryPetriNodesSolution -> Bool
(FindAuxiliaryPetriNodesSolution
 -> FindAuxiliaryPetriNodesSolution -> Bool)
-> (FindAuxiliaryPetriNodesSolution
    -> FindAuxiliaryPetriNodesSolution -> Bool)
-> Eq FindAuxiliaryPetriNodesSolution
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FindAuxiliaryPetriNodesSolution
-> FindAuxiliaryPetriNodesSolution -> Bool
== :: FindAuxiliaryPetriNodesSolution
-> FindAuxiliaryPetriNodesSolution -> Bool
$c/= :: FindAuxiliaryPetriNodesSolution
-> FindAuxiliaryPetriNodesSolution -> Bool
/= :: FindAuxiliaryPetriNodesSolution
-> FindAuxiliaryPetriNodesSolution -> Bool
Eq, ReadPrec [FindAuxiliaryPetriNodesSolution]
ReadPrec FindAuxiliaryPetriNodesSolution
Int -> ReadS FindAuxiliaryPetriNodesSolution
ReadS [FindAuxiliaryPetriNodesSolution]
(Int -> ReadS FindAuxiliaryPetriNodesSolution)
-> ReadS [FindAuxiliaryPetriNodesSolution]
-> ReadPrec FindAuxiliaryPetriNodesSolution
-> ReadPrec [FindAuxiliaryPetriNodesSolution]
-> Read FindAuxiliaryPetriNodesSolution
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FindAuxiliaryPetriNodesSolution
readsPrec :: Int -> ReadS FindAuxiliaryPetriNodesSolution
$creadList :: ReadS [FindAuxiliaryPetriNodesSolution]
readList :: ReadS [FindAuxiliaryPetriNodesSolution]
$creadPrec :: ReadPrec FindAuxiliaryPetriNodesSolution
readPrec :: ReadPrec FindAuxiliaryPetriNodesSolution
$creadListPrec :: ReadPrec [FindAuxiliaryPetriNodesSolution]
readListPrec :: ReadPrec [FindAuxiliaryPetriNodesSolution]
Read)

findAuxiliaryPetriNodesSolution
  :: FindAuxiliaryPetriNodesInstance
  -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution :: FindAuxiliaryPetriNodesInstance -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution FindAuxiliaryPetriNodesInstance
task =
  SimplePetriLike PetriKey -> FindAuxiliaryPetriNodesSolution
forall (p :: (* -> *) -> * -> *) (n :: * -> *).
Net p n =>
p n PetriKey -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution' (SimplePetriLike PetriKey -> FindAuxiliaryPetriNodesSolution)
-> SimplePetriLike PetriKey -> FindAuxiliaryPetriNodesSolution
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesInstance -> SimplePetriLike PetriKey
matchingNet FindAuxiliaryPetriNodesInstance
task

findAuxiliaryPetriNodesSolution'
  :: Net p n
  => p n PetriKey
  -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution' :: forall (p :: (* -> *) -> * -> *) (n :: * -> *).
Net p n =>
p n PetriKey -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution' p n PetriKey
petri = FindAuxiliaryPetriNodesSolution {
    $sel:countOfNonAuxiliaryNodes:FindAuxiliaryPetriNodesSolution :: Int
countOfNonAuxiliaryNodes = Int
totalNodes Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
auxiliaryPlacesCount Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
auxiliaryTransitionsCount,
    $sel:countOfAuxiliaryPlaces:FindAuxiliaryPetriNodesSolution :: Int
countOfAuxiliaryPlaces = Int
auxiliaryPlacesCount,
    $sel:countOfAuxiliaryTransitions:FindAuxiliaryPetriNodesSolution :: Int
countOfAuxiliaryTransitions = Int
auxiliaryTransitionsCount
  }
  where
    totalNodes :: Int
totalNodes = Map PetriKey (n PetriKey) -> Int
forall k a. Map k a -> Int
M.size (Map PetriKey (n PetriKey) -> Int)
-> Map PetriKey (n PetriKey) -> Int
forall a b. (a -> b) -> a -> b
$ p n PetriKey -> Map PetriKey (n PetriKey)
forall a. Ord a => p n a -> Map a (n a)
forall (p :: (* -> *) -> * -> *) (n :: * -> *) a.
(Net p n, Ord a) =>
p n a -> Map a (n a)
Petri.nodes p n PetriKey
petri
    auxiliaryPetriNodeMap :: Map PetriKey (n PetriKey)
auxiliaryPetriNodeMap = (PetriKey -> n PetriKey -> Bool)
-> Map PetriKey (n PetriKey) -> Map PetriKey (n PetriKey)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
M.filterWithKey
      (Bool -> n PetriKey -> Bool
forall a b. a -> b -> a
const (Bool -> n PetriKey -> Bool)
-> (PetriKey -> Bool) -> PetriKey -> n PetriKey -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PetriKey -> Bool
isAuxiliaryPetriNode)
      (Map PetriKey (n PetriKey) -> Map PetriKey (n PetriKey))
-> Map PetriKey (n PetriKey) -> Map PetriKey (n PetriKey)
forall a b. (a -> b) -> a -> b
$ p n PetriKey -> Map PetriKey (n PetriKey)
forall a. Ord a => p n a -> Map a (n a)
forall (p :: (* -> *) -> * -> *) (n :: * -> *) a.
(Net p n, Ord a) =>
p n a -> Map a (n a)
Petri.nodes p n PetriKey
petri
    auxiliaryPlacesCount :: Int
auxiliaryPlacesCount = Map PetriKey (n PetriKey) -> Int
forall k a. Map k a -> Int
M.size (Map PetriKey (n PetriKey) -> Int)
-> Map PetriKey (n PetriKey) -> Int
forall a b. (a -> b) -> a -> b
$ (n PetriKey -> Bool)
-> Map PetriKey (n PetriKey) -> Map PetriKey (n PetriKey)
forall a k. (a -> Bool) -> Map k a -> Map k a
M.filter n PetriKey -> Bool
forall a. n a -> Bool
forall (n :: * -> *) a. PetriNode n => n a -> Bool
isPlaceNode Map PetriKey (n PetriKey)
auxiliaryPetriNodeMap
    auxiliaryTransitionsCount :: Int
auxiliaryTransitionsCount = Map PetriKey (n PetriKey) -> Int
forall k a. Map k a -> Int
M.size (Map PetriKey (n PetriKey) -> Int)
-> Map PetriKey (n PetriKey) -> Int
forall a b. (a -> b) -> a -> b
$ (n PetriKey -> Bool)
-> Map PetriKey (n PetriKey) -> Map PetriKey (n PetriKey)
forall a k. (a -> Bool) -> Map k a -> Map k a
M.filter n PetriKey -> Bool
forall a. n a -> Bool
forall (n :: * -> *) a. PetriNode n => n a -> Bool
isTransitionNode Map PetriKey (n PetriKey)
auxiliaryPetriNodeMap

findAuxiliaryPetriNodesTask
  :: (MonadPlantUml m, MonadWriteFile m, OutputCapable m)
  => FilePath
  -> FindAuxiliaryPetriNodesInstance
  -> LangM m
findAuxiliaryPetriNodesTask :: forall (m :: * -> *).
(MonadPlantUml m, MonadWriteFile m, OutputCapable m) =>
String -> FindAuxiliaryPetriNodesInstance -> LangM m
findAuxiliaryPetriNodesTask String
path FindAuxiliaryPetriNodesInstance
task = do
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
    String -> State (Map Language String) ()
english String
"Consider the following activity diagram:"
    String -> State (Map Language String) ()
german String
"Betrachten Sie folgendes Aktivitätsdiagramm:"
  String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
image (String -> LangM m) -> m String -> LangM m
forall (m :: * -> *) a l b.
Monad m =>
(a -> GenericLangM l m b) -> m a -> GenericLangM l m b
$=<< String -> PlantUmlConfig -> UMLActivityDiagram -> m String
forall (m :: * -> *).
(MonadPlantUml m, MonadWriteFile m) =>
String -> PlantUmlConfig -> UMLActivityDiagram -> m String
drawAdToFile String
path (FindAuxiliaryPetriNodesInstance -> PlantUmlConfig
plantUMLConf FindAuxiliaryPetriNodesInstance
task) (UMLActivityDiagram -> m String) -> UMLActivityDiagram -> m String
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesInstance -> UMLActivityDiagram
activityDiagram FindAuxiliaryPetriNodesInstance
task
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
    String -> State (Map Language String) ()
english [iii|Translate the given activity diagram into a Petri net (on paper or in your head) and then state the total count of non-auxiliary nodes
(places and transitions minus auxiliary places and auxiliary transitions), the count of auxiliary places and the count of auxiliary transitions in the net.|]
    String -> State (Map Language String) ()
german [iii|Übersetzen Sie das gegebene Aktivitätsdiagramm in ein Petrinetz (auf dem Papier oder in Ihrem Kopf) und geben Sie dann die Gesamtanzahl
an Nicht-Hilfsknoten (Stellen und Transitionen minus Hilfsstellen und Hilfstransitionen), die Anzahl der Hilfsstellen und die Anzahl der Hilfstransitionen des Netzes an.|]
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ do
    State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
      String -> State (Map Language String) ()
english [i|To do this, enter your answer as in the following example:|]
      String -> State (Map Language String) ()
german [i|Geben Sie dazu Ihre Antwort wie im folgenden Beispiel an:|]
    String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
code (String -> LangM m) -> String -> LangM m
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesSolution -> String
forall a. Show a => a -> String
show FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesInitial
    State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
      String -> State (Map Language String) ()
english [iii|In this example, the resulting net contains 5 non-auxiliary nodes
(namely, 10 total nodes minus 2 auxiliary places minus 3 auxiliary transitions), plus
2 auxiliary places and 3 auxiliary transitions.|]
      String -> State (Map Language String) ()
german [iii|In diesem Beispiel etwa enthält das entstehende Netz 5 Nicht-Hilfsknoten
(nämlich 10 Knoten insgesamt minus 2 Hilfsstellen minus 3 Hilfstransitionen),
dazu 2 Hilfsstellen und 3 Hilfstransitionen.|]
    pure ()
  Bool -> LangM m
forall (m :: * -> *). OutputCapable m => Bool -> LangM m
finalNodesAdvice Bool
True

  Maybe (Map Language String) -> LangM m
forall (m :: * -> *).
OutputCapable m =>
Maybe (Map Language String) -> LangM m
extra (Maybe (Map Language String) -> LangM m)
-> Maybe (Map Language String) -> LangM m
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesInstance -> Maybe (Map Language String)
addText FindAuxiliaryPetriNodesInstance
task

  pure ()

findAuxiliaryPetriNodesInitial :: FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesInitial :: FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesInitial = FindAuxiliaryPetriNodesSolution {
  $sel:countOfNonAuxiliaryNodes:FindAuxiliaryPetriNodesSolution :: Int
countOfNonAuxiliaryNodes = Int
5,
  $sel:countOfAuxiliaryPlaces:FindAuxiliaryPetriNodesSolution :: Int
countOfAuxiliaryPlaces = Int
2,
  $sel:countOfAuxiliaryTransitions:FindAuxiliaryPetriNodesSolution :: Int
countOfAuxiliaryTransitions = Int
3
}

findAuxiliaryPetriNodesEvaluation
  :: OutputCapable m
  => FindAuxiliaryPetriNodesInstance
  -> FindAuxiliaryPetriNodesSolution
  -> Rated m
findAuxiliaryPetriNodesEvaluation :: forall (m :: * -> *).
OutputCapable m =>
FindAuxiliaryPetriNodesInstance
-> FindAuxiliaryPetriNodesSolution -> Rated m
findAuxiliaryPetriNodesEvaluation FindAuxiliaryPetriNodesInstance
task FindAuxiliaryPetriNodesSolution
sub = LangM' m Rational -> LangM' m Rational
forall (m :: * -> *) a. OutputCapable m => LangM' m a -> LangM' m a
addPretext (LangM' m Rational -> LangM' m Rational)
-> LangM' m Rational -> LangM' m Rational
forall a b. (a -> b) -> a -> b
$ do
  let as :: Map Language String
as = State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
        String -> State (Map Language String) ()
english String
"answer parts"
        String -> State (Map Language String) ()
german String
"Teilantworten"
      sol :: FindAuxiliaryPetriNodesSolution
sol = FindAuxiliaryPetriNodesInstance -> FindAuxiliaryPetriNodesSolution
findAuxiliaryPetriNodesSolution FindAuxiliaryPetriNodesInstance
task
      solution :: Map (Int, Int) Bool
solution = FindAuxiliaryPetriNodesSolution -> Map (Int, Int) Bool
findAuxiliaryPetriNodesSolutionMap FindAuxiliaryPetriNodesSolution
sol
      sub' :: [(Int, Int)]
sub' = Map (Int, Int) Bool -> [(Int, Int)]
forall k a. Map k a -> [k]
M.keys (Map (Int, Int) Bool -> [(Int, Int)])
-> Map (Int, Int) Bool -> [(Int, Int)]
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesSolution -> Map (Int, Int) Bool
findAuxiliaryPetriNodesSolutionMap FindAuxiliaryPetriNodesSolution
sub
      maybeSolutionString :: Maybe String
maybeSolutionString =
        if FindAuxiliaryPetriNodesInstance -> Bool
showSolution FindAuxiliaryPetriNodesInstance
task
        then String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesSolution -> String
forall a. Show a => a -> String
show FindAuxiliaryPetriNodesSolution
sol
        else Maybe String
forall a. Maybe a
Nothing
  ArticleToUse
-> Map Language String
-> Maybe String
-> Map (Int, Int) Bool
-> [(Int, Int)]
-> LangM' m Rational
forall (m :: * -> *) a.
(OutputCapable m, Ord a) =>
ArticleToUse
-> Map Language String
-> Maybe String
-> Map a Bool
-> [a]
-> Rated m
multipleChoice ArticleToUse
DefiniteArticle Map Language String
as Maybe String
maybeSolutionString Map (Int, Int) Bool
solution [(Int, Int)]
sub'

findAuxiliaryPetriNodesSolutionMap
  :: FindAuxiliaryPetriNodesSolution
  -> Map (Int, Int) Bool
findAuxiliaryPetriNodesSolutionMap :: FindAuxiliaryPetriNodesSolution -> Map (Int, Int) Bool
findAuxiliaryPetriNodesSolutionMap FindAuxiliaryPetriNodesSolution
sol =
  let xs :: [Int]
xs = [
        FindAuxiliaryPetriNodesSolution -> Int
countOfNonAuxiliaryNodes FindAuxiliaryPetriNodesSolution
sol,
        FindAuxiliaryPetriNodesSolution -> Int
countOfAuxiliaryPlaces FindAuxiliaryPetriNodesSolution
sol,
        FindAuxiliaryPetriNodesSolution -> Int
countOfAuxiliaryTransitions FindAuxiliaryPetriNodesSolution
sol
        ]
  in [((Int, Int), Bool)] -> Map (Int, Int) Bool
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([((Int, Int), Bool)] -> Map (Int, Int) Bool)
-> [((Int, Int), Bool)] -> Map (Int, Int) Bool
forall a b. (a -> b) -> a -> b
$ (Int -> Int -> ((Int, Int), Bool))
-> [Int] -> [Int] -> [((Int, Int), Bool)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (((Int, Int) -> ((Int, Int), Bool))
-> Int -> Int -> ((Int, Int), Bool)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (,Bool
True)) [Int
1..] [Int]
xs

findAuxiliaryPetriNodes
  :: (MonadAlloy m, MonadThrow m)
  => FindAuxiliaryPetriNodesConfig
  -> Int
  -> Int
  -> m FindAuxiliaryPetriNodesInstance
findAuxiliaryPetriNodes :: forall (m :: * -> *).
(MonadAlloy m, MonadThrow m) =>
FindAuxiliaryPetriNodesConfig
-> Int -> Int -> m FindAuxiliaryPetriNodesInstance
findAuxiliaryPetriNodes FindAuxiliaryPetriNodesConfig
config Int
segment Int
seed = do
  let g :: StdGen
g = Int -> StdGen
mkStdGen (Int -> StdGen) -> Int -> StdGen
forall a b. (a -> b) -> a -> b
$ (Int
segment Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
seed
  RandT StdGen m FindAuxiliaryPetriNodesInstance
-> StdGen -> m FindAuxiliaryPetriNodesInstance
forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
evalRandT (FindAuxiliaryPetriNodesConfig
-> RandT StdGen m FindAuxiliaryPetriNodesInstance
forall (m :: * -> *) g.
(MonadAlloy m, MonadThrow m, RandomGen g) =>
FindAuxiliaryPetriNodesConfig
-> RandT g m FindAuxiliaryPetriNodesInstance
getFindAuxiliaryPetriNodesTask FindAuxiliaryPetriNodesConfig
config) StdGen
g

getFindAuxiliaryPetriNodesTask
  :: (MonadAlloy m, MonadThrow m, RandomGen g)
  => FindAuxiliaryPetriNodesConfig
  -> RandT g m FindAuxiliaryPetriNodesInstance
getFindAuxiliaryPetriNodesTask :: forall (m :: * -> *) g.
(MonadAlloy m, MonadThrow m, RandomGen g) =>
FindAuxiliaryPetriNodesConfig
-> RandT g m FindAuxiliaryPetriNodesInstance
getFindAuxiliaryPetriNodesTask config :: FindAuxiliaryPetriNodesConfig
config@FindAuxiliaryPetriNodesConfig {Bool
Maybe Bool
Maybe Integer
Maybe (Map Language String)
(Int, Maybe Int)
AdConfig
$sel:adConfig:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> AdConfig
$sel:countOfPetriNodesBounds:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> (Int, Maybe Int)
$sel:maxInstances:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe Integer
$sel:hideNodeNames:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Bool
$sel:hideBranchConditions:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Bool
$sel:presenceOfSinkTransitionsForFinals:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe Bool
$sel:printSolution:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Bool
$sel:extraText:FindAuxiliaryPetriNodesConfig :: FindAuxiliaryPetriNodesConfig -> Maybe (Map Language String)
adConfig :: AdConfig
countOfPetriNodesBounds :: (Int, Maybe Int)
maxInstances :: Maybe Integer
hideNodeNames :: Bool
hideBranchConditions :: Bool
presenceOfSinkTransitionsForFinals :: Maybe Bool
printSolution :: Bool
extraText :: Maybe (Map Language String)
..} = do
  [AlloyInstance]
alloyInstances <- Maybe Integer -> Maybe Int -> String -> RandT g m [AlloyInstance]
forall (m :: * -> *).
MonadAlloy m =>
Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
getInstances
    Maybe Integer
maxInstances
    Maybe Int
forall a. Maybe a
Nothing
    (String -> RandT g m [AlloyInstance])
-> String -> RandT g m [AlloyInstance]
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesConfig -> String
findAuxiliaryPetriNodesAlloy FindAuxiliaryPetriNodesConfig
config
  [UMLActivityDiagram]
randomInstances <- [AlloyInstance] -> RandT g m [AlloyInstance]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [AlloyInstance]
alloyInstances RandT g m [AlloyInstance]
-> ([AlloyInstance] -> RandT g m [UMLActivityDiagram])
-> RandT g m [UMLActivityDiagram]
forall a b. RandT g m a -> (a -> RandT g m b) -> RandT g m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (AlloyInstance -> RandT g m UMLActivityDiagram)
-> [AlloyInstance] -> RandT g m [UMLActivityDiagram]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM AlloyInstance -> RandT g m UMLActivityDiagram
forall (m :: * -> *).
MonadThrow m =>
AlloyInstance -> m UMLActivityDiagram
parseInstance
  (UMLActivityDiagram
ad, SimplePetriLike PetriKey
matchingNet) <- (UMLActivityDiagram -> RandT g m UMLActivityDiagram)
-> [UMLActivityDiagram] -> RandT g m [UMLActivityDiagram]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (((Map String String, UMLActivityDiagram) -> UMLActivityDiagram)
-> RandT g m (Map String String, UMLActivityDiagram)
-> RandT g m UMLActivityDiagram
forall a b. (a -> b) -> RandT g m a -> RandT g m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map String String, UMLActivityDiagram) -> UMLActivityDiagram
forall a b. (a, b) -> b
snd (RandT g m (Map String String, UMLActivityDiagram)
 -> RandT g m UMLActivityDiagram)
-> (UMLActivityDiagram
    -> RandT g m (Map String String, UMLActivityDiagram))
-> UMLActivityDiagram
-> RandT g m UMLActivityDiagram
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMLActivityDiagram
-> RandT g m (Map String String, UMLActivityDiagram)
forall (m :: * -> *).
MonadRandom m =>
UMLActivityDiagram -> m (Map String String, UMLActivityDiagram)
shuffleAdNames) [UMLActivityDiagram]
randomInstances
    RandT g m [UMLActivityDiagram]
-> ([UMLActivityDiagram]
    -> RandT g m (UMLActivityDiagram, SimplePetriLike PetriKey))
-> RandT g m (UMLActivityDiagram, SimplePetriLike PetriKey)
forall a b. RandT g m a -> (a -> RandT g m b) -> RandT g m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [(UMLActivityDiagram, SimplePetriLike PetriKey)]
-> RandT g m (UMLActivityDiagram, SimplePetriLike PetriKey)
forall (m :: * -> *) a. MonadThrow m => [a] -> m a
getFirstInstance ([(UMLActivityDiagram, SimplePetriLike PetriKey)]
 -> RandT g m (UMLActivityDiagram, SimplePetriLike PetriKey))
-> ([UMLActivityDiagram]
    -> [(UMLActivityDiagram, SimplePetriLike PetriKey)])
-> [UMLActivityDiagram]
-> RandT g m (UMLActivityDiagram, SimplePetriLike PetriKey)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((UMLActivityDiagram, SimplePetriLike PetriKey) -> Bool)
-> [(UMLActivityDiagram, SimplePetriLike PetriKey)]
-> [(UMLActivityDiagram, SimplePetriLike PetriKey)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Int, Maybe Int) -> SimplePetriLike PetriKey -> Bool
forall (p :: (* -> *) -> * -> *) (n :: * -> *) a.
(Net p n, Ord a) =>
(Int, Maybe Int) -> p n a -> Bool
checkPetriNodeCount (Int, Maybe Int)
countOfPetriNodesBounds (SimplePetriLike PetriKey -> Bool)
-> ((UMLActivityDiagram, SimplePetriLike PetriKey)
    -> SimplePetriLike PetriKey)
-> (UMLActivityDiagram, SimplePetriLike PetriKey)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMLActivityDiagram, SimplePetriLike PetriKey)
-> SimplePetriLike PetriKey
forall a b. (a, b) -> b
snd)
                         ([(UMLActivityDiagram, SimplePetriLike PetriKey)]
 -> [(UMLActivityDiagram, SimplePetriLike PetriKey)])
-> ([UMLActivityDiagram]
    -> [(UMLActivityDiagram, SimplePetriLike PetriKey)])
-> [UMLActivityDiagram]
-> [(UMLActivityDiagram, SimplePetriLike PetriKey)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMLActivityDiagram
 -> (UMLActivityDiagram, SimplePetriLike PetriKey))
-> [UMLActivityDiagram]
-> [(UMLActivityDiagram, SimplePetriLike PetriKey)]
forall a b. (a -> b) -> [a] -> [b]
map (\UMLActivityDiagram
x -> (UMLActivityDiagram
x, forall (p :: (* -> *) -> * -> *) (n :: * -> *).
Net p n =>
UMLActivityDiagram -> p n PetriKey
convertToPetriNet @PetriLike @SimpleNode UMLActivityDiagram
x))
  FindAuxiliaryPetriNodesInstance
-> RandT g m FindAuxiliaryPetriNodesInstance
forall a. a -> RandT g m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FindAuxiliaryPetriNodesInstance
 -> RandT g m FindAuxiliaryPetriNodesInstance)
-> FindAuxiliaryPetriNodesInstance
-> RandT g m FindAuxiliaryPetriNodesInstance
forall a b. (a -> b) -> a -> b
$ FindAuxiliaryPetriNodesInstance {
    $sel:activityDiagram:FindAuxiliaryPetriNodesInstance :: UMLActivityDiagram
activityDiagram = UMLActivityDiagram
ad,
    $sel:matchingNet:FindAuxiliaryPetriNodesInstance :: SimplePetriLike PetriKey
matchingNet = SimplePetriLike PetriKey
matchingNet,
    $sel:plantUMLConf:FindAuxiliaryPetriNodesInstance :: PlantUmlConfig
plantUMLConf =
      PlantUmlConfig {
        suppressNodeNames :: Bool
suppressNodeNames = Bool
hideNodeNames,
        suppressBranchConditions :: Bool
suppressBranchConditions = Bool
hideBranchConditions
      },
    $sel:showSolution:FindAuxiliaryPetriNodesInstance :: Bool
showSolution = Bool
printSolution,
    $sel:addText:FindAuxiliaryPetriNodesInstance :: Maybe (Map Language String)
addText = Maybe (Map Language String)
extraText
  }

defaultFindAuxiliaryPetriNodesInstance :: FindAuxiliaryPetriNodesInstance
defaultFindAuxiliaryPetriNodesInstance :: FindAuxiliaryPetriNodesInstance
defaultFindAuxiliaryPetriNodesInstance =
  let ad :: UMLActivityDiagram
ad = UMLActivityDiagram {
    nodes :: [AdNode]
nodes = [
      AdActionNode {label :: Int
label = Int
1, name :: String
name = String
"A"},
      AdActionNode {label :: Int
label = Int
2, name :: String
name = String
"B"},
      AdActionNode {label :: Int
label = Int
3, name :: String
name = String
"C"},
      AdActionNode {label :: Int
label = Int
4, name :: String
name = String
"D"},
      AdObjectNode {label :: Int
label = Int
5, name :: String
name = String
"E"},
      AdObjectNode {label :: Int
label = Int
6, name :: String
name = String
"F"},
      AdObjectNode {label :: Int
label = Int
7, name :: String
name = String
"G"},
      AdObjectNode {label :: Int
label = Int
8, name :: String
name = String
"H"},
      AdDecisionNode {label :: Int
label = Int
9},
      AdDecisionNode {label :: Int
label = Int
10},
      AdMergeNode {label :: Int
label = Int
11},
      AdMergeNode {label :: Int
label = Int
12},
      AdForkNode {label :: Int
label = Int
13},
      AdJoinNode {label :: Int
label = Int
14},
      AdActivityFinalNode {label :: Int
label = Int
15},
      AdFlowFinalNode {label :: Int
label = Int
16},
      AdInitialNode {label :: Int
label = Int
17}
    ],
    connections :: [AdConnection]
connections = [
      AdConnection {from :: Int
from = Int
1, to :: Int
to = Int
14, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
2, to :: Int
to = Int
11, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
3, to :: Int
to = Int
14, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
4, to :: Int
to = Int
9, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
5, to :: Int
to = Int
11, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
6, to :: Int
to = Int
10, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
7, to :: Int
to = Int
16, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
8, to :: Int
to = Int
4, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
9, to :: Int
to = Int
2, guard :: String
guard = String
"a"},
      AdConnection {from :: Int
from = Int
9, to :: Int
to = Int
5, guard :: String
guard = String
"b"},
      AdConnection {from :: Int
from = Int
10, to :: Int
to = Int
8, guard :: String
guard = String
"b"},
      AdConnection {from :: Int
from = Int
10, to :: Int
to = Int
12, guard :: String
guard = String
"a"},
      AdConnection {from :: Int
from = Int
11, to :: Int
to = Int
15, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
12, to :: Int
to = Int
6, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
13, to :: Int
to = Int
1, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
13, to :: Int
to = Int
3, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
13, to :: Int
to = Int
7, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
14, to :: Int
to = Int
12, guard :: String
guard = String
""},
      AdConnection {from :: Int
from = Int
17, to :: Int
to = Int
13, guard :: String
guard = String
""}
    ]
  }
  in FindAuxiliaryPetriNodesInstance {
    $sel:activityDiagram:FindAuxiliaryPetriNodesInstance :: UMLActivityDiagram
activityDiagram = UMLActivityDiagram
ad,
    $sel:matchingNet:FindAuxiliaryPetriNodesInstance :: SimplePetriLike PetriKey
matchingNet = UMLActivityDiagram -> SimplePetriLike PetriKey
convertToSimple UMLActivityDiagram
ad,
    $sel:plantUMLConf:FindAuxiliaryPetriNodesInstance :: PlantUmlConfig
plantUMLConf = PlantUmlConfig
defaultPlantUmlConfig,
    $sel:showSolution:FindAuxiliaryPetriNodesInstance :: Bool
showSolution = Bool
False,
    $sel:addText:FindAuxiliaryPetriNodesInstance :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }