{-# language OverloadedStrings #-}
{-# language RecordWildCards #-}

module FastDownward.SAS.Plan ( Plan(..), toSAS ) where

import qualified Data.Text.Lazy
import qualified Data.Text.Lazy.Builder
import qualified Data.Text.Lazy.Builder.Int
import Data.Sequence ( Seq )
import qualified Data.Sequence as Seq
import FastDownward.SAS.Axiom ( Axiom )
import qualified FastDownward.SAS.Axiom as Axiom
import FastDownward.SAS.Goal ( Goal )
import qualified FastDownward.SAS.Goal as Goal
import FastDownward.SAS.MutexGroup ( MutexGroup )
import FastDownward.SAS.Operator ( Operator )
import qualified FastDownward.SAS.Operator as Operator
import FastDownward.SAS.State ( State )
import qualified FastDownward.SAS.State as State
import FastDownward.SAS.UseCosts ( UseCosts )
import qualified FastDownward.SAS.UseCosts as UseCosts
import FastDownward.SAS.Variable ( Variable )
import qualified FastDownward.SAS.Variable as Variable
import FastDownward.SAS.Version ( Version )
import qualified FastDownward.SAS.Version as Version


data Plan =
  Plan
    { Plan -> Version
version :: Version
    , Plan -> UseCosts
useCosts :: UseCosts
    , Plan -> Seq Variable
variables :: Seq Variable
    , Plan -> Seq MutexGroup
mutexGroups :: Seq MutexGroup
    , Plan -> State
initialState :: State
    , Plan -> Goal
goal :: Goal
    , Plan -> Seq Operator
operators :: Seq Operator
    , Plan -> Seq Axiom
axioms :: Seq Axiom
    }
  deriving
    ( Int -> Plan -> ShowS
[Plan] -> ShowS
Plan -> String
(Int -> Plan -> ShowS)
-> (Plan -> String) -> ([Plan] -> ShowS) -> Show Plan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Plan] -> ShowS
$cshowList :: [Plan] -> ShowS
show :: Plan -> String
$cshow :: Plan -> String
showsPrec :: Int -> Plan -> ShowS
$cshowsPrec :: Int -> Plan -> ShowS
Show )


toSAS :: Plan -> Data.Text.Lazy.Text
toSAS :: Plan -> Text
toSAS Plan{Seq Variable
Seq MutexGroup
Seq Operator
Seq Axiom
State
UseCosts
Goal
Version
axioms :: Seq Axiom
operators :: Seq Operator
goal :: Goal
initialState :: State
mutexGroups :: Seq MutexGroup
variables :: Seq Variable
useCosts :: UseCosts
version :: Version
axioms :: Plan -> Seq Axiom
operators :: Plan -> Seq Operator
goal :: Plan -> Goal
initialState :: Plan -> State
mutexGroups :: Plan -> Seq MutexGroup
variables :: Plan -> Seq Variable
useCosts :: Plan -> UseCosts
version :: Plan -> Version
..} =
     Builder -> Text
Data.Text.Lazy.Builder.toLazyText
   (Builder -> Text) -> Builder -> Text
forall a b. (a -> b) -> a -> b
$ Version -> Builder
Version.toSAS Version
version                                        Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> UseCosts -> Builder
UseCosts.toSAS UseCosts
useCosts                                       Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
forall a. Integral a => a -> Builder
Data.Text.Lazy.Builder.Int.decimal ( Seq Variable -> Int
forall a. Seq a -> Int
Seq.length Seq Variable
variables )   Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Variable -> Builder) -> Seq Variable -> Builder
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ( \Variable
v -> Variable -> Builder
Variable.toSAS Variable
v Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n" ) Seq Variable
variables
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
forall a. Integral a => a -> Builder
Data.Text.Lazy.Builder.Int.decimal ( Seq MutexGroup -> Int
forall a. Seq a -> Int
Seq.length Seq MutexGroup
mutexGroups ) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> State -> Builder
State.toSAS State
initialState                                      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Goal -> Builder
Goal.toSAS Goal
goal                                               Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
forall a. Integral a => a -> Builder
Data.Text.Lazy.Builder.Int.decimal ( Seq Operator -> Int
forall a. Seq a -> Int
Seq.length Seq Operator
operators )   Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Operator -> Builder) -> Seq Operator -> Builder
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ( \Operator
x -> Operator -> Builder
Operator.toSAS Operator
x Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n" ) Seq Operator
operators
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
forall a. Integral a => a -> Builder
Data.Text.Lazy.Builder.Int.decimal ( Seq Axiom -> Int
forall a. Seq a -> Int
Seq.length Seq Axiom
axioms )      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n"
  Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Axiom -> Builder) -> Seq Axiom -> Builder
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ( \Axiom
x -> Axiom -> Builder
Axiom.toSAS Axiom
x Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\n" ) Seq Axiom
axioms