{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CSMOF/As.hs
Description :  abstract CSMOF 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 CSMOF.As where

import Common.Id

import Data.Data

-- Simplified MOF Metamodel

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

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


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

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


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

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


-- When going downside-up, we can sort the auxiliary class TypeOrTypedElement and make super of type NamedElement
data Type = Type { Type -> NamedElement
typeSuper :: NamedElement
                 , Type -> DataTypeOrClass
typeSubClasses :: DataTypeOrClass
                 } deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq, Eq Type
Eq Type =>
(Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
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 :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmax :: Type -> Type -> Type
>= :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c< :: Type -> Type -> Bool
compare :: Type -> Type -> Ordering
$ccompare :: Type -> Type -> Ordering
$cp1Ord :: Eq Type
Ord, Typeable, Typeable Type
Constr
DataType
Typeable Type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> Constr
Type -> DataType
(forall b. Data b => b -> b) -> Type -> Type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
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) -> Type -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cType :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataTypeOf :: Type -> DataType
$cdataTypeOf :: Type -> DataType
toConstr :: Type -> Constr
$ctoConstr :: Type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cp1Data :: Typeable Type
Data)

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


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

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


-- When going downside-up, we can sort the auxiliary class DataTypeOrClass and make super of type Type
data Datatype = Datatype { Datatype -> Type
classSuper :: Type } deriving (Datatype -> Datatype -> Bool
(Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool) -> Eq Datatype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatype -> Datatype -> Bool
$c/= :: Datatype -> Datatype -> Bool
== :: Datatype -> Datatype -> Bool
$c== :: Datatype -> Datatype -> Bool
Eq, Eq Datatype
Eq Datatype =>
(Datatype -> Datatype -> Ordering)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Datatype)
-> (Datatype -> Datatype -> Datatype)
-> Ord Datatype
Datatype -> Datatype -> Bool
Datatype -> Datatype -> Ordering
Datatype -> Datatype -> Datatype
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 :: Datatype -> Datatype -> Datatype
$cmin :: Datatype -> Datatype -> Datatype
max :: Datatype -> Datatype -> Datatype
$cmax :: Datatype -> Datatype -> Datatype
>= :: Datatype -> Datatype -> Bool
$c>= :: Datatype -> Datatype -> Bool
> :: Datatype -> Datatype -> Bool
$c> :: Datatype -> Datatype -> Bool
<= :: Datatype -> Datatype -> Bool
$c<= :: Datatype -> Datatype -> Bool
< :: Datatype -> Datatype -> Bool
$c< :: Datatype -> Datatype -> Bool
compare :: Datatype -> Datatype -> Ordering
$ccompare :: Datatype -> Datatype -> Ordering
$cp1Ord :: Eq Datatype
Ord, Typeable, Typeable Datatype
Constr
DataType
Typeable Datatype =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Datatype -> c Datatype)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Datatype)
-> (Datatype -> Constr)
-> (Datatype -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Datatype))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datatype))
-> ((forall b. Data b => b -> b) -> Datatype -> Datatype)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Datatype -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Datatype -> r)
-> (forall u. (forall d. Data d => d -> u) -> Datatype -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Datatype -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Datatype -> m Datatype)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Datatype -> m Datatype)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Datatype -> m Datatype)
-> Data Datatype
Datatype -> Constr
Datatype -> DataType
(forall b. Data b => b -> b) -> Datatype -> Datatype
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datatype -> c Datatype
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datatype
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) -> Datatype -> u
forall u. (forall d. Data d => d -> u) -> Datatype -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Datatype -> m Datatype
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datatype -> m Datatype
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datatype
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datatype -> c Datatype
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Datatype)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datatype)
$cDatatype :: Constr
$tDatatype :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Datatype -> m Datatype
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datatype -> m Datatype
gmapMp :: (forall d. Data d => d -> m d) -> Datatype -> m Datatype
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datatype -> m Datatype
gmapM :: (forall d. Data d => d -> m d) -> Datatype -> m Datatype
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Datatype -> m Datatype
gmapQi :: Int -> (forall d. Data d => d -> u) -> Datatype -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Datatype -> u
gmapQ :: (forall d. Data d => d -> u) -> Datatype -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Datatype -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Datatype -> r
gmapT :: (forall b. Data b => b -> b) -> Datatype -> Datatype
$cgmapT :: (forall b. Data b => b -> b) -> Datatype -> Datatype
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datatype)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datatype)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Datatype)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Datatype)
dataTypeOf :: Datatype -> DataType
$cdataTypeOf :: Datatype -> DataType
toConstr :: Datatype -> Constr
$ctoConstr :: Datatype -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datatype
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datatype
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datatype -> c Datatype
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datatype -> c Datatype
$cp1Data :: Typeable Datatype
Data)

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


