{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}

module Modelling.CdOd.NameCdError (
  NameCdErrorAnswer (..),
  NameCdErrorConfig (..),
  NameCdErrorInstance (..),
  NameCdErrorTaskText,
  NameCdErrorTaskTextElement (..),
  NumberOfReasons (..),
  Reason (..),
  Relevance (..),
  checkNameCdErrorConfig,
  checkNameCdErrorInstance,
  classAndNonInheritanceNames,
  defaultNameCdErrorAnswer,
  defaultNameCdErrorConfig,
  defaultNameCdErrorInstance,
  isRelevant,
  nameCdErrorEvaluation,
  nameCdErrorGenerate,
  nameCdErrorSolution,
  nameCdErrorSyntax,
  nameCdErrorTask,
  parseNameCdErrorAnswer,
  renameInstance,
  showNameCdErrorAnswer,
  ) where

import qualified Modelling.CdOd.CdAndChanges.Transform as Changes (
  transformGetNextFix,
  )

import qualified Data.Bimap                       as BM (fromList)
import qualified Data.Map                         as M (
  elems,
  filter,
  fromAscList,
  keys,
  toList,
  )
import qualified Data.Set                         as S (
  (\\),
  filter,
  fromList,
  null,
  toList,
  )

import Capabilities.Alloy               (MonadAlloy, getInstances)
import Capabilities.Cache               (MonadCache)
import Capabilities.Diagrams            (MonadDiagrams)
import Capabilities.Graphviz            (MonadGraphviz)
import Data.Data                        (Data)
import Modelling.Auxiliary.Common (
  Randomise (randomise),
  RandomiseLayout (randomiseLayout),
  RandomiseNames (randomiseNames),
  upperToDash,
  )
import Modelling.Auxiliary.Output (
  addPretext,
  checkTaskText,
  hoveringInformation,
  simplifiedInformation,
  uniform,
  extra,
  )
import Modelling.Auxiliary.Shuffle.All  (shuffleEverything)
import Modelling.CdOd.Auxiliary.Util    (alloyInstanceToOd)
import Modelling.CdOd.CD2Alloy.Transform (
  ExtendsAnd (FieldPlacement),
  LinguisticReuse (ExtendsAnd),
  combineParts,
  createRunCommand,
  transform,
  )
import Modelling.CdOd.CdAndChanges.Instance (
  ChangeAndCd (..),
  GenericClassDiagramInstance (..),
  fromInstance,
  fromInstanceWithPredefinedNames,
  nameClassDiagramInstance,
  )
import Modelling.CdOd.Output (
  cacheCd,
  )
import Modelling.CdOd.Phrasing (
  phraseRelationship,
  )
import Modelling.CdOd.RepairCd (
  (.&.),
  checkClassConfigAndChanges,
  illegalStructuralWeakenings,
  legalStructuralWeakenings,
  toProperty,
  )
import Modelling.CdOd.Types (
  AllowedProperties (..),
  Annotation (..),
  AnnotatedCd,
  AnnotatedClassDiagram (..),
  AnyCd,
  AnyClassDiagram (..),
  AnyRelationship,
  ArticlePreference (..),
  CdConstraints (..),
  CdDrawSettings (..),
  ClassConfig (..),
  ClassDiagram (..),
  LimitedLinking (..),
  ObjectProperties (..),
  PhrasingKind (Denoted),
  Property (..),
  Relationship (..),
  RelationshipProperties (..),
  allowEverything,
  anonymiseObjects,
  anyAssociationNames,
  checkCdConstraints,
  checkCdDrawProperties,
  checkCdDrawSettings,
  checkClassConfigAndObjectProperties,
  checkObjectProperties,
  classNames,
  defaultCdConstraints,
  defaultCdDrawSettings,
  isIllegal,
  maxObjects,
  relationshipName,
  renameClassesAndRelationships,
  shuffleAnnotatedClassAndConnectionOrder,
  toArticleToUse,
  toPropertySet,
  toValidCd,
  towardsValidProperties,
  unannotateCd,
  )
import Modelling.Types                  (Change (..))

import Control.Applicative              (Alternative ((<|>)))
import Control.Monad                    ((>=>), forM, join)
import Control.Monad.Catch              (MonadCatch, MonadThrow)
import Control.Monad.Except             (runExceptT)
import Control.OutputCapable.Blocks (
  ArticleToUse (DefiniteArticle),
  GenericOutputCapable (..),
  LangM,
  Language (English, German),
  OutputCapable,
  Rated,
  ($=<<),
  english,
  enumerateM,
  german,
  multipleChoice,
  multipleChoiceSyntax,
  printSolutionAndAssert,
  recoverWith,
  singleChoice,
  singleChoiceSyntax,
  translate,
  translations,
  )
import Control.OutputCapable.Blocks.Generic (($>>), ($>>=))
import Control.OutputCapable.Blocks.Generic.Type (
  GenericOutput (Code, Paragraph, Special, Translated),
  )
import Control.OutputCapable.Blocks.Type (
  SpecialOutput,
  checkTranslation,
  specialToOutputCapable,
  )
import Control.Monad.Random
  (MonadRandom, RandT, RandomGen, evalRandT, mkStdGen)
import Control.Monad.Trans.Class        (MonadTrans (lift))
import Control.Monad.Trans.State        (put)
import Data.Aeson.TH                    (Options (..), defaultOptions, deriveJSON)
import Data.Bifunctor                   (second)
import Data.ByteString.UTF8             (fromString, toString)
import Data.Containers.ListUtils        (nubOrd)
import Data.Either.Extra                (eitherToMaybe, fromEither)
import Data.List (
  (\\),
  delete,
  partition,
  singleton,
  sortOn,
  )
import Data.Map                         (Map)
import Data.Maybe                       (catMaybes, listToMaybe, mapMaybe)
import Data.Ratio                       ((%))
import Data.Set                         (Set)
import Data.String.Interpolate          (i, iii)
import Data.Yaml                        (decodeEither', encode)
import GHC.Generics                     (Generic)
import System.Random.Shuffle            (shuffleM)
import Text.Parsec                      (parserFail, parserReturn)
import Text.ParserCombinators.Parsec    (Parser, anyToken, many)

data NameCdErrorAnswer = NameCdErrorAnswer {
  NameCdErrorAnswer -> Char
reason                      :: Char,
  NameCdErrorAnswer -> [Int]
dueTo                       :: [Int]
  } deriving ((forall x. NameCdErrorAnswer -> Rep NameCdErrorAnswer x)
-> (forall x. Rep NameCdErrorAnswer x -> NameCdErrorAnswer)
-> Generic NameCdErrorAnswer
forall x. Rep NameCdErrorAnswer x -> NameCdErrorAnswer
forall x. NameCdErrorAnswer -> Rep NameCdErrorAnswer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NameCdErrorAnswer -> Rep NameCdErrorAnswer x
from :: forall x. NameCdErrorAnswer -> Rep NameCdErrorAnswer x
$cto :: forall x. Rep NameCdErrorAnswer x -> NameCdErrorAnswer
to :: forall x. Rep NameCdErrorAnswer x -> NameCdErrorAnswer
Generic, ReadPrec [NameCdErrorAnswer]
ReadPrec NameCdErrorAnswer
Int -> ReadS NameCdErrorAnswer
ReadS [NameCdErrorAnswer]
(Int -> ReadS NameCdErrorAnswer)
-> ReadS [NameCdErrorAnswer]
-> ReadPrec NameCdErrorAnswer
-> ReadPrec [NameCdErrorAnswer]
-> Read NameCdErrorAnswer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NameCdErrorAnswer
readsPrec :: Int -> ReadS NameCdErrorAnswer
$creadList :: ReadS [NameCdErrorAnswer]
readList :: ReadS [NameCdErrorAnswer]
$creadPrec :: ReadPrec NameCdErrorAnswer
readPrec :: ReadPrec NameCdErrorAnswer
$creadListPrec :: ReadPrec [NameCdErrorAnswer]
readListPrec :: ReadPrec [NameCdErrorAnswer]
Read, Int -> NameCdErrorAnswer -> ShowS
[NameCdErrorAnswer] -> ShowS
NameCdErrorAnswer -> String
(Int -> NameCdErrorAnswer -> ShowS)
-> (NameCdErrorAnswer -> String)
-> ([NameCdErrorAnswer] -> ShowS)
-> Show NameCdErrorAnswer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NameCdErrorAnswer -> ShowS
showsPrec :: Int -> NameCdErrorAnswer -> ShowS
$cshow :: NameCdErrorAnswer -> String
show :: NameCdErrorAnswer -> String
$cshowList :: [NameCdErrorAnswer] -> ShowS
showList :: [NameCdErrorAnswer] -> ShowS
Show)

$(deriveJSON defaultOptions {fieldLabelModifier = upperToDash} ''NameCdErrorAnswer)

data Reason
  = Custom (Map Language String)
  | PreDefined Property
  deriving (Typeable Reason
Typeable Reason
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Reason -> c Reason)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Reason)
-> (Reason -> Constr)
-> (Reason -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Reason))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Reason))
-> ((forall b. Data b => b -> b) -> Reason -> Reason)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Reason -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Reason -> r)
-> (forall u. (forall d. Data d => d -> u) -> Reason -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Reason -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Reason -> m Reason)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Reason -> m Reason)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Reason -> m Reason)
-> Data Reason
Reason -> Constr
Reason -> DataType
(forall b. Data b => b -> b) -> Reason -> Reason
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Reason -> u
forall u. (forall d. Data d => d -> u) -> Reason -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Reason
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reason -> c Reason
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Reason)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Reason)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reason -> c Reason
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reason -> c Reason
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Reason
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Reason
$ctoConstr :: Reason -> Constr
toConstr :: Reason -> Constr
$cdataTypeOf :: Reason -> DataType
dataTypeOf :: Reason -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Reason)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Reason)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Reason)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Reason)
$cgmapT :: (forall b. Data b => b -> b) -> Reason -> Reason
gmapT :: (forall b. Data b => b -> b) -> Reason -> Reason
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Reason -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Reason -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Reason -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Reason -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Reason -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reason -> m Reason
Data, Reason -> Reason -> Bool
(Reason -> Reason -> Bool)
-> (Reason -> Reason -> Bool) -> Eq Reason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Reason -> Reason -> Bool
== :: Reason -> Reason -> Bool
$c/= :: Reason -> Reason -> Bool
/= :: Reason -> Reason -> Bool
Eq, (forall x. Reason -> Rep Reason x)
-> (forall x. Rep Reason x -> Reason) -> Generic Reason
forall x. Rep Reason x -> Reason
forall x. Reason -> Rep Reason x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Reason -> Rep Reason x
from :: forall x. Reason -> Rep Reason x
$cto :: forall x. Rep Reason x -> Reason
to :: forall x. Rep Reason x -> Reason
Generic, Eq Reason
Eq Reason
-> (Reason -> Reason -> Ordering)
-> (Reason -> Reason -> Bool)
-> (Reason -> Reason -> Bool)
-> (Reason -> Reason -> Bool)
-> (Reason -> Reason -> Bool)
-> (Reason -> Reason -> Reason)
-> (Reason -> Reason -> Reason)
-> Ord Reason
Reason -> Reason -> Bool
Reason -> Reason -> Ordering
Reason -> Reason -> Reason
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 :: Reason -> Reason -> Ordering
compare :: Reason -> Reason -> Ordering
$c< :: Reason -> Reason -> Bool
< :: Reason -> Reason -> Bool
$c<= :: Reason -> Reason -> Bool
<= :: Reason -> Reason -> Bool
$c> :: Reason -> Reason -> Bool
> :: Reason -> Reason -> Bool
$c>= :: Reason -> Reason -> Bool
>= :: Reason -> Reason -> Bool
$cmax :: Reason -> Reason -> Reason
max :: Reason -> Reason -> Reason
$cmin :: Reason -> Reason -> Reason
min :: Reason -> Reason -> Reason
Ord, ReadPrec [Reason]
ReadPrec Reason
Int -> ReadS Reason
ReadS [Reason]
(Int -> ReadS Reason)
-> ReadS [Reason]
-> ReadPrec Reason
-> ReadPrec [Reason]
-> Read Reason
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Reason
readsPrec :: Int -> ReadS Reason
$creadList :: ReadS [Reason]
readList :: ReadS [Reason]
$creadPrec :: ReadPrec Reason
readPrec :: ReadPrec Reason
$creadListPrec :: ReadPrec [Reason]
readListPrec :: ReadPrec [Reason]
Read, Int -> Reason -> ShowS
[Reason] -> ShowS
Reason -> String
(Int -> Reason -> ShowS)
-> (Reason -> String) -> ([Reason] -> ShowS) -> Show Reason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Reason -> ShowS
showsPrec :: Int -> Reason -> ShowS
$cshow :: Reason -> String
show :: Reason -> String
$cshowList :: [Reason] -> ShowS
showList :: [Reason] -> ShowS
Show)

isCustom :: Reason -> Bool
isCustom :: Reason -> Bool
isCustom = \case
  Custom {} -> Bool
True
  PreDefined {} -> Bool
False

renderReason :: OutputCapable m => Bool -> Reason -> LangM m
renderReason :: forall (m :: * -> *). OutputCapable m => Bool -> Reason -> LangM m
renderReason Bool
withDirections = State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> (Reason -> State (Map Language String) ())
-> Reason
-> GenericLangM Language m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Language String -> State (Map Language String) ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put (Map Language String -> State (Map Language String) ())
-> (Reason -> Map Language String)
-> Reason
-> State (Map Language String) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Reason -> Map Language String
toTranslations Bool
withDirections

toTranslations :: Bool -> Reason -> Map Language String
toTranslations :: Bool -> Reason -> Map Language String
toTranslations Bool
withDirections = \case
  Custom Map Language String
x -> Map Language String
x
  PreDefined Property
x -> Bool -> Property -> Map Language String
translateProperty Bool
withDirections Property
x

data NumberOfReasons = NumberOfReasons {
  NumberOfReasons -> Int
customReasons :: Int,
  NumberOfReasons -> Int
preDefinedInvalid :: Int,
  NumberOfReasons -> Int
preDefinedValid :: Int
  } deriving ((forall x. NumberOfReasons -> Rep NumberOfReasons x)
-> (forall x. Rep NumberOfReasons x -> NumberOfReasons)
-> Generic NumberOfReasons
forall x. Rep NumberOfReasons x -> NumberOfReasons
forall x. NumberOfReasons -> Rep NumberOfReasons x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NumberOfReasons -> Rep NumberOfReasons x
from :: forall x. NumberOfReasons -> Rep NumberOfReasons x
$cto :: forall x. Rep NumberOfReasons x -> NumberOfReasons
to :: forall x. Rep NumberOfReasons x -> NumberOfReasons
Generic, ReadPrec [NumberOfReasons]
ReadPrec NumberOfReasons
Int -> ReadS NumberOfReasons
ReadS [NumberOfReasons]
(Int -> ReadS NumberOfReasons)
-> ReadS [NumberOfReasons]
-> ReadPrec NumberOfReasons
-> ReadPrec [NumberOfReasons]
-> Read NumberOfReasons
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NumberOfReasons
readsPrec :: Int -> ReadS NumberOfReasons
$creadList :: ReadS [NumberOfReasons]
readList :: ReadS [NumberOfReasons]
$creadPrec :: ReadPrec NumberOfReasons
readPrec :: ReadPrec NumberOfReasons
$creadListPrec :: ReadPrec [NumberOfReasons]
readListPrec :: ReadPrec [NumberOfReasons]
Read, Int -> NumberOfReasons -> ShowS
[NumberOfReasons] -> ShowS
NumberOfReasons -> String
(Int -> NumberOfReasons -> ShowS)
-> (NumberOfReasons -> String)
-> ([NumberOfReasons] -> ShowS)
-> Show NumberOfReasons
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NumberOfReasons -> ShowS
showsPrec :: Int -> NumberOfReasons -> ShowS
$cshow :: NumberOfReasons -> String
show :: NumberOfReasons -> String
$cshowList :: [NumberOfReasons] -> ShowS
showList :: [NumberOfReasons] -> ShowS
Show)

