{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./QVTR/As.hs
Description :  abstract QVT-Relational syntax
Copyright   :  (c) Daniel Calegari Universidad de la Republica, Uruguay 2013
License     :  GPLv2 or higher, see LICENSE.txt
Maintainer  :  dcalegar@fing.edu.uy
Stability   :  provisional
Portability :  portable
-}


module QVTR.As where

import Common.Id

import Data.Data

import qualified CSMOF.As as CSMOF

-- Simplified QVTR Tranformation

data Transformation = Transformation
                 { Transformation -> String
transfName :: String
                 , Transformation -> (String, String, Metamodel)
sourceMetamodel :: (String, String, CSMOF.Metamodel)
                 , Transformation -> (String, String, Metamodel)
targetMetamodel :: (String, String, CSMOF.Metamodel)
                 , Transformation -> [Key]
keys :: [Key]
                 , Transformation -> [Relation]
relations :: [Relation]
                 } deriving (Transformation -> Transformation -> Bool
(Transformation -> Transformation -> Bool)
-> (Transformation -> Transformation -> Bool) -> Eq Transformation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Transformation -> Transformation -> Bool
$c/= :: Transformation -> Transformation -> Bool
== :: Transformation -> Transformation -> Bool
$c== :: Transformation -> Transformation -> Bool
Eq, Eq Transformation
Eq Transformation =>
(Transformation -> Transformation -> Ordering)
-> (Transformation -> Transformation -> Bool)
-> (Transformation -> Transformation -> Bool)
-> (Transformation -> Transformation -> Bool)
-> (Transformation -> Transformation -> Bool)
-> (Transformation -> Transformation -> Transformation)
-> (Transformation -> Transformation -> Transformation)
-> Ord Transformation
Transformation -> Transformation -> Bool
Transformation -> Transformation -> Ordering
Transformation -> Transformation -> Transformation
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
min :: Transformation -> Transformation -> Transformation
$cmin :: Transformation -> Transformation -> Transformation
max :: Transformation -> Transformation -> Transformation
$cmax :: Transformation -> Transformation -> Transformation
>= :: Transformation -> Transformation -> Bool
$c>= :: Transformation -> Transformation -> Bool
> :: Transformation -> Transformation -> Bool
$c> :: Transformation -> Transformation -> Bool
<= :: Transformation -> Transformation -> Bool
$c<= :: Transformation -> Transformation -> Bool
< :: Transformation -> Transformation -> Bool
$c< :: Transformation -> Transformation -> Bool
compare :: Transformation -> Transformation -> Ordering
$ccompare :: Transformation -> Transformation -> Ordering
$cp1Ord :: Eq Transformation
Ord, Typeable, Typeable Transformation
Constr
DataType
Typeable Transformation =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Transformation -> c Transformation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Transformation)
-> (Transformation -> Constr)
-> (Transformation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Transformation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Transformation))
-> ((forall b. Data b => b -> b)
    -> Transformation -> Transformation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Transformation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Transformation -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Transformation -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Transformation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Transformation -> m Transformation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Transformation -> m Transformation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Transformation -> m Transformation)
-> Data Transformation
Transformation -> Constr
Transformation -> DataType
(forall b. Data b => b -> b) -> Transformation -> Transformation
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transformation -> c Transformation
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transformation
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) -> Transformation -> u
forall u. (forall d. Data d => d -> u) -> Transformation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Transformation -> m Transformation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Transformation -> m Transformation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transformation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transformation -> c Transformation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Transformation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Transformation)
$cTransformation :: Constr
$tTransformation :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Transformation -> m Transformation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Transformation -> m Transformation
gmapMp :: (forall d. Data d => d -> m d)
-> Transformation -> m Transformation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Transformation -> m Transformation
gmapM :: (forall d. Data d => d -> m d)
-> Transformation -> m Transformation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Transformation -> m Transformation
gmapQi :: Int -> (forall d. Data d => d -> u) -> Transformation -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Transformation -> u
gmapQ :: (forall d. Data d => d -> u) -> Transformation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Transformation -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transformation -> r
gmapT :: (forall b. Data b => b -> b) -> Transformation -> Transformation
$cgmapT :: (forall b. Data b => b -> b) -> Transformation -> Transformation
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Transformation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Transformation)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Transformation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Transformation)
dataTypeOf :: Transformation -> DataType
$cdataTypeOf :: Transformation -> DataType
toConstr :: Transformation -> Constr
$ctoConstr :: Transformation -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transformation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transformation
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transformation -> c Transformation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transformation -> c Transformation
$cp1Data :: Typeable Transformation
Data)

instance GetRange Transformation where
  getRange :: Transformation -> Range
getRange _ = Range
nullRange
  rangeSpan :: Transformation -> [Pos]
rangeSpan _ = []


data Key = Key
        { Key -> String
metamodel :: String
        , Key -> String
typeName :: String
        , Key -> [PropKey]
properties :: [PropKey]
        } deriving (Key -> Key -> Bool
(Key -> Key -> Bool) -> (Key -> Key -> Bool) -> Eq Key
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Key -> Key -> Bool
$c/= :: Key -> Key -> Bool
== :: Key -> Key -> Bool
$c== :: Key -> Key -> Bool
Eq, Eq Key
Eq Key =>
(Key -> Key -> Ordering)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Key)
-> (Key -> Key -> Key)
-> Ord Key
Key -> Key -> Bool
Key -> Key -> Ordering
Key -> Key -> Key
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
min :: Key -> Key -> Key
$cmin :: Key -> Key -> Key
max :: Key -> Key -> Key
$cmax :: Key -> Key -> Key
>= :: Key -> Key -> Bool
$c>= :: Key -> Key -> Bool
> :: Key -> Key -> Bool
$c> :: Key -> Key -> Bool
<= :: Key -> Key -> Bool
$c<= :: Key -> Key -> Bool
< :: Key -> Key -> Bool
$c< :: Key -> Key -> Bool
compare :: Key -> Key -> Ordering
$ccompare :: Key -> Key -> Ordering
$cp1Ord :: Eq Key
Ord, Typeable, Typeable Key
Constr
DataType
Typeable Key =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Key -> c Key)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Key)
-> (Key -> Constr)
-> (Key -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Key))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key))
-> ((forall b. Data b => b -> b) -> Key -> Key)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r)
-> (forall u. (forall d. Data d => d -> u) -> Key -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Key -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> Data Key
Key -> Constr
Key -> DataType
(forall b. Data b => b -> b) -> Key -> Key
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
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) -> Key -> u
forall u. (forall d. Data d => d -> u) -> Key -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Key -> m Key
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Key)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
$cKey :: Constr
$tKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Key -> m Key
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapMp :: (forall d. Data d => d -> m d) -> Key -> m Key
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapM :: (forall d. Data d => d -> m d) -> Key -> m Key
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapQi :: Int -> (forall d. Data d => d -> u) -> Key -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Key -> u
gmapQ :: (forall d. Data d => d -> u) -> Key -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Key -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
gmapT :: (forall b. Data b => b -> b) -> Key -> Key
$cgmapT :: (forall b. Data b => b -> b) -> Key -> Key
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Key)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Key)
dataTypeOf :: Key -> DataType
$cdataTypeOf :: Key -> DataType
toConstr :: Key -> Constr
$ctoConstr :: Key -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
$cp1Data :: Typeable Key
Data)