-- When going downside-up, we can sort the auxiliary class DataTypeOrClass and make super of type Type
data Class = Class
             { Class -> Type
classSuperType :: Type
             , Class -> Bool
isAbstract :: Bool
             , Class -> [Class]
superClass :: [Class]
             , Class -> [Property]
ownedAttribute :: [Property]
             } deriving (Class -> Class -> Bool
(Class -> Class -> Bool) -> (Class -> Class -> Bool) -> Eq Class
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Class -> Class -> Bool
$c/= :: Class -> Class -> Bool
== :: Class -> Class -> Bool
$c== :: Class -> Class -> Bool
Eq, Eq Class
Eq Class =>
(Class -> Class -> Ordering)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Class)
-> (Class -> Class -> Class)
-> Ord Class
Class -> Class -> Bool
Class -> Class -> Ordering
Class -> Class -> Class
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 :: Class -> Class -> Class
$cmin :: Class -> Class -> Class
max :: Class -> Class -> Class
$cmax :: Class -> Class -> Class
>= :: Class -> Class -> Bool
$c>= :: Class -> Class -> Bool
> :: Class -> Class -> Bool
$c> :: Class -> Class -> Bool
<= :: Class -> Class -> Bool
$c<= :: Class -> Class -> Bool
< :: Class -> Class -> Bool
$c< :: Class -> Class -> Bool
compare :: Class -> Class -> Ordering
$ccompare :: Class -> Class -> Ordering
$cp1Ord :: Eq Class
Ord, Typeable, Typeable Class
Constr
DataType
Typeable Class =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Class -> c Class)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Class)
-> (Class -> Constr)
-> (Class -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Class))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class))
-> ((forall b. Data b => b -> b) -> Class -> Class)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r)
-> (forall u. (forall d. Data d => d -> u) -> Class -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Class -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Class -> m Class)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Class -> m Class)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Class -> m Class)
-> Data Class
Class -> Constr
Class -> DataType
(forall b. Data b => b -> b) -> Class -> Class
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Class -> c Class
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Class
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) -> Class -> u
forall u. (forall d. Data d => d -> u) -> Class -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Class -> m Class
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Class -> m Class
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Class
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Class -> c Class
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Class)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class)
$cClass :: Constr
$tClass :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Class -> m Class
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Class -> m Class
gmapMp :: (forall d. Data d => d -> m d) -> Class -> m Class
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Class -> m Class
gmapM :: (forall d. Data d => d -> m d) -> Class -> m Class
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Class -> m Class
gmapQi :: Int -> (forall d. Data d => d -> u) -> Class -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Class -> u
gmapQ :: (forall d. Data d => d -> u) -> Class -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Class -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r
gmapT :: (forall b. Data b => b -> b) -> Class -> Class
$cgmapT :: (forall b. Data b => b -> b) -> Class -> Class
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Class)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Class)
dataTypeOf :: Class -> DataType
$cdataTypeOf :: Class -> DataType
toConstr :: Class -> Constr
$ctoConstr :: Class -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Class
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Class
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Class -> c Class
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Class -> c Class
$cp1Data :: Typeable Class
Data)

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


