module DTD_Gdxl where

import Xml2Haskell
{- patches -}

instance (Show a, Show b) => Show (OneOf2 a b) where
    showsPrec i (OneOfTwo a) = showString "OneOfTwo" . showsPrec i a
    showsPrec i (TwoOfTwo b) = showString "TwoOfTwo" . showsPrec i b

instance (Eq a, Eq b) => Eq (OneOf2 a b) where
    (==) (OneOfTwo a) (OneOfTwo b) = a == b
    (==) (TwoOfTwo a) (TwoOfTwo b) = a == b
    (==) _ _ = False

{-Type decls-}

data Gdxl = Gdxl Gdxl_Attrs [Sequencematch]
		 [Graphdelta] (Maybe Xlinkdelta)
	  deriving (Eq,Show)
data Gdxl_Attrs = Gdxl_Attrs
    { gdxlSourcedoc :: (Maybe String)
    , gdxlTargetdoc :: (Maybe String)
    } deriving (Eq,Show)
data Typedelta = Typedelta (Maybe Xlinkdelta)
			   (Maybe Hrefdelta)
	       deriving (Eq,Show)
data Xlinkdelta = Xlinkdelta
    { xlinkdeltaOldxlink :: String
    , xlinkdeltaNewxlink :: String
    } deriving (Eq,Show)
data Hrefdelta = Hrefdelta
    { hrefdeltaHrefmode :: Hrefdelta_Hrefmode
    , hrefdeltaNewlink :: String
    , hrefdeltaOldlink :: String
    } deriving (Eq,Show)
data Hrefdelta_Hrefmode = Hrefdelta_Hrefmode_Absolute
			   |  Hrefdelta_Hrefmode_Local  | 
			  Hrefdelta_Hrefmode_Relative
			deriving (Eq,Show)
data Sequencematch = Sequencematch
    { sequencematchLength :: (Defaultable String)
    , sequencematchOldstart :: String
    , sequencematchNewstart :: String
    } deriving (Eq,Show)
data Graphdelta = Graphdelta (Maybe Typedelta)
			     Attributedelta [Nodedelta] [Edgedelta] [Reldelta]
			     (Maybe Iddelta) (Maybe Roledelta)
			     (OneOf2 Booldelta Skip) (Maybe Booldelta)
			     (Maybe Edgemodedelta)
		deriving (Eq,Show)
data Iddelta = Iddelta
    { iddeltaOldid :: String
    , iddeltaNewid :: String
    } deriving (Eq,Show)
data Roledelta = Roledelta
    { roledeltaOldrole :: String
    , roledeltaNewrole :: String
    } deriving (Eq,Show)
data Booldelta = Booldelta
    { booldeltaOldbool :: Booldelta_Oldbool
    , booldeltaNewbool :: Booldelta_Newbool
    } deriving (Eq,Show)
data Booldelta_Oldbool = Booldelta_Oldbool_True  | 
			 Booldelta_Oldbool_False
		       deriving (Eq,Show)
data Booldelta_Newbool = Booldelta_Newbool_True  | 
			 Booldelta_Newbool_False
		       deriving (Eq,Show)
data Skip = Skip 		deriving (Eq,Show)
data Edgemodedelta = Edgemodedelta
    { edgemodedeltaOldem :: Edgemodedelta_Oldem
    , edgemodedeltaNewem :: Edgemodedelta_Newem
    } deriving (Eq,Show)
data Edgemodedelta_Oldem = Edgemodedelta_Oldem_Directed
			    |  Edgemodedelta_Oldem_Undirected  | 
			   Edgemodedelta_Oldem_Defaultdirected  | 
			   Edgemodedelta_Oldem_Defaultundirected
			 deriving (Eq,Show)
data Edgemodedelta_Newem = Edgemodedelta_Newem_Directed
			    |  Edgemodedelta_Newem_Undirected  | 
			   Edgemodedelta_Newem_Defaultdirected  | 
			   Edgemodedelta_Newem_Defaultundirected
			 deriving (Eq,Show)
data Nodedelta = Nodedelta (Maybe Typedelta)
			   Attributedelta [Sequencematch] [Graphdelta]
			   (Maybe Iddelta)
	       deriving (Eq,Show)
data Edgedelta = Edgedelta (Maybe Typedelta)
			   Attributedelta [Sequencematch] [Graphdelta]
			   (Maybe Iddelta) (OneOf2 Iddelta Skip) (Maybe Iddelta)
			   (OneOf2 Orderingdelta Skip) (Maybe Orderingdelta)
			   (Maybe Booldelta)
	       deriving (Eq,Show)
data Orderingdelta = Orderingdelta
    { orderingdeltaOldorder :: String
    , orderingdeltaNeworder :: String
    } deriving (Eq,Show)
data Reldelta = Reldelta (Maybe Typedelta)
			 Attributedelta [Sequencematch]
			 (OneOf2 [Graphdelta] Skip) [Sequencematch]
			 [Relenddelta] (Maybe Iddelta) (Maybe Booldelta)
	      deriving (Eq,Show)