instance GetRange Key where
  getRange :: Key -> Range
getRange _ = Range
nullRange
  rangeSpan :: Key -> [Pos]
rangeSpan _ = []


data PropKey = SimpleProp { PropKey -> String
propName :: String }
             | OppositeProp { PropKey -> String
oppPropType :: String, PropKey -> String
oppPropName :: String }
             deriving (PropKey -> PropKey -> Bool
(PropKey -> PropKey -> Bool)
-> (PropKey -> PropKey -> Bool) -> Eq PropKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropKey -> PropKey -> Bool
$c/= :: PropKey -> PropKey -> Bool
== :: PropKey -> PropKey -> Bool
$c== :: PropKey -> PropKey -> Bool
Eq, Eq PropKey
Eq PropKey =>
(PropKey -> PropKey -> Ordering)
-> (PropKey -> PropKey -> Bool)
-> (PropKey -> PropKey -> Bool)
-> (PropKey -> PropKey -> Bool)
-> (PropKey -> PropKey -> Bool)
-> (PropKey -> PropKey -> PropKey)
-> (PropKey -> PropKey -> PropKey)
-> Ord PropKey
PropKey -> PropKey -> Bool
PropKey -> PropKey -> Ordering
PropKey -> PropKey -> PropKey
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
min :: PropKey -> PropKey -> PropKey
$cmin :: PropKey -> PropKey -> PropKey
max :: PropKey -> PropKey -> PropKey
$cmax :: PropKey -> PropKey -> PropKey
>= :: PropKey -> PropKey -> Bool
$c>= :: PropKey -> PropKey -> Bool
> :: PropKey -> PropKey -> Bool
$c> :: PropKey -> PropKey -> Bool
<= :: PropKey -> PropKey -> Bool
$c<= :: PropKey -> PropKey -> Bool
< :: PropKey -> PropKey -> Bool
$c< :: PropKey -> PropKey -> Bool
compare :: PropKey -> PropKey -> Ordering
$ccompare :: PropKey -> PropKey -> Ordering
$cp1Ord :: Eq PropKey
Ord, Typeable, Typeable PropKey
Constr
DataType
Typeable PropKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PropKey -> c PropKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PropKey)
-> (PropKey -> Constr)
-> (PropKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PropKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PropKey))
-> ((forall b. Data b => b -> b) -> PropKey -> PropKey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PropKey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PropKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> PropKey -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PropKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PropKey -> m PropKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PropKey -> m PropKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PropKey -> m PropKey)
-> Data PropKey
PropKey -> Constr
PropKey -> DataType
(forall b. Data b => b -> b) -> PropKey -> PropKey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropKey -> c PropKey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropKey
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) -> PropKey -> u
forall u. (forall d. Data d => d -> u) -> PropKey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PropKey -> m PropKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PropKey -> m PropKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropKey -> c PropKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PropKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PropKey)
$cOppositeProp :: Constr
$cSimpleProp :: Constr
$tPropKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PropKey -> m PropKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PropKey -> m PropKey
gmapMp :: (forall d. Data d => d -> m d) -> PropKey -> m PropKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PropKey -> m PropKey
gmapM :: (forall d. Data d => d -> m d) -> PropKey -> m PropKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PropKey -> m PropKey
gmapQi :: Int -> (forall d. Data d => d -> u) -> PropKey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PropKey -> u
gmapQ :: (forall d. Data d => d -> u) -> PropKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PropKey -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropKey -> r
gmapT :: (forall b. Data b => b -> b) -> PropKey -> PropKey
$cgmapT :: (forall b. Data b => b -> b) -> PropKey -> PropKey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PropKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PropKey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PropKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PropKey)
dataTypeOf :: PropKey -> DataType
$cdataTypeOf :: PropKey -> DataType
toConstr :: PropKey -> Constr
$ctoConstr :: PropKey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropKey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropKey -> c PropKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropKey -> c PropKey
$cp1Data :: Typeable PropKey
Data)

instance GetRange PropKey where
  getRange :: PropKey -> Range
getRange _ = Range
nullRange
  rangeSpan :: PropKey -> [Pos]
rangeSpan _ = []


data Relation = Relation
              { Relation -> Bool
top :: Bool
              , Relation -> String
relName :: String
              , Relation -> [RelVar]
varSet :: [RelVar]
              , Relation -> [PrimitiveDomain]
primDomains :: [PrimitiveDomain]
              , Relation -> Domain
sourceDomain :: Domain
              , Relation -> Domain
targetDomain :: Domain
              , Relation -> Maybe WhenWhere
whenCond :: Maybe WhenWhere
              , Relation -> Maybe WhenWhere
whereCond :: Maybe WhenWhere
              } deriving (Relation -> Relation -> Bool
(Relation -> Relation -> Bool)
-> (Relation -> Relation -> Bool) -> Eq Relation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Relation -> Relation -> Bool
$c/= :: Relation -> Relation -> Bool
== :: Relation -> Relation -> Bool
$c== :: Relation -> Relation -> Bool
Eq, Eq Relation
Eq Relation =>
(Relation -> Relation -> Ordering)
-> (Relation -> Relation -> Bool)
-> (Relation -> Relation -> Bool)
-> (Relation -> Relation -> Bool)
-> (Relation -> Relation -> Bool)
-> (Relation -> Relation -> Relation)
-> (Relation -> Relation -> Relation)
-> Ord Relation
Relation -> Relation -> Bool
Relation -> Relation -> Ordering
Relation -> Relation -> Relation
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
min :: Relation -> Relation -> Relation
$cmin :: Relation -> Relation -> Relation
max :: Relation -> Relation -> Relation
$cmax :: Relation -> Relation -> Relation
>= :: Relation -> Relation -> Bool
$c>= :: Relation -> Relation -> Bool
> :: Relation -> Relation -> Bool
$c> :: Relation -> Relation -> Bool
<= :: Relation -> Relation -> Bool
$c<= :: Relation -> Relation -> Bool
< :: Relation -> Relation -> Bool
$c< :: Relation -> Relation -> Bool
compare :: Relation -> Relation -> Ordering
$ccompare :: Relation -> Relation -> Ordering
$cp1Ord :: Eq Relation
Ord, Typeable, Typeable Relation
Constr
DataType
Typeable Relation =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Relation -> c Relation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Relation)
-> (Relation -> Constr)
-> (Relation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Relation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relation))
-> ((forall b. Data b => b -> b) -> Relation -> Relation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Relation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Relation -> r)
-> (forall u. (forall d. Data d => d -> u) -> Relation -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Relation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Relation -> m Relation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Relation -> m Relation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Relation -> m Relation)
-> Data Relation
Relation -> Constr
Relation -> DataType
(forall b. Data b => b -> b) -> Relation -> Relation
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relation -> c Relation
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relation
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) -> Relation -> u
forall u. (forall d. Data d => d -> u) -> Relation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Relation -> m Relation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relation -> m Relation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relation -> c Relation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Relation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relation)
$cRelation :: Constr
$tRelation :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Relation -> m Relation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relation -> m Relation
gmapMp :: (forall d. Data d => d -> m d) -> Relation -> m Relation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Relation -> m Relation
gmapM :: (forall d. Data d => d -> m d) -> Relation -> m Relation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Relation -> m Relation
gmapQi :: Int -> (forall d. Data d => d -> u) -> Relation -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Relation -> u
gmapQ :: (forall d. Data d => d -> u) -> Relation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Relation -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Relation -> r
gmapT :: (forall b. Data b => b -> b) -> Relation -> Relation
$cgmapT :: (forall b. Data b => b -> b) -> Relation -> Relation
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relation)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Relation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Relation)
dataTypeOf :: Relation -> DataType
$cdataTypeOf :: Relation -> DataType
toConstr :: Relation -> Constr
$ctoConstr :: Relation -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Relation
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relation -> c Relation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Relation -> c Relation
$cp1Data :: Typeable Relation
Data)