data NameCdErrorConfig = NameCdErrorConfig {
  NameCdErrorConfig -> AllowedProperties
allowedProperties           :: AllowedProperties,
  -- | the article preference when referring to relationships
  NameCdErrorConfig -> ArticlePreference
articleToUse                :: ArticlePreference,
  NameCdErrorConfig -> CdConstraints
cdConstraints               :: !CdConstraints,
  NameCdErrorConfig -> ClassConfig
classConfig                 :: ClassConfig,
  NameCdErrorConfig -> CdDrawSettings
drawSettings                :: !CdDrawSettings,
  NameCdErrorConfig -> Maybe Integer
maxInstances                :: Maybe Integer,
  NameCdErrorConfig -> ObjectProperties
objectProperties            :: ObjectProperties,
  NameCdErrorConfig -> [Reason]
possibleReasons             :: [Reason],
  NameCdErrorConfig -> Bool
printSolution               :: Bool,
  NameCdErrorConfig -> NumberOfReasons
reasonsPerInstance          :: NumberOfReasons,
  NameCdErrorConfig -> Maybe Int
timeout                     :: Maybe Int,
  NameCdErrorConfig -> Bool
useNames                    :: Bool,
  NameCdErrorConfig -> Maybe (Map Language String)
extraText                   :: Maybe (Map Language String)
  } deriving ((forall x. NameCdErrorConfig -> Rep NameCdErrorConfig x)
-> (forall x. Rep NameCdErrorConfig x -> NameCdErrorConfig)
-> Generic NameCdErrorConfig
forall x. Rep NameCdErrorConfig x -> NameCdErrorConfig
forall x. NameCdErrorConfig -> Rep NameCdErrorConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NameCdErrorConfig -> Rep NameCdErrorConfig x
from :: forall x. NameCdErrorConfig -> Rep NameCdErrorConfig x
$cto :: forall x. Rep NameCdErrorConfig x -> NameCdErrorConfig
to :: forall x. Rep NameCdErrorConfig x -> NameCdErrorConfig
Generic, ReadPrec [NameCdErrorConfig]
ReadPrec NameCdErrorConfig
Int -> ReadS NameCdErrorConfig
ReadS [NameCdErrorConfig]
(Int -> ReadS NameCdErrorConfig)
-> ReadS [NameCdErrorConfig]
-> ReadPrec NameCdErrorConfig
-> ReadPrec [NameCdErrorConfig]
-> Read NameCdErrorConfig
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NameCdErrorConfig
readsPrec :: Int -> ReadS NameCdErrorConfig
$creadList :: ReadS [NameCdErrorConfig]
readList :: ReadS [NameCdErrorConfig]
$creadPrec :: ReadPrec NameCdErrorConfig
readPrec :: ReadPrec NameCdErrorConfig
$creadListPrec :: ReadPrec [NameCdErrorConfig]
readListPrec :: ReadPrec [NameCdErrorConfig]
Read, Int -> NameCdErrorConfig -> ShowS
[NameCdErrorConfig] -> ShowS
NameCdErrorConfig -> String
(Int -> NameCdErrorConfig -> ShowS)
-> (NameCdErrorConfig -> String)
-> ([NameCdErrorConfig] -> ShowS)
-> Show NameCdErrorConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NameCdErrorConfig -> ShowS
showsPrec :: Int -> NameCdErrorConfig -> ShowS
$cshow :: NameCdErrorConfig -> String
show :: NameCdErrorConfig -> String
$cshowList :: [NameCdErrorConfig] -> ShowS
showList :: [NameCdErrorConfig] -> ShowS
Show)

defaultNameCdErrorConfig :: NameCdErrorConfig
defaultNameCdErrorConfig :: NameCdErrorConfig
defaultNameCdErrorConfig = NameCdErrorConfig {
  allowedProperties :: AllowedProperties
allowedProperties = AllowedProperties
allowEverything {
    reverseInheritances :: Bool
reverseInheritances = Bool
False,
    selfInheritances :: Bool
selfInheritances = Bool
False
    },
  articleToUse :: ArticlePreference
articleToUse = ArticlePreference
UseDefiniteArticleWherePossible,
  cdConstraints :: CdConstraints
cdConstraints = CdConstraints
defaultCdConstraints,
  classConfig :: ClassConfig
classConfig = ClassConfig {
    classLimits :: (Int, Int)
classLimits = (Int
4, Int
4),
    aggregationLimits :: (Int, Maybe Int)
aggregationLimits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1),
    associationLimits :: (Int, Maybe Int)
associationLimits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1),
    compositionLimits :: (Int, Maybe Int)
compositionLimits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3),
    inheritanceLimits :: (Int, Maybe Int)
inheritanceLimits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0),
    relationshipLimits :: (Int, Maybe Int)
relationshipLimits = (Int
3, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5)
    },
  drawSettings :: CdDrawSettings
drawSettings = CdDrawSettings
defaultCdDrawSettings {printNames :: Bool
printNames = Bool
True},
  maxInstances :: Maybe Integer
maxInstances = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
200,
  objectProperties :: ObjectProperties
objectProperties = ObjectProperties {
    anonymousObjectProportion :: Rational
anonymousObjectProportion = Integer
0 Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1,
    completelyInhabited :: Maybe Bool
completelyInhabited = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True,
    hasLimitedIsolatedObjects :: Bool
hasLimitedIsolatedObjects = Bool
True,
    hasSelfLoops :: Maybe Bool
hasSelfLoops = Maybe Bool
forall a. Maybe a
Nothing,
    usesEveryRelationshipName :: Maybe Bool
usesEveryRelationshipName = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
    },
  possibleReasons :: [Reason]
possibleReasons = (Property -> Reason) -> [Property] -> [Reason]
forall a b. (a -> b) -> [a] -> [b]
map Property -> Reason
PreDefined [Property
forall a. Bounded a => a
minBound ..],
  printSolution :: Bool
printSolution = Bool
False,
  reasonsPerInstance :: NumberOfReasons
reasonsPerInstance = NumberOfReasons {
    customReasons :: Int
customReasons = Int
0,
    preDefinedInvalid :: Int
preDefinedInvalid = [Property] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Property] -> Int) -> [Property] -> Int
forall a b. (a -> b) -> a -> b
$ (Property -> Bool) -> [Property] -> [Property]
forall a. (a -> Bool) -> [a] -> [a]
filter Property -> Bool
isIllegal [Property
forall a. Bounded a => a
minBound ..],
    preDefinedValid :: Int
preDefinedValid = [Property] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Property] -> Int) -> [Property] -> Int
forall a b. (a -> b) -> a -> b
$ (Property -> Bool) -> [Property] -> [Property]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Property -> Bool) -> Property -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Property -> Bool
isIllegal) [Property
forall a. Bounded a => a
minBound ..]
    },
  timeout :: Maybe Int
timeout = Maybe Int
forall a. Maybe a
Nothing,
  useNames :: Bool
useNames = Bool
True,
  extraText :: Maybe (Map Language String)
extraText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }

checkNameCdErrorConfig :: NameCdErrorConfig -> Maybe String
checkNameCdErrorConfig :: NameCdErrorConfig -> Maybe String
checkNameCdErrorConfig NameCdErrorConfig {Bool
[Reason]
Maybe Int
Maybe Integer
Maybe (Map Language String)
ArticlePreference
AllowedProperties
ObjectProperties
CdDrawSettings
CdConstraints
ClassConfig
NumberOfReasons
allowedProperties :: NameCdErrorConfig -> AllowedProperties
articleToUse :: NameCdErrorConfig -> ArticlePreference
cdConstraints :: NameCdErrorConfig -> CdConstraints
classConfig :: NameCdErrorConfig -> ClassConfig
drawSettings :: NameCdErrorConfig -> CdDrawSettings
maxInstances :: NameCdErrorConfig -> Maybe Integer
objectProperties :: NameCdErrorConfig -> ObjectProperties
possibleReasons :: NameCdErrorConfig -> [Reason]
printSolution :: NameCdErrorConfig -> Bool
reasonsPerInstance :: NameCdErrorConfig -> NumberOfReasons
timeout :: NameCdErrorConfig -> Maybe Int
useNames :: NameCdErrorConfig -> Bool
extraText :: NameCdErrorConfig -> Maybe (Map Language String)
allowedProperties :: AllowedProperties
articleToUse :: ArticlePreference
cdConstraints :: CdConstraints
classConfig :: ClassConfig
drawSettings :: CdDrawSettings
maxInstances :: Maybe Integer
objectProperties :: ObjectProperties
possibleReasons :: [Reason]
printSolution :: Bool
reasonsPerInstance :: NumberOfReasons
timeout :: Maybe Int
useNames :: Bool
extraText :: Maybe (Map Language String)
..}
  | Bool -> Bool
not (CdDrawSettings -> Bool
printNames CdDrawSettings
drawSettings) Bool -> Bool -> Bool
&& Bool
useNames
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"use names is only possible when printing names"
  | ObjectProperties -> Maybe Bool
completelyInhabited ObjectProperties
objectProperties Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"completelyInhabited needs to be set to 'Just True' for this task type"
  | ObjectProperties -> Maybe Bool
usesEveryRelationshipName ObjectProperties
objectProperties Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      usesEveryRelationshipName needs to be set to 'Just True' for this task type
      |]
  | Set Property -> Bool
forall a. Set a -> Bool
S.null Set Property
illegalProperties
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      There has to be set at least one illegal property for this task type,
      amend your allowedProperties
      |]
  | (Reason -> Bool) -> [Reason] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Reason -> [Reason] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Reason]
possibleReasons) [Reason]
illegalReasons
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      possibleReasons must contain at least #{illegalReasons}
      considering your current configuration.
      Suggested additional reasons are: #{additionalReasons}
      |]
  | NumberOfReasons -> Int
customReasons NumberOfReasons
reasonsPerInstance Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"customReasons must not be negative"
  | NumberOfReasons -> Int
preDefinedValid NumberOfReasons
reasonsPerInstance Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"preDefinedValid must not be negative"
  | NumberOfReasons -> Int
preDefinedInvalid NumberOfReasons
reasonsPerInstance Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"preDefinedInvalid must be set at least to one"
  | NumberOfReasons -> Int
customReasons NumberOfReasons
reasonsPerInstance Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> [Reason] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ((Reason -> Bool) -> [Reason] -> [Reason]
forall a. (a -> Bool) -> [a] -> [a]
filter Reason -> Bool
isCustom [Reason]
possibleReasons)
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      customReasons is set higher than the number of Custom reasons
      defined within possibleReasons
      |]
  | NumberOfReasons -> Int
preDefinedInvalid NumberOfReasons
reasonsPerInstance Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> [Property] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ((Property -> Bool) -> [Property] -> [Property]
forall a. (a -> Bool) -> [a] -> [a]
filter Property -> Bool
isIllegal [Property]
predefined)
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      preDefinedInvalid is set higher than the number of PreDefined reasons
      of illegal properties defined within possibleReasons
      |]
  | NumberOfReasons -> Int
preDefinedValid NumberOfReasons
reasonsPerInstance
    Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> [Property] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ((Property -> Bool) -> [Property] -> [Property]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Property -> Bool) -> Property -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Property -> Bool
isIllegal) [Property]
predefined)
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      preDefinedValid is set higher than the number of PreDefined reasons
      of legal properties defined within possibleReasons
      |]
  | Bool
otherwise
  = ClassConfig -> AllowedProperties -> Maybe String
checkClassConfigAndChanges ClassConfig
classConfig AllowedProperties
allowedProperties
  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
<|> AllowedProperties -> CdConstraints -> Maybe String
checkCdConstraints AllowedProperties
allowedProperties CdConstraints
cdConstraints
  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
<|> ObjectProperties -> Maybe String
checkObjectProperties ObjectProperties
objectProperties
  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
<|> ClassConfig -> ObjectProperties -> Maybe String
checkClassConfigAndObjectProperties ClassConfig
classConfig ObjectProperties
objectProperties
  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
<|> CdDrawSettings -> Maybe String
checkCdDrawSettings CdDrawSettings
drawSettings
  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
<|> CdDrawSettings -> AllowedProperties -> Maybe String
checkCdDrawProperties CdDrawSettings
drawSettings AllowedProperties
allowedProperties
  where
    predefined :: [Property]
predefined = (Reason -> [Property]) -> [Reason] -> [Property]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap
      (\case Custom {} -> []; PreDefined Property
x -> [Property
x])
      [Reason]
possibleReasons
    properties :: Set Property
properties = AllowedProperties -> Set Property
allowedPropertiesToPropertySet AllowedProperties
allowedProperties
    illegalProperties :: Set Property
illegalProperties = (Property -> Bool) -> Set Property -> Set Property
forall a. (a -> Bool) -> Set a -> Set a
S.filter Property -> Bool
isIllegal Set Property
properties
    illegalReasons :: [Reason]
illegalReasons = (Property -> Reason) -> [Property] -> [Reason]
forall a b. (a -> b) -> [a] -> [b]
map Property -> Reason
PreDefined ([Property] -> [Reason]) -> [Property] -> [Reason]
forall a b. (a -> b) -> a -> b
$ Set Property -> [Property]
forall a. Set a -> [a]
S.toList Set Property
illegalProperties
    additionalReasons :: [Reason]
additionalReasons = (Property -> Reason) -> [Property] -> [Reason]
forall a b. (a -> b) -> [a] -> [b]
map Property -> Reason
PreDefined
      ([Property] -> [Reason]) -> [Property] -> [Reason]
forall a b. (a -> b) -> a -> b
$ Set Property -> [Property]
forall a. Set a -> [a]
S.toList (Set Property
properties Set Property -> Set Property -> Set Property
forall a. Ord a => Set a -> Set a -> Set a
S.\\ Set Property
illegalProperties)

allowedPropertiesToPropertySet :: AllowedProperties -> Set Property
allowedPropertiesToPropertySet :: AllowedProperties -> Set Property
allowedPropertiesToPropertySet AllowedProperties {Bool
reverseInheritances :: AllowedProperties -> Bool
selfInheritances :: AllowedProperties -> Bool
compositionCycles :: Bool
doubleRelationships :: Bool
inheritanceCycles :: Bool
invalidInheritanceLimits :: Bool
reverseInheritances :: Bool
reverseRelationships :: Bool
selfInheritances :: Bool
selfRelationships :: Bool
wrongAssociationLimits :: Bool
wrongCompositionLimits :: Bool
compositionCycles :: AllowedProperties -> Bool
doubleRelationships :: AllowedProperties -> Bool
inheritanceCycles :: AllowedProperties -> Bool
invalidInheritanceLimits :: AllowedProperties -> Bool
reverseRelationships :: AllowedProperties -> Bool
selfRelationships :: AllowedProperties -> Bool
wrongAssociationLimits :: AllowedProperties -> Bool
wrongCompositionLimits :: AllowedProperties -> Bool
..} =
  [Property] -> Set Property
forall a. Ord a => [a] -> Set a
S.fromList ([Property] -> Set Property) -> [Property] -> Set Property
forall a b. (a -> b) -> a -> b
$ [Maybe Property] -> [Property]
forall a. [Maybe a] -> [a]
catMaybes [
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
compositionCycles Property
CompositionCycles,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
doubleRelationships Property
DoubleRelationships,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
inheritanceCycles Property
InheritanceCycles,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
invalidInheritanceLimits Property
InvalidInheritanceLimits,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
reverseInheritances Property
ReverseInheritances,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
reverseRelationships Property
ReverseRelationships,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
selfInheritances Property
SelfInheritances,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
selfRelationships Property
SelfRelationships,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
wrongAssociationLimits Property
WrongAssociationLimits,
    Bool -> Property -> Maybe Property
forall {a}. Bool -> a -> Maybe a
ifTrue Bool
wrongCompositionLimits Property
WrongCompositionLimits
    ]
  where
    ifTrue :: Bool -> a -> Maybe a
ifTrue Bool
x a
p = if Bool
x then a -> Maybe a
forall a. a -> Maybe a
Just a
p else Maybe a
forall a. Maybe a
Nothing

type NameCdErrorTaskText = [SpecialOutput NameCdErrorTaskTextElement]

data NameCdErrorTaskTextElement =
  IncorrectCd |
  ReasonsList |
  RelationshipsList
  deriving (NameCdErrorTaskTextElement
NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> Bounded NameCdErrorTaskTextElement
forall a. a -> a -> Bounded a
$cminBound :: NameCdErrorTaskTextElement
minBound :: NameCdErrorTaskTextElement
$cmaxBound :: NameCdErrorTaskTextElement
maxBound :: NameCdErrorTaskTextElement
Bounded, Typeable NameCdErrorTaskTextElement
Typeable NameCdErrorTaskTextElement
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> NameCdErrorTaskTextElement
    -> c NameCdErrorTaskTextElement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameCdErrorTaskTextElement)
-> (NameCdErrorTaskTextElement -> Constr)
-> (NameCdErrorTaskTextElement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c NameCdErrorTaskTextElement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameCdErrorTaskTextElement))
-> ((forall b. Data b => b -> b)
    -> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> NameCdErrorTaskTextElement
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> NameCdErrorTaskTextElement
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement)
-> Data NameCdErrorTaskTextElement
NameCdErrorTaskTextElement -> Constr
NameCdErrorTaskTextElement -> DataType
(forall b. Data b => b -> b)
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> u
forall u.
(forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorTaskTextElement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorTaskTextElement
-> c NameCdErrorTaskTextElement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c NameCdErrorTaskTextElement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorTaskTextElement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorTaskTextElement
-> c NameCdErrorTaskTextElement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorTaskTextElement
-> c NameCdErrorTaskTextElement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorTaskTextElement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorTaskTextElement
$ctoConstr :: NameCdErrorTaskTextElement -> Constr
toConstr :: NameCdErrorTaskTextElement -> Constr
$cdataTypeOf :: NameCdErrorTaskTextElement -> DataType
dataTypeOf :: NameCdErrorTaskTextElement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c NameCdErrorTaskTextElement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c NameCdErrorTaskTextElement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorTaskTextElement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorTaskTextElement)
$cgmapT :: (forall b. Data b => b -> b)
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
gmapT :: (forall b. Data b => b -> b)
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> NameCdErrorTaskTextElement
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> [u]
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> NameCdErrorTaskTextElement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorTaskTextElement -> m NameCdErrorTaskTextElement
Data, Int -> NameCdErrorTaskTextElement
NameCdErrorTaskTextElement -> Int
NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> [NameCdErrorTaskTextElement]
(NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement)
-> (NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement)
-> (Int -> NameCdErrorTaskTextElement)
-> (NameCdErrorTaskTextElement -> Int)
-> (NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement])
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement])
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement])
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement
    -> [NameCdErrorTaskTextElement])