data Relenddelta = Relenddelta Attributedelta
			       (Maybe Iddelta) (Maybe Roledelta)
			       (Maybe Directiondelta)
			       (OneOf2 Orderingdelta Skip) (Maybe Orderingdelta)
		 deriving (Eq,Show)
data Directiondelta = Directiondelta
    { directiondeltaOlddirection :: (Maybe Directiondelta_Olddirection)
    , directiondeltaNewdirection :: (Maybe Directiondelta_Newdirection)
    } deriving (Eq,Show)
data Directiondelta_Olddirection = Directiondelta_Olddirection_In
				    |  Directiondelta_Olddirection_Out  | 
				   Directiondelta_Olddirection_None
				 deriving (Eq,Show)
data Directiondelta_Newdirection = Directiondelta_Newdirection_In
				    |  Directiondelta_Newdirection_Out  | 
				   Directiondelta_Newdirection_None
				 deriving (Eq,Show)
newtype Attributedelta = Attributedelta [Attributedelta_] 		deriving (Eq,Show)
data Attributedelta_ = Attributedelta_Reduce Reduce
		     | Attributedelta_Change Change
		     | Attributedelta_Extend Extend
		     deriving (Eq,Show)
data Reduce = Reduce Reduce_Attrs [Attrdelta]
	    deriving (Eq,Show)
data Reduce_Attrs = Reduce_Attrs
    { reduceNewname :: (Maybe String)
    } deriving (Eq,Show)
data Extend = Extend Extend_Attrs [Attrdelta]
	    deriving (Eq,Show)
data Extend_Attrs = Extend_Attrs
    { extendOldname :: (Maybe String)
    } deriving (Eq,Show)
data Attrdelta = Attrdelta Attrdelta_Attrs
			   (Maybe Typedelta) (Maybe Attributedelta)
			   (Maybe Iddelta) (Maybe Kinddelta) (Maybe Valuedelta)
	       deriving (Eq,Show)
data Attrdelta_Attrs = Attrdelta_Attrs
    { attrdeltaName :: String
    } deriving (Eq,Show)
data Change = Change (Maybe Namedelta)
		     (Maybe Typedelta) (Maybe Attributedelta)
		     (Maybe Iddelta) (Maybe Kinddelta) (Maybe Valuedelta)
	    deriving (Eq,Show)
data Kinddelta = Kinddelta
    { kinddeltaOldkind :: (Maybe String)
    , kinddeltaNewkind :: (Maybe String)
    } deriving (Eq,Show)
data Valuedelta = ValuedeltaNewvalue Newvalue
		| ValuedeltaLocdelta Locdelta
		| ValuedeltaBooldelta Booldelta
		| ValuedeltaIntdelta Intdelta
		| ValuedeltaFloatdelta Floatdelta
		| ValuedeltaStringdelta Stringdelta
		| ValuedeltaAltdelta Altdelta
		| ValuedeltaGraphdelta Graphdelta
		deriving (Eq,Show)
data Newvalue = Newvalue Value Value
	      deriving (Eq,Show)
data Value = ValueLocdelta Locdelta
	   | ValueBooldelta Booldelta
	   | ValueIntdelta Intdelta
	   | ValueFloatdelta Floatdelta
	   | ValueStringdelta Stringdelta
	   | ValueAltdelta Altdelta
	   | ValueGraphdelta Graphdelta
	   deriving (Eq,Show)
data Locdelta = Locdelta (Maybe Typedelta)
			 (Maybe Hrefdelta)
	      deriving (Eq,Show)
data Intdelta = Intdelta
    { intdeltaOldint :: String
    , intdeltaNewint :: String
    } deriving (Eq,Show)
data Floatdelta = Floatdelta
    { floatdeltaOldfloat :: String
    , floatdeltaNewfloat :: String
    } deriving (Eq,Show)
data Stringdelta = Stringdelta
    { stringdeltaOldstring :: String
    , stringdeltaNewstring :: String
    } deriving (Eq,Show)
data Namedelta = Namedelta
    { namedeltaOldname :: String
    , namedeltaNewname :: String
    } deriving (Eq,Show)
data Altdelta = Altdelta (Maybe Altchange)
			 [Sequencematch] [(OneOf2 Valuedelta Accumdelta)]
	      deriving (Eq,Show)
data Altchange = Altchange
    { altchangeOldalt :: String
    , altchangeNewalt :: String
    } deriving (Eq,Show)
data Accumdelta = Accumdelta Accumdelta_Attrs
			     [Sequencematch] [Valuedelta]
		deriving (Eq,Show)
data Accumdelta_Attrs = Accumdelta_Attrs
    { accumdeltaAccumkind :: (Defaultable Accumdelta_Accumkind)
    } deriving (Eq,Show)