instance GetRange Relation where
  getRange :: Relation -> Range
getRange _ = Range
nullRange
  rangeSpan :: Relation -> [Pos]
rangeSpan _ = []


data RelVar = RelVar
            { RelVar -> String
varType :: String
            , RelVar -> String
varName :: String
            } deriving (RelVar -> RelVar -> Bool
(RelVar -> RelVar -> Bool)
-> (RelVar -> RelVar -> Bool) -> Eq RelVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RelVar -> RelVar -> Bool
$c/= :: RelVar -> RelVar -> Bool
== :: RelVar -> RelVar -> Bool
$c== :: RelVar -> RelVar -> Bool
Eq, Eq RelVar
Eq RelVar =>
(RelVar -> RelVar -> Ordering)
-> (RelVar -> RelVar -> Bool)
-> (RelVar -> RelVar -> Bool)
-> (RelVar -> RelVar -> Bool)
-> (RelVar -> RelVar -> Bool)
-> (RelVar -> RelVar -> RelVar)
-> (RelVar -> RelVar -> RelVar)
-> Ord RelVar
RelVar -> RelVar -> Bool
RelVar -> RelVar -> Ordering
RelVar -> RelVar -> RelVar
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
min :: RelVar -> RelVar -> RelVar
$cmin :: RelVar -> RelVar -> RelVar
max :: RelVar -> RelVar -> RelVar
$cmax :: RelVar -> RelVar -> RelVar
>= :: RelVar -> RelVar -> Bool
$c>= :: RelVar -> RelVar -> Bool
> :: RelVar -> RelVar -> Bool
$c> :: RelVar -> RelVar -> Bool
<= :: RelVar -> RelVar -> Bool
$c<= :: RelVar -> RelVar -> Bool
< :: RelVar -> RelVar -> Bool
$c< :: RelVar -> RelVar -> Bool
compare :: RelVar -> RelVar -> Ordering
$ccompare :: RelVar -> RelVar -> Ordering
$cp1Ord :: Eq RelVar
Ord, Typeable, Typeable RelVar
Constr
DataType
Typeable RelVar =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RelVar -> c RelVar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RelVar)
-> (RelVar -> Constr)
-> (RelVar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RelVar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelVar))
-> ((forall b. Data b => b -> b) -> RelVar -> RelVar)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RelVar -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RelVar -> r)
-> (forall u. (forall d. Data d => d -> u) -> RelVar -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RelVar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RelVar -> m RelVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelVar -> m RelVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelVar -> m RelVar)
-> Data RelVar
RelVar -> Constr
RelVar -> DataType
(forall b. Data b => b -> b) -> RelVar -> RelVar
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelVar -> c RelVar
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelVar
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) -> RelVar -> u
forall u. (forall d. Data d => d -> u) -> RelVar -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelVar -> m RelVar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelVar -> m RelVar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelVar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelVar -> c RelVar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelVar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelVar)
$cRelVar :: Constr
$tRelVar :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RelVar -> m RelVar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelVar -> m RelVar
gmapMp :: (forall d. Data d => d -> m d) -> RelVar -> m RelVar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelVar -> m RelVar
gmapM :: (forall d. Data d => d -> m d) -> RelVar -> m RelVar
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelVar -> m RelVar
gmapQi :: Int -> (forall d. Data d => d -> u) -> RelVar -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RelVar -> u
gmapQ :: (forall d. Data d => d -> u) -> RelVar -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RelVar -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RelVar -> r
gmapT :: (forall b. Data b => b -> b) -> RelVar -> RelVar
$cgmapT :: (forall b. Data b => b -> b) -> RelVar -> RelVar
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelVar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelVar)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RelVar)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelVar)
dataTypeOf :: RelVar -> DataType
$cdataTypeOf :: RelVar -> DataType
toConstr :: RelVar -> Constr
$ctoConstr :: RelVar -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelVar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelVar
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelVar -> c RelVar
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelVar -> c RelVar
$cp1Data :: Typeable RelVar
Data)

instance GetRange RelVar where
  getRange :: RelVar -> Range
getRange _ = Range
nullRange
  rangeSpan :: RelVar -> [Pos]
rangeSpan _ = []