-> Enum NameCdErrorTaskTextElement
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
succ :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
$cpred :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
pred :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
$ctoEnum :: Int -> NameCdErrorTaskTextElement
toEnum :: Int -> NameCdErrorTaskTextElement
$cfromEnum :: NameCdErrorTaskTextElement -> Int
fromEnum :: NameCdErrorTaskTextElement -> Int
$cenumFrom :: NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
enumFrom :: NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
$cenumFromThen :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
enumFromThen :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
$cenumFromTo :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
enumFromTo :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> [NameCdErrorTaskTextElement]
$cenumFromThenTo :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> [NameCdErrorTaskTextElement]
enumFromThenTo :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement
-> [NameCdErrorTaskTextElement]
Enum, NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
(NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Bool)
-> Eq NameCdErrorTaskTextElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
== :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
$c/= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
/= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
Eq, (forall x.
 NameCdErrorTaskTextElement -> Rep NameCdErrorTaskTextElement x)
-> (forall x.
    Rep NameCdErrorTaskTextElement x -> NameCdErrorTaskTextElement)
-> Generic NameCdErrorTaskTextElement
forall x.
Rep NameCdErrorTaskTextElement x -> NameCdErrorTaskTextElement
forall x.
NameCdErrorTaskTextElement -> Rep NameCdErrorTaskTextElement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
NameCdErrorTaskTextElement -> Rep NameCdErrorTaskTextElement x
from :: forall x.
NameCdErrorTaskTextElement -> Rep NameCdErrorTaskTextElement x
$cto :: forall x.
Rep NameCdErrorTaskTextElement x -> NameCdErrorTaskTextElement
to :: forall x.
Rep NameCdErrorTaskTextElement x -> NameCdErrorTaskTextElement
Generic, Eq NameCdErrorTaskTextElement
Eq NameCdErrorTaskTextElement
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Ordering)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Bool)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Bool)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Bool)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> Bool)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement)
-> (NameCdErrorTaskTextElement
    -> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement)
-> Ord NameCdErrorTaskTextElement
NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> Ordering
NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
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 :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> Ordering
compare :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> Ordering
$c< :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
< :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
$c<= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
<= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
$c> :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
> :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
$c>= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
>= :: NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement -> Bool
$cmax :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
max :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
$cmin :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
min :: NameCdErrorTaskTextElement
-> NameCdErrorTaskTextElement -> NameCdErrorTaskTextElement
Ord, ReadPrec [NameCdErrorTaskTextElement]
ReadPrec NameCdErrorTaskTextElement
Int -> ReadS NameCdErrorTaskTextElement
ReadS [NameCdErrorTaskTextElement]
(Int -> ReadS NameCdErrorTaskTextElement)
-> ReadS [NameCdErrorTaskTextElement]
-> ReadPrec NameCdErrorTaskTextElement
-> ReadPrec [NameCdErrorTaskTextElement]
-> Read NameCdErrorTaskTextElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NameCdErrorTaskTextElement
readsPrec :: Int -> ReadS NameCdErrorTaskTextElement
$creadList :: ReadS [NameCdErrorTaskTextElement]
readList :: ReadS [NameCdErrorTaskTextElement]
$creadPrec :: ReadPrec NameCdErrorTaskTextElement
readPrec :: ReadPrec NameCdErrorTaskTextElement
$creadListPrec :: ReadPrec [NameCdErrorTaskTextElement]
readListPrec :: ReadPrec [NameCdErrorTaskTextElement]
Read, Int -> NameCdErrorTaskTextElement -> ShowS
[NameCdErrorTaskTextElement] -> ShowS
NameCdErrorTaskTextElement -> String
(Int -> NameCdErrorTaskTextElement -> ShowS)
-> (NameCdErrorTaskTextElement -> String)
-> ([NameCdErrorTaskTextElement] -> ShowS)
-> Show NameCdErrorTaskTextElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NameCdErrorTaskTextElement -> ShowS
showsPrec :: Int -> NameCdErrorTaskTextElement -> ShowS
$cshow :: NameCdErrorTaskTextElement -> String
show :: NameCdErrorTaskTextElement -> String
$cshowList :: [NameCdErrorTaskTextElement] -> ShowS
showList :: [NameCdErrorTaskTextElement] -> ShowS
Show)

toTaskText
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> NameCdErrorInstance
  -> LangM m
toTaskText :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> NameCdErrorInstance -> LangM m
toTaskText String
path NameCdErrorInstance
task =
  (NameCdErrorTaskTextElement -> LangM m)
-> [SpecialOutput NameCdErrorTaskTextElement] -> LangM m
forall (m :: * -> *) element.
OutputCapable m =>
(element -> LangM m) -> [SpecialOutput element] -> LangM m
specialToOutputCapable (String
-> NameCdErrorInstance -> NameCdErrorTaskTextElement -> LangM m
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String
-> NameCdErrorInstance -> NameCdErrorTaskTextElement -> LangM m
toTaskSpecificText String
path NameCdErrorInstance
task) (NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
taskText NameCdErrorInstance
task)

toTaskSpecificText
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> NameCdErrorInstance
  -> NameCdErrorTaskTextElement
  -> LangM m
toTaskSpecificText :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String
-> NameCdErrorInstance -> NameCdErrorTaskTextElement -> LangM m
toTaskSpecificText String
path task :: NameCdErrorInstance
task@NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
..} = \case
    NameCdErrorTaskTextElement
IncorrectCd -> 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
$=<< CdDrawSettings -> Style V2 Double -> AnyCd -> String -> m String
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m) =>
CdDrawSettings -> Style V2 Double -> AnyCd -> String -> m String
cacheCd
      CdDrawSettings
cdDrawSettings
      Style V2 Double
forall a. Monoid a => a
mempty
      (AnnotatedCd Relevance -> AnyCd
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> AnyClassDiagram className relationshipName
unannotateCd AnnotatedCd Relevance
classDiagram)
      String
path
    NameCdErrorTaskTextElement
ReasonsList -> (Char -> LangM m) -> [(Char, LangM m)] -> LangM m
forall a. (a -> LangM m) -> [(a, LangM m)] -> LangM m
forall l (m :: * -> *) a.
GenericOutputCapable l m =>
(a -> GenericLangM l m ())
-> [(a, GenericLangM l m ())] -> GenericLangM l m ()
enumerateM (String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
text (String -> LangM m) -> (Char -> String) -> Char -> LangM m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> String
forall a. a -> [a]
singleton)
      ([(Char, LangM m)] -> LangM m) -> [(Char, LangM m)] -> LangM m
forall a b. (a -> b) -> a -> b
$ ((Char, (Bool, Reason)) -> (Char, LangM m))
-> [(Char, (Bool, Reason))] -> [(Char, LangM m)]
forall a b. (a -> b) -> [a] -> [b]
map (((Bool, Reason) -> LangM m)
-> (Char, (Bool, Reason)) -> (Char, LangM m)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Bool -> Reason -> LangM m
forall (m :: * -> *). OutputCapable m => Bool -> Reason -> LangM m
renderReason (CdDrawSettings -> Bool
printNavigations CdDrawSettings
cdDrawSettings) (Reason -> LangM m)
-> ((Bool, Reason) -> Reason) -> (Bool, Reason) -> LangM m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool, Reason) -> Reason
forall a b. (a, b) -> b
snd))
      ([(Char, (Bool, Reason))] -> [(Char, LangM m)])
-> [(Char, (Bool, Reason))] -> [(Char, LangM m)]
forall a b. (a -> b) -> a -> b
$ Map Char (Bool, Reason) -> [(Char, (Bool, Reason))]
forall k a. Map k a -> [(k, a)]
M.toList Map Char (Bool, Reason)
errorReasons
    NameCdErrorTaskTextElement
RelationshipsList -> do
      let defaults :: OmittedDefaultMultiplicities
defaults = CdDrawSettings -> OmittedDefaultMultiplicities
omittedDefaults CdDrawSettings
cdDrawSettings
          phrase :: ArticleToUse
-> Bool
-> Bool
-> AnyRelationship String String
-> GenericLangM Language m ()
phrase ArticleToUse
article Bool
x Bool
y AnyRelationship String String
z = State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ do
            String -> State (Map Language String) ()
english (String -> State (Map Language String) ())
-> String -> State (Map Language String) ()
forall a b. (a -> b) -> a -> b
$ Language
-> OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> Bool
-> Bool
-> AnyRelationship String String
-> String
phraseRelationship Language
English OmittedDefaultMultiplicities
defaults ArticleToUse
article PhrasingKind
Denoted Bool
x Bool
y AnyRelationship String String
z
            String -> State (Map Language String) ()
german (String -> State (Map Language String) ())
-> String -> State (Map Language String) ()
forall a b. (a -> b) -> a -> b
$ Language
-> OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> Bool
-> Bool
-> AnyRelationship String String
-> String
phraseRelationship Language
German OmittedDefaultMultiplicities
defaults ArticleToUse
article PhrasingKind
Denoted Bool
x Bool
y AnyRelationship String String
z
          phraseRelationship' :: Annotation Relevance (AnyRelationship String String)
-> GenericLangM Language m ()
phraseRelationship' Annotation {AnyRelationship String String
Relevance
annotated :: AnyRelationship String String
annotation :: Relevance
annotated :: forall annotation annotated.
Annotation annotation annotated -> annotated
annotation :: forall annotation annotated.
Annotation annotation annotated -> annotation
..} = ArticleToUse
-> Bool
-> Bool
-> AnyRelationship String String
-> GenericLangM Language m ()
forall {m :: * -> *}.
GenericOutputCapable Language m =>
ArticleToUse
-> Bool
-> Bool
-> AnyRelationship String String
-> GenericLangM Language m ()
phrase
            (Relevance -> ArticleToUse
referenceUsing Relevance
annotation)
            Bool
byName
            (CdDrawSettings -> Bool
printNavigations CdDrawSettings
cdDrawSettings)
            AnyRelationship String String
annotated
      (Int -> LangM m) -> [(Int, LangM m)] -> LangM m
forall a. (a -> LangM m) -> [(a, LangM m)] -> LangM m
forall l (m :: * -> *) a.
GenericOutputCapable l m =>
(a -> GenericLangM l m ())
-> [(a, GenericLangM l m ())] -> GenericLangM l m ()
enumerateM (String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
text (String -> LangM m) -> (Int -> String) -> Int -> LangM m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show)
        ([(Int, LangM m)] -> LangM m) -> [(Int, LangM m)] -> LangM m
forall a b. (a -> b) -> a -> b
$ ((Int, Annotation Relevance (AnyRelationship String String))
 -> (Int, LangM m))
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [(Int, LangM m)]
forall a b. (a -> b) -> [a] -> [b]
map ((Annotation Relevance (AnyRelationship String String) -> LangM m)
-> (Int, Annotation Relevance (AnyRelationship String String))
-> (Int, LangM m)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Annotation Relevance (AnyRelationship String String) -> LangM m
forall {m :: * -> *}.
GenericOutputCapable Language m =>
Annotation Relevance (AnyRelationship String String)
-> GenericLangM Language m ()
phraseRelationship')
        ([(Int, Annotation Relevance (AnyRelationship String String))]
 -> [(Int, LangM m)])
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [(Int, LangM m)]
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance
-> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships NameCdErrorInstance
task

data NameCdErrorInstance = NameCdErrorInstance {
  NameCdErrorInstance -> Bool
byName                      :: !Bool,
  NameCdErrorInstance -> AnnotatedCd Relevance
classDiagram                :: AnnotatedCd Relevance,
  NameCdErrorInstance -> CdDrawSettings
cdDrawSettings              :: !CdDrawSettings,
  NameCdErrorInstance -> Map Char (Bool, Reason)
errorReasons                :: !(Map Char (Bool, Reason)),
  NameCdErrorInstance -> Bool
showSolution                :: Bool,
  NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
taskText                    :: !NameCdErrorTaskText,
  NameCdErrorInstance -> Maybe (Map Language String)
addText                     :: Maybe (Map Language String)
  } deriving (Typeable NameCdErrorInstance
Typeable NameCdErrorInstance
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> NameCdErrorInstance
    -> c NameCdErrorInstance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameCdErrorInstance)
-> (NameCdErrorInstance -> Constr)
-> (NameCdErrorInstance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameCdErrorInstance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameCdErrorInstance))
-> ((forall b. Data b => b -> b)
    -> NameCdErrorInstance -> NameCdErrorInstance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NameCdErrorInstance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NameCdErrorInstance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorInstance -> m NameCdErrorInstance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorInstance -> m NameCdErrorInstance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NameCdErrorInstance -> m NameCdErrorInstance)
-> Data NameCdErrorInstance
NameCdErrorInstance -> Constr
NameCdErrorInstance -> DataType
(forall b. Data b => b -> b)
-> NameCdErrorInstance -> NameCdErrorInstance
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> NameCdErrorInstance -> u
forall u.
(forall d. Data d => d -> u) -> NameCdErrorInstance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorInstance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorInstance
-> c NameCdErrorInstance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameCdErrorInstance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorInstance)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorInstance
-> c NameCdErrorInstance
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> NameCdErrorInstance
-> c NameCdErrorInstance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorInstance
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameCdErrorInstance
$ctoConstr :: NameCdErrorInstance -> Constr
toConstr :: NameCdErrorInstance -> Constr
$cdataTypeOf :: NameCdErrorInstance -> DataType
dataTypeOf :: NameCdErrorInstance -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameCdErrorInstance)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameCdErrorInstance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorInstance)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameCdErrorInstance)
$cgmapT :: (forall b. Data b => b -> b)
-> NameCdErrorInstance -> NameCdErrorInstance
gmapT :: (forall b. Data b => b -> b)
-> NameCdErrorInstance -> NameCdErrorInstance
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameCdErrorInstance -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> NameCdErrorInstance -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> NameCdErrorInstance -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NameCdErrorInstance -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NameCdErrorInstance -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NameCdErrorInstance -> m NameCdErrorInstance
Data, NameCdErrorInstance -> NameCdErrorInstance -> Bool
(NameCdErrorInstance -> NameCdErrorInstance -> Bool)
-> (NameCdErrorInstance -> NameCdErrorInstance -> Bool)
-> Eq NameCdErrorInstance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NameCdErrorInstance -> NameCdErrorInstance -> Bool
== :: NameCdErrorInstance -> NameCdErrorInstance -> Bool
$c/= :: NameCdErrorInstance -> NameCdErrorInstance -> Bool
/= :: NameCdErrorInstance -> NameCdErrorInstance -> Bool
Eq, (forall x. NameCdErrorInstance -> Rep NameCdErrorInstance x)
-> (forall x. Rep NameCdErrorInstance x -> NameCdErrorInstance)
-> Generic NameCdErrorInstance
forall x. Rep NameCdErrorInstance x -> NameCdErrorInstance
forall x. NameCdErrorInstance -> Rep NameCdErrorInstance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NameCdErrorInstance -> Rep NameCdErrorInstance x
from :: forall x. NameCdErrorInstance -> Rep NameCdErrorInstance x
$cto :: forall x. Rep NameCdErrorInstance x -> NameCdErrorInstance
to :: forall x. Rep NameCdErrorInstance x -> NameCdErrorInstance
Generic, ReadPrec [NameCdErrorInstance]
ReadPrec NameCdErrorInstance
Int -> ReadS NameCdErrorInstance
ReadS [NameCdErrorInstance]
(Int -> ReadS NameCdErrorInstance)
-> ReadS [NameCdErrorInstance]
-> ReadPrec NameCdErrorInstance
-> ReadPrec [NameCdErrorInstance]
-> Read NameCdErrorInstance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NameCdErrorInstance
readsPrec :: Int -> ReadS NameCdErrorInstance
$creadList :: ReadS [NameCdErrorInstance]
readList :: ReadS [NameCdErrorInstance]
$creadPrec :: ReadPrec NameCdErrorInstance
readPrec :: ReadPrec NameCdErrorInstance
$creadListPrec :: ReadPrec [NameCdErrorInstance]
readListPrec :: ReadPrec [NameCdErrorInstance]
Read, Int -> NameCdErrorInstance -> ShowS
[NameCdErrorInstance] -> ShowS
NameCdErrorInstance -> String
(Int -> NameCdErrorInstance -> ShowS)
-> (NameCdErrorInstance -> String)
-> ([NameCdErrorInstance] -> ShowS)
-> Show NameCdErrorInstance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NameCdErrorInstance -> ShowS
showsPrec :: Int -> NameCdErrorInstance -> ShowS
$cshow :: NameCdErrorInstance -> String
show :: NameCdErrorInstance -> String
$cshowList :: [NameCdErrorInstance] -> ShowS
showList :: [NameCdErrorInstance] -> ShowS
Show)