-- When going downside-up, we can sort the auxiliary class TypeOrTypedElement and make super of type NamedElement
data TypedElement = TypedElement
                    { TypedElement -> NamedElement
typedElementSuper :: NamedElement
                    , TypedElement -> Type
typedElementType :: Type
                    , TypedElement -> Property
typedElementSubClasses :: Property
                    } deriving (TypedElement -> TypedElement -> Bool
(TypedElement -> TypedElement -> Bool)
-> (TypedElement -> TypedElement -> Bool) -> Eq TypedElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypedElement -> TypedElement -> Bool
$c/= :: TypedElement -> TypedElement -> Bool
== :: TypedElement -> TypedElement -> Bool
$c== :: TypedElement -> TypedElement -> Bool
Eq, Eq TypedElement
Eq TypedElement =>
(TypedElement -> TypedElement -> Ordering)
-> (TypedElement -> TypedElement -> Bool)
-> (TypedElement -> TypedElement -> Bool)
-> (TypedElement -> TypedElement -> Bool)
-> (TypedElement -> TypedElement -> Bool)
-> (TypedElement -> TypedElement -> TypedElement)
-> (TypedElement -> TypedElement -> TypedElement)
-> Ord TypedElement
TypedElement -> TypedElement -> Bool
TypedElement -> TypedElement -> Ordering
TypedElement -> TypedElement -> TypedElement
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 :: TypedElement -> TypedElement -> TypedElement
$cmin :: TypedElement -> TypedElement -> TypedElement
max :: TypedElement -> TypedElement -> TypedElement
$cmax :: TypedElement -> TypedElement -> TypedElement
>= :: TypedElement -> TypedElement -> Bool
$c>= :: TypedElement -> TypedElement -> Bool
> :: TypedElement -> TypedElement -> Bool
$c> :: TypedElement -> TypedElement -> Bool
<= :: TypedElement -> TypedElement -> Bool
$c<= :: TypedElement -> TypedElement -> Bool
< :: TypedElement -> TypedElement -> Bool
$c< :: TypedElement -> TypedElement -> Bool
compare :: TypedElement -> TypedElement -> Ordering
$ccompare :: TypedElement -> TypedElement -> Ordering
$cp1Ord :: Eq TypedElement
Ord, Typeable, Typeable TypedElement
Constr
DataType
Typeable TypedElement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypedElement -> c TypedElement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypedElement)
-> (TypedElement -> Constr)
-> (TypedElement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypedElement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypedElement))
-> ((forall b. Data b => b -> b) -> TypedElement -> TypedElement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypedElement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypedElement -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypedElement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypedElement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement)
-> Data TypedElement
TypedElement -> Constr
TypedElement -> DataType
(forall b. Data b => b -> b) -> TypedElement -> TypedElement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypedElement -> c TypedElement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypedElement
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) -> TypedElement -> u
forall u. (forall d. Data d => d -> u) -> TypedElement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypedElement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypedElement -> c TypedElement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypedElement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypedElement)
$cTypedElement :: Constr
$tTypedElement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
gmapMp :: (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
gmapM :: (forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypedElement -> m TypedElement
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypedElement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypedElement -> u
gmapQ :: (forall d. Data d => d -> u) -> TypedElement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypedElement -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypedElement -> r
gmapT :: (forall b. Data b => b -> b) -> TypedElement -> TypedElement
$cgmapT :: (forall b. Data b => b -> b) -> TypedElement -> TypedElement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypedElement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypedElement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypedElement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypedElement)
dataTypeOf :: TypedElement -> DataType
$cdataTypeOf :: TypedElement -> DataType
toConstr :: TypedElement -> Constr
$ctoConstr :: TypedElement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypedElement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypedElement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypedElement -> c TypedElement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypedElement -> c TypedElement
$cp1Data :: Typeable TypedElement
Data)

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


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

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


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

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


-- Model part of CSMOF

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

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


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

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


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

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