data PrimitiveDomain = PrimitiveDomain
                     { PrimitiveDomain -> String
primName :: String
                     , PrimitiveDomain -> String
primType :: String
                     } deriving (PrimitiveDomain -> PrimitiveDomain -> Bool
(PrimitiveDomain -> PrimitiveDomain -> Bool)
-> (PrimitiveDomain -> PrimitiveDomain -> Bool)
-> Eq PrimitiveDomain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c/= :: PrimitiveDomain -> PrimitiveDomain -> Bool
== :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c== :: PrimitiveDomain -> PrimitiveDomain -> Bool
Eq, Eq PrimitiveDomain
Eq PrimitiveDomain =>
(PrimitiveDomain -> PrimitiveDomain -> Ordering)
-> (PrimitiveDomain -> PrimitiveDomain -> Bool)
-> (PrimitiveDomain -> PrimitiveDomain -> Bool)
-> (PrimitiveDomain -> PrimitiveDomain -> Bool)
-> (PrimitiveDomain -> PrimitiveDomain -> Bool)
-> (PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain)
-> (PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain)
-> Ord PrimitiveDomain
PrimitiveDomain -> PrimitiveDomain -> Bool
PrimitiveDomain -> PrimitiveDomain -> Ordering
PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain
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
min :: PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain
$cmin :: PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain
max :: PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain
$cmax :: PrimitiveDomain -> PrimitiveDomain -> PrimitiveDomain
>= :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c>= :: PrimitiveDomain -> PrimitiveDomain -> Bool
> :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c> :: PrimitiveDomain -> PrimitiveDomain -> Bool
<= :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c<= :: PrimitiveDomain -> PrimitiveDomain -> Bool
< :: PrimitiveDomain -> PrimitiveDomain -> Bool
$c< :: PrimitiveDomain -> PrimitiveDomain -> Bool
compare :: PrimitiveDomain -> PrimitiveDomain -> Ordering
$ccompare :: PrimitiveDomain -> PrimitiveDomain -> Ordering
$cp1Ord :: Eq PrimitiveDomain
Ord, Typeable, Typeable PrimitiveDomain
Constr
DataType
Typeable PrimitiveDomain =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrimitiveDomain -> c PrimitiveDomain)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrimitiveDomain)
-> (PrimitiveDomain -> Constr)
-> (PrimitiveDomain -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrimitiveDomain))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrimitiveDomain))
-> ((forall b. Data b => b -> b)
    -> PrimitiveDomain -> PrimitiveDomain)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PrimitiveDomain -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrimitiveDomain -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveDomain -> m PrimitiveDomain)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveDomain -> m PrimitiveDomain)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrimitiveDomain -> m PrimitiveDomain)
-> Data PrimitiveDomain
PrimitiveDomain -> Constr
PrimitiveDomain -> DataType
(forall b. Data b => b -> b) -> PrimitiveDomain -> PrimitiveDomain
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveDomain -> c PrimitiveDomain
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveDomain
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) -> PrimitiveDomain -> u
forall u. (forall d. Data d => d -> u) -> PrimitiveDomain -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveDomain
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveDomain -> c PrimitiveDomain
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimitiveDomain)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveDomain)
$cPrimitiveDomain :: Constr
$tPrimitiveDomain :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
gmapMp :: (forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
gmapM :: (forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrimitiveDomain -> m PrimitiveDomain
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimitiveDomain -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrimitiveDomain -> u
gmapQ :: (forall d. Data d => d -> u) -> PrimitiveDomain -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrimitiveDomain -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimitiveDomain -> r
gmapT :: (forall b. Data b => b -> b) -> PrimitiveDomain -> PrimitiveDomain
$cgmapT :: (forall b. Data b => b -> b) -> PrimitiveDomain -> PrimitiveDomain
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveDomain)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrimitiveDomain)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrimitiveDomain)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimitiveDomain)
dataTypeOf :: PrimitiveDomain -> DataType
$cdataTypeOf :: PrimitiveDomain -> DataType
toConstr :: PrimitiveDomain -> Constr
$ctoConstr :: PrimitiveDomain -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveDomain
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimitiveDomain
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveDomain -> c PrimitiveDomain
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimitiveDomain -> c PrimitiveDomain
$cp1Data :: Typeable PrimitiveDomain
Data)

instance GetRange PrimitiveDomain where
  getRange :: PrimitiveDomain -> Range
getRange _ = Range
nullRange
  rangeSpan :: PrimitiveDomain -> [Pos]
rangeSpan _ = []


data Domain = Domain
            { Domain -> String
domModelId :: String
            , Domain -> ObjectTemplate
template :: ObjectTemplate
            } deriving (Domain -> Domain -> Bool
(Domain -> Domain -> Bool)
-> (Domain -> Domain -> Bool) -> Eq Domain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Domain -> Domain -> Bool
$c/= :: Domain -> Domain -> Bool
== :: Domain -> Domain -> Bool
$c== :: Domain -> Domain -> Bool
Eq, Eq Domain
Eq Domain =>
(Domain -> Domain -> Ordering)
-> (Domain -> Domain -> Bool)
-> (Domain -> Domain -> Bool)
-> (Domain -> Domain -> Bool)
-> (Domain -> Domain -> Bool)
-> (Domain -> Domain -> Domain)
-> (Domain -> Domain -> Domain)
-> Ord Domain
Domain -> Domain -> Bool
Domain -> Domain -> Ordering
Domain -> Domain -> Domain
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
min :: Domain -> Domain -> Domain
$cmin :: Domain -> Domain -> Domain
max :: Domain -> Domain -> Domain
$cmax :: Domain -> Domain -> Domain
>= :: Domain -> Domain -> Bool
$c>= :: Domain -> Domain -> Bool
> :: Domain -> Domain -> Bool
$c> :: Domain -> Domain -> Bool
<= :: Domain -> Domain -> Bool
$c<= :: Domain -> Domain -> Bool
< :: Domain -> Domain -> Bool
$c< :: Domain -> Domain -> Bool
compare :: Domain -> Domain -> Ordering
$ccompare :: Domain -> Domain -> Ordering
$cp1Ord :: Eq Domain
Ord, Typeable, Typeable Domain
Constr
DataType
Typeable Domain =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Domain -> c Domain)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Domain)
-> (Domain -> Constr)
-> (Domain -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Domain))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Domain))
-> ((forall b. Data b => b -> b) -> Domain -> Domain)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Domain -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Domain -> r)
-> (forall u. (forall d. Data d => d -> u) -> Domain -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Domain -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Domain -> m Domain)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Domain -> m Domain)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Domain -> m Domain)
-> Data Domain
Domain -> Constr
Domain -> DataType
(forall b. Data b => b -> b) -> Domain -> Domain
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Domain -> c Domain
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Domain
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) -> Domain -> u
forall u. (forall d. Data d => d -> u) -> Domain -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Domain -> m Domain
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Domain -> m Domain
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Domain
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Domain -> c Domain
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Domain)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Domain)
$cDomain :: Constr
$tDomain :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Domain -> m Domain
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Domain -> m Domain
gmapMp :: (forall d. Data d => d -> m d) -> Domain -> m Domain
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Domain -> m Domain
gmapM :: (forall d. Data d => d -> m d) -> Domain -> m Domain
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Domain -> m Domain
gmapQi :: Int -> (forall d. Data d => d -> u) -> Domain -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Domain -> u
gmapQ :: (forall d. Data d => d -> u) -> Domain -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Domain -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Domain -> r
gmapT :: (forall b. Data b => b -> b) -> Domain -> Domain
$cgmapT :: (forall b. Data b => b -> b) -> Domain -> Domain
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Domain)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Domain)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Domain)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Domain)
dataTypeOf :: Domain -> DataType
$cdataTypeOf :: Domain -> DataType
toConstr :: Domain -> Constr
$ctoConstr :: Domain -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Domain
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Domain
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Domain -> c Domain
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Domain -> c Domain
$cp1Data :: Typeable Domain
Data)