relevantRelationships
  :: NameCdErrorInstance
  -> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships :: NameCdErrorInstance
-> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..} = [Int]
-> [Annotation Relevance (AnyRelationship String String)]
-> [(Int, Annotation Relevance (AnyRelationship String String))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1..]
  ([Annotation Relevance (AnyRelationship String String)]
 -> [(Int, Annotation Relevance (AnyRelationship String String))])
-> ([Annotation Relevance (AnyRelationship String String)]
    -> [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
-> [(Int, Annotation Relevance (AnyRelationship String String))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Annotation Relevance (AnyRelationship String String) -> Int)
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Relevance -> Int
listingPriority (Relevance -> Int)
-> (Annotation Relevance (AnyRelationship String String)
    -> Relevance)
-> Annotation Relevance (AnyRelationship String String)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation)
  ([Annotation Relevance (AnyRelationship String String)]
 -> [Annotation Relevance (AnyRelationship String String)])
-> ([Annotation Relevance (AnyRelationship String String)]
    -> [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Annotation Relevance (AnyRelationship String String) -> Bool)
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall a. (a -> Bool) -> [a] -> [a]
filter Annotation Relevance (AnyRelationship String String) -> Bool
forall annotated. Annotation Relevance annotated -> Bool
isRelevant
  ([Annotation Relevance (AnyRelationship String String)]
 -> [(Int, Annotation Relevance (AnyRelationship String String))])
-> [Annotation Relevance (AnyRelationship String String)]
-> [(Int, Annotation Relevance (AnyRelationship String String))]
forall a b. (a -> b) -> a -> b
$ AnnotatedCd Relevance
-> [Annotation Relevance (AnyRelationship String String)]
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> [Annotation
      relationshipAnnotation
      (AnyRelationship className relationshipName)]
annotatedRelationships AnnotatedCd Relevance
classDiagram

data Relevance
  = NotRelevant
  | Relevant {
    Relevance -> Bool
contributingToProblem     :: Bool,
    -- | for 'randomiseLayout' to work without influencing
    --   the order of the relationships in the list of relevant relationships
    --   each priority has to be unique for each class diagram
    --
    --   * the order applies to the list of relevant relationships
    --   * a lower number means higher priority
    Relevance -> Int
listingPriority           :: Int,
    Relevance -> ArticleToUse
referenceUsing            :: ArticleToUse
    }
  deriving (Typeable Relevance
Typeable Relevance
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Relevance -> c Relevance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Relevance)
-> (Relevance -> Constr)
-> (Relevance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Relevance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relevance))
-> ((forall b. Data b => b -> b) -> Relevance -> Relevance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Relevance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Relevance -> r)
-> (forall u. (forall d. Data d => d -> u) -> Relevance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Relevance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Relevance -> m Relevance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Relevance -> m Relevance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Relevance -> m Relevance)
-> Data Relevance
Relevance -> Constr
Relevance -> DataType
(forall b. Data b => b -> b) -> Relevance -> Relevance
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Relevance -> u
forall u. (forall d. Data d => d -> u) -> Relevance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relevance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relevance -> c Relevance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Relevance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relevance)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relevance -> c Relevance
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relevance -> c Relevance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relevance
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relevance
$ctoConstr :: Relevance -> Constr
toConstr :: Relevance -> Constr
$cdataTypeOf :: Relevance -> DataType
dataTypeOf :: Relevance -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Relevance)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Relevance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relevance)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relevance)
$cgmapT :: (forall b. Data b => b -> b) -> Relevance -> Relevance
gmapT :: (forall b. Data b => b -> b) -> Relevance -> Relevance
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relevance -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Relevance -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Relevance -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Relevance -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Relevance -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relevance -> m Relevance
Data, Relevance -> Relevance -> Bool
(Relevance -> Relevance -> Bool)
-> (Relevance -> Relevance -> Bool) -> Eq Relevance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Relevance -> Relevance -> Bool
== :: Relevance -> Relevance -> Bool
$c/= :: Relevance -> Relevance -> Bool
/= :: Relevance -> Relevance -> Bool
Eq, (forall x. Relevance -> Rep Relevance x)
-> (forall x. Rep Relevance x -> Relevance) -> Generic Relevance
forall x. Rep Relevance x -> Relevance
forall x. Relevance -> Rep Relevance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Relevance -> Rep Relevance x
from :: forall x. Relevance -> Rep Relevance x
$cto :: forall x. Rep Relevance x -> Relevance
to :: forall x. Rep Relevance x -> Relevance
Generic, ReadPrec [Relevance]
ReadPrec Relevance
Int -> ReadS Relevance
ReadS [Relevance]
(Int -> ReadS Relevance)
-> ReadS [Relevance]
-> ReadPrec Relevance
-> ReadPrec [Relevance]
-> Read Relevance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Relevance
readsPrec :: Int -> ReadS Relevance
$creadList :: ReadS [Relevance]
readList :: ReadS [Relevance]
$creadPrec :: ReadPrec Relevance
readPrec :: ReadPrec Relevance
$creadListPrec :: ReadPrec [Relevance]
readListPrec :: ReadPrec [Relevance]
Read, Int -> Relevance -> ShowS
[Relevance] -> ShowS
Relevance -> String
(Int -> Relevance -> ShowS)
-> (Relevance -> String)
-> ([Relevance] -> ShowS)
-> Show Relevance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Relevance -> ShowS
showsPrec :: Int -> Relevance -> ShowS
$cshow :: Relevance -> String
show :: Relevance -> String
$cshowList :: [Relevance] -> ShowS
showList :: [Relevance] -> ShowS
Show)

isRelevant :: Annotation Relevance annotated -> Bool
isRelevant :: forall annotated. Annotation Relevance annotated -> Bool
isRelevant =
  (\case Relevance
NotRelevant -> Bool
False; Relevant {} -> Bool
True)
  (Relevance -> Bool)
-> (Annotation Relevance annotated -> Relevance)
-> Annotation Relevance annotated
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance annotated -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation

checkNameCdErrorInstance :: NameCdErrorInstance -> Maybe String
checkNameCdErrorInstance :: NameCdErrorInstance -> Maybe String
checkNameCdErrorInstance NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..}
  | Bool -> Bool
not (CdDrawSettings -> Bool
printNames CdDrawSettings
cdDrawSettings) Bool -> Bool -> Bool
&& Bool
byName
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"by name is only possible when printing names"
  | Int
1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= [(Bool, Reason)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (((Bool, Reason) -> Bool) -> [(Bool, Reason)] -> [(Bool, Reason)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool, Reason) -> Bool
forall a b. (a, b) -> a
fst ([(Bool, Reason)] -> [(Bool, Reason)])
-> [(Bool, Reason)] -> [(Bool, Reason)]
forall a b. (a -> b) -> a -> b
$ Map Char (Bool, Reason) -> [(Bool, Reason)]
forall k a. Map k a -> [a]
M.elems Map Char (Bool, Reason)
errorReasons)
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      There needs to be exactly one error defined within errorReasons
      (i.e., set to 'True')
      |]
  | Int
x:[Int]
_ <- [Int]
listingPriorities [Int] -> [Int] -> [Int]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Int] -> [Int]
forall a. Ord a => [a] -> [a]
nubOrd [Int]
listingPriorities
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      'listingPriority' has to be unique for the class diagram,
      but '#{x}' appears twice which is not allowed.
      |]
  | Char