data Accumdelta_Accumkind = Accumdelta_Accumkind_Unch
			     |  Accumdelta_Accumkind_Seq2set  | 
			    Accumdelta_Accumkind_Seq2bag  | 
			    Accumdelta_Accumkind_Set2seq  | 
			    Accumdelta_Accumkind_Set2bag  | 
			    Accumdelta_Accumkind_Bag2seq  | 
			    Accumdelta_Accumkind_Bag2set
			  deriving (Eq,Show)


{-Instance decls-}

instance XmlContent Gdxl where
    fromElem (CElem (Elem "gdxl" as c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (Just (Gdxl (fromAttrs as) a b c), rest))
	      (fromElem cb))
	   (many fromElem ca))
	(many fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Gdxl as a b c) =
	[CElem (Elem "gdxl" (toAttrs as) (concatMap toElem a
					  ++ concatMap toElem b ++
					  maybe [] toElem c))]
instance XmlAttributes Gdxl_Attrs where
    fromAttrs as =
	Gdxl_Attrs
	  { gdxlSourcedoc = possibleA fromAttrToStr "sourcedoc" as
	  , gdxlTargetdoc = possibleA fromAttrToStr "targetdoc" as
	  }
    toAttrs v = catMaybes 
	[ maybeToAttr toAttrFrStr "sourcedoc" (gdxlSourcedoc v)
	, maybeToAttr toAttrFrStr "targetdoc" (gdxlTargetdoc v)
	]