instance GetRange Domain where
  getRange :: Domain -> Range
getRange _ = Range
nullRange
  rangeSpan :: Domain -> [Pos]
rangeSpan _ = []


data ObjectTemplate = ObjectTemplate
                    { ObjectTemplate -> String
domVar :: String
                    , ObjectTemplate -> String
domMeta :: String
                    , ObjectTemplate -> String
domType :: String
                    , ObjectTemplate -> [PropertyTemplate]
templateList :: [PropertyTemplate]
                    } deriving (ObjectTemplate -> ObjectTemplate -> Bool
(ObjectTemplate -> ObjectTemplate -> Bool)
-> (ObjectTemplate -> ObjectTemplate -> Bool) -> Eq ObjectTemplate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectTemplate -> ObjectTemplate -> Bool
$c/= :: ObjectTemplate -> ObjectTemplate -> Bool
== :: ObjectTemplate -> ObjectTemplate -> Bool
$c== :: ObjectTemplate -> ObjectTemplate -> Bool
Eq, Eq ObjectTemplate
Eq ObjectTemplate =>
(ObjectTemplate -> ObjectTemplate -> Ordering)
-> (ObjectTemplate -> ObjectTemplate -> Bool)
-> (ObjectTemplate -> ObjectTemplate -> Bool)
-> (ObjectTemplate -> ObjectTemplate -> Bool)
-> (ObjectTemplate -> ObjectTemplate -> Bool)
-> (ObjectTemplate -> ObjectTemplate -> ObjectTemplate)
-> (ObjectTemplate -> ObjectTemplate -> ObjectTemplate)
-> Ord ObjectTemplate
ObjectTemplate -> ObjectTemplate -> Bool
ObjectTemplate -> ObjectTemplate -> Ordering
ObjectTemplate -> ObjectTemplate -> ObjectTemplate
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
min :: ObjectTemplate -> ObjectTemplate -> ObjectTemplate
$cmin :: ObjectTemplate -> ObjectTemplate -> ObjectTemplate
max :: ObjectTemplate -> ObjectTemplate -> ObjectTemplate
$cmax :: ObjectTemplate -> ObjectTemplate -> ObjectTemplate
>= :: ObjectTemplate -> ObjectTemplate -> Bool
$c>= :: ObjectTemplate -> ObjectTemplate -> Bool
> :: ObjectTemplate -> ObjectTemplate -> Bool
$c> :: ObjectTemplate -> ObjectTemplate -> Bool
<= :: ObjectTemplate -> ObjectTemplate -> Bool
$c<= :: ObjectTemplate -> ObjectTemplate -> Bool
< :: ObjectTemplate -> ObjectTemplate -> Bool
$c< :: ObjectTemplate -> ObjectTemplate -> Bool
compare :: ObjectTemplate -> ObjectTemplate -> Ordering
$ccompare :: ObjectTemplate -> ObjectTemplate -> Ordering
$cp1Ord :: Eq ObjectTemplate
Ord, Typeable, Typeable ObjectTemplate
Constr
DataType
Typeable ObjectTemplate =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ObjectTemplate -> c ObjectTemplate)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjectTemplate)
-> (ObjectTemplate -> Constr)
-> (ObjectTemplate -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjectTemplate))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjectTemplate))
-> ((forall b. Data b => b -> b)
    -> ObjectTemplate -> ObjectTemplate)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ObjectTemplate -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjectTemplate -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ObjectTemplate -> m ObjectTemplate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ObjectTemplate -> m ObjectTemplate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ObjectTemplate -> m ObjectTemplate)
-> Data ObjectTemplate
ObjectTemplate -> Constr
ObjectTemplate -> DataType
(forall b. Data b => b -> b) -> ObjectTemplate -> ObjectTemplate
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectTemplate -> c ObjectTemplate
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectTemplate
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) -> ObjectTemplate -> u
forall u. (forall d. Data d => d -> u) -> ObjectTemplate -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectTemplate
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectTemplate -> c ObjectTemplate
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectTemplate)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectTemplate)
$cObjectTemplate :: Constr
$tObjectTemplate :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
gmapMp :: (forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
gmapM :: (forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ObjectTemplate -> m ObjectTemplate
gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjectTemplate -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ObjectTemplate -> u
gmapQ :: (forall d. Data d => d -> u) -> ObjectTemplate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectTemplate -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectTemplate -> r
gmapT :: (forall b. Data b => b -> b) -> ObjectTemplate -> ObjectTemplate
$cgmapT :: (forall b. Data b => b -> b) -> ObjectTemplate -> ObjectTemplate
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectTemplate)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectTemplate)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ObjectTemplate)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectTemplate)
dataTypeOf :: ObjectTemplate -> DataType
$cdataTypeOf :: ObjectTemplate -> DataType
toConstr :: ObjectTemplate -> Constr
$ctoConstr :: ObjectTemplate -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectTemplate
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectTemplate
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectTemplate -> c ObjectTemplate
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectTemplate -> c ObjectTemplate
$cp1Data :: Typeable ObjectTemplate
Data)

instance GetRange ObjectTemplate where
  getRange :: ObjectTemplate -> Range
getRange _ = Range
nullRange
  rangeSpan :: ObjectTemplate -> [Pos]
rangeSpan _ = []