x:String
_ <- (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
filter (Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` String
letters) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Map Char (Bool, Reason) -> String
forall k a. Map k a -> [k]
M.keys Map Char (Bool, Reason)
errorReasons
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      'errorReasons' defines the invalid key character '#{x}' as one option,
      please choose one of #{letters} instead.
      |]
  | Reason
x:[Reason]
_ <- [Reason]
reasons [Reason] -> [Reason] -> [Reason]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Reason] -> [Reason]
forall a. Ord a => [a] -> [a]
nubOrd [Reason]
reasons
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      'errorReasons' contains duplicate '#{x}' which is not allowed.
      |]
  | String
x:[String]
_ <- (Reason -> [String]) -> [Reason] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Map Language String -> [String]
checkTranslation (Map Language String -> [String])
-> (Reason -> Map Language String) -> Reason -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Reason -> Map Language String
toTranslations Bool
True) [Reason]
reasons
  = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ [i|Problem within 'errorReasons': |] String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
x
  | Bool
otherwise
  = [SpecialOutput NameCdErrorTaskTextElement] -> Maybe String
forall element.
(Bounded element, Enum element, Eq element, Show element) =>
[SpecialOutput element] -> Maybe String
checkTaskText [SpecialOutput NameCdErrorTaskTextElement]
taskText
  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
<|> CdDrawSettings -> Maybe String
checkCdDrawSettings CdDrawSettings
cdDrawSettings
  where
    letters :: String
letters = [Char
'a' .. Char
'z'] String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'A' .. Char
'Z']
    reasons :: [Reason]
reasons = ((Bool, Reason) -> Reason) -> [(Bool, Reason)] -> [Reason]
forall a b. (a -> b) -> [a] -> [b]
map (Bool, Reason) -> Reason
forall a b. (a, b) -> b
snd ([(Bool, Reason)] -> [Reason]) -> [(Bool, Reason)] -> [Reason]
forall a b. (a -> b) -> a -> b
$ Map Char (Bool, Reason) -> [(Bool, Reason)]
forall k a. Map k a -> [a]
M.elems Map Char (Bool, Reason)
errorReasons
    listingPriorities :: [Int]
listingPriorities = (Annotation Relevance (AnyRelationship String String) -> Int)
-> [Annotation Relevance (AnyRelationship String String)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Relevance -> Int
listingPriority (Relevance -> Int)
-> (Annotation Relevance (AnyRelationship String String)
    -> Relevance)
-> Annotation Relevance (AnyRelationship String String)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation)
      ([Annotation Relevance (AnyRelationship String String)] -> [Int])
-> ([Annotation Relevance (AnyRelationship String String)]
    -> [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Annotation Relevance (AnyRelationship String String) -> Bool)
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall a. (a -> Bool) -> [a] -> [a]
filter Annotation Relevance (AnyRelationship String String) -> Bool
forall annotated. Annotation Relevance annotated -> Bool
isRelevant
      ([Annotation Relevance (AnyRelationship String String)] -> [Int])
-> [Annotation Relevance (AnyRelationship String String)] -> [Int]
forall a b. (a -> b) -> a -> b
$ AnnotatedCd Relevance
-> [Annotation Relevance (AnyRelationship String String)]
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> [Annotation
      relationshipAnnotation
      (AnyRelationship className relationshipName)]
annotatedRelationships AnnotatedCd Relevance
classDiagram

defaultNameCdErrorTaskText :: NameCdErrorTaskText
defaultNameCdErrorTaskText :: [SpecialOutput NameCdErrorTaskTextElement]
defaultNameCdErrorTaskText = [
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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
"Consider the following class diagram, which unfortunately is invalid:"
    String -> State (Map Language String) ()
german String
"Betrachten Sie folgendes Klassendiagramm, welches leider ungültig ist:",
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ NameCdErrorTaskTextElement
-> SpecialOutput NameCdErrorTaskTextElement
forall language element. element -> GenericOutput language element
Special NameCdErrorTaskTextElement
IncorrectCd,
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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
"It contains the following relationships between classes:"
    String -> State (Map Language String) ()
german String
"Es enthält die folgenden Beziehungen zwischen Klassen:",
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ NameCdErrorTaskTextElement
-> SpecialOutput NameCdErrorTaskTextElement
forall language element. element -> GenericOutput language element
Special NameCdErrorTaskTextElement
RelationshipsList,
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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 [iii|
      Choose what you think is the single reason that this class diagram is invalid,
      and mention all relationships that definitely contribute to the problem,
      i.e., removing any of them would fix the invalidity.
      |]
    String -> State (Map Language String) ()
german [iii|
      Wählen Sie aus, was Sie für den einen Grund dafür halten,
      dass dieses Klassendiagramm ungültig ist,
      und nennen Sie alle Beziehungen, die definitiv zum Problem beitragen,
      d.h., deren Entfernung die Ungültigkeit jeweils beheben würde.
      |],
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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 [i|Reasons available to choose from are:|]
    String -> State (Map Language String) ()
german [i|Gründe, die hierfür zur Auswahl stehen, sind:|],
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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 [i|The class diagram ...|]
    String -> State (Map Language String) ()
german [i|Das Klassendiagramm ...|],
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ NameCdErrorTaskTextElement
-> SpecialOutput NameCdErrorTaskTextElement
forall language element. element -> GenericOutput language element
Special NameCdErrorTaskTextElement
ReasonsList,
  [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph [
    [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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 [iii|
        Please state your answer by providing a letter for the reason,
        indicating the most specifically expressed reason
        for which you think this class diagram is invalid,
        and a listing of numbers for those relationships
        on whose individual presence the invalidity depends.
        For example,
        |]
      String -> State (Map Language String) ()
german [iii|
        Bitte geben Sie Ihre Antwort an, indem Sie Folgendes angeben:
        einen Buchstaben für den Grund,
        der Ihrer Meinung nach der am spezifischsten
        ausgedrückte Grund dafür ist,
        dass dieses Klassendiagramm ungültig ist,
        und eine Auflistung von Zahlen für diejenigen Beziehungen,
        von deren individueller Präsenz die Ungültigkeit abhängt.
        Zum Beispiel würde
        |],
    [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ String -> Map Language String
forall a. a -> Map Language a
uniform (String -> Map Language String) -> String -> Map Language String
forall a b. (a -> b) -> a -> b
$ NameCdErrorAnswer -> String
showNameCdErrorAnswer NameCdErrorAnswer
answer,
    [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([SpecialOutput NameCdErrorTaskTextElement]
 -> SpecialOutput NameCdErrorTaskTextElement)
-> [SpecialOutput NameCdErrorTaskTextElement]
-> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a. a -> [a]
singleton (SpecialOutput NameCdErrorTaskTextElement
 -> [SpecialOutput NameCdErrorTaskTextElement])
-> SpecialOutput NameCdErrorTaskTextElement
-> [SpecialOutput NameCdErrorTaskTextElement]
forall a b. (a -> b) -> a -> b
$ Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String -> SpecialOutput NameCdErrorTaskTextElement)
-> Map Language String -> SpecialOutput NameCdErrorTaskTextElement
forall a b. (a -> b) -> a -> b
$ 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 [iii|
        would indicate that the class diagram is invalid
        because of reason #{singleton $ reason answer}
        and that the #{dueTo1}. and #{dueTo2}. relationship (appearing together)
        create the invalidity.
        |]
      String -> State (Map Language String) ()
german [iii|
        bedeuten, dass das Klassendiagramm wegen Grund #{singleton $ reason answer} ungültig ist
        und dass die #{dueTo1}. und #{dueTo2}. Beziehung (zusammen auftretend)
        die Ungültigkeit erzeugen.
        |]
    ]
  ]
  where
    answer :: NameCdErrorAnswer
answer = NameCdErrorAnswer
defaultNameCdErrorAnswer

nameCdErrorTask
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> NameCdErrorInstance
  -> LangM m
nameCdErrorTask :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> NameCdErrorInstance -> LangM m
nameCdErrorTask String
path NameCdErrorInstance
task = do
  String -> NameCdErrorInstance -> LangM m
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> NameCdErrorInstance -> LangM m
toTaskText String
path NameCdErrorInstance
task
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph LangM m
forall (m :: * -> *). OutputCapable m => LangM m
simplifiedInformation
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph LangM m
forall (m :: * -> *). OutputCapable m => LangM m
hoveringInformation
  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
$ NameCdErrorInstance -> Maybe (Map Language String)
addText NameCdErrorInstance
task
  pure ()

dueTo1 :: Int
dueTo1 :: Int
dueTo1 = Int
3

dueTo2 :: Int
dueTo2 :: Int
dueTo2 = Int
4

defaultNameCdErrorAnswer :: NameCdErrorAnswer
defaultNameCdErrorAnswer :: NameCdErrorAnswer
defaultNameCdErrorAnswer = NameCdErrorAnswer {
  reason :: Char
reason = Char
'b',
  dueTo :: [Int]
dueTo = [Int
dueTo1, Int
dueTo2]
  }

showNameCdErrorAnswer :: NameCdErrorAnswer -> String
showNameCdErrorAnswer :: NameCdErrorAnswer -> String
showNameCdErrorAnswer = ByteString -> String
toString (ByteString -> String)
-> (NameCdErrorAnswer -> ByteString) -> NameCdErrorAnswer -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameCdErrorAnswer -> ByteString
forall a. ToJSON a => a -> ByteString
encode

parseNameCdErrorAnswer :: Parser NameCdErrorAnswer
parseNameCdErrorAnswer :: Parser NameCdErrorAnswer
parseNameCdErrorAnswer = do
  String
xs <- ParsecT String () Identity Char
-> ParsecT String () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT String () Identity Char
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m t
anyToken
  case ByteString -> Either ParseException NameCdErrorAnswer
forall a. FromJSON a => ByteString -> Either ParseException a
decodeEither' (ByteString -> Either ParseException NameCdErrorAnswer)
-> ByteString -> Either ParseException NameCdErrorAnswer
forall a b. (a -> b) -> a -> b
$ String -> ByteString
fromString String
xs of
    Left ParseException
e -> String -> Parser NameCdErrorAnswer
forall s u (m :: * -> *) a. String -> ParsecT s u m a
parserFail (String -> Parser NameCdErrorAnswer)
-> String -> Parser NameCdErrorAnswer
forall a b. (a -> b) -> a -> b
$ ParseException -> String
forall a. Show a => a -> String
show ParseException
e
    Right NameCdErrorAnswer
r -> NameCdErrorAnswer -> Parser NameCdErrorAnswer
forall a s u (m :: * -> *). a -> ParsecT s u m a
parserReturn NameCdErrorAnswer
r

nameCdErrorSyntax
  :: OutputCapable m
  => NameCdErrorInstance
  -> NameCdErrorAnswer
  -> LangM m
nameCdErrorSyntax :: forall (m :: * -> *).
OutputCapable m =>
NameCdErrorInstance -> NameCdErrorAnswer -> LangM m
nameCdErrorSyntax NameCdErrorInstance
inst NameCdErrorAnswer
x = 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
"Feedback on chosen reason:"
    String -> State (Map Language String) ()
german String
"Hinweis zum gewählten Grund:"
  Bool -> String -> Char -> LangM m
forall (m :: * -> *) a.
(OutputCapable m, Eq a, Show a) =>
Bool -> [a] -> a -> LangM m
singleChoiceSyntax Bool
False (Map Char (Bool, Reason) -> String
forall k a. Map k a -> [k]
M.keys (Map Char (Bool, Reason) -> String)
-> Map Char (Bool, Reason) -> String
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance -> Map Char (Bool, Reason)
errorReasons NameCdErrorInstance
inst) (Char -> LangM m) -> Char -> LangM m
forall a b. (a -> b) -> a -> b
$ NameCdErrorAnswer -> Char
reason NameCdErrorAnswer
x
  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
"Feedback on chosen relationships:"
    String -> State (Map Language String) ()
german String
"Hinweis zu gewählten Beziehungen:"
  Bool -> [Int] -> [Int] -> LangM m
forall (m :: * -> *) a.
(OutputCapable m, Ord a, Show a) =>
Bool -> [a] -> [a] -> LangM m
multipleChoiceSyntax Bool
False (((Int, Annotation Relevance (AnyRelationship String String))
 -> Int)
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Int, Annotation Relevance (AnyRelationship String String)) -> Int
forall a b. (a, b) -> a
fst ([(Int, Annotation Relevance (AnyRelationship String String))]
 -> [Int])
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Int]
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance
-> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships NameCdErrorInstance
inst) (NameCdErrorAnswer -> [Int]
dueTo NameCdErrorAnswer
x)
  pure ()

{-| Grading is done the following way:

 * 0 points if the reason is wrong
 * otherwise, multiple choice grading for answer on dueTo relationships
-}
nameCdErrorEvaluation
  :: (
    Alternative m,
    MonadCache m,
    MonadDiagrams m,
    MonadGraphviz m,
    OutputCapable m
    )
  => FilePath
  -> NameCdErrorInstance
  -> NameCdErrorAnswer
  -> Rated m
nameCdErrorEvaluation :: forall (m :: * -> *).
(Alternative m, MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> NameCdErrorInstance -> NameCdErrorAnswer -> Rated m
nameCdErrorEvaluation String
path inst :: NameCdErrorInstance
inst@NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..} NameCdErrorAnswer
x = 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 reasonTranslation :: Map Language String
reasonTranslation = [(Language, String)] -> Map Language String
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList [
        (Language
English, String
"reason"),
        (Language
German, String
"Grund")
        ]
      dueToTranslation :: Map Language String
dueToTranslation = [(Language, String)] -> Map Language String
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList [
        (Language
English, String
"relationships constituting the problem"),
        (Language
German, String
"das Problem ausmachenden Beziehungen")
        ]
      solutionReason :: Char
solutionReason = String -> Char
forall a. HasCallStack => [a] -> a
head (String -> Char)
-> (Map Char (Bool, Reason) -> String)
-> Map Char (Bool, Reason)
-> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Char (Bool, Reason) -> String
forall k a. Map k a -> [k]
M.keys (Map Char (Bool, Reason) -> String)
-> (Map Char (Bool, Reason) -> Map Char (Bool, Reason))
-> Map Char (Bool, Reason)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Bool, Reason) -> Bool)
-> Map Char (Bool, Reason) -> Map Char (Bool, Reason)
forall a k. (a -> Bool) -> Map k a -> Map k a
M.filter (Bool, Reason) -> Bool
forall a b. (a, b) -> a
fst (Map Char (Bool, Reason) -> Char)
-> Map Char (Bool, Reason) -> Char
forall a b. (a -> b) -> a -> b
$ Map Char (Bool, Reason)
errorReasons
      solutionDueTo :: Map Int Bool
solutionDueTo = [(Int, Bool)] -> Map Int Bool
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList
        ([(Int, Bool)] -> Map Int Bool) -> [(Int, Bool)] -> Map Int Bool
forall a b. (a -> b) -> a -> b
$ ((Int, Annotation Relevance (AnyRelationship String String))
 -> (Int, Bool))
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [(Int, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map ((Annotation Relevance (AnyRelationship String String) -> Bool)
-> (Int, Annotation Relevance (AnyRelationship String String))
-> (Int, Bool)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Relevance -> Bool
contributingToProblem (Relevance -> Bool)
-> (Annotation Relevance (AnyRelationship String String)
    -> Relevance)
-> Annotation Relevance (AnyRelationship String String)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation))
        [(Int, Annotation Relevance (AnyRelationship String String))]
relevant
      correctAnswer :: Maybe String
correctAnswer
        | Bool
showSolution = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ByteString -> String
toString (ByteString -> String) -> ByteString -> String
forall a b. (a -> b) -> a -> b
$ NameCdErrorAnswer -> ByteString
forall a. ToJSON a => a -> ByteString
encode (NameCdErrorAnswer -> ByteString)
-> NameCdErrorAnswer -> ByteString
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance -> NameCdErrorAnswer
nameCdErrorSolution NameCdErrorInstance
inst
        | Bool
otherwise = Maybe String
forall a. Maybe a
Nothing
  Rational
-> LangM' m Rational
-> GenericLangM Language m (Either Rational Rational)
forall (m :: * -> *) a l b.
Alternative m =>
a -> GenericLangM l m b -> GenericLangM l m (Either a b)
recoverWith Rational
0 (
    ArticleToUse
-> Map Language String -> Maybe String -> Char -> Char -> LangM m
forall (m :: * -> *) a.
(OutputCapable m, Eq a) =>
ArticleToUse
-> Map Language String -> Maybe String -> a -> a -> LangM m
singleChoice ArticleToUse
DefiniteArticle Map Language String
reasonTranslation Maybe String
forall a. Maybe a
Nothing Char
solutionReason (NameCdErrorAnswer -> Char
reason NameCdErrorAnswer
x)
      LangM m -> LangM' m Rational -> LangM' m Rational
forall (m :: * -> *) l a b.
Monad m =>
GenericLangM l m a -> GenericLangM l m b -> GenericLangM l m b
$>> ArticleToUse
-> Map Language String
-> Maybe String
-> Map Int Bool
-> [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
dueToTranslation
        Maybe String
forall a. Maybe a
Nothing
        Map Int Bool
solutionDueTo
        (NameCdErrorAnswer -> [Int]
dueTo NameCdErrorAnswer
x)
    )
    GenericLangM Language m (Either Rational Rational)
-> (Either Rational Rational -> LangM' m Rational)
-> LangM' m Rational
forall (m :: * -> *) l a b.
Monad m =>
GenericLangM l m a
-> (a -> GenericLangM l m b) -> GenericLangM l m b
$>>= \Either Rational Rational
points -> 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
$ Either Rational Rational -> State (Map Language String) ()
forall {a} {b}.
(Eq a, Eq b, Num b) =>
Either a b -> State (Map Language String) ()
classDiagramDescription Either Rational Rational
points
      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
$ 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
$=<< CdDrawSettings -> Style V2 Double -> AnyCd -> String -> m String
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m) =>
CdDrawSettings -> Style V2 Double -> AnyCd -> String -> m String
cacheCd CdDrawSettings
cdDrawSettings Style V2 Double
forall a. Monoid a => a
mempty AnyCd
changedCd String
path
      pure ()
    LangM m -> LangM' m Rational -> LangM' m Rational
forall (m :: * -> *) l a b.
Monad m =>
GenericLangM l m a -> GenericLangM l m b -> GenericLangM l m b
$>> ArticleToUse -> Maybe String -> Rational -> LangM' m Rational
forall (m :: * -> *).
OutputCapable m =>
ArticleToUse -> Maybe String -> Rational -> Rated m
printSolutionAndAssert ArticleToUse
DefiniteArticle Maybe String
correctAnswer (Rational -> LangM' m Rational) -> Rational -> LangM' m Rational
forall a b. (a -> b) -> a -> b
$ Either Rational Rational -> Rational
forall a. Either a a -> a
fromEither Either Rational Rational
points
  where
    relevant :: [(Int, Annotation Relevance (AnyRelationship String String))]
relevant = NameCdErrorInstance
-> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships NameCdErrorInstance
inst
    changedCd :: AnyCd
changedCd = AnnotatedCd Relevance -> AnyCd
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> AnyClassDiagram className relationshipName
unannotateCd (AnnotatedCd Relevance -> AnyCd) -> AnnotatedCd Relevance -> AnyCd
forall a b. (a -> b) -> a -> b
$ AnnotatedCd Relevance
classDiagram {
      annotatedRelationships :: [Annotation Relevance (AnyRelationship String String)]
annotatedRelationships = AnnotatedCd Relevance
-> [Annotation Relevance (AnyRelationship String String)]
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> [Annotation
      relationshipAnnotation
      (AnyRelationship className relationshipName)]
annotatedRelationships AnnotatedCd Relevance
classDiagram
        [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall a. Eq a => [a] -> [a] -> [a]
\\ ((Int, Annotation Relevance (AnyRelationship String String))
 -> Annotation Relevance (AnyRelationship String String))
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Annotation Relevance (AnyRelationship String String)]
forall a b. (a -> b) -> [a] -> [b]
map (Int, Annotation Relevance (AnyRelationship String String))
-> Annotation Relevance (AnyRelationship String String)
forall a b. (a, b) -> b
snd [(Int, Annotation Relevance (AnyRelationship String String))]
chosenRelevant
      }
    chosenRelevant :: [(Int, Annotation Relevance (AnyRelationship String String))]
chosenRelevant = ((Int, Annotation Relevance (AnyRelationship String String))
 -> Bool)
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [(Int, Annotation Relevance (AnyRelationship String String))]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Int -> [Int] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int] -> [Int]
forall a. Ord a => [a] -> [a]
nubOrd (NameCdErrorAnswer -> [Int]
dueTo NameCdErrorAnswer
x)) (Int -> Bool)
-> ((Int, Annotation Relevance (AnyRelationship String String))
    -> Int)
-> (Int, Annotation Relevance (AnyRelationship String String))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Annotation Relevance (AnyRelationship String String)) -> Int
forall a b. (a, b) -> a
fst) [(Int, Annotation Relevance (AnyRelationship String String))]
relevant
    classDiagramDescription :: Either a b -> State (Map Language String) ()
classDiagramDescription Either a b
points
      | Either a b
points Either a b -> Either a b -> Bool
forall a. Eq a => a -> a -> Bool
== b -> Either a b
forall a b. b -> Either a b
Right b
1 = do
        String -> State (Map Language String) ()
english [iii|
          If all relationships you correctly gave as constituting the problem
          would be removed, the following class diagram would result:
          |]
        String -> State (Map Language String) ()
german [iii|
          Wenn alle von Ihnen korrekterweise als das Problem ausmachend angegebenen
          Beziehungen entfernt würden,
          würde das folgende Klassendiagramm entstehen:
          |]
      | ((Int, Annotation Relevance (AnyRelationship String String))
 -> Bool)
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Relevance -> Bool
contributingToProblem (Relevance -> Bool)
-> ((Int, Annotation Relevance (AnyRelationship String String))
    -> Relevance)
-> (Int, Annotation Relevance (AnyRelationship String String))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation (Annotation Relevance (AnyRelationship String String) -> Relevance)
-> ((Int, Annotation Relevance (AnyRelationship String String))
    -> Annotation Relevance (AnyRelationship String String))
-> (Int, Annotation Relevance (AnyRelationship String String))
-> Relevance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Annotation Relevance (AnyRelationship String String))
-> Annotation Relevance (AnyRelationship String String)
forall a b. (a, b) -> b
snd) [(Int, Annotation Relevance (AnyRelationship String String))]
chosenRelevant = do
        String -> State (Map Language String) ()
english [iii|
          Nevertheless, the removal of all relationships you gave as
          contributing to the problem results in resolving the invalidity
          as the class diagram then would look like this:
          |]
        String -> State (Map Language String) ()
german [iii|
          Dennoch behebt das Entfernen aller von Ihnen als zum Problem beitragend
          angegebenen Beziehungen die Ungültigkeit,
          da das Klassendiagramm dann so aussehen würde:
          |]
      | Bool
otherwise = do
        String -> State (Map Language String) ()
english [iii|
          The removal of all relationships you gave as contributing to the problem
          still does not resolve the underlying issue
          as the class diagram then would look like this:
          |]
        String -> State (Map Language String) ()
german [iii|
          Das Entfernen aller von Ihnen als zum Problem beitragend angegebenen
          Beziehungen behebt das vorliegende Problem nicht,
          da das Klassendiagramm dann so aussehen würde:
          |]

nameCdErrorSolution :: NameCdErrorInstance -> NameCdErrorAnswer
nameCdErrorSolution :: NameCdErrorInstance -> NameCdErrorAnswer
nameCdErrorSolution NameCdErrorInstance
x = NameCdErrorAnswer {
  reason :: Char
reason = String -> Char
forall a. HasCallStack => [a] -> a
head (String -> Char)
-> (Map Char (Bool, Reason) -> String)
-> Map Char (Bool, Reason)
-> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Char (Bool, Reason) -> String
forall k a. Map k a -> [k]
M.keys (Map Char (Bool, Reason) -> String)
-> (Map Char (Bool, Reason) -> Map Char (Bool, Reason))
-> Map Char (Bool, Reason)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Bool, Reason) -> Bool)
-> Map Char (Bool, Reason) -> Map Char (Bool, Reason)
forall a k. (a -> Bool) -> Map k a -> Map k a
M.filter (Bool, Reason) -> Bool
forall a b. (a, b) -> a
fst (Map Char (Bool, Reason) -> Char)
-> Map Char (Bool, Reason) -> Char
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance -> Map Char (Bool, Reason)
errorReasons NameCdErrorInstance
x,
  dueTo :: [Int]
dueTo = ((Int, Annotation Relevance (AnyRelationship String String))
 -> Int)
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Int, Annotation Relevance (AnyRelationship String String)) -> Int
forall a b. (a, b) -> a
fst
    ([(Int, Annotation Relevance (AnyRelationship String String))]
 -> [Int])
-> ([(Int, Annotation Relevance (AnyRelationship String String))]
    -> [(Int, Annotation Relevance (AnyRelationship String String))])
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, Annotation Relevance (AnyRelationship String String))
 -> Bool)
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [(Int, Annotation Relevance (AnyRelationship String String))]
forall a. (a -> Bool) -> [a] -> [a]
filter (Relevance -> Bool
contributingToProblem (Relevance -> Bool)
-> ((Int, Annotation Relevance (AnyRelationship String String))
    -> Relevance)
-> (Int, Annotation Relevance (AnyRelationship String String))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation (Annotation Relevance (AnyRelationship String String) -> Relevance)
-> ((Int, Annotation Relevance (AnyRelationship String String))
    -> Annotation Relevance (AnyRelationship String String))
-> (Int, Annotation Relevance (AnyRelationship String String))
-> Relevance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Annotation Relevance (AnyRelationship String String))
-> Annotation Relevance (AnyRelationship String String)
forall a b. (a, b) -> b
snd)
    ([(Int, Annotation Relevance (AnyRelationship String String))]
 -> [Int])
-> [(Int, Annotation Relevance (AnyRelationship String String))]
-> [Int]
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance
-> [(Int, Annotation Relevance (AnyRelationship String String))]
relevantRelationships NameCdErrorInstance
x
  }

classAndNonInheritanceNames :: NameCdErrorInstance -> ([String], [String])
classAndNonInheritanceNames :: NameCdErrorInstance -> ([String], [String])
classAndNonInheritanceNames NameCdErrorInstance
inst =
  let cd :: AnyCd
cd = AnnotatedCd Relevance -> AnyCd
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> AnyClassDiagram className relationshipName
unannotateCd (AnnotatedCd Relevance -> AnyCd) -> AnnotatedCd Relevance -> AnyCd
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance -> AnnotatedCd Relevance
classDiagram NameCdErrorInstance
inst
      names :: [String]
names = [String] -> [String]
forall a. Ord a => [a] -> [a]
nubOrd ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ AnyCd -> [String]
forall className relationshipName.
AnyClassDiagram className relationshipName -> [className]
anyClassNames AnyCd
cd
      nonInheritances :: [String]
nonInheritances = [String] -> [String]
forall a. Ord a => [a] -> [a]
nubOrd ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ AnyCd -> [String]
anyAssociationNames AnyCd
cd
  in ([String]
names, [String]
nonInheritances)

instance Randomise NameCdErrorInstance where
  randomise :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
NameCdErrorInstance -> m NameCdErrorInstance
randomise = NameCdErrorInstance -> m NameCdErrorInstance
forall (m :: * -> *).
MonadRandom m =>
NameCdErrorInstance -> m NameCdErrorInstance
shuffleInstance

instance RandomiseNames NameCdErrorInstance where
  randomiseNames :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
NameCdErrorInstance -> m NameCdErrorInstance
randomiseNames NameCdErrorInstance
inst = do
    let ([String]
names, [String]
nonInheritances) = NameCdErrorInstance -> ([String], [String])
classAndNonInheritanceNames NameCdErrorInstance
inst
    [String]
names' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
names
    [String]
nonInheritances' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
nonInheritances
    NameCdErrorInstance
-> [String] -> [String] -> m NameCdErrorInstance
forall (m :: * -> *).
MonadThrow m =>
NameCdErrorInstance
-> [String] -> [String] -> m NameCdErrorInstance
renameInstance NameCdErrorInstance
inst [String]
names' [String]
nonInheritances'

instance RandomiseLayout NameCdErrorInstance where
  randomiseLayout :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
NameCdErrorInstance -> m NameCdErrorInstance
randomiseLayout NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..} = do
    AnnotatedCd Relevance
cd <- AnnotatedCd Relevance -> m (AnnotatedCd Relevance)
forall (m :: * -> *) annotation classes relationships.
MonadRandom m =>
AnnotatedClassDiagram annotation classes relationships
-> m (AnnotatedClassDiagram annotation classes relationships)
shuffleAnnotatedClassAndConnectionOrder AnnotatedCd Relevance
classDiagram
    return NameCdErrorInstance {
      byName :: Bool
byName = Bool
byName,
      cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings
cdDrawSettings,
      classDiagram :: AnnotatedCd Relevance
classDiagram = AnnotatedCd Relevance
cd,
      errorReasons :: Map Char (Bool, Reason)
errorReasons = Map Char (Bool, Reason)
errorReasons,
      showSolution :: Bool
showSolution = Bool
showSolution,
      taskText :: [SpecialOutput NameCdErrorTaskTextElement]
taskText = [SpecialOutput NameCdErrorTaskTextElement]
taskText,
      addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
addText
      }

shuffleInstance :: MonadRandom m => NameCdErrorInstance -> m NameCdErrorInstance
shuffleInstance :: forall (m :: * -> *).
MonadRandom m =>
NameCdErrorInstance -> m NameCdErrorInstance
shuffleInstance NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..} = do
  [Int]
priorities <- [Int] -> m [Int]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM
    ([Int] -> m [Int]) -> [Int] -> m [Int]
forall a b. (a -> b) -> a -> b
$ (Annotation Relevance (AnyRelationship String String) -> Int)
-> [Annotation Relevance (AnyRelationship String String)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Relevance -> Int
listingPriority (Relevance -> Int)
-> (Annotation Relevance (AnyRelationship String String)
    -> Relevance)
-> Annotation Relevance (AnyRelationship String String)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation Relevance (AnyRelationship String String) -> Relevance
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation)
    ([Annotation Relevance (AnyRelationship String String)] -> [Int])
-> [Annotation Relevance (AnyRelationship String String)] -> [Int]
forall a b. (a -> b) -> a -> b
$ (Annotation Relevance (AnyRelationship String String) -> Bool)
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall a. (a -> Bool) -> [a] -> [a]
filter Annotation Relevance (AnyRelationship String String) -> Bool
forall annotated. Annotation Relevance annotated -> Bool
isRelevant
    ([Annotation Relevance (AnyRelationship String String)]
 -> [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
-> [Annotation Relevance (AnyRelationship String String)]
forall a b. (a -> b) -> a -> b
$ AnnotatedCd Relevance
-> [Annotation Relevance (AnyRelationship String String)]
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> [Annotation
      relationshipAnnotation
      (AnyRelationship className relationshipName)]
annotatedRelationships AnnotatedCd Relevance
classDiagram
  Map Char (Bool, Reason)
rs <- [(Char, (Bool, Reason))] -> Map Char (Bool, Reason)
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Char, (Bool, Reason))] -> Map Char (Bool, Reason))
-> ([(Bool, Reason)] -> [(Char, (Bool, Reason))])
-> [(Bool, Reason)]
-> Map Char (Bool, Reason)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [(Bool, Reason)] -> [(Char, (Bool, Reason))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Char
'a' ..] ([(Bool, Reason)] -> Map Char (Bool, Reason))
-> m [(Bool, Reason)] -> m (Map Char (Bool, Reason))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Bool, Reason)] -> m [(Bool, Reason)]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM (Map Char (Bool, Reason) -> [(Bool, Reason)]
forall k a. Map k a -> [a]
M.elems Map Char (Bool, Reason)
errorReasons)
  return $ NameCdErrorInstance {
    byName :: Bool
byName = Bool
byName,
    cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings
cdDrawSettings,
    classDiagram :: AnnotatedCd Relevance
classDiagram = AnnotatedCd Relevance
classDiagram {
      annotatedRelationships :: [Annotation Relevance (AnyRelationship String String)]
annotatedRelationships = ([Int], [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
forall a b. (a, b) -> b
snd (([Int], [Annotation Relevance (AnyRelationship String String)])
 -> [Annotation Relevance (AnyRelationship String String)])
-> ([Int], [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
forall a b. (a -> b) -> a -> b
$ (Annotation Relevance (AnyRelationship String String)
 -> ([Int], [Annotation Relevance (AnyRelationship String String)])
 -> ([Int], [Annotation Relevance (AnyRelationship String String)]))
-> ([Int], [Annotation Relevance (AnyRelationship String String)])
-> [Annotation Relevance (AnyRelationship String String)]
-> ([Int], [Annotation Relevance (AnyRelationship String String)])
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
        Annotation Relevance (AnyRelationship String String)
-> ([Int], [Annotation Relevance (AnyRelationship String String)])
-> ([Int], [Annotation Relevance (AnyRelationship String String)])
forall {annotated}.
Annotation Relevance annotated
-> ([Int], [Annotation Relevance annotated])
-> ([Int], [Annotation Relevance annotated])
updatePriority
        ([Int]
priorities, [])
        (AnnotatedCd Relevance
-> [Annotation Relevance (AnyRelationship String String)]
forall relationshipAnnotation className relationshipName.
AnnotatedClassDiagram
  relationshipAnnotation className relationshipName
-> [Annotation
      relationshipAnnotation
      (AnyRelationship className relationshipName)]
annotatedRelationships AnnotatedCd Relevance
classDiagram)
      },
    errorReasons :: Map Char (Bool, Reason)
errorReasons = Map Char (Bool, Reason)
rs,
    showSolution :: Bool
showSolution = Bool
showSolution,
    taskText :: [SpecialOutput NameCdErrorTaskTextElement]
taskText = [SpecialOutput NameCdErrorTaskTextElement]
taskText,
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
addText
    }
  where
    updatePriority :: Annotation Relevance annotated
-> ([Int], [Annotation Relevance annotated])
-> ([Int], [Annotation Relevance annotated])
updatePriority Annotation Relevance annotated
x ([Int]
priorities, [Annotation Relevance annotated]
ys) = case Annotation Relevance annotated
x of
      Annotation {annotation :: forall annotation annotated.
Annotation annotation annotated -> annotation
annotation = Relevance
NotRelevant} -> ([Int]
priorities, Annotation Relevance annotated
x Annotation Relevance annotated
-> [Annotation Relevance annotated]
-> [Annotation Relevance annotated]
forall a. a -> [a] -> [a]
: [Annotation Relevance annotated]
ys)
      Annotation {annotated
Relevance
annotated :: forall annotation annotated.
Annotation annotation annotated -> annotated
annotation :: forall annotation annotated.
Annotation annotation annotated -> annotation
annotated :: annotated
annotation :: Relevance
..} -> ([Int] -> [Int]
forall a. HasCallStack => [a] -> [a]
tail [Int]
priorities,) ([Annotation Relevance annotated]
 -> ([Int], [Annotation Relevance annotated]))
-> [Annotation Relevance annotated]
-> ([Int], [Annotation Relevance annotated])
forall a b. (a -> b) -> a -> b
$
        Annotation {
          annotation :: Relevance
annotation = Relevance
annotation {listingPriority :: Int
listingPriority = [Int] -> Int
forall a. HasCallStack => [a] -> a
head [Int]
priorities},
          annotated :: annotated
annotated = annotated
annotated
          }
        Annotation Relevance annotated
-> [Annotation Relevance annotated]
-> [Annotation Relevance annotated]
forall a. a -> [a] -> [a]
: [Annotation Relevance annotated]
ys

renameInstance
  :: MonadThrow m
  => NameCdErrorInstance
  -> [String]
  -> [String]
  -> m NameCdErrorInstance
renameInstance :: forall (m :: * -> *).
MonadThrow m =>
NameCdErrorInstance
-> [String] -> [String] -> m NameCdErrorInstance
renameInstance inst :: NameCdErrorInstance
inst@NameCdErrorInstance {Bool
[SpecialOutput NameCdErrorTaskTextElement]
Maybe (Map Language String)
Map Char (Bool, Reason)
AnnotatedCd Relevance
CdDrawSettings
taskText :: NameCdErrorInstance -> [SpecialOutput NameCdErrorTaskTextElement]
byName :: NameCdErrorInstance -> Bool
classDiagram :: NameCdErrorInstance -> AnnotatedCd Relevance
cdDrawSettings :: NameCdErrorInstance -> CdDrawSettings
errorReasons :: NameCdErrorInstance -> Map Char (Bool, Reason)
showSolution :: NameCdErrorInstance -> Bool
addText :: NameCdErrorInstance -> Maybe (Map Language String)
byName :: Bool
classDiagram :: AnnotatedCd Relevance
cdDrawSettings :: CdDrawSettings
errorReasons :: Map Char (Bool, Reason)
showSolution :: Bool
taskText :: [SpecialOutput NameCdErrorTaskTextElement]
addText :: Maybe (Map Language String)
..} [String]
names' [String]
nonInheritances' = do
  let ([String]
names, [String]
nonInheritances) = NameCdErrorInstance -> ([String], [String])
classAndNonInheritanceNames NameCdErrorInstance
inst
      bmNames :: Bimap String String
bmNames  = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
names [String]
names'
      bmNonInheritances :: Bimap String String
bmNonInheritances = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
nonInheritances [String]
nonInheritances'
      renameCd :: AnnotatedCd Relevance -> m (AnnotatedCd Relevance)
renameCd = Bimap String String
-> Bimap String String
-> AnnotatedCd Relevance
-> m (AnnotatedCd Relevance)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
  AnnotatedCd Relevance
cd <- AnnotatedCd Relevance -> m (AnnotatedCd Relevance)
renameCd AnnotatedCd Relevance
classDiagram
  return $ NameCdErrorInstance {
    byName :: Bool
byName = Bool
byName,
    cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings
cdDrawSettings,
    classDiagram :: AnnotatedCd Relevance
classDiagram = AnnotatedCd Relevance
cd,
    errorReasons :: Map Char (Bool, Reason)
errorReasons = Map Char (Bool, Reason)
errorReasons,
    showSolution :: Bool
showSolution = Bool
showSolution,
    taskText :: [SpecialOutput NameCdErrorTaskTextElement]
taskText = [SpecialOutput NameCdErrorTaskTextElement]
taskText,
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
addText
    }

nameCdErrorGenerate
  :: (MonadAlloy m, MonadCatch m)
  => NameCdErrorConfig
  -> Int
  -> Int
  -> m NameCdErrorInstance
nameCdErrorGenerate :: forall (m :: * -> *).
(MonadAlloy m, MonadCatch m) =>
NameCdErrorConfig -> Int -> Int -> m NameCdErrorInstance
nameCdErrorGenerate NameCdErrorConfig
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 NameCdErrorInstance
 -> StdGen -> m NameCdErrorInstance)
-> StdGen
-> RandT StdGen m NameCdErrorInstance
-> m NameCdErrorInstance
forall a b c. (a -> b -> c) -> b -> a -> c
flip RandT StdGen m NameCdErrorInstance
-> StdGen -> m NameCdErrorInstance
forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
evalRandT StdGen
g (RandT StdGen m NameCdErrorInstance -> m NameCdErrorInstance)
-> RandT StdGen m NameCdErrorInstance -> m NameCdErrorInstance
forall a b. (a -> b) -> a -> b
$ NameCdErrorConfig -> RandT StdGen m NameCdErrorInstance
forall (m :: * -> *) g.
(MonadAlloy m, MonadCatch m, RandomGen g) =>
NameCdErrorConfig -> RandT g m NameCdErrorInstance
generateAndRandomise NameCdErrorConfig
config

generateAndRandomise
  :: (MonadAlloy m, MonadCatch m, RandomGen g)
  => NameCdErrorConfig
  -> RandT g m NameCdErrorInstance
generateAndRandomise :: forall (m :: * -> *) g.
(MonadAlloy m, MonadCatch m, RandomGen g) =>
NameCdErrorConfig -> RandT g m NameCdErrorInstance
generateAndRandomise config :: NameCdErrorConfig
config@NameCdErrorConfig {Bool
[Reason]
Maybe Int
Maybe Integer
Maybe (Map Language String)
ArticlePreference
AllowedProperties
ObjectProperties
CdDrawSettings
CdConstraints
ClassConfig
NumberOfReasons
allowedProperties :: NameCdErrorConfig -> AllowedProperties
articleToUse :: NameCdErrorConfig -> ArticlePreference
cdConstraints :: NameCdErrorConfig -> CdConstraints
classConfig :: NameCdErrorConfig -> ClassConfig
drawSettings :: NameCdErrorConfig -> CdDrawSettings
maxInstances :: NameCdErrorConfig -> Maybe Integer
objectProperties :: NameCdErrorConfig -> ObjectProperties
possibleReasons :: NameCdErrorConfig -> [Reason]
printSolution :: NameCdErrorConfig -> Bool
reasonsPerInstance :: NameCdErrorConfig -> NumberOfReasons
timeout :: NameCdErrorConfig -> Maybe Int
useNames :: NameCdErrorConfig -> Bool
extraText :: NameCdErrorConfig -> Maybe (Map Language String)
allowedProperties :: AllowedProperties
articleToUse :: ArticlePreference
cdConstraints :: CdConstraints
classConfig :: ClassConfig
drawSettings :: CdDrawSettings
maxInstances :: Maybe Integer
objectProperties :: ObjectProperties
possibleReasons :: [Reason]
printSolution :: Bool
reasonsPerInstance :: NumberOfReasons
timeout :: Maybe Int
useNames :: Bool
extraText :: Maybe (Map Language String)
..} = do
  (AnyCd
cd, Property
reason, [AnyRelationship String String]
rs) <- NameCdErrorConfig
-> RandT g m (AnyCd, Property, [AnyRelationship String String])
forall (m :: * -> *) g.
(MonadAlloy m, MonadCatch m, RandomGen g) =>
NameCdErrorConfig
-> RandT g m (AnyCd, Property, [AnyRelationship String String])
nameCdError NameCdErrorConfig
config
  [Reason]
reasons <- [Reason] -> RandT g m [Reason]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [Reason]
possibleReasons
  let ([Reason]
custom, [Reason]
predefined) = (Reason -> Bool) -> [Reason] -> ([Reason], [Reason])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition Reason -> Bool
isCustom ([Reason] -> ([Reason], [Reason]))
-> [Reason] -> ([Reason], [Reason])
forall a b. (a -> b) -> a -> b
$ Reason -> [Reason] -> [Reason]
forall a. Eq a => a -> [a] -> [a]
delete (Property -> Reason
PreDefined Property
reason) [Reason]
reasons
      ([Reason]
invalid, [Reason]
valid) = (Reason -> Bool) -> [Reason] -> ([Reason], [Reason])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition
        (\case (PreDefined Property
x) -> Property -> Bool
isIllegal Property
x; Custom {} -> Bool
False)
        [Reason]
predefined
      chosenReasons :: [Reason]
chosenReasons = Int -> [Reason] -> [Reason]
forall a. Int -> [a] -> [a]
take (NumberOfReasons -> Int
customReasons NumberOfReasons
reasonsPerInstance) [Reason]
custom
        [Reason] -> [Reason] -> [Reason]
forall a. [a] -> [a] -> [a]
++ Int -> [Reason] -> [Reason]
forall a. Int -> [a] -> [a]
take (NumberOfReasons -> Int
preDefinedInvalid NumberOfReasons
reasonsPerInstance Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Reason]
invalid
        [Reason] -> [Reason] -> [Reason]
forall a. [a] -> [a] -> [a]
++ Int -> [Reason] -> [Reason]
forall a. Int -> [a] -> [a]
take (NumberOfReasons -> Int
preDefinedValid NumberOfReasons
reasonsPerInstance) [Reason]
valid
  NameCdErrorInstance -> RandT g m NameCdErrorInstance
forall (m :: * -> *) a.
(MonadRandom m, MonadThrow m, Randomise a, RandomiseLayout a,
 RandomiseNames a) =>
a -> m a
shuffleEverything (NameCdErrorInstance -> RandT g m NameCdErrorInstance)
-> NameCdErrorInstance -> RandT g m NameCdErrorInstance
forall a b. (a -> b) -> a -> b
$ NameCdErrorInstance {
    byName :: Bool
byName = CdDrawSettings -> Bool
printNames CdDrawSettings
drawSettings Bool -> Bool -> Bool
&& Bool
useNames,
    cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings
drawSettings,
    classDiagram :: AnnotatedCd Relevance
classDiagram = AnnotatedClassDiagram {
      annotatedClasses :: [String]
annotatedClasses = AnyCd -> [String]
forall className relationshipName.
AnyClassDiagram className relationshipName -> [className]
anyClassNames AnyCd
cd,
      annotatedRelationships :: [Annotation Relevance (AnyRelationship String String)]
annotatedRelationships = (Int
 -> AnyRelationship String String
 -> Annotation Relevance (AnyRelationship String String))
-> [Int]
-> [AnyRelationship String String]
-> [Annotation Relevance (AnyRelationship String String)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith
        ([AnyRelationship String String]
-> Int
-> AnyRelationship String String
-> Annotation Relevance (AnyRelationship String String)
forall {t :: * -> *} {a}.
(Foldable t, Eq a) =>
t a -> Int -> a -> Annotation Relevance a
relevanceFor [AnyRelationship String String]
rs)
        [Int
1..]
        (AnyCd -> [AnyRelationship String String]
forall className relationshipName.
AnyClassDiagram className relationshipName
-> [AnyRelationship className relationshipName]
anyRelationships AnyCd
cd)
      },
    errorReasons :: Map Char (Bool, Reason)
errorReasons = [(Char, (Bool, Reason))] -> Map Char (Bool, Reason)
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Char, (Bool, Reason))] -> Map Char (Bool, Reason))
-> [(Char, (Bool, Reason))] -> Map Char (Bool, Reason)
forall a b. (a -> b) -> a -> b
$ String -> [(Bool, Reason)] -> [(Char, (Bool, Reason))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Char
'a' ..]
      ([(Bool, Reason)] -> [(Char, (Bool, Reason))])
-> [(Bool, Reason)] -> [(Char, (Bool, Reason))]
forall a b. (a -> b) -> a -> b
$ (Bool
True, Property -> Reason
PreDefined Property
reason)
      (Bool, Reason) -> [(Bool, Reason)] -> [(Bool, Reason)]
forall a. a -> [a] -> [a]
: (Reason -> (Bool, Reason)) -> [Reason] -> [(Bool, Reason)]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
False,) [Reason]
chosenReasons,
    showSolution :: Bool
showSolution = Bool
printSolution,
    taskText :: [SpecialOutput NameCdErrorTaskTextElement]
taskText = [SpecialOutput NameCdErrorTaskTextElement]
defaultNameCdErrorTaskText,
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
extraText
    }
  where
    relevanceFor :: t a -> Int -> a -> Annotation Relevance a
relevanceFor t a
xs Int
n a
x = Annotation {
      annotated :: a
annotated = a
x,
      annotation :: Relevance
annotation = Relevant {
        contributingToProblem :: Bool
contributingToProblem = a
x a -> t a -> Bool
forall a. Eq a => a -> t a -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` t a
xs,
        listingPriority :: Int
listingPriority = Int
n,
        referenceUsing :: ArticleToUse
referenceUsing = ArticlePreference -> ArticleToUse
toArticleToUse ArticlePreference
articleToUse
        }
      }

