hets/QVTR/As.hs

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


module QVTR.As where

import Common.Id

import Data.Data

import qualified CSMOF.As as CSMOF

-- Simplified QVTR Tranformation

data Transformation = Transformation
                 { transfName :: String
                 , sourceMetamodel :: (String, String, CSMOF.Metamodel)
                 , targetMetamodel :: (String, String, CSMOF.Metamodel)
                 , keys :: [Key]
                 , relations :: [Relation]
                 } deriving (Eq, Ord, Typeable, Data)

instance GetRange Transformation where
  getRange _ = nullRange
  rangeSpan _ = []


data Key = Key
        { metamodel :: String
        , typeName :: String
        , properties :: [PropKey]
        } deriving (Eq, Ord, Typeable, Data)

instance GetRange Key where
  getRange _ = nullRange
  rangeSpan _ = []


data PropKey = SimpleProp { propName :: String }
             | OppositeProp { oppPropType :: String, oppPropName :: String }
             deriving (Eq, Ord, Typeable, Data)

instance GetRange PropKey where
  getRange _ = nullRange
  rangeSpan _ = []


data Relation = Relation
              { top :: Bool
              , relName :: String
              , varSet :: [RelVar]
              , primDomains :: [PrimitiveDomain]
              , sourceDomain :: Domain
              , targetDomain :: Domain
              , whenCond :: Maybe WhenWhere
              , whereCond :: Maybe WhenWhere
              } deriving (Eq, Ord, Typeable, Data)

instance GetRange Relation where
  getRange _ = nullRange
  rangeSpan _ = []


data RelVar = RelVar
            { varType :: String
            , varName :: String
            } deriving (Eq, Ord, Typeable, Data)

instance GetRange RelVar where
  getRange _ = nullRange
  rangeSpan _ = []


data PrimitiveDomain = PrimitiveDomain
                     { primName :: String
                     , primType :: String
                     } deriving (Eq, Ord, Typeable, Data)

instance GetRange PrimitiveDomain where
  getRange _ = nullRange
  rangeSpan _ = []


data Domain = Domain
            { domModelId :: String
            , template :: ObjectTemplate
            } deriving (Eq, Ord, Typeable, Data)

instance GetRange Domain where
  getRange _ = nullRange
  rangeSpan _ = []


data ObjectTemplate = ObjectTemplate
                    { domVar :: String
                    , domMeta :: String
                    , domType :: String
                    , templateList :: [PropertyTemplate]
                    } deriving (Eq, Ord, Typeable, Data)

instance GetRange ObjectTemplate where
  getRange _ = nullRange
  rangeSpan _ = []


data PropertyTemplate = PropertyTemplate
                      { pName :: String
                      , oclExpre :: Maybe OCL
                      , objTemp :: Maybe ObjectTemplate
                      } deriving (Eq, Ord, Typeable, Data)

instance GetRange PropertyTemplate where
  getRange _ = nullRange
  rangeSpan _ = []


data WhenWhere = WhenWhere { relInvokWhen :: [RelInvok], oclExpreWhen :: [OCL] }
  deriving (Eq, Ord, Typeable, Data)

instance GetRange WhenWhere where
  getRange _ = nullRange
  rangeSpan _ = []


data RelInvok = RelInvok
              { name :: String
              , params :: [String]
              } deriving (Eq, Ord, Typeable, Data)

instance GetRange RelInvok where
  getRange _ = nullRange
  rangeSpan _ = []


-- Fake OCL expressions

data OCL = Paren { exp :: OCL }
         | StringExp { strExp :: STRING }
         | BExp { bExp :: Bool }
         | NotB { notExp :: OCL }
         | AndB { lExpA :: OCL, rExpA :: OCL }
         | OrB { lExpO :: OCL, rExpO :: OCL }
         | Equal { lExpre :: STRING, rExpre :: STRING }
         deriving (Eq, Ord, Typeable, Data)

instance GetRange OCL where
  getRange _ = nullRange
  rangeSpan _ = []


data STRING = Str { simpleStr :: String }
            | ConcatExp { lStr :: STRING, rStr :: STRING }
            | VarExp { varExp :: String }
            deriving (Eq, Ord, Typeable, Data)

instance GetRange STRING where
  getRange _ = nullRange
  rangeSpan _ = []