data PropertyTemplate = PropertyTemplate
                      { PropertyTemplate -> String
pName :: String
                      , PropertyTemplate -> Maybe OCL
oclExpre :: Maybe OCL
                      , PropertyTemplate -> Maybe ObjectTemplate
objTemp :: Maybe ObjectTemplate
                      } deriving (PropertyTemplate -> PropertyTemplate -> Bool
(PropertyTemplate -> PropertyTemplate -> Bool)
-> (PropertyTemplate -> PropertyTemplate -> Bool)
-> Eq PropertyTemplate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropertyTemplate -> PropertyTemplate -> Bool
$c/= :: PropertyTemplate -> PropertyTemplate -> Bool
== :: PropertyTemplate -> PropertyTemplate -> Bool
$c== :: PropertyTemplate -> PropertyTemplate -> Bool
Eq, Eq PropertyTemplate
Eq PropertyTemplate =>
(PropertyTemplate -> PropertyTemplate -> Ordering)
-> (PropertyTemplate -> PropertyTemplate -> Bool)
-> (PropertyTemplate -> PropertyTemplate -> Bool)
-> (PropertyTemplate -> PropertyTemplate -> Bool)
-> (PropertyTemplate -> PropertyTemplate -> Bool)
-> (PropertyTemplate -> PropertyTemplate -> PropertyTemplate)
-> (PropertyTemplate -> PropertyTemplate -> PropertyTemplate)
-> Ord PropertyTemplate
PropertyTemplate -> PropertyTemplate -> Bool
PropertyTemplate -> PropertyTemplate -> Ordering
PropertyTemplate -> PropertyTemplate -> PropertyTemplate
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
min :: PropertyTemplate -> PropertyTemplate -> PropertyTemplate
$cmin :: PropertyTemplate -> PropertyTemplate -> PropertyTemplate
max :: PropertyTemplate -> PropertyTemplate -> PropertyTemplate
$cmax :: PropertyTemplate -> PropertyTemplate -> PropertyTemplate
>= :: PropertyTemplate -> PropertyTemplate -> Bool
$c>= :: PropertyTemplate -> PropertyTemplate -> Bool
> :: PropertyTemplate -> PropertyTemplate -> Bool
$c> :: PropertyTemplate -> PropertyTemplate -> Bool
<= :: PropertyTemplate -> PropertyTemplate -> Bool
$c<= :: PropertyTemplate -> PropertyTemplate -> Bool
< :: PropertyTemplate -> PropertyTemplate -> Bool
$c< :: PropertyTemplate -> PropertyTemplate -> Bool
compare :: PropertyTemplate -> PropertyTemplate -> Ordering
$ccompare :: PropertyTemplate -> PropertyTemplate -> Ordering
$cp1Ord :: Eq PropertyTemplate
Ord, Typeable, Typeable PropertyTemplate
Constr
DataType
Typeable PropertyTemplate =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PropertyTemplate -> c PropertyTemplate)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PropertyTemplate)
-> (PropertyTemplate -> Constr)
-> (PropertyTemplate -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PropertyTemplate))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PropertyTemplate))
-> ((forall b. Data b => b -> b)
    -> PropertyTemplate -> PropertyTemplate)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PropertyTemplate -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PropertyTemplate -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PropertyTemplate -> m PropertyTemplate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PropertyTemplate -> m PropertyTemplate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PropertyTemplate -> m PropertyTemplate)
-> Data PropertyTemplate
PropertyTemplate -> Constr
PropertyTemplate -> DataType
(forall b. Data b => b -> b)
-> PropertyTemplate -> PropertyTemplate
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropertyTemplate -> c PropertyTemplate
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropertyTemplate
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) -> PropertyTemplate -> u
forall u. (forall d. Data d => d -> u) -> PropertyTemplate -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropertyTemplate
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropertyTemplate -> c PropertyTemplate
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PropertyTemplate)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PropertyTemplate)
$cPropertyTemplate :: Constr
$tPropertyTemplate :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
gmapMp :: (forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
gmapM :: (forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PropertyTemplate -> m PropertyTemplate
gmapQi :: Int -> (forall d. Data d => d -> u) -> PropertyTemplate -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PropertyTemplate -> u
gmapQ :: (forall d. Data d => d -> u) -> PropertyTemplate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PropertyTemplate -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PropertyTemplate -> r
gmapT :: (forall b. Data b => b -> b)
-> PropertyTemplate -> PropertyTemplate
$cgmapT :: (forall b. Data b => b -> b)
-> PropertyTemplate -> PropertyTemplate
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PropertyTemplate)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PropertyTemplate)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PropertyTemplate)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PropertyTemplate)
dataTypeOf :: PropertyTemplate -> DataType
$cdataTypeOf :: PropertyTemplate -> DataType
toConstr :: PropertyTemplate -> Constr
$ctoConstr :: PropertyTemplate -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropertyTemplate
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PropertyTemplate
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropertyTemplate -> c PropertyTemplate
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PropertyTemplate -> c PropertyTemplate
$cp1Data :: Typeable PropertyTemplate
Data)

instance GetRange PropertyTemplate where
  getRange :: PropertyTemplate -> Range
getRange _ = Range
nullRange
  rangeSpan :: PropertyTemplate -> [Pos]
rangeSpan _ = []


data WhenWhere = WhenWhere { WhenWhere -> [RelInvok]
relInvokWhen :: [RelInvok], WhenWhere -> [OCL]
oclExpreWhen :: [OCL] }
  deriving (WhenWhere -> WhenWhere -> Bool
(WhenWhere -> WhenWhere -> Bool)
-> (WhenWhere -> WhenWhere -> Bool) -> Eq WhenWhere
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WhenWhere -> WhenWhere -> Bool
$c/= :: WhenWhere -> WhenWhere -> Bool
== :: WhenWhere -> WhenWhere -> Bool
$c== :: WhenWhere -> WhenWhere -> Bool
Eq, Eq WhenWhere
Eq WhenWhere =>
(WhenWhere -> WhenWhere -> Ordering)
-> (WhenWhere -> WhenWhere -> Bool)
-> (WhenWhere -> WhenWhere -> Bool)
-> (WhenWhere -> WhenWhere -> Bool)
-> (WhenWhere -> WhenWhere -> Bool)
-> (WhenWhere -> WhenWhere -> WhenWhere)
-> (WhenWhere -> WhenWhere -> WhenWhere)
-> Ord WhenWhere
WhenWhere -> WhenWhere -> Bool
WhenWhere -> WhenWhere -> Ordering
WhenWhere -> WhenWhere -> WhenWhere
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
min :: WhenWhere -> WhenWhere -> WhenWhere
$cmin :: WhenWhere -> WhenWhere -> WhenWhere
max :: WhenWhere -> WhenWhere -> WhenWhere
$cmax :: WhenWhere -> WhenWhere -> WhenWhere
>= :: WhenWhere -> WhenWhere -> Bool
$c>= :: WhenWhere -> WhenWhere -> Bool
> :: WhenWhere -> WhenWhere -> Bool
$c> :: WhenWhere -> WhenWhere -> Bool
<= :: WhenWhere -> WhenWhere -> Bool
$c<= :: WhenWhere -> WhenWhere -> Bool
< :: WhenWhere -> WhenWhere -> Bool
$c< :: WhenWhere -> WhenWhere -> Bool
compare :: WhenWhere -> WhenWhere -> Ordering
$ccompare :: WhenWhere -> WhenWhere -> Ordering
$cp1Ord :: Eq WhenWhere
Ord, Typeable, Typeable WhenWhere
Constr
DataType
Typeable WhenWhere =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WhenWhere -> c WhenWhere)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WhenWhere)
-> (WhenWhere -> Constr)
-> (WhenWhere -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WhenWhere))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhenWhere))
-> ((forall b. Data b => b -> b) -> WhenWhere -> WhenWhere)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WhenWhere -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WhenWhere -> r)
-> (forall u. (forall d. Data d => d -> u) -> WhenWhere -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WhenWhere -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere)
-> Data WhenWhere
WhenWhere -> Constr
WhenWhere -> DataType
(forall b. Data b => b -> b) -> WhenWhere -> WhenWhere
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WhenWhere -> c WhenWhere
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WhenWhere
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) -> WhenWhere -> u
forall u. (forall d. Data d => d -> u) -> WhenWhere -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WhenWhere
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WhenWhere -> c WhenWhere
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WhenWhere)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhenWhere)
$cWhenWhere :: Constr
$tWhenWhere :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
gmapMp :: (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
gmapM :: (forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WhenWhere -> m WhenWhere
gmapQi :: Int -> (forall d. Data d => d -> u) -> WhenWhere -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WhenWhere -> u
gmapQ :: (forall d. Data d => d -> u) -> WhenWhere -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WhenWhere -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WhenWhere -> r
gmapT :: (forall b. Data b => b -> b) -> WhenWhere -> WhenWhere
$cgmapT :: (forall b. Data b => b -> b) -> WhenWhere -> WhenWhere
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhenWhere)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhenWhere)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WhenWhere)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WhenWhere)
dataTypeOf :: WhenWhere -> DataType
$cdataTypeOf :: WhenWhere -> DataType
toConstr :: WhenWhere -> Constr
$ctoConstr :: WhenWhere -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WhenWhere
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WhenWhere
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WhenWhere -> c WhenWhere
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WhenWhere -> c WhenWhere
$cp1Data :: Typeable WhenWhere
Data)