nameCdError
  :: (MonadAlloy m, MonadCatch m, RandomGen g)
  => NameCdErrorConfig
  -> RandT g m (AnyCd, Property, [AnyRelationship String String])
nameCdError :: forall (m :: * -> *) g.
(MonadAlloy m, MonadCatch m, RandomGen g) =>
NameCdErrorConfig
-> RandT g m (AnyCd, Property, [AnyRelationship String String])
nameCdError NameCdErrorConfig {Bool
[Reason]
Maybe Int
Maybe Integer
Maybe (Map Language String)
ArticlePreference
AllowedProperties
ObjectProperties
CdDrawSettings
CdConstraints
ClassConfig
NumberOfReasons
allowedProperties :: NameCdErrorConfig -> AllowedProperties
articleToUse :: NameCdErrorConfig -> ArticlePreference
cdConstraints :: NameCdErrorConfig -> CdConstraints
classConfig :: NameCdErrorConfig -> ClassConfig
drawSettings :: NameCdErrorConfig -> CdDrawSettings
maxInstances :: NameCdErrorConfig -> Maybe Integer
objectProperties :: NameCdErrorConfig -> ObjectProperties
possibleReasons :: NameCdErrorConfig -> [Reason]
printSolution :: NameCdErrorConfig -> Bool
reasonsPerInstance :: NameCdErrorConfig -> NumberOfReasons
timeout :: NameCdErrorConfig -> Maybe Int
useNames :: NameCdErrorConfig -> Bool
extraText :: NameCdErrorConfig -> Maybe (Map Language String)
allowedProperties :: AllowedProperties
articleToUse :: ArticlePreference
cdConstraints :: CdConstraints
classConfig :: ClassConfig
drawSettings :: CdDrawSettings
maxInstances :: Maybe Integer
objectProperties :: ObjectProperties
possibleReasons :: [Reason]
printSolution :: Bool
reasonsPerInstance :: NumberOfReasons
timeout :: Maybe Int
useNames :: Bool
extraText :: Maybe (Map Language String)
..}  = do
  [(StructuralWeakening, StructuralWeakening)]