instance XmlContent Typedelta where
    fromElem (CElem (Elem "typedelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (Just (Typedelta a b), rest))
	   (fromElem ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Typedelta a b) =
	[CElem (Elem "typedelta" [] (maybe [] toElem a ++
				     maybe [] toElem b))]
instance XmlContent Xlinkdelta where
    fromElem (CElem (Elem "xlinkdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "xlinkdelta" (toAttrs as) [])]
instance XmlAttributes Xlinkdelta where
    fromAttrs as =
	Xlinkdelta
	  { xlinkdeltaOldxlink = definiteA fromAttrToStr "xlinkdelta" "oldxlink" as
	  , xlinkdeltaNewxlink = definiteA fromAttrToStr "xlinkdelta" "newxlink" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldxlink" (xlinkdeltaOldxlink v)
	, toAttrFrStr "newxlink" (xlinkdeltaNewxlink v)
	]
instance XmlContent Hrefdelta where
    fromElem (CElem (Elem "hrefdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "hrefdelta" (toAttrs as) [])]
instance XmlAttributes Hrefdelta where
    fromAttrs as =
	Hrefdelta
	  { hrefdeltaHrefmode = definiteA fromAttrToTyp "hrefdelta" "hrefmode" as
	  , hrefdeltaNewlink = definiteA fromAttrToStr "hrefdelta" "newlink" as
	  , hrefdeltaOldlink = definiteA fromAttrToStr "hrefdelta" "oldlink" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrTyp "hrefmode" (hrefdeltaHrefmode v)
	, toAttrFrStr "newlink" (hrefdeltaNewlink v)
	, toAttrFrStr "oldlink" (hrefdeltaOldlink v)
	]
instance XmlAttrType Hrefdelta_Hrefmode where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "absolute" = Just Hrefdelta_Hrefmode_Absolute
	    translate "local" = Just Hrefdelta_Hrefmode_Local
	    translate "relative" = Just Hrefdelta_Hrefmode_Relative
	    translate _ = Nothing
    toAttrFrTyp n Hrefdelta_Hrefmode_Absolute = Just (n, str2attr "absolute")
    toAttrFrTyp n Hrefdelta_Hrefmode_Local = Just (n, str2attr "local")
    toAttrFrTyp n Hrefdelta_Hrefmode_Relative = Just (n, str2attr "relative")
instance XmlContent Sequencematch where
    fromElem (CElem (Elem "sequencematch" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "sequencematch" (toAttrs as) [])]
instance XmlAttributes Sequencematch where
    fromAttrs as =
	Sequencematch
	  { sequencematchLength = defaultA fromAttrToStr "1" "length" as
	  , sequencematchOldstart = definiteA fromAttrToStr "sequencematch" "oldstart" as
	  , sequencematchNewstart = definiteA fromAttrToStr "sequencematch" "newstart" as
	  }
    toAttrs v = catMaybes 
	[ defaultToAttr toAttrFrStr "length" (sequencematchLength v)
	, toAttrFrStr "oldstart" (sequencematchOldstart v)
	, toAttrFrStr "newstart" (sequencematchNewstart v)
	]
instance XmlContent Graphdelta where
    fromElem (CElem (Elem "graphdelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (\(f,cf)->
			  (\(g,cg)->
			     (\(h,ch)->
				(\(i,ci)->
				   (\(j,cj)->
				      (Just (Graphdelta a b c d e f g h i
							j), rest))
				   (fromElem ci))
				(fromElem ch))
			     (fromElem cg))
			  (fromElem cf))
		       (fromElem ce))
		    (many fromElem cd))
		 (many fromElem cc))
	      (many fromElem cb))
	   (definite fromElem "<attributedelta>" "graphdelta" ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Graphdelta a b c d e f g h i j) =
	[CElem (Elem "graphdelta" [] (maybe [] toElem a ++
				      toElem b ++ concatMap toElem c ++
				      concatMap toElem d ++ concatMap toElem e
				      ++ maybe [] toElem f ++ maybe [] toElem g
				      ++ toElem h ++ maybe [] toElem i ++
				      maybe [] toElem j))]
instance XmlContent Iddelta where
    fromElem (CElem (Elem "iddelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "iddelta" (toAttrs as) [])]
instance XmlAttributes Iddelta where
    fromAttrs as =
	Iddelta
	  { iddeltaOldid = definiteA fromAttrToStr "iddelta" "oldid" as
	  , iddeltaNewid = definiteA fromAttrToStr "iddelta" "newid" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldid" (iddeltaOldid v)
	, toAttrFrStr "newid" (iddeltaNewid v)
	]
instance XmlContent Roledelta where
    fromElem (CElem (Elem "roledelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "roledelta" (toAttrs as) [])]
instance XmlAttributes Roledelta where
    fromAttrs as =
	Roledelta
	  { roledeltaOldrole = definiteA fromAttrToStr "roledelta" "oldrole" as
	  , roledeltaNewrole = definiteA fromAttrToStr "roledelta" "newrole" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldrole" (roledeltaOldrole v)
	, toAttrFrStr "newrole" (roledeltaNewrole v)
	]
instance XmlContent Booldelta where
    fromElem (CElem (Elem "booldelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "booldelta" (toAttrs as) [])]
instance XmlAttributes Booldelta where
    fromAttrs as =
	Booldelta
	  { booldeltaOldbool = definiteA fromAttrToTyp "booldelta" "oldbool" as
	  , booldeltaNewbool = definiteA fromAttrToTyp "booldelta" "newbool" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrTyp "oldbool" (booldeltaOldbool v)
	, toAttrFrTyp "newbool" (booldeltaNewbool v)
	]
instance XmlAttrType Booldelta_Oldbool where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "true" = Just Booldelta_Oldbool_True
	    translate "false" = Just Booldelta_Oldbool_False
	    translate _ = Nothing
    toAttrFrTyp n Booldelta_Oldbool_True = Just (n, str2attr "true")
    toAttrFrTyp n Booldelta_Oldbool_False = Just (n, str2attr "false")
instance XmlAttrType Booldelta_Newbool where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "true" = Just Booldelta_Newbool_True
	    translate "false" = Just Booldelta_Newbool_False
	    translate _ = Nothing
    toAttrFrTyp n Booldelta_Newbool_True = Just (n, str2attr "true")
    toAttrFrTyp n Booldelta_Newbool_False = Just (n, str2attr "false")
instance XmlContent Skip where
    fromElem (CElem (Elem "skip" [] []):rest) =
	(Just Skip, rest)
    fromElem rest = (Nothing, rest)
    toElem Skip =
	[CElem (Elem "skip" [] [])]
instance XmlContent Edgemodedelta where
    fromElem (CElem (Elem "edgemodedelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "edgemodedelta" (toAttrs as) [])]
instance XmlAttributes Edgemodedelta where
    fromAttrs as =
	Edgemodedelta
	  { edgemodedeltaOldem = definiteA fromAttrToTyp "edgemodedelta" "oldem" as
	  , edgemodedeltaNewem = definiteA fromAttrToTyp "edgemodedelta" "newem" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrTyp "oldem" (edgemodedeltaOldem v)
	, toAttrFrTyp "newem" (edgemodedeltaNewem v)
	]
instance XmlAttrType Edgemodedelta_Oldem where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "directed" = Just Edgemodedelta_Oldem_Directed
	    translate "undirected" = Just Edgemodedelta_Oldem_Undirected
	    translate "defaultdirected" = Just Edgemodedelta_Oldem_Defaultdirected
	    translate "defaultundirected" = Just Edgemodedelta_Oldem_Defaultundirected
	    translate _ = Nothing
    toAttrFrTyp n Edgemodedelta_Oldem_Directed = Just (n, str2attr "directed")
    toAttrFrTyp n Edgemodedelta_Oldem_Undirected = Just (n, str2attr "undirected")
    toAttrFrTyp n Edgemodedelta_Oldem_Defaultdirected = Just (n, str2attr "defaultdirected")
    toAttrFrTyp n Edgemodedelta_Oldem_Defaultundirected = Just (n, str2attr "defaultundirected")
instance XmlAttrType Edgemodedelta_Newem where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "directed" = Just Edgemodedelta_Newem_Directed
	    translate "undirected" = Just Edgemodedelta_Newem_Undirected
	    translate "defaultdirected" = Just Edgemodedelta_Newem_Defaultdirected
	    translate "defaultundirected" = Just Edgemodedelta_Newem_Defaultundirected
	    translate _ = Nothing
    toAttrFrTyp n Edgemodedelta_Newem_Directed = Just (n, str2attr "directed")
    toAttrFrTyp n Edgemodedelta_Newem_Undirected = Just (n, str2attr "undirected")
    toAttrFrTyp n Edgemodedelta_Newem_Defaultdirected = Just (n, str2attr "defaultdirected")
    toAttrFrTyp n Edgemodedelta_Newem_Defaultundirected = Just (n, str2attr "defaultundirected")
instance XmlContent Nodedelta where
    fromElem (CElem (Elem "nodedelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (Just (Nodedelta a b c d e), rest))
		    (fromElem cd))
		 (many fromElem cc))
	      (many fromElem cb))
	   (definite fromElem "<attributedelta>" "nodedelta" ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Nodedelta a b c d e) =
	[CElem (Elem "nodedelta" [] (maybe [] toElem a ++
				     toElem b ++ concatMap toElem c ++
				     concatMap toElem d ++ maybe [] toElem e))]
instance XmlContent Edgedelta where
    fromElem (CElem (Elem "edgedelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (\(f,cf)->
			  (\(g,cg)->
			     (\(h,ch)->
				(\(i,ci)->
				   (\(j,cj)->
				      (Just (Edgedelta a b c d e f g h i
						       j), rest))
				   (fromElem ci))
				(fromElem ch))
			     (fromElem cg))
			  (fromElem cf))
		       (fromElem ce))
		    (fromElem cd))
		 (many fromElem cc))
	      (many fromElem cb))
	   (definite fromElem "<attributedelta>" "edgedelta" ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Edgedelta a b c d e f g h i j) =
	[CElem (Elem "edgedelta" [] (maybe [] toElem a ++
				     toElem b ++ concatMap toElem c ++
				     concatMap toElem d ++ maybe [] toElem e ++
				     toElem f ++ maybe [] toElem g ++ toElem h
				     ++ maybe [] toElem i ++
				     maybe [] toElem j))]
instance XmlContent Orderingdelta where
    fromElem (CElem (Elem "orderingdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "orderingdelta" (toAttrs as) [])]
instance XmlAttributes Orderingdelta where
    fromAttrs as =
	Orderingdelta
	  { orderingdeltaOldorder = definiteA fromAttrToStr "orderingdelta" "oldorder" as
	  , orderingdeltaNeworder = definiteA fromAttrToStr "orderingdelta" "neworder" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldorder" (orderingdeltaOldorder v)
	, toAttrFrStr "neworder" (orderingdeltaNeworder v)
	]
instance XmlContent Reldelta where
    fromElem (CElem (Elem "reldelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (\(f,cf)->
			  (\(g,cg)->
			     (\(h,ch)->
				(Just (Reldelta a b c d e f g h), rest))
			     (fromElem cg))
			  (fromElem cf))
		       (many fromElem ce))
		    (many fromElem cd))
		 (fromElem cc))
	      (many fromElem cb))
	   (definite fromElem "<attributedelta>" "reldelta" ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Reldelta a b c d e f g h) =
	[CElem (Elem "reldelta" [] (maybe [] toElem a ++
				    toElem b ++ concatMap toElem c ++ toElem d
				    ++ concatMap toElem e ++ concatMap toElem f
				    ++ maybe [] toElem g ++ maybe [] toElem h))]
instance XmlContent Relenddelta where
    fromElem (CElem (Elem "relenddelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (\(f,cf)->
			  (Just (Relenddelta a b c d e f), rest))
		       (fromElem ce))
		    (fromElem cd))
		 (fromElem cc))
	      (fromElem cb))
	   (fromElem ca))
	(definite fromElem "<attributedelta>" "relenddelta" c0)
    fromElem rest = (Nothing, rest)
    toElem (Relenddelta a b c d e f) =
	[CElem (Elem "relenddelta" [] (toElem a ++
				       maybe [] toElem b ++ maybe [] toElem c ++
				       maybe [] toElem d ++ toElem e ++
				       maybe [] toElem f))]
instance XmlContent Directiondelta where
    fromElem (CElem (Elem "directiondelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "directiondelta" (toAttrs as) [])]
instance XmlAttributes Directiondelta where
    fromAttrs as =
	Directiondelta
	  { directiondeltaOlddirection = possibleA fromAttrToTyp "olddirection" as
	  , directiondeltaNewdirection = possibleA fromAttrToTyp "newdirection" as
	  }
    toAttrs v = catMaybes 
	[ maybeToAttr toAttrFrTyp "olddirection" (directiondeltaOlddirection v)
	, maybeToAttr toAttrFrTyp "newdirection" (directiondeltaNewdirection v)
	]
instance XmlAttrType Directiondelta_Olddirection where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "in" = Just Directiondelta_Olddirection_In
	    translate "out" = Just Directiondelta_Olddirection_Out
	    translate "none" = Just Directiondelta_Olddirection_None
	    translate _ = Nothing
    toAttrFrTyp n Directiondelta_Olddirection_In = Just (n, str2attr "in")
    toAttrFrTyp n Directiondelta_Olddirection_Out = Just (n, str2attr "out")
    toAttrFrTyp n Directiondelta_Olddirection_None = Just (n, str2attr "none")
instance XmlAttrType Directiondelta_Newdirection where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "in" = Just Directiondelta_Newdirection_In
	    translate "out" = Just Directiondelta_Newdirection_Out
	    translate "none" = Just Directiondelta_Newdirection_None
	    translate _ = Nothing
    toAttrFrTyp n Directiondelta_Newdirection_In = Just (n, str2attr "in")
    toAttrFrTyp n Directiondelta_Newdirection_Out = Just (n, str2attr "out")
    toAttrFrTyp n Directiondelta_Newdirection_None = Just (n, str2attr "none")
instance XmlContent Attributedelta where
    fromElem (CElem (Elem "attributedelta" [] c0):rest) =
	(\(a,ca)->
	   (Just (Attributedelta a), rest))
	(many fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Attributedelta a) =
	[CElem (Elem "attributedelta" [] (concatMap toElem a))]
instance XmlContent Attributedelta_ where
    fromElem c0 =
	case (fromElem c0) of
	(Just a,rest) -> (Just (Attributedelta_Reduce a), rest)
	(Nothing,_) ->
		case (fromElem c0) of
		(Just a,rest) -> (Just (Attributedelta_Change a), rest)
		(Nothing,_) ->
			case (fromElem c0) of
			(Just a,rest) -> (Just (Attributedelta_Extend a), rest)
			(Nothing,_) ->
			    (Nothing, c0)
    fromElem rest = (Nothing, rest)
    toElem (Attributedelta_Reduce a) = toElem a
    toElem (Attributedelta_Change a) = toElem a
    toElem (Attributedelta_Extend a) = toElem a
instance XmlContent Reduce where
    fromElem (CElem (Elem "reduce" as c0):rest) =
	(\(a,ca)->
	   (Just (Reduce (fromAttrs as) a), rest))
	(many fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Reduce as a) =
	[CElem (Elem "reduce" (toAttrs as) (concatMap toElem a))]
instance XmlAttributes Reduce_Attrs where
    fromAttrs as =
	Reduce_Attrs
	  { reduceNewname = possibleA fromAttrToStr "newname" as
	  }
    toAttrs v = catMaybes 
	[ maybeToAttr toAttrFrStr "newname" (reduceNewname v)
	]
instance XmlContent Extend where
    fromElem (CElem (Elem "extend" as c0):rest) =
	(\(a,ca)->
	   (Just (Extend (fromAttrs as) a), rest))
	(many fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Extend as a) =
	[CElem (Elem "extend" (toAttrs as) (concatMap toElem a))]
instance XmlAttributes Extend_Attrs where
    fromAttrs as =
	Extend_Attrs
	  { extendOldname = possibleA fromAttrToStr "oldname" as
	  }
    toAttrs v = catMaybes 
	[ maybeToAttr toAttrFrStr "oldname" (extendOldname v)
	]
instance XmlContent Attrdelta where
    fromElem (CElem (Elem "attrdelta" as c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (Just (Attrdelta (fromAttrs as) a b c d e), rest))
		    (fromElem cd))
		 (fromElem cc))
	      (fromElem cb))
	   (fromElem ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Attrdelta as a b c d e) =
	[CElem (Elem "attrdelta" (toAttrs as) (maybe [] toElem a
					       ++ maybe [] toElem b ++
					       maybe [] toElem c ++
					       maybe [] toElem d ++
					       maybe [] toElem e))]
instance XmlAttributes Attrdelta_Attrs where
    fromAttrs as =
	Attrdelta_Attrs
	  { attrdeltaName = definiteA fromAttrToStr "attrdelta" "name" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "name" (attrdeltaName v)
	]
instance XmlContent Change where
    fromElem (CElem (Elem "change" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (\(d,cd)->
		    (\(e,ce)->
		       (\(f,cf)->
			  (Just (Change a b c d e f), rest))
		       (fromElem ce))
		    (fromElem cd))
		 (fromElem cc))
	      (fromElem cb))
	   (fromElem ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Change a b c d e f) =
	[CElem (Elem "change" [] (maybe [] toElem a ++
				  maybe [] toElem b ++ maybe [] toElem c ++
				  maybe [] toElem d ++ maybe [] toElem e ++
				  maybe [] toElem f))]
instance XmlContent Kinddelta where
    fromElem (CElem (Elem "kinddelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "kinddelta" (toAttrs as) [])]
instance XmlAttributes Kinddelta where
    fromAttrs as =
	Kinddelta
	  { kinddeltaOldkind = possibleA fromAttrToStr "oldkind" as
	  , kinddeltaNewkind = possibleA fromAttrToStr "newkind" as
	  }
    toAttrs v = catMaybes 
	[ maybeToAttr toAttrFrStr "oldkind" (kinddeltaOldkind v)
	, maybeToAttr toAttrFrStr "newkind" (kinddeltaNewkind v)
	]
instance XmlContent Valuedelta where
    fromElem (CElem (Elem "valuedelta" [] c0):rest) =
	case (fromElem c0) of
	(Just a,_) -> (Just (ValuedeltaNewvalue a), rest)
	(Nothing,_) ->
		case (fromElem c0) of
		(Just a,_) -> (Just (ValuedeltaLocdelta a), rest)
		(Nothing,_) ->
			case (fromElem c0) of
			(Just a,_) -> (Just (ValuedeltaBooldelta a), rest)
			(Nothing,_) ->
				case (fromElem c0) of
				(Just a,_) -> (Just (ValuedeltaIntdelta a), rest)
				(Nothing,_) ->
					case (fromElem c0) of
					(Just a,_) -> (Just (ValuedeltaFloatdelta a), rest)
					(Nothing,_) ->
						case (fromElem c0) of
						(Just a,_) -> (Just (ValuedeltaStringdelta a), rest)
						(Nothing,_) ->
							case (fromElem c0) of
							(Just a,_) -> (Just (ValuedeltaAltdelta a), rest)
							(Nothing,_) ->
								case (fromElem c0) of
								(Just a,_) -> (Just (ValuedeltaGraphdelta a), rest)
								(Nothing,_) ->
								    (Nothing, c0)
    fromElem rest = (Nothing, rest)
    toElem (ValuedeltaNewvalue a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaLocdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaBooldelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaIntdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaFloatdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaStringdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaAltdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
    toElem (ValuedeltaGraphdelta a) = [CElem (Elem "valuedelta" [] (toElem a) )]
instance XmlContent Newvalue where
    fromElem (CElem (Elem "newvalue" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (Just (Newvalue a b), rest))
	   (definite fromElem "<value>" "newvalue" ca))
	(definite fromElem "<value>" "newvalue" c0)
    fromElem rest = (Nothing, rest)
    toElem (Newvalue a b) =
	[CElem (Elem "newvalue" [] (toElem a ++ toElem b))]
instance XmlContent Value where
    fromElem (CElem (Elem "value" [] c0):rest) =
	case (fromElem c0) of
	(Just a,_) -> (Just (ValueLocdelta a), rest)
	(Nothing,_) ->
		case (fromElem c0) of
		(Just a,_) -> (Just (ValueBooldelta a), rest)
		(Nothing,_) ->
			case (fromElem c0) of
			(Just a,_) -> (Just (ValueIntdelta a), rest)
			(Nothing,_) ->
				case (fromElem c0) of
				(Just a,_) -> (Just (ValueFloatdelta a), rest)
				(Nothing,_) ->
					case (fromElem c0) of
					(Just a,_) -> (Just (ValueStringdelta a), rest)
					(Nothing,_) ->
						case (fromElem c0) of
						(Just a,_) -> (Just (ValueAltdelta a), rest)
						(Nothing,_) ->
							case (fromElem c0) of
							(Just a,_) -> (Just (ValueGraphdelta a), rest)
							(Nothing,_) ->
							    (Nothing, c0)
    fromElem rest = (Nothing, rest)
    toElem (ValueLocdelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueBooldelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueIntdelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueFloatdelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueStringdelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueAltdelta a) = [CElem (Elem "value" [] (toElem a) )]
    toElem (ValueGraphdelta a) = [CElem (Elem "value" [] (toElem a) )]
instance XmlContent Locdelta where
    fromElem (CElem (Elem "locdelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (Just (Locdelta a b), rest))
	   (fromElem ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Locdelta a b) =
	[CElem (Elem "locdelta" [] (maybe [] toElem a ++
				    maybe [] toElem b))]
instance XmlContent Intdelta where
    fromElem (CElem (Elem "intdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "intdelta" (toAttrs as) [])]
instance XmlAttributes Intdelta where
    fromAttrs as =
	Intdelta
	  { intdeltaOldint = definiteA fromAttrToStr "intdelta" "oldint" as
	  , intdeltaNewint = definiteA fromAttrToStr "intdelta" "newint" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldint" (intdeltaOldint v)
	, toAttrFrStr "newint" (intdeltaNewint v)
	]
instance XmlContent Floatdelta where
    fromElem (CElem (Elem "floatdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "floatdelta" (toAttrs as) [])]
instance XmlAttributes Floatdelta where
    fromAttrs as =
	Floatdelta
	  { floatdeltaOldfloat = definiteA fromAttrToStr "floatdelta" "oldfloat" as
	  , floatdeltaNewfloat = definiteA fromAttrToStr "floatdelta" "newfloat" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldfloat" (floatdeltaOldfloat v)
	, toAttrFrStr "newfloat" (floatdeltaNewfloat v)
	]
instance XmlContent Stringdelta where
    fromElem (CElem (Elem "stringdelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "stringdelta" (toAttrs as) [])]
instance XmlAttributes Stringdelta where
    fromAttrs as =
	Stringdelta
	  { stringdeltaOldstring = definiteA fromAttrToStr "stringdelta" "oldstring" as
	  , stringdeltaNewstring = definiteA fromAttrToStr "stringdelta" "newstring" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldstring" (stringdeltaOldstring v)
	, toAttrFrStr "newstring" (stringdeltaNewstring v)
	]
instance XmlContent Namedelta where
    fromElem (CElem (Elem "namedelta" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "namedelta" (toAttrs as) [])]
instance XmlAttributes Namedelta where
    fromAttrs as =
	Namedelta
	  { namedeltaOldname = definiteA fromAttrToStr "namedelta" "oldname" as
	  , namedeltaNewname = definiteA fromAttrToStr "namedelta" "newname" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldname" (namedeltaOldname v)
	, toAttrFrStr "newname" (namedeltaNewname v)
	]
instance XmlContent Altdelta where
    fromElem (CElem (Elem "altdelta" [] c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (\(c,cc)->
		 (Just (Altdelta a b c), rest))
	      (many fromElem cb))
	   (many fromElem ca))
	(fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Altdelta a b c) =
	[CElem (Elem "altdelta" [] (maybe [] toElem a ++
				    concatMap toElem b ++ concatMap toElem c))]
instance XmlContent Altchange where
    fromElem (CElem (Elem "altchange" as []):rest) =
	(Just (fromAttrs as), rest)
    fromElem rest = (Nothing, rest)
    toElem as =
	[CElem (Elem "altchange" (toAttrs as) [])]
instance XmlAttributes Altchange where
    fromAttrs as =
	Altchange
	  { altchangeOldalt = definiteA fromAttrToStr "altchange" "oldalt" as
	  , altchangeNewalt = definiteA fromAttrToStr "altchange" "newalt" as
	  }
    toAttrs v = catMaybes 
	[ toAttrFrStr "oldalt" (altchangeOldalt v)
	, toAttrFrStr "newalt" (altchangeNewalt v)
	]
instance XmlContent Accumdelta where
    fromElem (CElem (Elem "accumdelta" as c0):rest) =
	(\(a,ca)->
	   (\(b,cb)->
	      (Just (Accumdelta (fromAttrs as) a b), rest))
	   (many fromElem ca))
	(many fromElem c0)
    fromElem rest = (Nothing, rest)
    toElem (Accumdelta as a b) =
	[CElem (Elem "accumdelta" (toAttrs as) (concatMap toElem a
						++ concatMap toElem b))]
instance XmlAttributes Accumdelta_Attrs where
    fromAttrs as =
	Accumdelta_Attrs
	  { accumdeltaAccumkind = defaultA fromAttrToTyp Accumdelta_Accumkind_Unch "accumkind" as
	  }
    toAttrs v = catMaybes 
	[ defaultToAttr toAttrFrTyp "accumkind" (accumdeltaAccumkind v)
	]
instance XmlAttrType Accumdelta_Accumkind where
    fromAttrToTyp n (n',v)
	| n==n'     = translate (attr2str v)
	| otherwise = Nothing
      where translate "unch" = Just Accumdelta_Accumkind_Unch
	    translate "seq2set" = Just Accumdelta_Accumkind_Seq2set
	    translate "seq2bag" = Just Accumdelta_Accumkind_Seq2bag
	    translate "set2seq" = Just Accumdelta_Accumkind_Set2seq
	    translate "set2bag" = Just Accumdelta_Accumkind_Set2bag
	    translate "bag2seq" = Just Accumdelta_Accumkind_Bag2seq
	    translate "bag2set" = Just Accumdelta_Accumkind_Bag2set
	    translate _ = Nothing
    toAttrFrTyp n Accumdelta_Accumkind_Unch = Just (n, str2attr "unch")
    toAttrFrTyp n Accumdelta_Accumkind_Seq2set = Just (n, str2attr "seq2set")
    toAttrFrTyp n Accumdelta_Accumkind_Seq2bag = Just (n, str2attr "seq2bag")
    toAttrFrTyp n Accumdelta_Accumkind_Set2seq = Just (n, str2attr "set2seq")
    toAttrFrTyp n Accumdelta_Accumkind_Set2bag = Just (n, str2attr "set2bag")
    toAttrFrTyp n Accumdelta_Accumkind_Bag2seq = Just (n, str2attr "bag2seq")
    toAttrFrTyp n Accumdelta_Accumkind_Bag2set = Just (n, str2attr "bag2set")


{-Done-}