instance GetRange WhenWhere where
  getRange :: WhenWhere -> Range
getRange _ = Range
nullRange
  rangeSpan :: WhenWhere -> [Pos]
rangeSpan _ = []


data RelInvok = RelInvok
              { RelInvok -> String
name :: String
              , RelInvok -> [String]
params :: [String]
              } deriving (RelInvok -> RelInvok -> Bool
(RelInvok -> RelInvok -> Bool)
-> (RelInvok -> RelInvok -> Bool) -> Eq RelInvok
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RelInvok -> RelInvok -> Bool
$c/= :: RelInvok -> RelInvok -> Bool
== :: RelInvok -> RelInvok -> Bool
$c== :: RelInvok -> RelInvok -> Bool
Eq, Eq RelInvok
Eq RelInvok =>
(RelInvok -> RelInvok -> Ordering)
-> (RelInvok -> RelInvok -> Bool)
-> (RelInvok -> RelInvok -> Bool)
-> (RelInvok -> RelInvok -> Bool)
-> (RelInvok -> RelInvok -> Bool)
-> (RelInvok -> RelInvok -> RelInvok)
-> (RelInvok -> RelInvok -> RelInvok)
-> Ord RelInvok
RelInvok -> RelInvok -> Bool
RelInvok -> RelInvok -> Ordering
RelInvok -> RelInvok -> RelInvok
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
min :: RelInvok -> RelInvok -> RelInvok
$cmin :: RelInvok -> RelInvok -> RelInvok
max :: RelInvok -> RelInvok -> RelInvok
$cmax :: RelInvok -> RelInvok -> RelInvok
>= :: RelInvok -> RelInvok -> Bool
$c>= :: RelInvok -> RelInvok -> Bool
> :: RelInvok -> RelInvok -> Bool
$c> :: RelInvok -> RelInvok -> Bool
<= :: RelInvok -> RelInvok -> Bool
$c<= :: RelInvok -> RelInvok -> Bool
< :: RelInvok -> RelInvok -> Bool
$c< :: RelInvok -> RelInvok -> Bool
compare :: RelInvok -> RelInvok -> Ordering
$ccompare :: RelInvok -> RelInvok -> Ordering
$cp1Ord :: Eq RelInvok
Ord, Typeable, Typeable RelInvok
Constr
DataType
Typeable RelInvok =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RelInvok -> c RelInvok)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RelInvok)
-> (RelInvok -> Constr)
-> (RelInvok -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RelInvok))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelInvok))
-> ((forall b. Data b => b -> b) -> RelInvok -> RelInvok)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RelInvok -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RelInvok -> r)
-> (forall u. (forall d. Data d => d -> u) -> RelInvok -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RelInvok -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok)
-> Data RelInvok
RelInvok -> Constr
RelInvok -> DataType
(forall b. Data b => b -> b) -> RelInvok -> RelInvok
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelInvok -> c RelInvok
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelInvok
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) -> RelInvok -> u
forall u. (forall d. Data d => d -> u) -> RelInvok -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelInvok
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelInvok -> c RelInvok
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelInvok)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelInvok)
$cRelInvok :: Constr
$tRelInvok :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
gmapMp :: (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
gmapM :: (forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RelInvok -> m RelInvok
gmapQi :: Int -> (forall d. Data d => d -> u) -> RelInvok -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RelInvok -> u
gmapQ :: (forall d. Data d => d -> u) -> RelInvok -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RelInvok -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RelInvok -> r
gmapT :: (forall b. Data b => b -> b) -> RelInvok -> RelInvok
$cgmapT :: (forall b. Data b => b -> b) -> RelInvok -> RelInvok
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelInvok)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelInvok)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RelInvok)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RelInvok)
dataTypeOf :: RelInvok -> DataType
$cdataTypeOf :: RelInvok -> DataType
toConstr :: RelInvok -> Constr
$ctoConstr :: RelInvok -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelInvok
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RelInvok
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelInvok -> c RelInvok
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RelInvok -> c RelInvok
$cp1Data :: Typeable RelInvok
Data)

instance GetRange RelInvok where
  getRange :: RelInvok -> Range
getRange _ = Range
nullRange
  rangeSpan :: RelInvok -> [Pos]
rangeSpan _ = []


-- Fake OCL expressions