structuralWeakenings <- [(StructuralWeakening, StructuralWeakening)]
-> RandT g m [(StructuralWeakening, StructuralWeakening)]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [ (StructuralWeakening
x,StructuralWeakening
y) |
    StructuralWeakening
x <- AllowedProperties -> [StructuralWeakening]
illegalStructuralWeakenings AllowedProperties
allowedProperties,
    StructuralWeakening
y <- AllowedProperties -> [StructuralWeakening]
legalStructuralWeakenings AllowedProperties
allowedProperties
    ]
  [(StructuralWeakening, StructuralWeakening)]
-> RandT g m (AnyCd, Property, [AnyRelationship String String])
forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(MonadCatch (t m), MonadTrans t, MonadAlloy m, MonadAlloy (t m),
 MonadRandom (t m), MonadThrow m) =>
[(StructuralWeakening, StructuralWeakening)]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithStructuralWeakenings [(StructuralWeakening, StructuralWeakening)]
structuralWeakenings
  where
    getFixWith :: Maybe AnyCd -> RelationshipProperties -> String
getFixWith Maybe AnyCd
cd RelationshipProperties
properties = Maybe AnyCd
-> ClassConfig
-> CdConstraints
-> RelationshipProperties
-> AllowedProperties
-> Bool
-> String
Changes.transformGetNextFix
      Maybe AnyCd
cd
      ClassConfig
classConfig
      CdConstraints
cdConstraints
      RelationshipProperties
properties
      AllowedProperties
allowedProperties
      Bool
useNames
    getInstanceWithStructuralWeakenings :: [(StructuralWeakening, StructuralWeakening)]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithStructuralWeakenings [] =
      String -> t m (AnyCd, Property, [AnyRelationship String String])
forall a. HasCallStack => String -> a
error String
"there seems to be no instance for the provided configuration"
    getInstanceWithStructuralWeakenings ((StructuralWeakening
e0, StructuralWeakening
l0) : [(StructuralWeakening, StructuralWeakening)]
chs) = do
      let p :: RelationshipProperties
p = StructuralWeakening -> RelationshipProperties
toProperty (StructuralWeakening -> RelationshipProperties)
-> StructuralWeakening -> RelationshipProperties
forall a b. (a -> b) -> a -> b
$ StructuralWeakening
e0 StructuralWeakening -> StructuralWeakening -> StructuralWeakening
.&. StructuralWeakening
l0
          alloyCode :: String
alloyCode = Maybe AnyCd -> RelationshipProperties -> String
getFixWith Maybe AnyCd
forall a. Maybe a
Nothing RelationshipProperties
p
      [AlloyInstance]
instances <- m [AlloyInstance] -> t m [AlloyInstance]
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m [AlloyInstance] -> t m [AlloyInstance])
-> m [AlloyInstance] -> t m [AlloyInstance]
forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
forall (m :: * -> *).
MonadAlloy m =>
Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
getInstances Maybe Integer
maxInstances Maybe Int
timeout String
alloyCode
      [AlloyInstance]
randomInstances <- [AlloyInstance] -> t m [AlloyInstance]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [AlloyInstance]
instances
      [(StructuralWeakening, StructuralWeakening)]
-> RelationshipProperties
-> [AlloyInstance]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithODs [(StructuralWeakening, StructuralWeakening)]
chs RelationshipProperties
p [AlloyInstance]
randomInstances
    getInstanceWithODs :: [(StructuralWeakening, StructuralWeakening)]
-> RelationshipProperties
-> [AlloyInstance]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithODs [(StructuralWeakening, StructuralWeakening)]
chs RelationshipProperties
_ [] = [(StructuralWeakening, StructuralWeakening)]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithStructuralWeakenings [(StructuralWeakening, StructuralWeakening)]
chs
    getInstanceWithODs [(StructuralWeakening, StructuralWeakening)]
chs RelationshipProperties
p (AlloyInstance
randomInstance:[AlloyInstance]
randomInstances) = do
      GenericClassDiagramInstance String String
cdInstance <- m (GenericClassDiagramInstance String String)
-> t m (GenericClassDiagramInstance String String)
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
        (m (GenericClassDiagramInstance String String)
 -> t m (GenericClassDiagramInstance String String))
-> m (GenericClassDiagramInstance String String)
-> t m (GenericClassDiagramInstance String String)
forall a b. (a -> b) -> a -> b
$ AlloyInstance -> m (GenericClassDiagramInstance String String)
forall (m :: * -> *).
MonadThrow m =>
AlloyInstance -> m (GenericClassDiagramInstance String String)
fromInstance AlloyInstance
randomInstance
        m (GenericClassDiagramInstance String String)
-> (GenericClassDiagramInstance String String
    -> m (GenericClassDiagramInstance String String))
-> m (GenericClassDiagramInstance String String)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GenericClassDiagramInstance String String
-> m (GenericClassDiagramInstance String String)
forall (m :: * -> *) className relationshipName.
(MonadThrow m, Ord className, Ord relationshipName) =>
GenericClassDiagramInstance className relationshipName
-> m (GenericClassDiagramInstance String String)
nameClassDiagramInstance
      let cd :: AnyCd
cd = GenericClassDiagramInstance String String -> AnyCd
forall className relationshipName.
GenericClassDiagramInstance className relationshipName
-> AnyClassDiagram className relationshipName
instanceClassDiagram GenericClassDiagramInstance String String
cdInstance
          p' :: RelationshipProperties
p' = RelationshipProperties
p {
            hasDoubleRelationships :: Maybe Bool
hasDoubleRelationships = Maybe Bool
forall a. Maybe a
Nothing,
            hasReverseRelationships :: Maybe Bool
hasReverseRelationships = Maybe Bool
forall a. Maybe a
Nothing,
            hasMultipleInheritances :: Maybe Bool
hasMultipleInheritances = Maybe Bool
forall a. Maybe a
Nothing
            }
          alloyCode :: String
alloyCode = Maybe AnyCd -> RelationshipProperties -> String
getFixWith (AnyCd -> Maybe AnyCd
forall a. a -> Maybe a
Just AnyCd
cd) RelationshipProperties
p'
      [AlloyInstance]
instances <- m [AlloyInstance] -> t m [AlloyInstance]
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m [AlloyInstance] -> t m [AlloyInstance])
-> m [AlloyInstance] -> t m [AlloyInstance]
forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
forall (m :: * -> *).
MonadAlloy m =>
Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
getInstances Maybe Integer
forall a. Maybe a
Nothing Maybe Int
timeout String
alloyCode
      [GenericClassDiagramInstance String String]
correctInstance <- m [GenericClassDiagramInstance String String]
-> t m [GenericClassDiagramInstance String String]
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m [GenericClassDiagramInstance String String]
 -> t m [GenericClassDiagramInstance String String])
-> m [GenericClassDiagramInstance String String]
-> t m [GenericClassDiagramInstance String String]
forall a b. (a -> b) -> a -> b
$ (AlloyInstance -> m (GenericClassDiagramInstance String String))
-> [AlloyInstance] -> m [GenericClassDiagramInstance String String]
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 -> m (GenericClassDiagramInstance String String)
forall (m :: * -> *).
MonadThrow m =>
AlloyInstance -> m (GenericClassDiagramInstance String String)
fromInstanceWithPredefinedNames [AlloyInstance]
instances
      let allChs :: [ChangeAndCd String String]
allChs = (GenericClassDiagramInstance String String
 -> [ChangeAndCd String String])
-> [GenericClassDiagramInstance String String]
-> [ChangeAndCd String String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap GenericClassDiagramInstance String String
-> [ChangeAndCd String String]
forall className relationshipName.
GenericClassDiagramInstance className relationshipName
-> [ChangeAndCd className relationshipName]
instanceChangesAndCds [GenericClassDiagramInstance String String]
correctInstance
          cd2 :: AnyCd
cd2 = GenericClassDiagramInstance String String -> AnyCd
forall className relationshipName.
GenericClassDiagramInstance className relationshipName
-> AnyClassDiagram className relationshipName
instanceClassDiagram (GenericClassDiagramInstance String String -> AnyCd)
-> GenericClassDiagramInstance String String -> AnyCd
forall a b. (a -> b) -> a -> b
$ [GenericClassDiagramInstance String String]
-> GenericClassDiagramInstance String String
forall a. HasCallStack => [a] -> a
head [GenericClassDiagramInstance String String]
correctInstance
      Maybe [AnyRelationship String String]
possibleRemoves <- do
        [ClassDiagram String String]
validCds <- m [ClassDiagram String String] -> t m [ClassDiagram String String]
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m [ClassDiagram String String]
 -> t m [ClassDiagram String String])