data OCL = Paren { OCL -> OCL
exp :: OCL }
         | StringExp { OCL -> STRING
strExp :: STRING }
         | BExp { OCL -> Bool
bExp :: Bool }
         | NotB { OCL -> OCL
notExp :: OCL }
         | AndB { OCL -> OCL
lExpA :: OCL, OCL -> OCL
rExpA :: OCL }
         | OrB { OCL -> OCL
lExpO :: OCL, OCL -> OCL
rExpO :: OCL }
         | Equal { OCL -> STRING
lExpre :: STRING, OCL -> STRING
rExpre :: STRING }
         deriving (OCL -> OCL -> Bool
(OCL -> OCL -> Bool) -> (OCL -> OCL -> Bool) -> Eq OCL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OCL -> OCL -> Bool
$c/= :: OCL -> OCL -> Bool
== :: OCL -> OCL -> Bool
$c== :: OCL -> OCL -> Bool
Eq, Eq OCL
Eq OCL =>
(OCL -> OCL -> Ordering)
-> (OCL -> OCL -> Bool)
-> (OCL -> OCL -> Bool)
-> (OCL -> OCL -> Bool)
-> (OCL -> OCL -> Bool)
-> (OCL -> OCL -> OCL)
-> (OCL -> OCL -> OCL)
-> Ord OCL
OCL -> OCL -> Bool
OCL -> OCL -> Ordering
OCL -> OCL -> OCL
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
min :: OCL -> OCL -> OCL
$cmin :: OCL -> OCL -> OCL
max :: OCL -> OCL -> OCL
$cmax :: OCL -> OCL -> OCL
>= :: OCL -> OCL -> Bool
$c>= :: OCL -> OCL -> Bool
> :: OCL -> OCL -> Bool
$c> :: OCL -> OCL -> Bool
<= :: OCL -> OCL -> Bool
$c<= :: OCL -> OCL -> Bool
< :: OCL -> OCL -> Bool
$c< :: OCL -> OCL -> Bool
compare :: OCL -> OCL -> Ordering
$ccompare :: OCL -> OCL -> Ordering
$cp1Ord :: Eq OCL
Ord, Typeable, Typeable OCL
Constr
DataType
Typeable OCL =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OCL -> c OCL)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OCL)
-> (OCL -> Constr)
-> (OCL -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OCL))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OCL))
-> ((forall b. Data b => b -> b) -> OCL -> OCL)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r)
-> (forall u. (forall d. Data d => d -> u) -> OCL -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OCL -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OCL -> m OCL)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OCL -> m OCL)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OCL -> m OCL)
-> Data OCL
OCL -> Constr
OCL -> DataType
(forall b. Data b => b -> b) -> OCL -> OCL
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OCL -> c OCL
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OCL
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) -> OCL -> u
forall u. (forall d. Data d => d -> u) -> OCL -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OCL -> m OCL
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OCL -> m OCL
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OCL
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OCL -> c OCL
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OCL)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OCL)
$cEqual :: Constr
$cOrB :: Constr
$cAndB :: Constr
$cNotB :: Constr
$cBExp :: Constr
$cStringExp :: Constr
$cParen :: Constr
$tOCL :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OCL -> m OCL
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OCL -> m OCL
gmapMp :: (forall d. Data d => d -> m d) -> OCL -> m OCL
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OCL -> m OCL
gmapM :: (forall d. Data d => d -> m d) -> OCL -> m OCL
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OCL -> m OCL
gmapQi :: Int -> (forall d. Data d => d -> u) -> OCL -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OCL -> u
gmapQ :: (forall d. Data d => d -> u) -> OCL -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OCL -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OCL -> r
gmapT :: (forall b. Data b => b -> b) -> OCL -> OCL
$cgmapT :: (forall b. Data b => b -> b) -> OCL -> OCL
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OCL)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OCL)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OCL)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OCL)
dataTypeOf :: OCL -> DataType
$cdataTypeOf :: OCL -> DataType
toConstr :: OCL -> Constr
$ctoConstr :: OCL -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OCL
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OCL
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OCL -> c OCL
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OCL -> c OCL
$cp1Data :: Typeable OCL
Data)

instance GetRange OCL where
  getRange :: OCL -> Range
getRange _ = Range
nullRange
  rangeSpan :: OCL -> [Pos]
rangeSpan _ = []


data STRING = Str { STRING -> String
simpleStr :: String }
            | ConcatExp { STRING -> STRING
lStr :: STRING, STRING -> STRING
rStr :: STRING }
            | VarExp { STRING -> String
varExp :: String }
            deriving (STRING -> STRING -> Bool
(STRING -> STRING -> Bool)
-> (STRING -> STRING -> Bool) -> Eq STRING
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: STRING -> STRING -> Bool
$c/= :: STRING -> STRING -> Bool
== :: STRING -> STRING -> Bool
$c== :: STRING -> STRING -> Bool
Eq, Eq STRING
Eq STRING =>
(STRING -> STRING -> Ordering)
-> (STRING -> STRING -> Bool)
-> (STRING -> STRING -> Bool)
-> (STRING -> STRING -> Bool)
-> (STRING -> STRING -> Bool)
-> (STRING -> STRING -> STRING)
-> (STRING -> STRING -> STRING)
-> Ord STRING
STRING -> STRING -> Bool
STRING -> STRING -> Ordering
STRING -> STRING -> STRING
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
min :: STRING -> STRING -> STRING
$cmin :: STRING -> STRING -> STRING
max :: STRING -> STRING -> STRING
$cmax :: STRING -> STRING -> STRING
>= :: STRING -> STRING -> Bool
$c>= :: STRING -> STRING -> Bool
> :: STRING -> STRING -> Bool
$c> :: STRING -> STRING -> Bool
<= :: STRING -> STRING -> Bool
$c<= :: STRING -> STRING -> Bool
< :: STRING -> STRING -> Bool
$c< :: STRING -> STRING -> Bool
compare :: STRING -> STRING -> Ordering
$ccompare :: STRING -> STRING -> Ordering
$cp1Ord :: Eq STRING
Ord, Typeable, Typeable STRING
Constr
DataType
Typeable STRING =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> STRING -> c STRING)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c STRING)
-> (STRING -> Constr)
-> (STRING -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c STRING))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STRING))
-> ((forall b. Data b => b -> b) -> STRING -> STRING)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> STRING -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> STRING -> r)
-> (forall u. (forall d. Data d => d -> u) -> STRING -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> STRING -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> STRING -> m STRING)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> STRING -> m STRING)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> STRING -> m STRING)
-> Data STRING
STRING -> Constr
STRING -> DataType
(forall b. Data b => b -> b) -> STRING -> STRING
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STRING -> c STRING
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STRING
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) -> STRING -> u
forall u. (forall d. Data d => d -> u) -> STRING -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> STRING -> m STRING
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STRING -> m STRING
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STRING
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STRING -> c STRING
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c STRING)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STRING)
$cVarExp :: Constr
$cConcatExp :: Constr
$cStr :: Constr
$tSTRING :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> STRING -> m STRING
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STRING -> m STRING
gmapMp :: (forall d. Data d => d -> m d) -> STRING -> m STRING
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> STRING -> m STRING
gmapM :: (forall d. Data d => d -> m d) -> STRING -> m STRING
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> STRING -> m STRING
gmapQi :: Int -> (forall d. Data d => d -> u) -> STRING -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> STRING -> u
gmapQ :: (forall d. Data d => d -> u) -> STRING -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> STRING -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> STRING -> r
gmapT :: (forall b. Data b => b -> b) -> STRING -> STRING
$cgmapT :: (forall b. Data b => b -> b) -> STRING -> STRING
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STRING)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c STRING)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c STRING)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c STRING)
dataTypeOf :: STRING -> DataType
$cdataTypeOf :: STRING -> DataType
toConstr :: STRING -> Constr
$ctoConstr :: STRING -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STRING
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c STRING
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STRING -> c STRING
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> STRING -> c STRING
$cp1Data :: Typeable STRING
Data)

instance GetRange STRING where
  getRange :: STRING -> Range
getRange _ = Range
nullRange
  rangeSpan :: STRING -> [Pos]
rangeSpan _ = []