-> m [ClassDiagram String String]
-> t m [ClassDiagram String String]
forall a b. (a -> b) -> a -> b
$ (ChangeAndCd String String -> m (ClassDiagram String String))
-> [ChangeAndCd String String] -> m [ClassDiagram String String]
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 (AnyCd -> m (ClassDiagram String String)
forall className (m :: * -> *) relationshipName.
(Eq className, MonadThrow m, Show className, Show relationshipName,
 Typeable className, Typeable relationshipName) =>
AnyClassDiagram className relationshipName
-> m (ClassDiagram className relationshipName)
toValidCd (AnyCd -> m (ClassDiagram String String))
-> (ChangeAndCd String String -> AnyCd)
-> ChangeAndCd String String
-> m (ClassDiagram String String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChangeAndCd String String -> AnyCd
forall className relationshipName.
ChangeAndCd className relationshipName
-> AnyClassDiagram className relationshipName
changeClassDiagram) [ChangeAndCd String String]
allChs
        (ClassDiagram String String
 -> t m (Maybe (ObjectDiagram String String String)))
-> [ClassDiagram String String] -> t m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ClassDiagram String String
-> t m (Maybe (ObjectDiagram String String String))
forall {m :: * -> *}.
(MonadAlloy m, MonadCatch m, MonadRandom m) =>
ClassDiagram String String
-> m (Maybe (ObjectDiagram String String String))
getOD [ClassDiagram String String]
validCds
        return $ (ChangeAndCd String String
 -> Maybe (AnyRelationship String String))
-> [ChangeAndCd String String]
-> Maybe [AnyRelationship String String]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (Change (AnyRelationship String String)
-> Maybe (AnyRelationship String String)
forall a. Change a -> Maybe a
remove (Change (AnyRelationship String String)
 -> Maybe (AnyRelationship String String))
-> (ChangeAndCd String String
    -> Change (AnyRelationship String String))
-> ChangeAndCd String String
-> Maybe (AnyRelationship String String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChangeAndCd String String -> Change (AnyRelationship String String)
forall className relationshipName.
ChangeAndCd className relationshipName
-> Change (AnyRelationship className relationshipName)
relationshipChange) [ChangeAndCd String String]
allChs
      case Maybe [AnyRelationship String String]
possibleRemoves of
        Maybe [AnyRelationship String String]
Nothing -> [(StructuralWeakening, StructuralWeakening)]
-> RelationshipProperties
-> [AlloyInstance]
-> t m (AnyCd, Property, [AnyRelationship String String])
getInstanceWithODs [(StructuralWeakening, StructuralWeakening)]
chs RelationshipProperties
p [AlloyInstance]
randomInstances
        Just [AnyRelationship String String]
removes ->
          let fixes :: Set Property
fixes = RelationshipProperties -> Set Property
toPropertySet RelationshipProperties
p
                Set Property -> Set Property -> Set Property
forall a. Ord a => Set a -> Set a -> Set a
S.\\ RelationshipProperties -> Set Property
toPropertySet (RelationshipProperties -> RelationshipProperties
towardsValidProperties RelationshipProperties
p)
          in case Set Property -> [Property]
forall a. Set a -> [a]
S.toList Set Property
fixes of
            [Property
problem] -> (AnyCd, Property, [AnyRelationship String String])
-> t m (AnyCd, Property, [AnyRelationship String String])
forall a. a -> t m a
forall (m :: * -> *) a. Monad m => a -> m a
return (AnyCd
cd2, Property
problem, [AnyRelationship String String]
removes)
            [Property]
_ -> String -> t m (AnyCd, Property, [AnyRelationship String String])
forall a. HasCallStack => String -> a
error String
"error in task type: property fix is not unique"
    getOD :: ClassDiagram String String
-> m (Maybe (ObjectDiagram String String String))
getOD ClassDiagram String String
cd = do
      let maxNumberOfObjects :: ObjectConfig
maxNumberOfObjects = Int -> ObjectConfig
maxObjects (Int -> ObjectConfig) -> Int -> ObjectConfig
forall a b. (a -> b) -> a -> b
$ (Int, Int) -> Int
forall a b. (a, b) -> b
snd ((Int, Int) -> Int) -> (Int, Int) -> Int
forall a b. (a -> b) -> a -> b
$ ClassConfig -> (Int, Int)
classLimits ClassConfig
classConfig
          parts :: Parts
parts = LinguisticReuse
-> ClassDiagram String String
-> Maybe [String]
-> [String]
-> ObjectConfig
-> ObjectProperties
-> String
-> String
-> Parts
transform
            (ExtendsAnd -> LinguisticReuse
ExtendsAnd ExtendsAnd
FieldPlacement)
            ClassDiagram String String
cd
            Maybe [String]
forall a. Maybe a
Nothing
            []
            ObjectConfig
maxNumberOfObjects
            ObjectProperties
objectProperties
            String
""
            String
""
          command :: String
command = String
-> Maybe [String]
-> Int
-> ObjectConfig
-> [Relationship String String]
-> String
forall a b.
String
-> Maybe [String]
-> Int
-> ObjectConfig
-> [Relationship a b]
-> String
createRunCommand
            String
"cd"
            ([String] -> Maybe [String]
forall a. a -> Maybe a
Just ([String] -> Maybe [String]) -> [String] -> Maybe [String]
forall a b. (a -> b) -> a -> b
$ ClassDiagram String String -> [String]
forall className relationshipName.
ClassDiagram className relationshipName -> [className]
classNames ClassDiagram String String
cd)
            ([String] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([String] -> Int) -> [String] -> Int
forall a b. (a -> b) -> a -> b
$ ClassDiagram String String -> [String]
forall className relationshipName.
ClassDiagram className relationshipName -> [className]
classNames ClassDiagram String String
cd)
            ObjectConfig
maxNumberOfObjects
            (ClassDiagram String String -> [Relationship String String]
forall className relationshipName.
ClassDiagram className relationshipName
-> [Relationship className relationshipName]
relationships ClassDiagram String String
cd)
          possibleLinkNames :: [String]
possibleLinkNames = (Relationship String String -> Maybe String)
-> [Relationship String String] -> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Relationship String String -> Maybe String
forall c r. Relationship c r -> Maybe r
relationshipName ([Relationship String String] -> [String])
-> [Relationship String String] -> [String]
forall a b. (a -> b) -> a -> b
$ ClassDiagram String String -> [Relationship String String]
forall className relationshipName.
ClassDiagram className relationshipName
-> [Relationship className relationshipName]
relationships ClassDiagram String String
cd
      Maybe AlloyInstance
od <- [AlloyInstance] -> Maybe AlloyInstance
forall a. [a] -> Maybe a
listToMaybe
        ([AlloyInstance] -> Maybe AlloyInstance)
-> m [AlloyInstance] -> m (Maybe AlloyInstance)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
forall (m :: * -> *).
MonadAlloy m =>
Maybe Integer -> Maybe Int -> String -> m [AlloyInstance]
getInstances (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
1) Maybe Int
timeout (Parts -> String
combineParts Parts
parts String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
command)
      Maybe (ObjectDiagram String String String)
od' <- (Maybe (Maybe (ObjectDiagram String String String))
 -> Maybe (ObjectDiagram String String String))
-> m (Maybe (Maybe (ObjectDiagram String String String)))
-> m (Maybe (ObjectDiagram String String String))
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (Maybe (ObjectDiagram String String String))
-> Maybe (ObjectDiagram String String String)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (m (Maybe (Maybe (ObjectDiagram String String String)))
 -> m (Maybe (ObjectDiagram String String String)))
-> m (Maybe (Maybe (ObjectDiagram String String String)))
-> m (Maybe (ObjectDiagram String String String))
forall a b. (a -> b) -> a -> b
$ Maybe AlloyInstance
-> (AlloyInstance
    -> m (Maybe (ObjectDiagram String String String)))
-> m (Maybe (Maybe (ObjectDiagram String String String)))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM Maybe AlloyInstance
od
        ((AlloyInstance -> m (Maybe (ObjectDiagram String String String)))
 -> m (Maybe (Maybe (ObjectDiagram String String String))))
-> (AlloyInstance
    -> m (Maybe (ObjectDiagram String String String)))
-> m (Maybe (Maybe (ObjectDiagram String String String)))
forall a b. (a -> b) -> a -> b
$ ExceptT Any m (ObjectDiagram String String String)
-> m (Either Any (ObjectDiagram String String String))
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT Any m (ObjectDiagram String String String)
 -> m (Either Any (ObjectDiagram String String String)))
-> (AlloyInstance
    -> ExceptT Any m (ObjectDiagram String String String))
-> AlloyInstance
-> m (Either Any (ObjectDiagram String String String))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe [String]
-> [String]
-> AlloyInstance
-> ExceptT Any m (ObjectDiagram String String String)
forall (m :: * -> *).
MonadCatch m =>
Maybe [String]
-> [String]
-> AlloyInstance
-> m (ObjectDiagram String String String)
alloyInstanceToOd ([String] -> Maybe [String]
forall a. a -> Maybe a
Just ([String] -> Maybe [String]) -> [String] -> Maybe [String]
forall a b. (a -> b) -> a -> b
$ ClassDiagram String String -> [String]
forall className relationshipName.
ClassDiagram className relationshipName -> [className]
classNames ClassDiagram String String
cd) [String]
possibleLinkNames
        (AlloyInstance
 -> m (Either Any (ObjectDiagram String String String)))
-> (Either Any (ObjectDiagram String String String)
    -> m (Maybe (ObjectDiagram String String String)))
-> AlloyInstance
-> m (Maybe (ObjectDiagram String String String))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Maybe (ObjectDiagram String String String)
-> m (Maybe (ObjectDiagram String String String))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (ObjectDiagram String String String)
 -> m (Maybe (ObjectDiagram String String String)))
-> (Either Any (ObjectDiagram String String String)
    -> Maybe (ObjectDiagram String String String))
-> Either Any (ObjectDiagram String String String)
-> m (Maybe (ObjectDiagram String String String))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either Any (ObjectDiagram String String String)
-> Maybe (ObjectDiagram String String String)
forall a b. Either a b -> Maybe b
eitherToMaybe
      (ObjectDiagram String String String
 -> m (ObjectDiagram String String String))
-> Maybe (ObjectDiagram String String String)
-> m (Maybe (ObjectDiagram String String String))
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) -> Maybe a -> m (Maybe b)
mapM (Rational
-> ObjectDiagram String String String
-> m (ObjectDiagram String String String)
forall (m :: * -> *) className relationshipName linkLabel.
MonadRandom m =>
Rational
-> ObjectDiagram className relationshipName linkLabel
-> m (ObjectDiagram className relationshipName linkLabel)
anonymiseObjects (ObjectProperties -> Rational
anonymousObjectProportion ObjectProperties
objectProperties)) Maybe (ObjectDiagram String String String)
od'

translateProperty :: Bool -> Property -> Map Language String
translateProperty :: Bool -> Property -> Map Language String
translateProperty Bool
True Property
x = Property -> Map Language String
translatePropertyWithDirections Property
x
translateProperty Bool
False Property
x = case Property
x of
  Property
DoubleRelationships -> Map Language String
doubleOrReverseRelationships
  Property
_ -> Property -> Map Language String
translatePropertyWithDirections Property
x
  where
    doubleOrReverseRelationships :: Map Language String
doubleOrReverseRelationships = 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 [iii|
        contains at least two non-inheritance relationships
        between the same two classes.
        |]
      String -> State (Map Language String) ()
german [iii|
        enthält mindestens zwei Nicht-Vererbungsbeziehungen
        zwischen denselben beiden Klassen.
        |]

translatePropertyWithDirections :: Property -> Map Language String
translatePropertyWithDirections :: Property -> Map Language String
translatePropertyWithDirections Property
x = 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
$ case Property
x of
  Property
CompositionCycles -> do
    String -> State (Map Language String) ()
english String
"contains at least one composition cycle."
    String -> State (Map Language String) ()
german String
"enthält mindestens einen Kompositionszyklus."
  Property
DoubleRelationships -> do
    String -> State (Map Language String) ()
english [iii|
      contains at least two non-inheritance relationships
      between the same two classes each pointing in the same direction.
      |]
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens zwei Nicht-Vererbungsbeziehungen
      zwischen denselben beiden Klassen, die in dieselbe Richtung zeigen.
      |]
  Property
InheritanceCycles -> do
    String -> State (Map Language String) ()
english String
"contains at least one inheritance cycle."
    String -> State (Map Language String) ()
german String
"enthält mindestens einen Vererbungszyklus."
  Property
InvalidInheritanceLimits -> do
    String -> State (Map Language String) ()
english String
"contains at least one invalid multiplicity at some inheritance."
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens eine ungültige Multiplizität an einer Vererbung.
      |]
  Property
MultipleInheritances -> do
    String -> State (Map Language String) ()
english String
"contains at least one multiple inheritance."
    String -> State (Map Language String) ()
german String
"enthält mindestens eine Mehrfachvererbung."
  Property
ReverseInheritances -> do
    String -> State (Map Language String) ()
english String
"contains at least one pair of classes each inheriting from the other."
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens ein Paar von Klassen, die sich gegenseitig beerben.
      |]
  Property
ReverseRelationships -> do
    String -> State (Map Language String) ()
english [iii|
      contains at least two non-inheritance relationships
      between the same two classes pointing in opposite directions.
      |]
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens zwei Nicht-Vererbungsbeziehungen
      zwischen denselben beiden Klassen,
      die in entgegengesetzte Richtungen zeigen.
      |]
  Property
SelfInheritances -> do
    String -> State (Map Language String) ()
english String
"contains at least one self-inheritance."
    String -> State (Map Language String) ()
german String
"enthält mindestens eine Selbstvererbung."
  Property
SelfRelationships -> do
    String -> State (Map Language String) ()
english String
"contains at least one self-relationship that is no inheritance."
    String -> State (Map Language String) ()
german String
"enthält mindestens eine Selbstbeziehung, die keine Vererbung ist."
  Property
WrongAssociationLimits -> do
    String -> State (Map Language String) ()
english [iii|
      contains at least one invalid multiplicity at some relationship
      that is no inheritance.
      |]
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens eine ungültige Multiplizität an einer Beziehung,
      die keine Vererbung ist.
      |]
  Property
WrongCompositionLimits -> do
    String -> State (Map Language String) ()
english [iii|
      contains at least one invalid multiplicity near the whole of a composition.
      |]
    String -> State (Map Language String) ()
german [iii|
      enthält mindestens eine ungültige Multiplizität am Ganzen einer Komposition.
      |]

defaultNameCdErrorInstance :: NameCdErrorInstance
defaultNameCdErrorInstance :: NameCdErrorInstance
defaultNameCdErrorInstance = NameCdErrorInstance {
  byName :: Bool
byName = Bool
True,
  cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings
defaultCdDrawSettings {printNames :: Bool
printNames = Bool
True},
  classDiagram :: AnnotatedCd Relevance
classDiagram = AnnotatedClassDiagram {
    annotatedClasses :: [String]
annotatedClasses = [String
"C", String
"B", String
"D", String
"A"],
    annotatedRelationships :: [Annotation Relevance (AnyRelationship String String)]
annotatedRelationships = [
      Annotation {
        annotated :: AnyRelationship String String
annotated = Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Association {
          associationName :: String
associationName = String
"w",
          associationFrom :: LimitedLinking String
associationFrom =
            LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
          associationTo :: LimitedLinking String
associationTo =
            LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
2, Maybe Int
forall a. Maybe a
Nothing)}
          },
        annotation :: Relevance
annotation = Relevant {
          contributingToProblem :: Bool
contributingToProblem = Bool
False,
          listingPriority :: Int
listingPriority = Int
3,
          referenceUsing :: ArticleToUse
referenceUsing = ArticleToUse
DefiniteArticle
          }
        },
      Annotation {
        annotated :: AnyRelationship String String
annotated = Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Composition {
          compositionName :: String
compositionName = String
"x",
          compositionPart :: LimitedLinking String
compositionPart =
            LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
          compositionWhole :: LimitedLinking String
compositionWhole =
            LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
          },
        annotation :: Relevance
annotation = Relevant {
          contributingToProblem :: Bool
contributingToProblem = Bool
True,
          listingPriority :: Int
listingPriority = Int
2,
          referenceUsing :: ArticleToUse
referenceUsing = ArticleToUse
DefiniteArticle
          }
        },
      Annotation {
        annotated :: AnyRelationship String String
annotated = Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Aggregation {
          aggregationName :: String
aggregationName = String
"y",
          aggregationPart :: LimitedLinking String
aggregationPart =
            LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
          aggregationWhole :: LimitedLinking String
aggregationWhole =
            LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)}
          },
        annotation :: Relevance
annotation = Relevant {
          contributingToProblem :: Bool
contributingToProblem = Bool
False,
          listingPriority :: Int
listingPriority = Int
1,
          referenceUsing :: ArticleToUse
referenceUsing = ArticleToUse
DefiniteArticle
          }
        },
      Annotation {
        annotated :: AnyRelationship String String
annotated = Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Composition {
          compositionName :: String
compositionName = String
"z",
          compositionPart :: LimitedLinking String
compositionPart =
            LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
2, Maybe Int
forall a. Maybe a
Nothing)},
          compositionWhole :: LimitedLinking String
compositionWhole =
            LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
          },
        annotation :: Relevance
annotation = Relevant {
          contributingToProblem :: Bool
contributingToProblem = Bool
False,
          listingPriority :: Int
listingPriority = Int
4,
          referenceUsing :: ArticleToUse
referenceUsing = ArticleToUse
DefiniteArticle
          }
        }
      ]
    },
  errorReasons :: Map Char (Bool, Reason)
errorReasons = [(Char, (Bool, Reason))] -> Map Char (Bool, Reason)
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList [
    (Char
'a', (Bool
False, Property -> Reason
PreDefined Property
DoubleRelationships)),
    (Char
'b', (Bool
False, Property -> Reason
PreDefined Property
SelfRelationships)),
    (Char
'c', (Bool
True, Property -> Reason
PreDefined Property
WrongCompositionLimits)),
    (Char
'd', (Bool
False, Property -> Reason
PreDefined Property
WrongAssociationLimits)),
    (Char
'e', (Bool
False, Property -> Reason
PreDefined Property
SelfInheritances)),
    (Char
'f', (Bool
False, Property -> Reason
PreDefined Property
InvalidInheritanceLimits)),
    (Char
'g', (Bool
False, Property -> Reason
PreDefined Property
CompositionCycles)),
    (Char
'h', (Bool
False, Property -> Reason
PreDefined Property
ReverseInheritances)),
    (Char
'i', (Bool
False, Property -> Reason
PreDefined Property
InheritanceCycles)),
    (Char
'j', (Bool
False, Property -> Reason
PreDefined Property
MultipleInheritances)),
    (Char
'k', (Bool
False, Property -> Reason
PreDefined Property
ReverseRelationships))
    ],
  showSolution :: Bool
showSolution = Bool
False,
  taskText :: [SpecialOutput NameCdErrorTaskTextElement]
taskText = [SpecialOutput NameCdErrorTaskTextElement]
defaultNameCdErrorTaskText,
  addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }