source: TI02-CSML/trunk/newparser/Parser.py @ 882

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/newparser/Parser.py@882
Revision 882, 122.5 KB checked in by domlowe, 14 years ago (diff)

removed annoying print statement

Line 
1#!/usr/bin/env python
2
3from cElementTree import *
4import sys
5from UserString import MutableString
6
7# NOTES
8# ~~~~~
9#
10# (1) Testing existence in cElementTree.
11# ElementTree structures evaluate as false unless they have child elements:
12#
13# >>> b=Element('blah')
14# >>> dump(b)
15# <blah />
16# >>> if b: print 'non-null'
17#
18# >>> b.append(Element('moreblah'))
19# >>> dump(b)
20# <blah><moreblah /></blah>
21# >>> if b: print 'non-null'
22#
23# non-null
24#
25#
26# For this reason, existence tests should always be done as:
27#
28# >>> b=Element('blah')
29# >>> if b is not None: print 'non-null'
30#
31# non-null
32#
33# (2) Namesmape processing
34# Everything is namespace qualified in ElementTree.
35# The module provides a utility class QName(uri,tag) with QName().text providing
36# the text representation "{uri}tag" used by ElementTree. Instead, a lightweight
37# equivalent function myQName(uri,tag) has been defined here to do the
38# same thing. Also, CSML(tag), GML(tag), XLINK(tag) provide even shorter cuts.
39#
40# (3) Mandatory elements
41# The basic pattern used in the toXML() method here is to look for those
42# attributes of the class that are expected and add to the XML fragment under
43# construction. Where those attributes are mandatory, however, (i.e. UML
44# multiplicity one), the test is not performed - they are assumed to exist.
45# This eliminates an 'if' statement, but will geneate an error if they don't
46# exist.
47
48nsCSML = 'http://ndg.nerc.ac.uk/csml'
49nsGML = 'http://www.opengis.net/gml'
50nsOM = 'http://www.opengis.net/om'
51nsXLINK = 'http://www.w3.org/1999/xlink'
52nsXML = 'http://ndg.nerc.ac.uk/csml'
53
54def myQName(uri,tag):
55    return "{"+uri+"}"+tag
56
57def CSML(tag):
58    return myQName(nsCSML,tag)
59
60def GML(tag):
61    return myQName(nsGML,tag)
62
63def XLINK(tag):
64    return myQName(nsXLINK,tag)
65
66def XML(tag):
67    return myQName(nsXML,tag)
68
69def OM(tag):
70    return myQName(nsOM,tag)
71
72def checkArrayAttrib(obj,attrib):
73    if not hasattr(obj,attrib) or not isinstance(getattr(obj,attrib),list):
74        setattr(obj,attrib,[])
75
76##class TemplateClass(Base):
77##    def __init__(self,myarg=None,*args,**kwargs):
78##        Base.__init__(self,*args,**kwargs)
79##        # code specific to TemplateClass
80##    def fromXML(self,csmlFrag):
81##        Base.fromXML(self,csmlFrag)
82##        # code specific to TemplateClass
83##    def toXML(self,csmlFrag):
84##        csmlFrag = Base.toXML(self,csmlFrag)
85##        # code specific to TemplateClass
86##        return csmlFrag
87
88class MetaDataProperty:
89    """Class representing metadata property (gmlBase.xsd)
90    MetaDataProperty:
91    +href: URI
92    """
93    def __init__(self,href=None):
94        if href:
95            self.href = href
96    def fromXML(self,csmlFrag):
97        if csmlFrag.attrib.has_key(XLINK('href')):
98             self.href = csmlFrag.attrib[XLINK('href')]
99    def toXML(self,csmlFrag):
100        if hasattr(self,'href'):
101            csmlFrag.attrib[XLINK('href')] = self.href
102        return csmlFrag
103
104class Description(MutableString):
105    """Class representing a GML description element
106    Description(string):
107    """
108    def __init__(self,val=''):
109        MutableString.__init__(self,val)
110    def fromXML(self,csmlFrag):
111        self.data = csmlFrag.text
112    def toXML(self,csmlFrag):
113        csmlFrag.text = self.data
114        return csmlFrag
115
116class Name(MutableString):
117    """Class representing a GML name element
118    Name(string):
119     +codeSpace[0..1]: anyURI
120    """
121    def __init__(self,val='',codeSpace=None):
122        MutableString.__init__(self,val)
123        if val:
124            self.val=val
125        if codeSpace:
126            self.codeSpace = codeSpace
127    def fromXML(self,csmlFrag):
128        self.val = csmlFrag.text
129        if csmlFrag.attrib.has_key('codeSpace'):
130            self.codeSpace = csmlFrag.attrib['codeSpace']
131    def toXML(self,csmlFrag):
132        if hasattr(self, 'codeSpace'):
133            csmlFrag.attrib['codeSpace'] = self.codeSpace
134        if hasattr(self, 'val'):
135            csmlFrag.text = self.val
136       
137        return csmlFrag
138
139class AbstractGML:
140    """Base abstract GML type
141
142    AbstractGML:
143     +id[0..1]: ID
144     +metaDataProperty[0..*]: MetaDataProperty
145     +description[0..1]: Description
146     +name[0..*]: Name
147    """
148    def __init__(self,gmlid=None,metaDataProperty=[],description=None,name=[],*args,**kwargs):
149        if gmlid:
150            self.id = gmlid
151        if metaDataProperty:
152            self.metaDataProperty = metaDataProperty
153        if description:
154            self.description = description
155        if name:
156            self.name = name
157    def fromXML(self,csmlFrag):
158        if csmlFrag.attrib.has_key(GML('id')):
159            self.id = csmlFrag.attrib[GML('id')]
160        for frag in csmlFrag.getchildren():
161            if frag.tag == GML('metaDataProperty'):
162                checkArrayAttrib(self,'metaDataProperty')
163                self.metaDataProperty.append(MetaDataProperty())
164                self.metaDataProperty[-1].fromXML(frag)
165            elif frag.tag == GML('description'):
166                self.description = Description()
167                self.description.fromXML(frag)
168            elif frag.tag == GML('name'):
169                checkArrayAttrib(self,'name')
170                self.name.append(Name())
171                self.name[-1].fromXML(frag)
172    def toXML(self,csmlFrag):
173        if hasattr(self,'id'):
174            csmlFrag.attrib[GML('id')] = self.id
175        if hasattr(self,'metaDataProperty'):
176            for md in self.metaDataProperty:
177                frag = Element(GML('metaDataProperty'))
178                frag = MetaDataProperty.toXML(md,frag)
179                csmlFrag.append(frag)
180        if hasattr(self,'description'):
181            frag = Element(GML('description'))
182            frag = Description.toXML(self.description,frag)
183            csmlFrag.append(frag)
184        if hasattr(self,'name'):
185            for name in self.name:
186                frag = Element(GML('name'))
187                frag = Name.toXML(name,frag)
188                csmlFrag.append(frag)
189        return csmlFrag
190
191
192class SRSReferenceGroup:
193# class to represeent gml:SRSReferenceGroup
194# class SRSReferenceGroup:
195#     +srsName[0...]:anyURI
196# #     +srsDimension[0...1]:positiveInteger
197    def __init__(self,srsName=None,srsDimension=None):
198        if srsName:
199            self.srsName=srsName
200        if srsDimension:
201            self.srsDimension=srsDimension
202    def fromXML(self,csmlFrag):
203        if csmlFrag.attrib.has_key('srsName'):
204            self.srsName=csmlFrag.attrib['srsName']
205        if csmlFrag.attrib.has_key('srsDimension'):
206            self.srsDimension=csmlFrag.attrib['srsDimension']
207    def toXML(self,csmlFrag):
208            if hasattr(self,'srsName'):
209                csmlFrag.attrib['srsName']= self.srsName
210            if hasattr(self,'srsDimension'):
211                csmlFrag.attrib['srsDimension']= self.srsDimension
212            return csmlFrag
213class AssociationAttributeGroup:
214    '''Class to represent gml:AssociationAttributeGroup which is based on the xlink 'simplelink' attribute group (not implemented)
215    #class AssociationAttributeGroup
216    +xlink:href[0..1]:string
217    +xlink:role[0..1]:string
218    +xlink:arcrole[0..1]:string
219    +xlink:title[0..1]:string
220    +xlink:show[0..1]:string
221    +xlink:actuate[0..1]:string '''
222    def __init__(self, href=None, role=None,arcrole=None,title=None,show=None,actuate=None):
223         if href:
224             self.href=href
225         if role:
226             self.role=role
227         if arcrole:
228             self.arcrole=arcrole
229         if title:
230             self.title=title
231         if show:
232             self.show=show
233         if actuate:
234             self.actuate=actuate
235    def fromXML(self,csmlFrag):
236        if csmlFrag.attrib.has_key(XLINK('href')):
237            self.href=csmlFrag.attrib[XLINK('href')]
238        if csmlFrag.attrib.has_key(XLINK('role')):
239            self.role=csmlFrag.attrib[XLINK('role')]
240        if csmlFrag.attrib.has_key(XLINK('arcrole')):
241            self.arcrole=csmlFrag.attrib[XLINK('arcrole')]
242        if csmlFrag.attrib.has_key(XLINK('title')):
243            self.title=csmlFrag.attrib[XLINK('title')]
244        if csmlFrag.attrib.has_key(XLINK('show')):
245            self.show=csmlFrag.attrib[XLINK('show')]
246        if csmlFrag.attrib.has_key(XLINK('actuate')):
247            self.actuate=csmlFrag.attrib[XLINK('actuate')]
248       
249    def toXML(self,csmlFrag):
250        if hasattr(self,'href'):
251            csmlFrag.attrib[XLINK('href')]= self.href
252        if hasattr(self,'role'):
253            csmlFrag.attrib[XLINK('role')]= self.role
254        if hasattr(self,'arcrole'):
255            csmlFrag.attrib[XLINK('arcrole')]= self.arcrole
256        if hasattr(self,'title'):
257            csmlFrag.attrib[XLINK('title')]= self.title
258        if hasattr(self,'show'):
259            csmlFrag.attrib[XLINK('show')]= self.show
260        if hasattr(self,'actuate'):
261            csmlFrag.attrib[XLINK('actuate')]= self.actuate
262       
263        return csmlFrag
264   
265           
266class Definition(AbstractGML):
267    #Class Definition(AbstractGML), restricts AbstractGML
268    #gml:id is mandatory
269    #
270    # Definition(AbstractGML):
271    # +id[1]: ID
272     
273    def __init__(self,*args,**kwargs):
274        AbstractGML.__init__(self,*args,**kwargs)
275    def fromXML(self,csmlFrag):
276        AbstractGML.fromXML(self,csmlFrag)
277        #TO DO: how  best to handle errors?
278        if not hasattr(self,'id'):
279            #print 'gml:id mandatory value missing in ' + csmlFrag.tag
280            pass
281    def toXML(self,csmlFrag):
282        csmlFrag=AbstractGML.toXML(self,csmlFrag)
283        return csmlFrag
284
285class CodeType(MutableString):
286        #Class for gml:CodeType element
287       
288        #CodeType(MutableString)
289        # +codeSpace[0..1]:anyURI
290    def __init__(self,val='',codeSpace=None):
291        MutableString.__init__(self,val)
292        if codeSpace:
293            self.codeSpace = codeSpace
294    def fromXML(self,csmlFrag):
295        self.data = csmlFrag.text
296        if csmlFrag.attrib.has_key('codeSpace'):
297            self.codeSpace = csmlFrag.attrib['codeSpace']
298    def toXML(self,csmlFrag):
299        csmlFrag.text = self.data
300        if hasattr(self,'codeSpace'):
301            csmlFrag.attrib['codeSpace'] = self.codeSpace
302        return csmlFrag
303
304       
305       
306class TimeIntervalLength:
307    # class for gml:TimeIntervalLength (decimal)
308    # n.b. have not implemented 'decimal' class
309    # +unit[1]: gml:UnitType
310    # +radix[0...1]: posint
311    # +factor[0...1] :int
312    def __init__(self, unit=None, radix=None, factor=None,data=None):
313        if unit:
314            self.unit =unit
315        if radix:
316            self.radix=radix
317        if factor:
318            self.factor=factor
319        if data:
320            self.data=data
321    def fromXML(self, csmlFrag):
322        self.data = csmlFrag.text
323        if csmlFrag.attrib.has_key('unit'):
324            self.unit=csmlFrag.attrib['unit']
325        if csmlFrag.attrib.has_key('radix'):
326            self.radix=csmlFrag.attrib['radix']
327        if csmlFrag.attrib.has_key('factor'):
328            self.factor=csmlFrag.attrib['factor']
329    def toXML(self,csmlFrag):
330        csmlFrag.text=self.data
331        if hasattr(self,'unit'):
332            csmlFrag.attrib['unit'] = self.unit
333        if hasattr(self,'radix'):
334            csmlFrag.attrib['radix'] = self.radix
335        if hasattr(self,'factor'):
336            csmlFrag.attrib['factor'] = self.factor
337        return csmlFrag   
338   
339class TimeCoordinateSystem(Definition):
340    #Class for csml:TimeCoordinateSystem(gml:Definition) element
341    # + originPosition
342    # + interval
343   
344    ### TO DO!
345    #This is wrong, interval should be of type TimeIntervalLength
346#     <element name="originPosition" type="gml:TimePositionType"/>
347#             <element name="origin" type="gml:TimeInstantPropertyType"/>
348#           </choice>
349#           <element name="interval" type="gml:TimeIntervalLengthType"/>
350#Or is it okay as is.??
351
352    def __init__(self,originPosition=None,interval=None,unit=None,*args,**kwargs):
353        Definition.__init__(self,*args,**kwargs)
354        if originPosition:
355            self.originPosition=originPosition
356        if interval:
357            self.interval=interval
358        if unit:
359            self.unit=unit
360    def fromXML(self,csmlFrag):
361        Definition.fromXML(self,csmlFrag)
362        for frag in csmlFrag.getchildren():
363            if frag.tag == GML('originPosition'):
364                self.originPosition=frag.text
365            elif frag.tag == GML('interval'):
366                self.interval=frag.text
367                self.unit = frag.attrib
368    def toXML(self,csmlFrag):
369        Definition.toXML(self,csmlFrag)
370        if hasattr(self, 'originPosition'):
371            frag=Element(GML('originPosition'))
372            frag.text=self.originPosition
373            csmlFrag.append(frag)
374        if hasattr(self, 'interval'):
375            frag=Element(GML('interval'))
376            frag.text=self.interval
377            if hasattr(self,'unit'):
378                frag.attrib=self.unit
379            csmlFrag.append(frag)
380        return csmlFrag
381
382
383class AbstractReferenceSystemBase(Definition):
384# AbstractReferenceSystemBase(Definition)
385# +gml:MetaDataProperty[0...*]:MetaDataProperty
386# +gml:remarks[0...1]
387# +gml:srsName [?]
388
389
390    def __init__(self,remarks=None,srsName=None,*args,**kwargs):
391        Definition.__init__(self, *args, **kwargs)
392        if remarks:
393            self.remarks=remarks
394        if srsName:
395            self.srsName=srsName
396    def fromXML(self,csmlFrag):
397        Definition.fromXML(self, csmlFrag)
398        for frag in csmlFrag.getchildren():
399            if frag.tag==GML('remarks'):
400                self.remarks=frag.text
401            if frag.tag==GML('srsName'):
402                self.srsName=frag.text
403    def toXML(self,csmlFrag):
404        Definition.toXML(self, csmlFrag)
405        if hasattr(self,'remarks'):
406            frag = Element(GML('remarks'))
407            frag.text=self.remarks
408            csmlFrag.append(frag)
409        if hasattr(self,'srsName'):
410            frag = Element(GML('srsName'))
411            frag.text=self.srsName
412            csmlFrag.append(frag)
413        return csmlFrag
414
415class AbstractReferenceSystem(AbstractReferenceSystemBase):
416#AbstractReferenceSystem(AbstractReferenceSystemBase):
417    def __init__(self,*args,**kwargs):
418        AbstractReferenceSystemBase.__init__(self, *args, **kwargs)
419    def fromXML(self,csmlFrag):
420        AbstractReferenceSystemBase.fromXML(self, csmlFrag)
421    def toXML(self,csmlFrag):
422        AbstractReferenceSystemBase.toXML(self, csmlFrag)
423        return csmlFrag
424
425           
426class AbstractCRS(AbstractReferenceSystem):
427#AbstractCRS(AbstractReferenceSystem):
428
429    def __init__(self,*args,**kwargs):
430        AbstractReferenceSystem.__init__(self, *args, **kwargs)
431    def fromXML(self,csmlFrag):
432        AbstractReferenceSystem.fromXML(self, csmlFrag)
433    def toXML(self,csmlFrag):
434        AbstractReferenceSystem.toXML(self, csmlFrag)
435        return csmlFrag
436           
437
438class AbstractTimeReferenceSystem(Definition):
439    def __init__(self,*args,**kwargs):
440        Definition.__init__(self, *args, **kwargs)
441    def fromXML(self,csmlFrag):
442        Definition.fromXML(self, csmlFrag)
443    def toXML(self,csmlFrag):
444        Definition.toXML(self, csmlFrag)
445        return csmlFrag
446
447
448class AbstractCoordinateReferenceSystem(AbstractCRS):
449    def __init__(self,*args,**kwargs):
450        AbstractCRS.__init__(self, *args, **kwargs)
451    def fromXML(self,csmlFrag):
452        AbstractCRS.fromXML(self, csmlFrag)
453    def toXML(self,csmlFrag):
454        AbstractCRS.toXML(self, csmlFrag)
455        return csmlFrag
456
457   
458class DictionaryEntry(AssociationAttributeGroup,AbstractGML):
459    def __init__(self,*args,**kwargs):
460        pass
461    def fromXML(self,csmlFrag):
462        pass
463    def toXML(self,csmlFrag):
464        return csmlFrag
465   
466class DatumRef(DictionaryEntry):
467    def __init__(self,*args,**kwargs):
468        DictionaryEntry.__init__(self, *args, **kwargs)
469    def fromXML(self,csmlFrag):
470        DictionaryEntry.fromXML(self, csmlFrag)
471    def toXML(self,csmlFrag):
472        DictionaryEntry.toXML(self, csmlFrag)
473        return csmlFrag
474
475class AbstractDatumBase(Definition):
476#         <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
477#                                       <element ref="gml:remarks" minOccurs="0">
478#                                               <annotation>
479#                                                       <documentation>Comments on this reference system, including source information. </documentation>
480#                                               </annotation>
481#                                       </element>
482#                                       <element ref="gml:datumName"/>
483    def __init__(self,metaDataProperty=None,remarks=None,datumName=None,*args,**kwargs):
484        Definition.__init__(self,*args,**kwargs)
485        if metaDataProperty:
486            self.metaDataProperty=metaDataProperty
487        if remarks:
488            self.remarks=remarks
489        if datumName:
490            self.datumName=datumName
491    def fromXML(self,csmlFrag):
492        if csmlFrag.attrib.has_key(GML('metaDataProperty')):
493            self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')]
494        for frag in csmlFrag.getchildren():
495            if frag.tag==GML('remarks'):
496                self.remarks=frag.text
497            if frag.tag==GML('datumName'):
498                self.datumName=frag.text
499        Definition.fromXML(self,csmlFrag)
500    def toXML(self,csmlFrag):
501        Definition.toXML(self,csmlFrag)
502        if hasattr(self,'metaDataProperty'):
503            csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty
504        if hasattr(self, 'remarks'):
505            frag=Element(GML('remarks'))
506            frag.text=self.remarks
507            csmlFrag.append(frag)
508        if hasattr(self, 'datumName'):
509            frag=Element(GML('datumName'))
510            frag.text=self.datumName
511            csmlFrag.append(frag)
512        return csmlFrag
513   
514class AbstractDatum(AbstractDatumBase):
515#             <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded">
516#                                               <annotation>
517#                                                       <documentation>Set of alternative identifications of this datum. The first datumID, if any, is normally the primary identification code, and any others are aliases. </documentation>
518#                                               </annotation>
519#                                       </element>
520#                                       <element ref="gml:anchorPoint" minOccurs="0"/>
521#                                       <element ref="gml:realizationEpoch" minOccurs="0"/>
522#                                       <element ref="gml:validArea" minOccurs="0"/>
523#                                       <element ref="gml:scope" minOccurs="0"/>
524    def __init__(self,datumID=None,anchorPoint=None,realizationEpoch=None,validArea=None, scope=None,*args,**kwargs):
525        if datumID:
526            self.datumID=datumID
527        if anchorPoint:
528            self.anchorPoint=anchorPoint
529        if realizationEpoch:
530            self.realizationEpoch=realizationEpoch
531        if validArea:
532            self.validArea=validArea
533        AbstractDatumBase.__init__(self,*args,**kwargs)
534    def fromXML(self,csmlFrag):
535        AbstractDatumBase.fromXML(self,csmlFrag)
536        for frag in csmlFrag.getchildren():
537            if frag.tag==GML('datumID'):
538                self.datumID=frag.text
539            if frag.tag==GML('anchorPoint'):
540                self.anchorPoint=frag.text
541            if frag.tag==GML('realizationEpoch'):
542                self.realizationEpoch=frag.text
543            if frag.tag==GML('validArea'):
544                self.validArea=frag.text
545    def toXML(self,csmlFrag):
546        AbstractDatumBase.toXML(self,csmlFrag)
547        if hasattr(self, 'datumID'):
548            frag=Element(GML('datumID'))
549            frag.text=self.datumID
550            csmlFrag.append(frag)
551        if hasattr(self, 'anchorPoint'):
552            frag=Element(GML('anchorPoint'))
553            frag.text=self.anchorPoint
554            csmlFrag.append(frag)
555        if hasattr(self, 'realizationEpoch'):
556            frag=Element(GML('realizationEpoch'))
557            frag.text=self.realizationEpoch
558            csmlFrag.append(frag)
559        if hasattr(self, 'validArea'):
560            frag=Element(GML('validArea'))
561            frag.text=self.validArea
562            csmlFrag.append(frag)
563   
564        return csmlFrag
565   
566class EngineeringDatum(AbstractDatum):
567    def __init__(self,*args,**kwargs):
568        AbstractDatum.__init__(self,*args,**kwargs)
569    def fromXML(self,csmlFrag):
570        AbstractDatum.fromXML(self,csmlFrag)
571    def toXML(self,csmlFrag):
572        AbstractDatum.toXML(self,csmlFrag)
573        return csmlFrag
574
575class VerticalDatumType(CodeType):
576    def __init__(self,*args,**kwargs):
577        CodeType.__init__(self,*args,**kwargs)
578    def fromXML(self,csmlFrag):
579        CodeType.fromXML(self,csmlFrag)
580    def toXML(self,csmlFrag):
581        CodeType.toXML(self,csmlFrag)
582        return csmlFrag
583
584class VerticalDatum(AbstractDatum):
585    def __init__(self,verticalDatumType=None,*args,**kwargs):
586        AbstractDatum.__init__(self,*args,**kwargs)
587        #Note to Andrew, "Type" is part of the element name here. the element <VerticalDatumType> has type: VerticalDatumTypeType.
588        if verticalDatumType:
589            self.verticalDatumType=verticalDatumType
590    def fromXML(self,csmlFrag):
591        AbstractDatum.fromXML(self,csmlFrag)
592        for frag in csmlFrag.getchildren():
593            if frag.tag==GML('VerticalDatumType'):
594                self.verticalDatumType=VerticalDatumType()
595                VerticalDatumType.fromXML(self.verticalDatumType,frag)
596       
597    def toXML(self,csmlFrag):
598        AbstractDatum.toXML(self,csmlFrag)
599        if hasattr(self,'verticalDatumType'):
600            frag=Element(GML('VerticalDatumType'))
601            frag=VerticalDatumType.toXML(self.verticalDatumType,frag)
602        return csmlFrag
603
604class TemporalDatumBase(AbstractDatum):
605#       <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
606#                                       <element ref="gml:datumName"/>
607#                                       <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded"/>
608#                                       <element ref="gml:validArea" minOccurs="0"/>
609#                                       <element ref="gml:scope" minOccurs="0"/>
610    def __init__(self,datumName=None, datumID = None, validArea=None, scope=None,*args,**kwargs):
611        AbstractDatum.__init__(self,*args,**kwargs)
612    def fromXML(self,csmlFrag):
613        AbstractDatum.fromXML(self,csmlFrag)
614        for frag in csmlFrag.getchildren():
615            if frag.tag==GML('datumName'):
616                self.datumName=frag.text
617            if frag.tag==GML('datumID'):
618                self.datumID=frag.text
619            if frag.tag==GML('validArea'):
620                self.validArea=frag.text
621            if frag.tag==GML('scope'):
622                self.scope=frag.text
623    def toXML(self,csmlFrag):
624        AbstractDatum.toXML(self,csmlFrag)
625        if hasattr(self,'datumName'):
626            frag=Element(GML('datumName'))
627            frag.text=self.datumName
628        if hasattr(self,'datumID'):
629            frag=Element(GML('datumID'))
630            frag.text=self.datumID
631        if hasattr(self,'validArea'):
632            frag=Element(GML('validArea'))
633            frag.text=self.validArea
634        if hasattr(self,'scope'):
635            frag=Element(GML('scope'))
636            frag.text=self.scope
637        return csmlFrag
638
639
640class TemporalDatumType(TemporalDatumBase):
641    def __init__(self,*args,**kwargs):
642        CodeType.__init__(self,*args,**kwargs)
643    def fromXML(self,csmlFrag):
644        CodeType.fromXML(self,csmlFrag)
645    def toXML(self,csmlFrag):
646        CodeType.toXML(self,csmlFrag)
647        return csmlFrag
648
649class TemporalDatum(AbstractDatum):
650    def __init__(self,origin=None,*args,**kwargs):
651        AbstractDatum.__init__(self,*args,**kwargs)
652        #Note to Andrew, "Type" is part of the element name here. the element <TemporalDatumType> has type: TemporalDatumTypeType.
653        if origin:
654            self.origin=origin
655    def fromXML(self,csmlFrag):
656        AbstractDatum.fromXML(self,csmlFrag)
657        for frag in csmlFrag.getchildren():
658            if frag.tag==GML('TemporalDatumType'):
659                self.temporalDatumType=TemporalDatumType()
660                TemporalDatumType.fromXML(self.temporalDatumType,frag)
661    def toXML(self,csmlFrag):
662        AbstractDatum.toXML(self,csmlFrag)
663        if hasattr(self,'temporalDatumType'):
664            frag=Element(GML('TemporalDatumType'))
665            frag=TemporalDatumType.toXML(self.temporalDatumType,frag)
666        return csmlFrag
667       
668class PrimeMeridianBase(Definition):
669#                       <restriction base="gml:DefinitionType">
670#                               <sequence>
671#                                       <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
672#                                       <element ref="gml:remarks" minOccurs="0">
673#                                               <annotation>
674#                                                       <documentation>Comments on or information about this prime meridian, including source information. </documentation>
675#                                               </annotation>
676#                                       </element>
677#                                       <element ref="gml:meridianName"/>
678#                               </sequence>
679#                               <attribute ref="gml:id" use="required"/>
680#                       </restriction>
681    def __init__(self,metaDataProperty=None, remarks=None, meridianName=None, *args,**kwargs):
682        Definition.__init__(self,*args,**kwargs)
683        if metaDataProperty:
684            self.metaDataProperty=metaDataProperty
685        if remarks:
686            self.remarks=remarks
687        if meridianName:
688            self.meridianName=meridianName
689
690    def fromXML(self,csmlFrag):
691        Definition.fromXML(self,csmlFrag)
692        if csmlFrag.attrib.has_key(GML('metaDataProperty')):
693            self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')]
694        for frag in csmlFrag.getchildren():
695            if frag.tag==GML('remarks'):
696                self.remarks=frag.text
697            if frag.tag==GML('meridianName'):
698                self.meridianName=frag.text
699    def toXML(self,csmlFrag):
700        Definition.toXML(self,csmlFrag)
701        if hasattr(self,'metaDataProperty'):
702            csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty
703        if hasattr(self, 'remarks'):
704            frag=Element(GML('remarks'))
705            frag.text=self.remarks
706            csmlFrag.append(frag)
707        if hasattr(self, 'meridianName'):
708            frag=Element(GML('meridianName'))
709            frag.text=self.meridianName
710            csmlFrag.append(frag)
711        return csmlFrag
712
713
714   
715class PrimeMeridian(PrimeMeridianBase):
716#untested
717    def __init__(self,meridianID=None, greenwichLongitude=None, *args,**kwargs):
718        PrimeMeridianBase.__init__(self,*args,**kwargs)
719        if meridianID:
720            self.meridianID=meridianID
721        if greenwichLongitude:
722            self.greenwichLongitude=greenwichLongitude
723    def fromXML(self,csmlFrag):
724        PrimeMeridianBase.fromXML(self,csmlFrag)
725        if frag.tag==GML('meridianID'):
726            self.meridianID=frag.text
727        if frag.tag==GML('greenwichLongitude'):
728            self.greenwichLongitude=frag.text
729    def toXML(self,csmlFrag):
730        PrimeMeridianBase.toXML(self,csmlFrag)
731        if hasattr(self,'meridianID'):
732            frag=Element(GML('meridianID'))
733            frag.text=self.meridianID
734            csmlFrag.append(frag)
735        if hasattr(self,'greenwichLongitude'):
736            frag=Element(GML('greenwichLongitude'))
737            frag.text=self.greenwichLongitude
738        return csmlFrag
739
740class PrimeMeridianRef(DictionaryEntry):
741#untested
742    def __init__(self,primeMeridian=None,*args,**kwargs):
743        DictionaryEntry.__init__(self,*args,**kwargs)
744        if primeMeridian:
745            self.primeMeridian=primeMeridian
746    def fromXML(self,csmlFrag):
747        DictionaryEntry.fromXML(self,csmlFrag)
748        for frag in csmlFrag.getchildren():
749            if frag.tag==GML('PrimeMeridian'):
750                self.primeMeridian=PrimeMeridian()
751                PrimeMeridian.fromXML(self.primeMeridian,frag)
752    def toXML(self,csmlFrag):
753        DictionaryEntry.toXML(self,csmlFrag)
754        if hasattr(self,'primeMeridian'):
755            frag=Element(GML('PrimeMeridian'))
756            frag=PrimeMeridian.toXML(self.primeMeridian,frag)
757            csmlFrag.append(frag)
758        return csmlFrag
759   
760class GeodeticDatum(AbstractDatum):
761#untested
762        #<element ref="gml:usesPrimeMeridian"/>
763        #<element ref="gml:usesEllipsoid"/>
764    def __init__(self,usesPrimeMeridian=None,usesEllipsoid=None,*args,**kwargs):
765        AbstractDatum.__init__(self,*args,**kwargs)
766        if usesPrimeMeridian:
767            self.usesPrimeMeridian=usesPrimeMeridian
768        if usesEllipsoid:
769            self.usesEllipsoid=usesEllipsoid
770    def fromXML(self,csmlFrag):
771        AbstractDatum.fromXML(self,csmlFrag)
772        for frag in csmlFrag.getchildren():
773            if frag.tag==GML('usesPrimeMeridian'):
774                self.usesPrimeMeridian=PrimeMeridianRef()
775                PrimeMeridianRef.fromXML(self.usesPrimeMeridian,frag)
776        for frag in csmlFrag.getchildren():
777            if frag.tag==GML('usesEllipsoid'):
778                self.usesEllipsoid=EllipsoidRef()
779                EllipsoidRef.fromXML(self.usesEllipsoid,frag)
780    def toXML(self,csmlFrag):
781        AbstractDatum.toXML(self,csmlFrag)
782        if hasattr(self,'usesPrimeMeridian'):
783            frag=Element(GML('usesPrimeMeridian'))
784            frag=PrimeMeridianRef.toXML(self.usesPrimeMeridian,frag)
785            csmlFrag.append(frag)
786        if hasattr(self,'usesEllipsoid'):
787            frag=Element(GML('usesEllipsoid'))
788            frag=EllipsoidRef.toXML(self.usesEllipsoid,frag)
789        return csmlFrag
790   
791   
792class EngineeringDatumRef(DatumRef, AssociationAttributeGroup):
793    def __init__(self,engineeringDatum=None,*args,**kwargs):
794        DatumRef.__init__(self, *args, **kwargs)
795        AssociationAttributeGroup.__init__(self, *args, **kwargs)
796        if engineeringDatum:
797            self.engineeringDatum=engineeringDatum
798    def fromXML(self,csmlFrag):
799        DatumRef.fromXML(self, csmlFrag)
800        AssociationAttributeGroup.fromXML(self, csmlFrag)
801        for frag in csmlFrag.getchildren():
802            if frag.tag==GML('EngineeringDatum'):
803                self.engineeringDatum=EngineeringDatum()
804                EngineeringDatum.fromXML(self.engineeringDatum,frag)
805    def toXML(self,csmlFrag):
806        DatumRef.toXML(self, csmlFrag)
807        AssociationAttributeGroup.toXML(self, csmlFrag)
808        if hasattr(self,'engineeringDatum'):
809            frag=Element(GML('EngineeringDatum'))
810            frag=EngineeringDatum.toXML(self.engineeringDatum,frag)
811            csmlFrag.append(frag)
812        return csmlFrag
813
814class VerticalDatumRef(DatumRef, AssociationAttributeGroup):
815    def __init__(self,verticalDatum=None,*args,**kwargs):
816        DatumRef.__init__(self, *args, **kwargs)
817        AssociationAttributeGroup.__init__(self, *args, **kwargs)
818        if verticalDatum:
819            self.verticalDatum=verticalDatum
820    def fromXML(self,csmlFrag):
821        DatumRef.fromXML(self, csmlFrag)
822        AssociationAttributeGroup.fromXML(self, csmlFrag)
823        for frag in csmlFrag.getchildren():
824            if frag.tag==GML('VerticalDatum'):
825                self.verticalDatum=VerticalDatum()
826                VerticalDatum.fromXML(self.verticalDatum,frag)
827    def toXML(self,csmlFrag):
828        DatumRef.toXML(self, csmlFrag)
829        AssociationAttributeGroup.toXML(self, csmlFrag)
830        if hasattr(self,'verticalDatum'):
831            frag=Element(GML('VerticalDatum'))
832            frag=VerticalDatum.toXML(self.verticalDatum,frag)
833            csmlFrag.append(frag)
834        return csmlFrag
835
836class GeodeticDatumRef(DatumRef,AssociationAttributeGroup):
837    def __init__(self,geodeticDatum=None,*args,**kwargs):
838        DatumRef.__init__(self, *args, **kwargs)
839        AssociationAttributeGroup.__init__(self, *args, **kwargs)
840        if geodeticDatum:
841            self.geodeticDatum=geodeticDatum
842    def fromXML(self,csmlFrag):
843        DatumRef.fromXML(self, csmlFrag)
844        AssociationAttributeGroup.fromXML(self, csmlFrag)
845        for frag in csmlFrag.getchildren():
846            if frag.tag==GML('GeodeticDatum'):
847                self.geodeticDatum=GeodeticDatum()
848                GeodeticDatum.fromXML(self.geodeticDatum,frag)
849    def toXML(self,csmlFrag):
850        DatumRef.toXML(self, csmlFrag)
851        AssociationAttributeGroup.toXML(self, csmlFrag)
852        if hasattr(self,'geodeticDatum'):
853            frag=Element(GML('GeodeticDatum'))
854            frag=GeodeticDatum.toXML(self.geodeticDatum,frag)
855            csmlFrag.append(frag)
856        return csmlFrag
857
858class CoordinateSystemAxisBase(Definition):
859    def __init__(self,*args,**kwargs):
860        Definition.__init__(self, *args, **kwargs)
861    def fromXML(self,csmlFrag):
862        Definition.fromXML(self, csmlFrag)
863    def toXML(self,csmlFrag):
864        Definition.toXML(self, csmlFrag)
865        return csmlFrag
866   
867class CoordinateSystemAxis(CoordinateSystemAxisBase):
868    def __init__(self,uom=None,axisIDs=None,axisAbbrev=None, axisDirection=None, *args,**kwargs):
869        #gml:uom[1]
870        #gml:axisID[0..1]:identifier
871        #gml:axisAbbrev[0..1]:string
872        #gml:axisDirection[0...1]:string
873        CoordinateSystemAxisBase.__init__(self, *args, **kwargs)
874        if uom:
875            self.uom=uom
876        if axisIDs:
877            self.axisIDs=axisIDs
878        if axisAbbrev:
879            self.axisAbbrev=axisAbbrev
880        if axisDirection:
881            self.axisDirection=axisDirection
882
883    def fromXML(self,csmlFrag):
884        CoordinateSystemAxisBase.fromXML(self,csmlFrag)
885        if csmlFrag.attrib.has_key(GML('uom')):
886            self.uom=csmlFrag.attrib[GML('uom')]
887        for frag in csmlFrag.getchildren():
888            if frag.tag==GML('axisID'):
889                checkArrayAttrib(self,'axisIDs')
890                axisID=frag.text
891                self.axisIDs.append(axisID)
892            if frag.tag==GML('axisAbbrev'):
893                self.axisAbbrev=frag.text
894            if frag.tag==GML('axisDirection'):
895                self.axisDirection=frag.text
896    def toXML(self,csmlFrag):
897        CoordinateSystemAxisBase.toXML(self,csmlFrag)
898        if hasattr(self,'uom'):
899            csmlFrag.attrib[GML('uom')]=self.uom
900        if hasattr(self,'axisIDs'):
901            print 'do something'
902        if hasattr(self,'axisAbbrev'):
903            frag=Element(GML('axisAbbrev'))
904            frag.text=self.axisAbbrev
905            csmlFrag.append(frag)
906        if hasattr(self,'axisDirection'):
907            frag=Element(GML('axisDirection'))
908            frag.text=self.axisDirection
909            csmlFrag.append(frag)
910        return csmlFrag
911   
912class CoordinateSystemRef(DictionaryEntry):
913    def __init__(self,*args,**kwargs):
914        DictionaryEntry.__init__(self, *args, **kwargs)
915    def fromXML(self,csmlFrag):
916        DictionaryEntry.fromXML(self, csmlFrag)
917    def toXML(self,csmlFrag):
918        DictionaryEntry.toXML(self, csmlFrag)
919        return csmlFrag
920
921class AbstractCoordinateSystemBase(Definition):
922#         <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
923#                                       <element ref="gml:remarks" minOccurs="0">
924#                                               <annotation>
925#                                                       <documentation>Comments on or information about this coordinate system, including data source information. </documentation>
926#                                               </annotation>
927#                                       </element>
928#                                       <element ref="gml:csName"/>
929    def __init__(self,metaDataProperty=None,remarks=None,csName=None,*args,**kwargs):
930        Definition.__init__(self, *args, **kwargs)
931        if metaDataProperty:
932            self.metaDataProperty=metaDataProperty
933        if remarks:
934            self.remarks=remarks
935        if csName:
936            self.csName=csName
937    def fromXML(self,csmlFrag):
938        Definition.fromXML(self, csmlFrag)
939        for frag in csmlFrag.getchildren():
940            if frag.tag==GML('metaDataProperty'):
941                self.metaDataProperty=MetaDataProperty()
942                MetaDataProperty.fromXML(self.metaDataProperty, frag)
943            if frag.tag==GML('remarks'):
944                self.remarks=frag.text
945            if frag.tag==GML('csName'):
946                self.csName=frag.text
947
948    def toXML(self,csmlFrag):
949        Definition.toXML(self, csmlFrag)
950        return csmlFrag
951   
952class AbstractCoordinateSystem(AbstractCoordinateSystemBase):
953        #class AbstractCoordinateSystem
954        #+gml:csid[0...1]:string
955        #+gml:usesAxis[1...*]
956       
957    def __init__(self,csid=None,usesAxes=None,*args,**kwargs):
958        AbstractCoordinateSystemBase.__init__(self, *args, **kwargs)
959        if csid:
960            self.csid=csid
961        if usesAxes:
962            self.usesAxes=usesAxes
963            #usesAxes should be a list containing multiple gml:usesAxis
964    def fromXML(self,csmlFrag):
965        AbstractCoordinateSystemBase.fromXML(self, csmlFrag)
966        for frag in csmlFrag.getchildren():
967            if frag.tag==GML('csid'):
968                self.csid=frag.text
969            if frag.tag==GML('usesAxis'):
970                checkArrayAttrib(self,'usesAxes')
971                self.usesAxes.append(CoordinateSystemAxis())
972                self.usesAxes[-1].fromXML(frag.getchildren()[0])
973
974    def toXML(self,csmlFrag):
975        AbstractCoordinateSystemBase.toXML(self, csmlFrag)
976        if hasattr(self,'csid'):
977            frag=Element(GML('csid'))
978            frag.tag=self.csid
979            csmlFrag.append(frag)
980        if hasattr(self,'usesAxes'):
981            for axis in self.usesAxes:
982                frag=Element(GML('usesAxis'))
983                subFrag=Element(GML('CoordinateSystemAxis'))
984                subFrag=axis.toXML(subFrag)
985                frag.append(subFrag)
986                csmlFrag.append(frag)
987        return csmlFrag
988
989class LinearCS(AbstractCoordinateSystem):
990    def __init__(self,*args,**kwargs):
991        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
992    def fromXML(self,csmlFrag):
993        AbstractCoordinateSystem.fromXML(self, csmlFrag)
994    def toXML(self,csmlFrag):
995        AbstractCoordinateSystem.toXML(self, csmlFrag)
996        return csmlFrag
997
998
999class EllipsoidalCS(AbstractCoordinateSystem):
1000    def __init__(self,*args,**kwargs):
1001        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1002    def fromXML(self,csmlFrag):
1003        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1004    def toXML(self,csmlFrag):
1005        AbstractCoordinateSystem.toXML(self, csmlFrag)
1006        return csmlFrag
1007
1008class VerticalCS(AbstractCoordinateSystem):
1009    def __init__(self,*args,**kwargs):
1010        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1011    def fromXML(self,csmlFrag):
1012        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1013    def toXML(self,csmlFrag):
1014        AbstractCoordinateSystem.toXML(self, csmlFrag)
1015        return csmlFrag
1016
1017class TemporalCS(AbstractCoordinateSystem):
1018    def __init__(self,*args,**kwargs):
1019        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1020    def fromXML(self,csmlFrag):
1021        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1022    def toXML(self,csmlFrag):
1023        AbstractCoordinateSystem.toXML(self, csmlFrag)
1024        return csmlFrag
1025class EngineeringCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1026        #<element ref="gml:usesCS"/>type="gml:CoordinateSystemRefType">
1027        #<element ref="gml:usesEngineeringDatum"/>
1028    def __init__(self,usesCS=None, usesEngineeringDatum=None,*args,**kwargs):
1029        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1030        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1031        if usesCS:
1032            self.usesCS=usesCS
1033        if usesEngineeringDatum:
1034            self.usesEngineeringDatum=usesEngineeringDatum
1035    def fromXML(self,csmlFrag):
1036        AssociationAttributeGroup.fromXML(self, csmlFrag)
1037        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1038        for frag in csmlFrag.getchildren():
1039            if frag.tag == GML('usesCS'):
1040                subFrag=frag.getchildren()[0]
1041                if subFrag.tag==GML('LinearCS'):
1042                    self.usesCS=LinearCS()
1043                    LinearCS.fromXML(self.usesCS,subFrag)
1044                else:
1045                    print subFrag.tag + ' Coordinate System not supported'
1046            if frag.tag == GML('usesEngineeringDatum'):
1047                self.usesEngineeringDatum=EngineeringDatumRef()
1048                EngineeringDatumRef.fromXML(self.usesEngineeringDatum,frag)
1049    def toXML(self,csmlFrag):
1050        AssociationAttributeGroup.toXML(self, csmlFrag)
1051        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1052        if hasattr(self, 'usesCS'):
1053            frag=Element(GML('usesCS'))
1054            if isinstance(self.usesCS,LinearCS):
1055                subFrag=Element(GML('LinearCS'))
1056                LinearCS.toXML(self.usesCS,subFrag)
1057                frag.append(subFrag)
1058                csmlFrag.append(frag)
1059        if hasattr(self, 'usesEngineeringDatum'):
1060            frag=Element(GML('usesEngineeringDatum'))
1061            EngineeringDatumRef.toXML(self.usesEngineeringDatum, frag)
1062            csmlFrag.append(frag)
1063        return csmlFrag
1064
1065class VerticalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1066        #<element ref="gml:usesVerticalCS"/>type="gml:VerticalCSRefType">
1067        #<element ref="gml:usesVerticalDatum"/>type="gml:VerticalDatumRefType
1068    def __init__(self,usesVerticalCS=None, usesVerticalDatum=None,*args,**kwargs):
1069        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1070        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1071        if usesVerticalCS:
1072            self.usesVerticalCS=usesVerticalCS
1073        if usesVerticalDatum:
1074            self.usesVerticalDatum=usesVerticalDatum
1075    def fromXML(self,csmlFrag):
1076        AssociationAttributeGroup.fromXML(self, csmlFrag)
1077        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1078        for frag in csmlFrag.getchildren():
1079            if frag.tag == GML('usesVerticalCS'):
1080                subFrag=frag.getchildren()[0]
1081                if subFrag.tag==GML('VerticalCS'):
1082                    self.usesVerticalCS=VerticalCS()
1083                    VerticalCS.fromXML(self.usesVerticalCS,subFrag)
1084                else:
1085                    print subFrag.tag + ' Coordinate System not supported'
1086            if frag.tag == GML('usesVerticalDatum'):
1087                self.usesVerticalDatum=VerticalDatumRef()
1088                VerticalDatumRef.fromXML(self.usesVerticalDatum,frag)
1089    def toXML(self,csmlFrag):
1090        AssociationAttributeGroup.toXML(self, csmlFrag)
1091        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1092        if hasattr(self, 'usesVerticalCS'):
1093            frag=Element(GML('usesVerticalCS'))
1094            if isinstance(self.usesVerticalCS,VerticalCS):
1095                subFrag=Element(GML('VerticalCS'))
1096                VerticalCS.toXML(self.usesVerticalCS,subFrag)
1097                frag.append(subFrag)
1098                csmlFrag.append(frag)
1099        if hasattr(self, 'usesVerticalDatum'):
1100            frag=Element(GML('usesVerticalDatum'))
1101            VerticalDatumRef.toXML(self.usesVerticalDatum, frag)
1102            csmlFrag.append(frag)
1103        return csmlFrag
1104
1105class TemporalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1106        #<element ref="gml:usesTemporalCS"/>type="gml:TemporalCSRefType">
1107        #<element ref="gml:usesTemporalDatum"/>type="gml:TemporalDatumRefType
1108    def __init__(self,usesTemporalCS=None, usesTemporalDatum=None,*args,**kwargs):
1109        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1110        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1111        if usesTemporalCS:
1112            self.usesTemporalCS=usesTemporalCS
1113        if usesTemporalDatum:
1114            self.usesTemporalDatum=usesTemporalDatum
1115    def fromXML(self,csmlFrag):
1116        AssociationAttributeGroup.fromXML(self, csmlFrag)
1117        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1118        for frag in csmlFrag.getchildren():
1119            if frag.tag == GML('usesTemporalCS'):
1120                subFrag=frag.getchildren()[0]
1121                if subFrag.tag==GML('TemporalCS'):
1122                    self.usesTemporalCS=TemporalCS()
1123                    TemporalCS.fromXML(self.usesTemporalCS,subFrag)
1124                else:
1125                    print subFrag.tag + ' Coordinate System not supported'
1126            if frag.tag == GML('usesTemporalDatum'):
1127                self.usesTemporalDatum=TemporalDatumRef()
1128                TemporalDatumRef.fromXML(self.usesTemporalDatum,frag)
1129    def toXML(self,csmlFrag):
1130        AssociationAttributeGroup.toXML(self, csmlFrag)
1131        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1132        if hasattr(self, 'usesTemporalCS'):
1133            frag=Element(GML('usesTemporalCS'))
1134            if isinstance(self.usesTemporalCS,TemporalCS):
1135                subFrag=Element(GML('TemporalCS'))
1136                TemporalCS.toXML(self.usesTemporalCS,subFrag)
1137                frag.append(subFrag)
1138                csmlFrag.append(frag)
1139        if hasattr(self, 'usesTemporalDatum'):
1140            frag=Element(GML('usesTemporalDatum'))
1141            TemporalDatumRef.toXML(self.usesTemporalDatum, frag)
1142            csmlFrag.append(frag)
1143        return csmlFrag
1144class GeographicCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1145            #<element ref="gml:usesEllipsoidalCS"/>
1146    #<element ref="gml:usesGeodeticDatum"/>
1147    def __init__(self,usesEllipsoidalCS=None, usesGeodeticDatum=None,*args,**kwargs):
1148        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1149        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1150        if usesEllipsoidalCS:
1151            self.usesEllipsoidalCS=usesEllipsoidalCS
1152        if usesGeodeticDatum:
1153            self.usesGeodeticDatum=usesGeodeticDatum
1154    def fromXML(self,csmlFrag):
1155        AssociationAttributeGroup.fromXML(self, csmlFrag)
1156        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1157        for frag in csmlFrag.getchildren():
1158            if frag.tag == GML('usesEllipsoidalCS'):
1159                subFrag=frag.getchildren()[0]
1160                if subFrag.tag==GML('EllipsoidalCS'):
1161                    self.usesEllipsoidalCS=EllipsoidalCS()
1162                    EllipsoidalCS.fromXML(self.usesEllipsoidalCS,subFrag)
1163                else:
1164                    print subFrag.tag + ' Coordinate System not supported'
1165            if frag.tag == GML('usesGeodeticDatum'):
1166                self.usesGeodeticDatum=GeodeticDatumRef()
1167                GeodeticDatumRef.fromXML(self.usesEngineeringDatum,frag)
1168    def toXML(self,csmlFrag):
1169        AssociationAttributeGroup.toXML(self, csmlFrag)
1170        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1171        if hasattr(self, 'usesEllipsoidalCS'):
1172            frag=Element(GML('usesEllipsoidalCS'))
1173            if isinstance(self.usesCS,LinearCS):
1174                subFrag=Element(GML('usesEllipsoidalCS'))
1175                EllipsoidalCS.toXML(self.usesEllipsoidalCS,subFrag)
1176                frag.append(subFrag)
1177                csmlFrag.append(frag)
1178        if hasattr(self, 'usesEngineeringDatum'):
1179            frag=Element(GML('usesGeodeticDatum'))
1180            GeodeticDatumRef.toXML(self.usesGeodeticDatum, frag)
1181            csmlFrag.append(frag)
1182        return csmlFrag
1183
1184class CompoundCRS(AbstractCRS,AssociationAttributeGroup):
1185    #untested
1186    def __init__(self, includes=None, *args,**kwargs):
1187        AbstractCRS.__init__(self, *args, **kwargs)
1188        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1189        if includes:
1190            self.includes=includes
1191    def fromXML(self,csmlFrag):
1192        AssociationAttributeGroup.fromXML(self, csmlFrag)
1193        AbstractCRS.fromXML(self, csmlFrag)
1194        for frag in csmlFrag.getchildren():
1195            if frag.tag == GML('includesCRS'):
1196                checkArrayAttrib(self,'includes')
1197                if frag.getchildren()[1].tag==GML('EngineeringCRS'):
1198                    self.includes.append(EngineeringCRS())
1199                if frag.getchildren()[1].tag==GML('VerticalCRS'):
1200                    self.includes.append(VerticalCRS())
1201                if frag.getchildren()[1].tag==GML('GeographicCRS'):
1202                    self.includes.append(GeographicCRS())
1203                #if frag.getchildren()[1].tag==GML('TemporalCRS'):
1204                    #self.includes.append(TemporalCRS())
1205                self.includes[-1].fromXML(frag.getchildren()[0])
1206               
1207    def toXML(self,csmlFrag):
1208        AssociationAttributeGroup.toXML(self, csmlFrag)
1209        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1210        if hasattr(self,'includes'):
1211            for crs in self.includes:
1212                frag=Element(GML('includesCRS'))
1213                if isinstance(crs,EngineeringCRS):
1214                    subFrag=Element(GML('EngineeringCRS'))
1215                    subFrag=crs.toXML(subFrag)
1216                    frag.append(subFrag)
1217                    csmlFrag.append(frag)
1218                if isinstance(crs,VerticalCRS):
1219                    subFrag=Element(GML('VerticalCRS'))
1220                    subFrag=crs.toXML(subFrag)
1221                    frag.append(subFrag)
1222                    csmlFrag.append(frag)
1223                if isinstance(crs,GeographicCRS):
1224                    subFrag=Element(GML('GeographicCRS'))
1225                    subFrag=crs.toXML(subFrag)
1226                    frag.append(subFrag)
1227                    csmlFrag.append(frag)
1228#                 if isinstance(crs,TemporalCRS):
1229#                     subFrag=Element(GML('TemporalCRS'))
1230#                     subFrag=crs.toXML(subFrag)
1231#                     frag.append(subFrag)
1232#                     csmlFrag.append(frag)
1233        return csmlFrag
1234
1235class UnitDefinition(Definition):
1236        #Class gml:UnitDefinition
1237        # +quantityType
1238        # +catalogSymbol, codeSpace
1239    def __init__(self,quantityType=None,catalogSymbol=None,*args,**kwargs):
1240        Definition.__init__(self,*args,**kwargs)
1241        if quantityType:
1242            self.quantityType=quantityType
1243        if catalogSymbol:
1244            self.catalogSymbol=catalogSymbol
1245    def fromXML(self,csmlFrag):
1246        Definition.fromXML(self,csmlFrag)
1247        for frag in csmlFrag.getchildren():
1248            if frag.tag == GML('quantityType'):
1249                self.quantityType=frag.text
1250            elif frag.tag == GML('catalogSymbol'):
1251                self.catalogSymbol=CodeType()
1252                CodeType.fromXML(self.catalogSymbol, frag)
1253    def toXML(self,csmlFrag):
1254        Definition.toXML(self,csmlFrag)
1255        if hasattr(self, 'quantityType'):
1256            frag=Element(GML('quantityType'))
1257            frag.text=self.quantityType
1258            csmlFrag.append(frag)
1259        if hasattr(self, 'catalogSymbol'):
1260            frag=Element(GML('catalogSymbol'))
1261            CodeType.toXML(self.catalogSymbol,frag)
1262            csmlFrag.append(frag)
1263        return csmlFrag
1264   
1265class Dictionary(Definition):
1266    #Class for gml:Dictionary elements
1267    # + gml:definitionMembers [1....*]
1268    def __init__(self, definitionMembers=None,*args,**kwargs):
1269        Definition.__init__(self,*args,**kwargs)
1270        if definitionMembers:
1271            self.definitionMembers = definitionMembers
1272    def fromXML(self,csmlFrag):
1273        Definition.fromXML(self,csmlFrag)
1274        for frag in csmlFrag.getchildren():
1275            if frag.tag == GML('definitionMember'):
1276                checkArrayAttrib(self, 'definitionMembers')
1277                subFrag = frag.getchildren()[0]
1278                if subFrag.tag == GML('UnitDefinition'):
1279                    definitionMember=UnitDefinition()
1280                    definitionMember.fromXML(subFrag)
1281                    self.definitionMembers.append(definitionMember)
1282                elif subFrag.tag == CSML('TimeCoordinateSystem'):
1283                    definitionMember=TimeCoordinateSystem()
1284                    definitionMember.fromXML(subFrag)
1285                    self.definitionMembers.append(definitionMember)
1286                elif subFrag.tag == GML('EngineeringCRS'):
1287                    definitionMember=EngineeringCRS()
1288                    definitionMember.fromXML(subFrag)
1289                    self.definitionMembers.append(definitionMember)
1290                elif subFrag.tag == GML('GeographicCRS'):
1291                    definitionMember=GeographicCRS()
1292                    definitionMember.fromXML(subFrag)
1293                    self.definitionMembers.append(definitionMember)
1294                elif subFrag.tag == GML('VerticalCRS'):
1295                    definitionMember=VerticalCRS()
1296                    definitionMember.fromXML(subFrag)
1297                    self.definitionMembers.append(definitionMember)
1298                elif subFrag.tag == GML('TemporalCRS'):
1299                    definitionMember=TemporalCRS()
1300                    definitionMember.fromXML(subFrag)
1301                    self.definitionMembers.append(definitionMember)
1302                elif subFrag.tag == GML('CompoundCRS'):
1303                    definitionMember=CompoundCRS()
1304                    definitionMember.fromXML(subFrag)
1305                    self.definitionMembers.append(definitionMember)
1306                elif subFrag.tag == OM('Phenomenon'):
1307                    definitionMember=Phenomenon()
1308                    definitionMember.fromXML(subFrag)
1309                    self.definitionMembers.append(definitionMember)
1310    def toXML(self,csmlFrag):
1311        Definition.toXML(self,csmlFrag)
1312        if hasattr(self, 'definitionMembers'):
1313            for definitionMember in self.definitionMembers:
1314                if isinstance(definitionMember,UnitDefinition):
1315                    superFrag=Element(GML('definitionMember'))
1316                    frag=Element(GML('UnitDefinition'))
1317                    UnitDefinition.toXML(definitionMember,frag)
1318                    superFrag.append(frag)
1319                    csmlFrag.append(superFrag)
1320                if isinstance(definitionMember,TimeCoordinateSystem):
1321                    superFrag=Element(GML('definitionMember'))
1322                    frag=Element(CSML('TimeCoordinateSystem'))
1323                    TimeCoordinateSystem.toXML(definitionMember,frag)
1324                    superFrag.append(frag)
1325                    csmlFrag.append(superFrag)
1326                if isinstance(definitionMember,EngineeringCRS):
1327                    superFrag=Element(GML('definitionMember'))
1328                    frag=Element(GML('EngineeringCRS'))
1329                    EngineeringCRS.toXML(definitionMember,frag)
1330                    superFrag.append(frag)
1331                    csmlFrag.append(superFrag)
1332                if isinstance(definitionMember,Phenomenon):
1333                    superFrag=Element(GML('definitionMember'))
1334                    frag=Element(OM('Phenomenon'))
1335                    Phenomenon.toXML(definitionMember,frag)
1336                    superFrag.append(frag)
1337                    csmlFrag.append(superFrag)
1338        return csmlFrag
1339
1340
1341class UnitDefinitions(Dictionary):
1342        #Class for csml:UnitDefinitions(gml:Dictionary)
1343    def __init__(self,*args,**kwargs):
1344        Dictionary.__init__(self,*args,**kwargs)
1345    def fromXML(self,csmlFrag):
1346        Dictionary.fromXML(self,csmlFrag)
1347    def toXML(self,csmlFrag):
1348        Dictionary.toXML(self,csmlFrag)
1349        return csmlFrag
1350
1351class ReferenceSystemDefinitions(Dictionary):
1352    def __init__(self,*args,**kwargs):
1353        Dictionary.__init__(self,*args,**kwargs)
1354    def fromXML(self,csmlFrag):
1355        Dictionary.fromXML(self,csmlFrag)
1356    def toXML(self,csmlFrag):
1357        Dictionary.toXML(self,csmlFrag)
1358        return csmlFrag
1359
1360class PhenomenonDefinitions(Dictionary):
1361    def __init__(self,*args,**kwargs):
1362        Dictionary.__init__(self,*args,**kwargs)
1363    def fromXML(self,csmlFrag):
1364        Dictionary.fromXML(self,csmlFrag)
1365    def toXML(self,csmlFrag):
1366        Dictionary.toXML(self,csmlFrag)
1367        return csmlFrag
1368
1369class AbstractArrayDescriptor(AbstractGML):
1370    """Base abstract class for CSML array descriptors
1371
1372    AbstractArrayDescriptor(AbstractGML):
1373     +arraySize[1..*]: int
1374     +uom[0..1]: anyURI  #Amended to also take a 'UnitDefinition' - needed to resolve internal references
1375     +numericType[0..1]: string
1376     +regExpTransform[0..1]: string
1377     +numericTransform[0..1]: string
1378    """
1379    def __init__(self,arraySize=None,uom=None,numericType=None,
1380                 regExpTransform=None,numericTransform=None,*args,**kwargs):
1381        AbstractGML.__init__(self,*args,**kwargs)
1382        if arraySize:
1383            self.arraySize = arraySize
1384        if uom:
1385            self.uom = uom
1386        if numericType:
1387            self.numericType = numericType
1388        if regExpTransform:
1389            self.regExpTransform = regExpTransform
1390        if numericTransform:
1391            self.numericTransform = numericTransform
1392    def fromXML(self,csmlFrag):
1393        AbstractGML.fromXML(self,csmlFrag)
1394        for frag in csmlFrag.getchildren():
1395            if frag.tag == CSML('arraySize'):
1396                self.arraySize = map(int,frag.text.split())
1397                #self.arraySize = frag.text
1398            elif frag.tag == CSML('uom'):
1399                if frag.getchildren() !=[]:
1400                    subFrag= frag.getchildren()[0]
1401                    if subFrag.tag == GML ('UnitDefinition'):
1402                        self.uom=UnitDefinition()
1403                        UnitDefinition.fromXML(self.uom, subFrag)
1404                else:
1405                    self.uom=frag.text
1406            elif frag.tag == CSML('numericType'):
1407                self.numericType = frag.text
1408            elif frag.tag == CSML('regExpTransform'):
1409                self.regExpTransform = frag.text
1410            elif frag.tag == CSML('numericTransform'):
1411                self.numericTransform = frag.text
1412    def toXML(self,csmlFrag):
1413        csmlFrag = AbstractGML.toXML(self,csmlFrag)
1414        if hasattr(self,'arraySize'):
1415            frag = Element(CSML('arraySize'))
1416            frag.text = ' '.join(map(str,self.arraySize))
1417            #frag.text = self.arraySize
1418            csmlFrag.append(frag)
1419        if hasattr(self,'uom'):
1420            frag = Element(CSML('uom'))
1421            if isinstance(self.uom,UnitDefinition):
1422                subFrag=Element(GML('UnitDefinition'))
1423                UnitDefinition.toXML(self.uom,subFrag)
1424                frag.append(subFrag)
1425            else:
1426                frag.text = self.uom
1427            csmlFrag.append(frag)
1428        if hasattr(self,'numericType'):
1429            frag = Element(CSML('numericType'))
1430            frag.text  = self.numericType
1431            csmlFrag.append(frag)
1432        if hasattr(self,'regExpTransform'):
1433            frag = Element(CSML('regExpTransform'))
1434            frag.text = self.regExpTransform
1435            csmlFrag.append(frag)
1436        if hasattr(self,'numericTransform'):
1437            frag = Element(CSML('numericTransform'))
1438            frag.text = self.numericTransform
1439            csmlFrag.append(frag)
1440        return csmlFrag
1441
1442class AggregatedArray(AbstractArrayDescriptor):
1443    """CSML class for aggregated array
1444
1445    AggregatedArray(AbstractArrayDescriptor):
1446     +aggType: string
1447     +aggIndex: int
1448     +component[1..*]: AbstractArrayDescriptor
1449    """
1450    def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs):
1451        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1452        if aggType:
1453            self.aggType = aggType
1454        if aggIndex:
1455            self.aggIndex = aggIndex
1456        if component:
1457            self.component = component
1458    def fromXML(self,csmlFrag):
1459        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1460        for frag in csmlFrag.getchildren():
1461            if frag.tag == CSML('aggType'):
1462                self.aggType = frag.text
1463            elif frag.tag == CSML('aggIndex'):
1464                self.aggIndex = int(frag.text)
1465            elif frag.tag == CSML('component'):
1466                checkArrayAttrib(self,'component')
1467                componentFrag = frag[0]
1468                if componentFrag.tag == CSML('AggregatedArray'):
1469                    self.component.append(AggregatedArray())
1470                elif componentFrag.tag == CSML('InlineArray'):
1471                    self.component.append(InlineArray())
1472                elif componentFrag.tag == CSML('ArrayGenerator'):
1473                    self.component.append(ArrayGenerator())
1474                elif componentFrag.tag == CSML('NASAAmesExtract'):
1475                    self.component.append(NASAAmesExtract())
1476                elif componentFrag.tag == CSML('NetCDFExtract'):
1477                    self.component.append(NetCDFExtract())
1478                elif componentFrag.tag == CSML('GRIBExtract'):
1479                    self.component.append(GRIBExtract())
1480##                else:
1481##                    raise Exception('Unexpected element: "'+componentFrag.tag+'"')
1482                self.component[-1].fromXML(componentFrag)
1483    def toXML(self,csmlFrag):
1484        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1485        if hasattr(self,'aggType'):
1486            frag = Element(CSML('aggType'))
1487            frag.text = self.aggType
1488            csmlFrag.append(frag)
1489        if hasattr(self,'aggIndex'):
1490            frag = Element(CSML('aggIndex'))
1491            frag.text = str(self.aggIndex)
1492            csmlFrag.append(frag)
1493        if hasattr(self,'component'):
1494            compFrag = Element(CSML('component'))
1495            for comp in self.component:
1496                if isinstance(comp,AggregatedArray):
1497                    frag = Element(CSML('AggregatedArray'))
1498                    frag = AggregatedArray.toXML(comp,frag)
1499                elif isinstance(comp,InlineArray):
1500                    frag = Element(CSML('InlineArray'))
1501                    frag = InlineArray.toXML(comp,frag)
1502                elif isinstance(comp,ArrayGenerator):
1503                    frag = Element(CSML('ArrayGenerator'))
1504                    frag = ArrayGenerator.toXML(comp,frag)
1505                elif isinstance(comp,NASAAmesExtract):
1506                    frag = Element(CSML('NASAAmesExtract'))
1507                    frag = NASAAmesExtract.toXML(comp,frag)
1508                elif isinstance(comp,NetCDFExtract):
1509                    frag = Element(CSML('NetCDFExtract'))
1510                    frag = NetCDFExtract.toXML(comp,frag)
1511                elif isinstance(comp,GRIBExtract):
1512                    frag = Element(CSML('GRIBExtract'))
1513                    frag = NASAAmesExtract.toXML(comp,frag)
1514                compFrag.append(frag)
1515            csmlFrag.append(compFrag)
1516        return csmlFrag
1517
1518class InlineArray(AbstractArrayDescriptor):
1519    pass
1520
1521class ArrayGenerator(AbstractArrayDescriptor):
1522    pass
1523
1524class AbstractFileExtract(AbstractArrayDescriptor):
1525    """Base abstract clas for CSML file array extract
1526
1527    AbstractFileExtract(AbstractArrayDescriptor):
1528     +fileName: string
1529    """
1530    def __init__(self,fileName=None,*args,**kwargs):
1531        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1532        if fileName:
1533            self.fileName = fileName
1534    def fromXML(self,csmlFrag):
1535        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1536        for frag in csmlFrag.getchildren():
1537            if frag.tag == CSML('fileName'):
1538                self.fileName = frag.text
1539##        else:
1540##            raise Exception('Unexpected element: "'+frag.tag+'"')
1541    def toXML(self,csmlFrag):
1542        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1543        if hasattr(self,'fileName'):
1544            frag = Element(CSML('fileName'))
1545            frag.text = self.fileName
1546            csmlFrag.append(frag)
1547        return csmlFrag
1548
1549class NASAAmesExtract(AbstractFileExtract):
1550    """CSML class for NASA Ames file extract
1551
1552    NASAAmesExtract(AbstractFileExtract):
1553     +variableName: string
1554     +index[0..1]: int
1555    """
1556    def __init__(self,variableName=None,index=None,*args,**kwargs):
1557        AbstractFileExtract.__init__(self,*args,**kwargs)
1558        if variableName:
1559            self.variableName = variableName
1560        if index:
1561            self.index = index
1562    def fromXML(self,csmlFrag):
1563        AbstractFileExtract.fromXML(self,csmlFrag)
1564        for frag in csmlFrag.getchildren():
1565            if frag.tag == CSML('variableName'):
1566                self.variableName = frag.text
1567            elif frag.tag == CSML('index'):
1568                self.index = int(frag.text)
1569##            else:
1570##                raise Exception('Unexpected element: "'+frag.tag+'"')
1571    def toXML(self,csmlFrag):
1572        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1573        frag = Element(CSML('variableName'))
1574        frag.text = self.variableName
1575        csmlFrag.append(frag)
1576        if hasattr(self,'index'):
1577            frag = Element(CSML('index'))
1578            frag.text = str(self.index)
1579            csmlFrag.append(frag)
1580        return csmlFrag
1581
1582class NetCDFExtract(AbstractFileExtract):
1583    """CSML class for netCDF file extract
1584
1585    NetCDFExtract(AbstractFileExtract):
1586     +variableName: string
1587    """
1588    def __init__(self,variableName=None,*args,**kwargs):
1589        AbstractFileExtract.__init__(self,*args,**kwargs)
1590        if variableName:
1591            self.variableName = variableName
1592    def fromXML(self,csmlFrag):
1593        AbstractFileExtract.fromXML(self,csmlFrag)
1594        for frag in csmlFrag.getchildren():
1595            if frag.tag == CSML('variableName'):
1596                self.variableName = frag.text
1597##        else:
1598##            raise Exception('Unexpected element: "'+frag.tag+'"')
1599    def toXML(self,csmlFrag):
1600        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1601        if hasattr(self, 'variableName'):
1602            frag = Element(CSML('variableName'))
1603            frag.text = self.variableName
1604            csmlFrag.append(frag)
1605        return csmlFrag
1606
1607class GRIBExtract(AbstractFileExtract):
1608    """CSML class for GRIB file extract
1609
1610    GRIBExtract(AbstractFileExtract):
1611     +parameterCode: int
1612     +recordNumber[0..1]: int
1613     +fileOffset[0..1]: int
1614    """
1615    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, *args,**kwargs):
1616        AbstractFileExtract.__init__(self,*args,**kwargs)
1617        if parameterCode:
1618            self.parameterCode = parameterCode
1619        if recordNumber:
1620            self.recordNumber = recordNumber
1621        if fileOffset:
1622            self.fileOffset = fileOffset
1623    def fromXML(self,csmlFrag):
1624        AbstractFileExtract.fromXML(self,csmlFrag)
1625        for frag in csmlFrag.getchildren():
1626            if frag.tag == CSML('parameterCode'):
1627                self.parameterCode = int(frag.text)
1628            elif frag.tag == CSML('recordNumber'):
1629                self.recordNumber = int(frag.text)
1630            elif frag.tag == CSML('fileOffset'):
1631                self.fileOffset = int(frag.text)
1632##            else:
1633##                raise Exception('Unexpected element: "'+frag.tag+'"')
1634    def toXML(self,csmlFrag):
1635        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1636        frag = Element(CSML('parameterCode'))
1637        frag.text = str(self.parameterCode)
1638        csmlFrag.append(frag)
1639        if hasattr(self,'recordNumber'):
1640            frag = Element(CSML('recordNumber'))
1641            frag.text = str(self.recordNumber)
1642            csmlFrag.append(frag)
1643        if hasattr(self,'fileOffset'):
1644            frag = Element(CSML('fileOffset'))
1645            frag.text = str(self.fileOffset)
1646            csmlFrag.append(frag)
1647        return csmlFrag
1648
1649class DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup):
1650    #class representing a DirectPositionList
1651    def __init__(self, order=None, vals=None,*args,**kwargs):
1652        if order:
1653            self.order=order
1654        if vals:
1655            self.vals=vals
1656        AssociationAttributeGroup.__init__(self,*args,**kwargs)
1657        SRSReferenceGroup.__init__(self,*args,**kwargs)
1658    def fromXML(self,csmlFrag):
1659        AssociationAttributeGroup.fromXML(self,csmlFrag)
1660        SRSReferenceGroup.fromXML(self,csmlFrag)
1661        self.vals=csmlFrag.text
1662        if csmlFrag.attrib.has_key('order'):
1663            self.order=csmlFrag.attrib['order']
1664    def toXML(self,csmlFrag): 
1665        AssociationAttributeGroup.toXML(self,csmlFrag)
1666        SRSReferenceGroup.toXML(self,csmlFrag)
1667        csmlFrag.text=self.vals
1668        if hasattr(self,'order'):
1669            csmlFrag.attrib['order']=self.order
1670        return csmlFrag
1671       
1672class MappingRule(MutableString):
1673    """Class representing a GML MappingRule element(string):
1674    """
1675    def __init__(self,val=''):
1676        MutableString.__init__(self,val)
1677    def fromXML(self,csmlFrag):
1678        self.data = csmlFrag.text
1679        if csmlFrag.attrib.has_key('scanOrder'):
1680            self.scanOrder=csmlFrag.attrib['scanOrder']
1681    def toXML(self,csmlFrag):
1682        csmlFrag.text = self.data
1683        if hasattr(self,'scanOrder'):
1684            csmlFrag.attrib['scanOrder']=self.scanOrder
1685        return csmlFrag
1686
1687   
1688   
1689   
1690   
1691class AbstractDiscreteCoverage(AbstractGML):
1692     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
1693    #GML AbstractDiscreteCoverage Class
1694    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs):
1695        AbstractGML.__init__(self,*args,**kwargs)
1696        if rangeSet:
1697            self.rangeSet=rangeSet
1698        if coverageFunction:
1699            self.coverageFunction=coverageFunction
1700
1701    def fromXML(self,csmlFrag):
1702        AbstractGML.fromXML(self,csmlFrag)
1703        for frag in csmlFrag.getchildren():
1704            if frag.tag == GML('rangeSet'):
1705                self.rangeSet=RangeSet()
1706                self.rangeSet.fromXML(frag)
1707            if frag.tag == GML('coverageFunction'):
1708                self.coverageFunction=MappingRule()
1709                for subFrag in frag.getchildren():
1710                    if subFrag.tag==CSML('MappingRule'):
1711                        self.coverageFunction.fromXML(subFrag)
1712
1713
1714    def toXML(self,csmlFrag):
1715        AbstractGML.toXML(self,csmlFrag)
1716        if hasattr(self,'rangeSet'):
1717            frag = Element(GML('rangeSet'))
1718            RangeSet.toXML(self.rangeSet,frag)
1719            csmlFrag.append(frag)
1720        if hasattr(self,'coverageFunction'):
1721            frag = Element(GML('coverageFunction'))
1722            subFrag=Element(CSML('MappingRule'))
1723            MappingRule.toXML(self.coverageFunction,subFrag)
1724            frag.append(subFrag)
1725            csmlFrag.append(frag)
1726        return csmlFrag
1727       
1728class AbstractCoverageFeature(AbstractDiscreteCoverage):
1729    #CSML Abstract Coverage FT class
1730    #     AbstractCoverageFeature(AbstractDiscreteCoverage)
1731    #       + om:parameter:PhenomenonPropertyType
1732   
1733    def __init__(self, parameter=None, *args,**kwargs):
1734        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
1735        if parameter:
1736            self.parameter=parameter
1737    def fromXML(self,csmlFrag):
1738        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
1739        for frag in csmlFrag.getchildren():
1740            if frag.tag == CSML('parameter'):
1741                self.parameter=None
1742                if frag.getchildren() == []:
1743                    self.parameter=Phenomenon()
1744                    self.parameter.fromXML(frag)
1745                else:
1746                    subFrag=frag.getchildren()[0]
1747                    if subFrag.tag == OM('Phenomenon'):
1748                        self.parameter = Phenomenon()
1749                    elif subFrag.tag == OM('CompositePhenomenon'):
1750                        self.parameter = CompositePhenomenon()
1751                    elif subFrag.tag == OM('ParameterisedPhenomenon'):
1752                        self.parameter = ParameterisedPhenomenon()
1753                    self.parameter.fromXML(subFrag)
1754                       
1755    def toXML(self,csmlFrag):
1756        AbstractDiscreteCoverage.toXML(self,csmlFrag)
1757        if hasattr(self,'parameter'):
1758            frag = Element(CSML('parameter'))
1759            if isinstance(self.parameter,ParameterisedPhenomenon):
1760                subFrag=Element(OM('ParameterisedPhenomenon'))
1761                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
1762                frag.append(subFrag)
1763                csmlFrag.append(frag)
1764            elif isinstance(self.parameter,CompositePhenomenon):
1765                subFrag=Element(OM('CompositePhenomenon'))
1766                CompositePhenomenon.toXML(self.parameter,subFrag)
1767                frag.append(subFrag)
1768                csmlFrag.append(frag)
1769            elif isinstance(self.parameter,Phenomenon):
1770                Phenomenon.toXML(self.parameter,frag)
1771                subFrag=Element(OM('Phenomenon'))
1772                Phenomenon.toXML(self.parameter,subFrag)
1773                if subFrag.attrib != frag.attrib:
1774                    frag.append(subFrag)
1775                csmlFrag.append(frag)
1776               
1777               
1778                #frag.attrib[XLINK('href')] = self.href
1779
1780        return csmlFrag
1781
1782   
1783class AbstractStaticCoverageFeature(AbstractCoverageFeature):
1784    #CSML Abstract Static Coverage FT class
1785    def __init__(self,*args,**kwargs):
1786        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1787    def fromXML(self,csmlFrag):
1788        AbstractCoverageFeature.fromXML(self,csmlFrag)
1789    def toXML(self,csmlFrag):
1790        AbstractCoverageFeature.toXML(self,csmlFrag)
1791        return csmlFrag
1792   
1793class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
1794    #CSML Abstract Series Coverage FT class
1795    def __init__(self,*args,**kwargs):
1796        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1797    def fromXML(self,csmlFrag):
1798        AbstractCoverageFeature.fromXML(self,csmlFrag)
1799    def toXML(self,csmlFrag):
1800        AbstractCoverageFeature.toXML(self,csmlFrag)
1801        return csmlFrag
1802   
1803class AbstractDomain:
1804    #CSML AbstractDomain class
1805    #   AbstractDomain()
1806    #   +csml:domainReference
1807    #   +csml:domainComplement [0...1]
1808       
1809    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
1810        if domainReference:
1811            self.domainReference=domainReference
1812        if domainComplement:
1813            self.domainComplement=domainComplement
1814    def fromXML(self,csmlFrag):
1815        for frag in csmlFrag.getchildren():
1816            if frag.tag == CSML('domainReference'):
1817                subfrag=frag.getchildren()[0]
1818                if subfrag.tag==CSML('Position'):
1819                    self.domainReference=Position()
1820                elif subfrag.tag == CSML('Trajectory'):
1821                    self.domainReference=Trajectory()
1822                elif subfrag.tag==CSML('OrientedPosition'):
1823                    self.domainReference=OrientedPosition()
1824                elif subfrag.tag == CSML('OrientedTrajectory'):
1825                    self.domainReference=OrientedTrajectory()
1826                elif subfrag.tag == GML('TimeInstant'):
1827                    self.domainReference=TimeInstant()
1828                elif subfrag.tag == GML('TimePositionList'):
1829                    self.domainReference=TimePositionList()
1830                self.domainReference.fromXML(subfrag)
1831               
1832            if frag.tag == CSML('domainComplement'):
1833                subfrag=frag.getchildren()[0]
1834                if subfrag.tag==CSML('DirectPositionList'):
1835                    self.domainComplement=DirectPositionList()
1836                    self.domainComplement.fromXML(subfrag)
1837                elif subfrag.tag==CSML('Grid'):
1838                    self.domainComplement=Grid()
1839                    self.domainComplement.fromXML(subfrag)
1840    def toXML(self,csmlFrag):
1841        if hasattr(self,'domainReference'):
1842            frag = Element(CSML('domainReference'))
1843            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
1844            #self.domainReference.toXML(frag)
1845            if isinstance(self.domainReference,OrientedPosition):
1846                subFrag=Element(CSML('OrientedPosition'))
1847                self.domainReference.toXML(subFrag)
1848                frag.append(subFrag)
1849                csmlFrag.append(frag)
1850            elif isinstance(self.domainReference,OrientedTrajectory):
1851                subFrag=Element(CSML('OrientedTrajectory'))
1852                self.domainReference.toXML(subFrag)
1853                frag.append(subFrag)
1854                csmlFrag.append(frag)       
1855            elif isinstance(self.domainReference,Position):
1856                subFrag=Element(CSML('Position'))
1857                self.domainReference.toXML(subFrag)
1858                frag.append(subFrag)
1859                csmlFrag.append(frag)
1860            elif isinstance(self.domainReference,Trajectory):
1861                subFrag=Element(CSML('Trajectory'))
1862                self.domainReference.toXML(subFrag)
1863                frag.append(subFrag)
1864                csmlFrag.append(frag)
1865            elif isinstance(self.domainReference,TimeInstant):
1866                subFrag=Element(GML('TimeInstant'))
1867                self.domainReference.toXML(subFrag)
1868                frag.append(subFrag)
1869                csmlFrag.append(frag)
1870            elif isinstance(self.domainReference,TimePositionList):
1871                subFrag=Element(GML('TimePositionList'))
1872                self.domainReference.toXML(subFrag)
1873                frag.append(subFrag)
1874                csmlFrag.append(frag)   
1875        if hasattr(self,'domainComplement'):
1876            frag = Element(CSML('domainComplement'))
1877            if isinstance(self.domainComplement,DirectPositionList):
1878                    subFrag=Element(CSML('DirectPositionList'))
1879                    self.domainComplement.toXML(subFrag)
1880                    frag.append(subFrag)
1881                    csmlFrag.append(frag)
1882            elif isinstance(self.domainComplement,Grid):
1883                    subFrag=Element(CSML('Grid'))
1884                    self.domainComplement.toXML(subFrag)
1885                    frag.append(subFrag)
1886                    csmlFrag.append(frag)
1887        return csmlFrag
1888
1889
1890class EnvelopeWithTimePeriod:
1891    # CSML EnvelopeWithTimePeriod class
1892    # EnvelopeWithTimePeriod():
1893        # +gml:lowerCorner
1894        # +gml:upperCorner
1895        # +gml:timePosition [2] ?
1896       
1897    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
1898        if srsName:
1899            self.srsName=srsName
1900        if lowerCorner:
1901            self.lowerCorner=lowerCorner
1902        if upperCorner:
1903            self.upperCorner=upperCorner
1904        if timePosition:
1905            self.timePosition=timePosition
1906        if timePosition2:
1907            self.timePosition2=timePosition2
1908    def fromXML(self,csmlFrag):
1909        EnvTPfrag=csmlFrag.getchildren()[0]
1910        for frag in EnvTPfrag.getchildren():
1911            if frag.attrib.has_key('srsName'):
1912                self.srsName=frag.attrib['srsName']
1913            if frag.tag == GML('lowerCorner'):
1914                self.lowerCorner=frag.text
1915            if frag.tag == GML('upperCorner'):
1916                self.upperCorner=frag.text
1917            if frag.tag == GML('timePosition'):
1918                if hasattr(self, 'timePosition'):
1919                    self.timePosition2=frag.text
1920                else:
1921                    self.timePosition=frag.text
1922    def toXML(self,csmlFrag):
1923        if hasattr(self,'srsName'):
1924            csmlFrag.attrib['srsName'] = self.srsName
1925        if hasattr(self,'lowerCorner'):
1926            frag=Element(GML('lowerCorner'))
1927            frag.text=self.lowerCorner
1928            csmlFrag.append(frag)
1929        if hasattr(self,'upperCorner'):
1930            frag=Element(GML('upperCorner'))
1931            frag.text=self.upperCorner
1932            csmlFrag.append(frag)
1933        if hasattr(self,'timePosition'):
1934            frag=Element(GML('timePosition'))
1935            frag.text=self.timePosition
1936            csmlFrag.append(frag)
1937        if hasattr(self,'timePosition2'):
1938            frag=Element(GML('timePosition'))
1939            frag.text=self.timePosition2
1940            csmlFrag.append(frag)
1941        return csmlFrag
1942
1943
1944       
1945class AngleList:
1946    #Should really inherit from MeasureList, but not implemented.
1947    #class AngleList
1948    #+uom[1]:anyURI
1949    #+double[0...1]
1950    def __init__(self,uom=None, vals=None):
1951        if uom:
1952            self.uom=uom
1953        if vals:
1954            self.vals=vals
1955    def fromXML(self,csmlFrag):
1956        self.vals=csmlFrag.text
1957        if csmlFrag.attrib.has_key('uom'):
1958            self.uom = csmlFrag.attrib['uom']
1959    def toXML(self, csmlFrag):
1960        if hasattr(self,'vals'):
1961            csmlFrag.text = self.vals
1962        if hasattr(self,'uom'):
1963            csmlFrag.attrib[('uom')] = self.uom
1964        return csmlFrag
1965       
1966class DirectionVectorList:
1967    def __init__(self, horizontalAngle=None, verticalAngle=None):
1968        if horizontalAngle:
1969            self.horizontalAngle=horizontalAngle
1970        if verticalAngle:
1971            self.verticalAngle=verticalAngle
1972    def fromXML(self, csmlFrag):
1973        for frag in csmlFrag.getchildren():
1974            if frag.tag==GML('horizontalAngle'):
1975                self.horizontalAngle=AngleList()
1976                AngleList.fromXML(self.horizontalAngle,frag)
1977            elif frag.tag==GML('verticalAngle'):
1978                self.verticalAngle=AngleList()
1979                AngleList.fromXML(self.verticalAngle,frag)
1980    def toXML(self,csmlFrag):
1981         if hasattr(self,'horizontalAngle'):
1982            frag = Element(GML('horizontalAngle'))
1983            AngleList.toXML(self.horizontalAngle,frag)
1984            csmlFrag.append(frag)
1985         if hasattr(self,'verticalAngle'):
1986            frag = Element(GML('verticalAngle'))
1987            AngleList.toXML(self.verticalAngle,frag)
1988            csmlFrag.append(frag)
1989         return csmlFrag
1990
1991       
1992class Position:
1993    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
1994        if srsName:
1995            self.srsName=srsName
1996        if axisLabels:
1997            self.axisLabels=axisLabels
1998        if uomLabels:
1999            self.uomLabels=uomLabels
2000        if location:
2001            self.location=location
2002        if time:
2003            self.time = time
2004    def fromXML(self,csmlFrag):
2005        if csmlFrag.attrib.has_key('srsName'):           
2006            self.srsName = csmlFrag.attrib['srsName']
2007        if csmlFrag.attrib.has_key('axisLabels'):
2008            self.axisLabels = csmlFrag.attrib['axisLabels']
2009            if csmlFrag.attrib.has_key('uomLabels'):
2010                self.uomLabels = csmlFrag.attrib['uomLabels']
2011        for frag in csmlFrag.getchildren():
2012            if frag.tag==CSML('location'):
2013                self.location=frag.text
2014            if frag.tag==CSML('time'):
2015                self.time=frag.text
2016    def toXML(self,csmlFrag):
2017        #subFrag = Element(CSML('Position'))
2018        if hasattr(self,'uomLabels'):
2019            csmlFrag.attrib['uomLabels'] = self.uomLabels
2020        if hasattr(self,'axisLabels'):
2021            csmlFrag.attrib['axisLabels'] = self.axisLabels
2022        if hasattr(self,'srsName'):
2023            csmlFrag.attrib['srsName'] = self.srsName
2024        if hasattr(self,'location'):
2025            frag = Element(CSML('location'))
2026            frag.text=self.location
2027            csmlFrag.append(frag)
2028        if hasattr(self,'time'):
2029            frag = Element(CSML('time'))
2030            frag.text=self.time
2031            csmlFrag.append(frag)
2032        return csmlFrag
2033
2034class OrientedPosition(Position):
2035    def __init__(self, direction=None, *args,**kwargs):
2036        Position.__init__(self, *args,**kwargs)
2037        if direction:
2038            self.direction=direction
2039    def fromXML(self,csmlFrag):
2040        Position.fromXML(self, csmlFrag)
2041        for frag in csmlFrag.getchildren():
2042            if frag.tag==CSML('direction'):
2043                self.direction=DirectionVectorList()
2044                DirectionVectorList.fromXML(self.direction,frag)
2045    def toXML(self, csmlFrag):
2046        Position.toXML(self,csmlFrag)
2047        if hasattr(self,'direction'):
2048            frag = Element(CSML('direction'))
2049            DirectionVectorList.toXML(self.direction,frag)
2050            csmlFrag.append(frag)
2051        return csmlFrag
2052       
2053
2054
2055class Trajectory(SRSReferenceGroup):
2056    def __init__(self,locations=None,times=None,*args,**kwargs):
2057
2058        if locations:
2059            self.locations=locations
2060        if times:
2061            self.times = times
2062        SRSReferenceGroup.__init__(self,*args,**kwargs)
2063    def fromXML(self,csmlFrag):
2064        SRSReferenceGroup.fromXML(self,csmlFrag)
2065        for frag in csmlFrag.getchildren():
2066            if frag.tag==CSML('locations'):
2067                self.locations=DirectPositionList()
2068                DirectPositionList.fromXML(self.locations,frag)
2069            if frag.tag==CSML('times'):
2070                self.times=TimePositionList()
2071                TimePositionList.fromXML(self.times,frag)
2072    def toXML(self,csmlFrag):
2073        SRSReferenceGroup.toXML(self,csmlFrag)
2074        if hasattr(self,'srsName'):
2075            csmlFrag.attrib['srsName'] = self.srsName
2076        if hasattr(self,'locations'):
2077            frag = Element(CSML('locations'))
2078            frag=DirectPositionList.toXML(self.locations,frag)
2079            csmlFrag.append(frag)
2080        if hasattr(self,'times'):
2081            frag = Element(CSML('times'))
2082            TimePositionList.toXML(self.times, frag)
2083            csmlFrag.append(frag)
2084        return csmlFrag
2085
2086class OrientedTrajectory(Trajectory):
2087    def __init__(self, direction=None, *args,**kwargs):
2088        Trajectory.__init__(self, *args,**kwargs)
2089        if direction:
2090             self.direction=direction
2091    def fromXML(self,csmlFrag):
2092        Trajectory.fromXML(self, csmlFrag)
2093        for frag in csmlFrag.getchildren():
2094            if frag.tag==CSML('direction'):
2095                self.direction=DirectionVectorList()
2096                DirectionVectorList.fromXML(self.direction,frag)
2097    def toXML(self, csmlFrag):
2098        Trajectory.toXML(self,csmlFrag)
2099        if hasattr(self,'direction'):
2100            frag = Element(CSML('direction'))
2101            DirectionVectorList.toXML(self.direction,frag)
2102            csmlFrag.append(frag)
2103        return csmlFrag
2104
2105class AbstractGeometryType(AbstractGML):
2106    def __init__(self, low=None, high=None):
2107        AbstractGML.__init__(self)
2108        if low:
2109            self.low=low
2110        if high:
2111            self.high=high
2112    def fromXML(self, csmlFrag):
2113        AbstractGML.fromXML(self,csmlFrag)
2114    def toXML(self,csmlFrag):
2115        AbstractGML.toXML(self,csmlFrag)
2116        return csmlFrag
2117
2118class GridEnvelope:
2119    def __init__(self, low=None, high = None):
2120        if low:
2121            self.low = low
2122        if high:
2123            self.high = high
2124    def fromXML(self, csmlFrag):
2125        frag = csmlFrag.getchildren()[0]
2126        for subFrag in frag.getchildren():
2127            if subFrag.tag == GML('low'):
2128                self.low=subFrag.text
2129            elif subFrag.tag == GML('high'):
2130                self.high=subFrag.text
2131    def toXML(self,csmlFrag):
2132        if hasattr(self, 'low'):
2133            frag=Element(GML('low'))
2134            frag.text=self.low
2135            csmlFrag.append(frag)
2136        if hasattr(self, 'high'):
2137            frag=Element(GML('high'))
2138            frag.text=self.high
2139            csmlFrag.append(frag)
2140        return csmlFrag
2141
2142class GmlGrid(AbstractGeometryType):
2143    #Class GmlGrid, representing a gml:Grid element.
2144    #  +dimension positiveInteger [1]
2145    # +gml:limits  (gml:GridLimitsType) </gml:limits> [1]
2146    #+gml:axisNames  (string) [1..*]
2147    def __init__(self,dimension=None,limits=None,axisNames=None):
2148        AbstractGeometryType.__init__(self)
2149        if dimension:
2150            self.dimension=dimension
2151        if limits:
2152            self.limits=limits
2153        if axisNames:
2154            self.axisNames=axisNames
2155    def fromXML(self, csmlFrag):
2156        AbstractGeometryType.fromXML(self,csmlFrag)
2157        for frag in csmlFrag.getchildren():
2158            if frag.tag == GML('limits'):
2159                self.limits=GridEnvelope()
2160                GridEnvelope.fromXML(self.limits,frag)
2161            elif frag.tag == GML('axisName'):
2162                checkArrayAttrib(self,'axisNames')
2163                self.axisNames.append(frag.text)
2164    def toXML(self,csmlFrag):
2165        AbstractGeometryType.toXML(self,csmlFrag)
2166        if hasattr(self, 'limits'):
2167            frag=Element(GML('limits'))
2168            subFrag =Element(GML('GridEnvelope'))
2169            GridEnvelope.toXML(self.limits, subFrag)
2170            frag.append(subFrag)
2171            csmlFrag.append(frag)
2172        if hasattr(self, 'axisNames'):
2173            for axis in self.axisNames:
2174                frag=Element(GML('axisName'))
2175                frag.text =axis
2176                csmlFrag.append(frag)
2177        return csmlFrag
2178           
2179class GridOrdinateDescription:
2180    #Class GridOrdinateDescription:
2181        #+gridAxesSpanned
2182        #+sequenceRule
2183        #+definesAxis,attrib -href
2184        #+axisValues
2185
2186    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
2187        if gridAxesSpanned:
2188            self.gridAxesSpanned=gridAxesSpanned
2189        if sequenceRule:
2190            self.sequenceRule=sequenceRule
2191        if definesAxis:
2192            self.definesAxis=definesAxis
2193            if href:
2194                self.href = href
2195        if axisValues:
2196            self.axisValues=axisValues
2197       
2198    def fromXML(self,csmlFrag):
2199        for frag in csmlFrag.getchildren():
2200            if frag.tag ==CSML('gridAxesSpanned'):
2201                self.gridAxesSpanned=frag.text
2202            elif frag.tag ==CSML('sequenceRule'):
2203                self.sequenceRule=frag.text
2204            elif frag.tag ==CSML('definesAxis'):
2205                self.definesAxis=frag.text
2206                if frag.attrib.has_key(XLINK('href')):
2207                        self.href = frag.attrib[XLINK('href')]
2208            elif frag.tag ==CSML('axisValues'):
2209                if frag.getchildren() !=[]:
2210                    subFrag= frag.getchildren()[0]
2211                    if subFrag.tag == CSML ('NetCDFExtract'):
2212                        self.axisValues=NetCDFExtract()
2213                        NetCDFExtract.fromXML(self.axisValues, subFrag)
2214                else:
2215                    self.axisValues=frag.text
2216                   
2217               
2218    def toXML(self, csmlFrag):
2219        if hasattr(self, 'gridAxesSpanned'):
2220            frag=Element(CSML('gridAxesSpanned'))
2221            frag.text = self.gridAxesSpanned
2222            csmlFrag.append(frag)
2223        if hasattr(self, 'sequenceRule'):
2224            frag=Element(CSML('sequenceRule'))
2225            frag.text = self.sequenceRule
2226            csmlFrag.append(frag)
2227        if hasattr(self, 'definesAxis'):
2228            frag=Element(CSML('definesAxis'))
2229            frag.text = self.definesAxis
2230            if hasattr(self, 'href'):
2231                frag.attrib[XLINK('href')] = self.href
2232            csmlFrag.append(frag)
2233        if hasattr(self, 'axisValues'):
2234            frag=Element(CSML('axisValues'))
2235            if isinstance(self.axisValues,NetCDFExtract):
2236                subFrag=Element(CSML('NetCDFExtract'))
2237                NetCDFExtract.toXML(self.axisValues,subFrag)
2238                frag.append(subFrag)
2239            else:
2240                frag.text = self.axisValues
2241            csmlFrag.append(frag)
2242        return csmlFrag
2243
2244
2245class Grid(GmlGrid):
2246#Class GmlGrid representing a gml:Grid
2247# + dimension(attrib) [1]
2248#  +ordinate [1..*]
2249    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
2250        GmlGrid.__init__(self)
2251        if srsName:
2252            self.srsName=srsName
2253        if srsDimension:
2254            self.srsDimension=srsDimension
2255        if dimension:
2256            self.dimension=dimension
2257        if ordinates:
2258            self.ordinates=ordinates
2259    def fromXML(self, csmlFrag):
2260        GmlGrid.fromXML(self,csmlFrag)
2261        if csmlFrag.attrib.has_key('srsName'):
2262            self.srsName = csmlFrag.attrib['srsName']
2263        if csmlFrag.attrib.has_key('srsDimension'):
2264            self.srsDimension = csmlFrag.attrib['srsDimension']
2265        if csmlFrag.attrib.has_key('dimension'):
2266            self.dimension = csmlFrag.attrib['dimension']
2267        for frag in csmlFrag:
2268            if frag.tag==CSML('ordinate'):
2269                checkArrayAttrib(self,'ordinates')
2270                ordinate=GridOrdinateDescription()
2271                GridOrdinateDescription.fromXML(ordinate, frag)
2272                self.ordinates.append(ordinate)
2273    def toXML(self,csmlFrag):
2274        GmlGrid.toXML(self,csmlFrag)
2275        if hasattr(self, 'srsName'):
2276            csmlFrag.attrib['srsName'] = self.srsName
2277        if hasattr(self, 'srsDimension'):
2278            csmlFrag.attrib['srsDimension'] = self.srsDimension
2279        if hasattr(self, 'dimension'):
2280            csmlFrag.attrib['dimension'] = self.dimension
2281       
2282        if hasattr(self, 'ordinates'):
2283            for ordinate in self.ordinates:
2284                frag=Element(CSML('ordinate'))
2285                GridOrdinateDescription.toXML(ordinate, frag)
2286                csmlFrag.append(frag)
2287        return csmlFrag
2288
2289class TimeInstant:
2290    def __init__(self, timePosition=None):
2291        if timePosition:
2292            self.timePosition=timePosition
2293    def fromXML(self,csmlFrag):
2294        for frag in csmlFrag.getchildren():
2295            if frag.tag==GML('timePosition'):
2296                self.timePosition=frag.text
2297    def toXML(self,csmlFrag):
2298         if hasattr(self,'timePosition'):
2299            frag = Element(GML('timePosition'))
2300            frag.text=self.timePosition
2301            csmlFrag.append(frag)
2302         return csmlFrag
2303
2304class TimePositionList(AssociationAttributeGroup):
2305              #class TimePositionList
2306              #+frame[0..1]:anyURI
2307              # + calendarEraName [0..1]:string (not implemented)
2308              # +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType  (not implemented)
2309    def __init__(self, frame=None, timePositions=None,*args, **kwargs):
2310        if frame:
2311            self.frame=frame
2312        if timePositions:
2313            self.timePositions=timePositions
2314        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2315    def fromXML(self,csmlFrag):
2316        self.timePositions=csmlFrag.text
2317        if csmlFrag.attrib.has_key('frame'):
2318            self.frame = csmlFrag.attrib['frame']
2319        AssociationAttributeGroup.fromXML(self,csmlFrag)
2320    def toXML(self,csmlFrag):
2321         if hasattr(self,'timePositions'):
2322            csmlFrag.text=self.timePositions
2323         if hasattr(self,'frame'):
2324             csmlFrag.attrib['frame']=self.frame
2325         AssociationAttributeGroup.toXML(self,csmlFrag)
2326         return csmlFrag
2327             
2328class Measure:
2329    def __init__(self, uom=None, vals=None):
2330        if uom:
2331            self.uom=uom
2332        if vals:
2333            self.vals=vals
2334    def fromXML(self,csmlFrag):
2335        self.vals=csmlFrag.text
2336        if csmlFrag.attrib.has_key('uom'):
2337            self.uom = csmlFrag.attrib['uom']
2338    def toXML(self, csmlFrag):
2339        frag = Element(GML('measure'))
2340        if hasattr(self, 'vals'):
2341            frag.text = self.vals
2342        if hasattr(self,'uom'):
2343            frag.attrib[('uom')] = self.uom
2344        csmlFrag.append(frag)
2345        return csmlFrag
2346
2347class MeasureOrNullList:
2348    #class MeasureOrNullList:
2349    # +uom[1]:anyURI
2350    #Actually based on doubleOrNullList, but not modelled to that level of detail.
2351   
2352    def __init__(self, uom=None, val=None):
2353        if uom:
2354            self.uom=uom
2355        if val:
2356            self.val=val
2357    def fromXML(self,csmlFrag):
2358        self.val=csmlFrag.text
2359        if csmlFrag.attrib.has_key('uom'):
2360            self.uom = csmlFrag.attrib['uom']
2361    def toXML(self, csmlFrag):
2362        if hasattr(self,'val'):
2363            csmlFrag.text = self.val
2364        if hasattr(self,'uom'):
2365           csmlFrag.attrib[('uom')] = self.uom
2366        return csmlFrag
2367   
2368class CompositeValue:
2369    def __init__(self, valueComponents=None):
2370        if valueComponents:
2371            self.valueComponents=valueComponents
2372    def fromXML(self,csmlFrag):
2373        for frag in csmlFrag.getchildren():
2374            if frag.tag == GML('valueComponents'):
2375                self.valueComponents = []
2376                for subFrag in frag.getchildren():                   
2377                    if subFrag.tag == GML('measure'):
2378                        self.valueComponents.append(Measure())
2379                        self.valueComponents[-1].fromXML(subFrag)
2380
2381    def toXML(self, csmlFrag):
2382         if hasattr(self,'valueComponents'):
2383            frag=Element(GML('valueComponents'))
2384            for valueComponent in self.valueComponents:
2385                if isinstance(valueComponent,Measure):
2386                    subFrag=Element(GML('measure'))
2387                    Measure.toXML(valueComponent,subFrag)
2388                    frag.append(subFrag)
2389            csmlFrag.append(frag)
2390         return csmlFrag
2391   
2392
2393   
2394class DataBlock:
2395    #class GML DataBlock
2396   
2397    #DataBlock()
2398    #+gml:rangeParameters
2399    def __init__(self,rangeParameters=None, doubleOrNullTupleList=None):
2400        if rangeParameters:
2401            self.rangeParameters=rangeParameters
2402        if doubleOrNullTupleList:
2403            self.doubleOrNullTupleList=doubleOrNullTupleList
2404    def fromXML(self,csmlFrag):
2405        for frag in csmlFrag.getchildren():
2406            if frag.tag == GML('rangeParameters'):
2407                for subFrag in frag.getchildren():
2408                    if subFrag.tag==GML('CompositeValue'):
2409                        self.rangeParameters=CompositeValue()
2410                        CompositeValue.fromXML(self.rangeParameters,subFrag)
2411            if frag.tag == GML('doubleOrNullTupleList'):
2412                self.doubleOrNullTupleList=frag.text
2413    def toXML(self,csmlFrag):
2414        if hasattr(self, 'rangeParameters'):
2415            frag=Element(GML('rangeParameters'))
2416            subFrag=Element(GML('CompositeValue'))
2417            CompositeValue.toXML(self.rangeParameters, subFrag)
2418            frag.append(subFrag)
2419            csmlFrag.append(frag)
2420        if hasattr(self,'doubleOrNullTupleList'):
2421            frag=Element(GML('doubleOrNullTupleList'))
2422            frag.text=self.doubleOrNullTupleList
2423            csmlFrag.append(frag)
2424        return csmlFrag
2425
2426
2427
2428class TypedCategory:
2429#class om:TypedCategory
2430    # +axis (attrib)
2431    # + codeSpace (attrib)
2432    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
2433        if axis:
2434            self.axis=axis
2435        if codeSpace:
2436            self.codeSpace=codeSpace
2437        if text:
2438            self.text=text
2439    def fromXML(self,csmlFrag):
2440        if csmlFrag.attrib.has_key('axis'):
2441            self.axis=csmlFrag.attrib['axis']
2442        if csmlFrag.attrib.has_key('codeSpace'):
2443            self.codeSpace=csmlFrag.attrib['codeSpace']
2444        self.text=csmlFrag.text
2445    def toXML(self,csmlFrag):
2446        if hasattr(self,'axis'):
2447            csmlFrag.attrib[('axis')] =self.axis
2448        if hasattr(self,'codeSpace'):
2449            csmlFrag.attrib[('codeSpace')] =self.codeSpace
2450        csmlFrag.text=self.text
2451        return csmlFrag
2452
2453class Phenomenon(Definition,AssociationAttributeGroup):
2454    #class Obs& Measures: PhenomenonProperty
2455    #Note, in this does not really inherit from AbstractGML, but for CMSL
2456    #purposes it is used  to pick up the basic description, id, name attributes
2457    def __init__(self,*args,**kwargs):
2458         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
2459        self.MetaDataProperty=None
2460        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
2461        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2462    def fromXML(self,csmlFrag):
2463        Definition.fromXML(self,csmlFrag)
2464        AssociationAttributeGroup.fromXML(self,csmlFrag)
2465       
2466    def toXML(self,csmlFrag):
2467        csmlFrag=Definition.toXML(self,csmlFrag)
2468        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2469        return csmlFrag
2470
2471
2472class OLD_CompositePhenomenon(Phenomenon):
2473    #Class om:CompositePhenomenon
2474    # + om:componentPhenomenon [1...*]
2475    def __init__(self,componentPhenomenon=None,*args,**kwargs):
2476        Phenomenon.__init__(self,*args,**kwargs)
2477        if componentPhenomenon:
2478            self.componentPhenomenon=componentPhenomenon
2479    def fromXML(self,csmlFrag):
2480        Phenomenon.fromXML(self,csmlFrag)
2481        for frag in csmlFrag.getchildren():
2482            if frag.tag == OM('componentPhenomenon'):
2483                checkArrayAttrib(self,'componentPhenomenon')
2484                self.componentPhenomenon.append(frag.attrib)
2485    def toXML(self,csmlFrag):
2486        Phenomenon.toXML(self,csmlFrag)
2487        if hasattr(self, 'componentPhenomenon'):
2488            for cp in self.componentPhenomenon:
2489                frag=Element(OM('componentPhenomenon'))
2490                frag.attrib= cp
2491                csmlFrag.append(frag)
2492        return csmlFrag
2493
2494class CompositePhenomenon(Phenomenon):
2495    #Class om:CompositePhenomenon
2496    # + om:componentPhenomenon [1...*]
2497    def __init__(self,componentPhenomena=None,*args,**kwargs):
2498        Phenomenon.__init__(self,*args,**kwargs)
2499        if componentPhenomena:
2500            self.componentPhenomena=componentPhenomena
2501    def fromXML(self,csmlFrag):
2502        Phenomenon.fromXML(self,csmlFrag)
2503        self.componentPhenomena=[]
2504        for frag in csmlFrag.getchildren():
2505            if frag.tag == OM('componentPhenomenon'):
2506                componentPhenomenon=Phenomenon()
2507                Phenomenon.fromXML(componentPhenomenon,frag)
2508                self.componentPhenomena.append(componentPhenomenon)
2509    def toXML(self,csmlFrag):
2510        Phenomenon.toXML(self,csmlFrag)
2511        if hasattr(self, 'componentPhenomena'):
2512            for phenomenon in self.componentPhenomena:
2513                frag=Element(OM('componentPhenomenon'))
2514                Phenomenon.toXML(phenomenon,frag)
2515                csmlFrag.append(frag)
2516        return csmlFrag
2517           
2518               
2519class ParameterisedPhenomenon(Phenomenon):
2520    #Class ParameterisedPhenomenon:
2521        # + basePhenomenon
2522        # + constraint
2523        # + href (attrib)
2524    def __init__(self,*args,**kwargs):
2525        Phenomenon.__init__(self,*args,**kwargs)
2526    def fromXML(self,csmlFrag):
2527        Phenomenon.fromXML(self,csmlFrag)
2528        for frag in csmlFrag.getchildren():
2529            if frag.tag == OM('basePhenomenon'):
2530                self.basePhenomenon=frag.text
2531                if frag.attrib.has_key(XLINK('href')):
2532                    self.href = frag.attrib[XLINK('href')]
2533            if frag.tag == OM('constraint'):
2534                subFrag=frag.getchildren()[0]
2535                if subFrag.tag== OM('TypedCategory'):
2536                    self.constraint = TypedCategory()
2537                #TO DO: what other types are valid?
2538                elif subFrag.tag== OM('??'):
2539                    self.constraint = 123
2540                self.constraint.fromXML(subFrag)
2541    def toXML(self,csmlFrag):
2542        csmlFrag=Phenomenon.toXML(self,csmlFrag)
2543        if hasattr(self,'basePhenomenon'):
2544            frag=Element(OM('basePhenomenon'))
2545            frag.text=self.basePhenomenon
2546            if hasattr(self, 'href'):
2547                frag.attrib[XLINK('href')] = self.href
2548            csmlFrag.append(frag)
2549        if hasattr(self, 'constraint'):
2550            frag=Element(OM('constraint'))
2551            subFrag=Element(OM('TypedCategory'))
2552            subFrag=self.constraint.toXML(subFrag)
2553            frag.append(subFrag)
2554            csmlFrag.append(frag)
2555        return csmlFrag
2556
2557class RangeSet:
2558#class GML RangeSet 
2559
2560        # RangeSet()
2561        # +gml:ValueArray
2562        # +gml:_ScalarValueList
2563        # +gml:DataBlock
2564        # +gml:File
2565    #class GML RangeSet
2566    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None):
2567        if quantityList:
2568            self.quantityList=quantityList
2569        if dataBlock:
2570            self.dataBlock=dataBlock
2571        if arrayDescriptor:
2572            self.arrayDescriptor=arrayDescriptor
2573        if aggregatedArray:
2574            self.aggregatedArray=aggregatedArray
2575           
2576    def fromXML(self,csmlFrag):
2577        for frag in csmlFrag.getchildren():
2578            if frag.tag==GML('QuantityList'):
2579                self.quantityList=MeasureOrNullList()
2580                MeasureOrNullList.fromXML(self.quantityList,frag)
2581            elif frag.tag==GML('DataBlock'):
2582                self.dataBlock=DataBlock()
2583                DataBlock.fromXML(self.dataBlock, frag)
2584            elif frag.tag == CSML('NetCDFExtract'):
2585                self.arrayDescriptor=NetCDFExtract()
2586                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
2587            elif frag.tag == CSML('NASAmesExtract'):
2588                self.arrayDescriptor=NASAAmesExtract()
2589                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
2590            elif frag.tag == CSML('GRIBExtract'):
2591                self.arrayDescriptor=GRIBExtract()
2592                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
2593            elif frag.tag == CSML('AggregatedArray'):
2594                self.aggregatedArray=AggregatedArray()
2595                AggregatedArray.fromXML(self.aggregatedArray,frag)
2596    def toXML(self, csmlFrag):
2597        if hasattr(self,'quantityList'):
2598            frag = Element(GML('QuantityList'))
2599            MeasureOrNullList.toXML(self.quantityList,frag)
2600            csmlFrag.append(frag)
2601        if hasattr(self,'dataBlock'):
2602            frag=Element(GML('DataBlock'))
2603            DataBlock.toXML(self.dataBlock,frag)
2604            csmlFrag.append(frag)
2605        if hasattr(self,'aggregatedArray'):
2606            frag=Element(CSML('AggregatedArray'))
2607            AggregatedArray.toXML(self.aggregatedArray,frag)
2608            csmlFrag.append(frag)
2609        if hasattr(self,'arrayDescriptor'):
2610            if isinstance(self.arrayDescriptor,NetCDFExtract):
2611                frag=Element(CSML('NetCDFExtract'))
2612                NetCDFExtract.toXML(self.arrayDescriptor,frag)
2613                csmlFrag.append(frag)
2614            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
2615                frag=Element(CSML('NASAAmesExtract'))
2616                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
2617                csmlFrag.append(frag)
2618            elif isinstance(self.arrayDescriptor,GRIBExtract):
2619                frag=Element(CSML('GRIBExtract'))
2620                GRIBAmesExtract.toXML(self.arrayDescriptor,frag)
2621                csmlFrag.append(frag)
2622               
2623        return csmlFrag
2624
2625class PointDomain(AbstractDomain):
2626    def __init__(self,*args,**kwargs):
2627        AbstractDomain.__init__(self,*args,**kwargs)
2628    def fromXML(self,csmlFrag):
2629        AbstractDomain.fromXML(self,csmlFrag)
2630    def toXML(self,csmlFrag):
2631        AbstractDomain.toXML(self,csmlFrag)
2632        return csmlFrag
2633   
2634class ProfileDomain(AbstractDomain):
2635    def __init__(self,*args,**kwargs):
2636        AbstractDomain.__init__(self,*args,**kwargs)
2637    def fromXML(self,csmlFrag):
2638        AbstractDomain.fromXML(self,csmlFrag)
2639    def toXML(self,csmlFrag):
2640        AbstractDomain.toXML(self,csmlFrag)
2641        return csmlFrag
2642
2643class GridDomain(AbstractDomain):
2644    def __init__(self,*args,**kwargs):
2645        AbstractDomain.__init__(self,*args,**kwargs)
2646    def fromXML(self,csmlFrag):
2647        AbstractDomain.fromXML(self,csmlFrag)
2648    def toXML(self,csmlFrag):
2649        AbstractDomain.toXML(self,csmlFrag)
2650        return csmlFrag
2651   
2652class PointSeriesDomain(AbstractDomain):
2653    def __init__(self,*args,**kwargs):
2654        AbstractDomain.__init__(self,*args,**kwargs)
2655    def fromXML(self,csmlFrag):
2656        AbstractDomain.fromXML(self,csmlFrag)
2657    def toXML(self,csmlFrag):
2658        AbstractDomain.toXML(self,csmlFrag)
2659        return csmlFrag
2660   
2661class ProfileSeriesDomain(AbstractDomain):
2662    def __init__(self,*args,**kwargs):
2663        AbstractDomain.__init__(self,*args,**kwargs)
2664    def fromXML(self,csmlFrag):
2665        AbstractDomain.fromXML(self,csmlFrag)
2666    def toXML(self,csmlFrag):
2667        AbstractDomain.toXML(self,csmlFrag)
2668        return csmlFrag
2669   
2670class GridSeriesDomain(AbstractDomain):
2671    def __init__(self,*args,**kwargs):
2672        AbstractDomain.__init__(self,*args,**kwargs)
2673    def fromXML(self,csmlFrag):
2674        AbstractDomain.fromXML(self,csmlFrag)
2675    def toXML(self,csmlFrag):
2676        AbstractDomain.toXML(self,csmlFrag)
2677        return csmlFrag
2678
2679class PointFeature(AbstractStaticCoverageFeature):
2680    #CSML PointFeature class
2681    #       PointFeature(AbstractStaticCoverageFeatureType):
2682    #      +PointDomain
2683    def __init__(self, domain=None,*args,**kwargs):
2684        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2685        if domain:
2686            self.domain=domain
2687    def fromXML(self,csmlFrag):
2688        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2689        for frag in csmlFrag.getchildren():
2690            if frag.tag == CSML('PointDomain'):
2691                self.domain = PointDomain()
2692                self.domain.fromXML(frag)
2693    def toXML(self,csmlFrag):
2694        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2695        if hasattr(self,'domain'):
2696            frag = Element(CSML('PointDomain'))
2697            PointDomain.toXML(self.domain,frag)
2698#             if hasattr(self,'href'):
2699#                 frag.attrib[XLINK('href')] = self.href
2700            csmlFrag.append(frag)
2701        return csmlFrag
2702
2703   
2704class PointSeriesFeature(AbstractSeriesCoverageFeature):
2705    #CSML PointSeriesFeature class
2706    #       PointSeriesFeature(AbstractStaticCoverageFeatureType):
2707    #      +pointSeriesDomain[1]:PointSeriesDomain
2708
2709    def __init__(self,domain=None,*args,**kwargs):
2710        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
2711        if domain:
2712            self.domain=domain
2713    def fromXML(self,csmlFrag):
2714        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
2715        for frag in csmlFrag.getchildren():
2716            if frag.tag == CSML('PointSeriesDomain'):
2717                self.domain = PointSeriesDomain()
2718                self.domain.fromXML(frag)
2719    def toXML(self,csmlFrag):
2720        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
2721        if hasattr(self,'domain'):
2722             frag = Element(CSML('PointSeriesDomain'))
2723             PointSeriesDomain.toXML(self.domain,frag)
2724             csmlFrag.append(frag)
2725        return csmlFrag
2726
2727class ProfileFeature(AbstractStaticCoverageFeature):
2728     #CSML ProfileFeature class
2729    #       ProfileFeature(AbstractStaticCoverageFeature):
2730    #      +profileDomain[1]:ProfileDomain
2731
2732    def __init__(self,domain=None,*args,**kwargs):
2733        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2734        if domain:
2735            self.domain=domain
2736    def fromXML(self,csmlFrag):
2737        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2738        for frag in csmlFrag.getchildren():
2739            if frag.tag == CSML('ProfileDomain'):
2740                self.domain = ProfileDomain()
2741                ProfileDomain.fromXML(self.domain,frag)
2742    def toXML(self,csmlFrag):
2743        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2744        if hasattr(self,'domain'):
2745             frag = Element(CSML('ProfileDomain'))
2746             ProfileDomain.toXML(self.domain,frag)
2747             csmlFrag.append(frag)
2748        return csmlFrag
2749
2750
2751class ProfileSeriesFeature(AbstractStaticCoverageFeature):
2752#CSML ProfileSeriesFeature class
2753    #       ProfileSeriesFeature(AbstractStaticCoverageFeature):
2754    #      +ProfileSeriesDomain
2755
2756    def __init__(self,domain=None,*args,**kwargs):
2757        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2758        if domain:
2759            self.domain=domain
2760    def fromXML(self,csmlFrag):
2761        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2762        for frag in csmlFrag.getchildren():
2763            if frag.tag == CSML('ProfileSeriesDomain'):
2764                self.domain = ProfileSeriesDomain()
2765                ProfileSeriesDomain.fromXML(self.domain,frag)
2766    def toXML(self,csmlFrag):
2767        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2768        if hasattr(self,'domain'):
2769             frag = Element(CSML('ProfileSeriesDomain'))
2770             ProfileSeriesDomain.toXML(self.domain,frag)
2771             csmlFrag.append(frag)
2772        return csmlFrag
2773
2774
2775class GridFeature(AbstractStaticCoverageFeature):
2776#CSML GridFeature class
2777    #       GridFeature(AbstractStaticCoverageFeature):
2778    #      +gridDomain[1]:gridDomain
2779
2780    def __init__(self,domain=None,*args,**kwargs):
2781        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2782        if domain:
2783            self.domain=domain
2784    def fromXML(self,csmlFrag):
2785        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2786        for frag in csmlFrag.getchildren():
2787            if frag.tag == CSML('GridDomain'):
2788                self.domain = GridDomain()
2789                self.domain.fromXML(frag)
2790    def toXML(self,csmlFrag):
2791        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2792        if hasattr(self,'domain'):
2793             frag = Element(CSML('GridDomain'))
2794             GridDomain.toXML(self.domain,frag)
2795             csmlFrag.append(frag)
2796        return csmlFrag
2797
2798
2799class GridSeriesFeature(AbstractStaticCoverageFeature):
2800    def __init__(self,domain=None,*args,**kwargs):
2801        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2802        if domain:
2803            self.domain=domain
2804    def fromXML(self,csmlFrag):
2805        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2806        for frag in csmlFrag.getchildren():
2807            if frag.tag == CSML('GridSeriesDomain'):
2808                self.domain = GridSeriesDomain()
2809                self.domain.fromXML(frag)
2810    def toXML(self,csmlFrag):
2811        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2812        if hasattr(self,'domain'):
2813             frag = Element(CSML('GridSeriesDomain'))
2814             GridSeriesDomain.toXML(self.domain,frag)
2815             csmlFrag.append(frag)
2816        return csmlFrag
2817
2818
2819   
2820class AbstractFeature(AbstractGML):
2821    def __init__(self,boundedBy=None,*args,**kwargs):
2822        AbstractGML.__init__(self,*args,**kwargs)
2823        if boundedBy:
2824            self.boundedBy=boundedBy
2825    def fromXML(self,csmlFrag):
2826        AbstractGML.fromXML(self,csmlFrag)
2827        for frag in csmlFrag.getchildren():
2828            if frag.tag == GML('boundedBy'):
2829                self.boundedBy = EnvelopeWithTimePeriod()
2830                self.boundedBy.fromXML(frag)
2831    def toXML(self,csmlFrag):
2832        AbstractGML.toXML(self,csmlFrag)
2833        if hasattr(self,'boundedBy'):
2834             superfrag = Element(GML('boundedBy'))
2835             frag = Element (GML('EnvelopeWithTimePeriod'))
2836             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
2837             superfrag.append(frag)
2838             csmlFrag.append(superfrag)
2839        return csmlFrag
2840
2841class AbstractGeometryFeature(AbstractFeature):
2842    def __init__(self,*args,**kwargs):
2843        AbstractFeature.__init__(self,*args,**kwargs)
2844    def fromXML(self,csmlFrag):
2845        AbstractFeature.fromXML(self,csmlFrag)
2846    def toXML(self, csmlFrag):
2847        AbstractFeature.toXML(self,csmlFrag)
2848        return csmlFrag
2849
2850
2851class TrajectoryFeature(AbstractGeometryFeature):
2852    def __init__(self,track=None, *args, **kwargs):
2853        AbstractGeometryFeature.__init__(self,*args,**kwargs)
2854        if track:
2855            self.track=track
2856    def fromXML(self,csmlFrag):
2857        AbstractGeometryFeature.fromXML(self,csmlFrag)
2858        for frag in csmlFrag.getchildren():
2859            if frag.tag == CSML('track'):
2860                self.track=Trajectory()
2861                Trajectory.fromXML(self.track,frag)
2862    def toXML(self,csmlFrag):
2863        AbstractGeometryFeature.toXML(self,csmlFrag)
2864        if hasattr(self, 'track'):
2865            frag = Element(CSML('track'))
2866            subFrag=Element(CSML('Trajectory'))
2867            Trajectory.toXML(self.track,subFrag)
2868            frag.append(subFrag)
2869            csmlFrag.append(frag)
2870        return csmlFrag
2871       
2872class AbstractFeatureCollection(AbstractFeature):
2873    """GML AbstractFeatureCollection class
2874
2875    AbstractFeatureCollection(AbstractFeature):
2876     +featureMember[0..*]: AbstractFeature
2877     +featureMembers[0..1]: FeatureArray
2878    """
2879    def __init__(self,members=[]):
2880        if members:
2881            self.members=members
2882    def fromXML(self,csmlFrag):
2883        AbstractFeature.fromXML(self,csmlFrag)
2884        for frag in csmlFrag.getchildren():
2885            if frag.tag == GML('featureMember'):
2886                checkArrayAttrib(self,'members')
2887                featureFrag = frag.getchildren()[0]
2888                if featureFrag.tag == CSML('PointFeature'):
2889                    self.members.append(PointFeature())
2890                    self.members[-1].fromXML(featureFrag)
2891                if featureFrag.tag == CSML('ProfileFeature'):
2892                    self.members.append(ProfileFeature())
2893                    self.members[-1].fromXML(featureFrag)
2894                if featureFrag.tag == CSML('GridFeature'):
2895                    self.members.append(GridFeature())
2896                    self.members[-1].fromXML(featureFrag)
2897                if featureFrag.tag == CSML('PointSeriesFeature'):
2898                    self.members.append(PointSeriesFeature())
2899                    self.members[-1].fromXML(featureFrag)
2900                if featureFrag.tag == CSML('ProfileSeriesFeature'):
2901                    self.members.append(ProfileSeriesFeature())
2902                    self.members[-1].fromXML(featureFrag)
2903                if featureFrag.tag == CSML('GridSeriesFeature'):
2904                    self.members.append(GridSeriesFeature())
2905                    self.members[-1].fromXML(featureFrag)
2906                if featureFrag.tag == CSML('TrajectoryFeature'):
2907                    self.members.append(TrajectoryFeature())
2908                    self.members[-1].fromXML(featureFrag)
2909    def toXML(self,csmlFrag):
2910        AbstractFeature.toXML(self,csmlFrag)
2911        for member in self.members:
2912            if isinstance(member,PointFeature):
2913                superFrag=Element(GML('FeatureMember'))
2914                frag=Element(CSML('PointFeature'))
2915                PointFeature.toXML(member,frag)
2916                superFrag.append(frag)
2917                csmlFrag.append(superFrag)
2918            if isinstance(member,ProfileFeature):
2919                superFrag=Element(GML('FeatureMember'))
2920                frag=Element(CSML('ProfileFeature'))
2921                ProfileFeature.toXML(member,frag)
2922                superFrag.append(frag)
2923                csmlFrag.append(superFrag)
2924            if isinstance(member,GridFeature):
2925                superFrag=Element(GML('FeatureMember'))
2926                frag=Element(CSML('GridFeature'))
2927                GridFeature.toXML(member,frag)
2928                superFrag.append(frag)
2929                csmlFrag.append(superFrag)
2930            if isinstance(member,PointSeriesFeature):
2931                superFrag=Element(GML('FeatureMember'))
2932                frag=Element(CSML('PointSeriesFeature'))
2933                PointSeriesFeature.toXML(member,frag)
2934                superFrag.append(frag)
2935                csmlFrag.append(superFrag)
2936            if isinstance(member,ProfileSeriesFeature):
2937                superFrag=Element(GML('FeatureMember'))
2938                frag=Element(CSML('ProfileSeriesFeature'))
2939                ProfileSeriesFeature.toXML(member,frag)
2940                superFrag.append(frag)
2941                csmlFrag.append(superFrag)
2942            if isinstance(member,GridSeriesFeature):
2943                superFrag=Element(GML('FeatureMember'))
2944                frag=Element(CSML('GridSeriesFeature'))
2945                GridSeriesFeature.toXML(member,frag)
2946                superFrag.append(frag)
2947                csmlFrag.append(superFrag)
2948            if isinstance(member,TrajectoryFeature):
2949                superFrag=Element(GML('FeatureMember'))
2950                frag=Element(CSML('TrajectoryFeature'))
2951                TrajectoryFeature.toXML(member,frag)
2952                superFrag.append(frag)
2953                csmlFrag.append(superFrag)
2954       
2955        return csmlFrag
2956
2957class FeatureCollection(AbstractFeatureCollection):
2958    """GML FeatureCollection class
2959        FeatureCollection()
2960        +FeatureMembers[0..*]
2961    """
2962    def __init__(self,*args,**kwargs):
2963        AbstractFeatureCollection.__init__(self,*args,**kwargs)
2964    def fromXML(self,csmlFrag):
2965        AbstractFeatureCollection.fromXML(self,csmlFrag)
2966    def toXML(self,csmlFrag):
2967        AbstractFeatureCollection.toXML(self,csmlFrag)
2968        return csmlFrag
2969
2970class Dataset(AbstractGML):
2971    """CSML Dataset class
2972
2973    Dataset(AbstractGML):
2974     +unitDefinitions[0..*]: UnitDefinitions
2975     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
2976     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
2977     +arrayDescriptors[0..*]: AbstractArrayDescriptor
2978     +featureCollection[0..1]: FeatureCollection
2979    """
2980    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
2981                 phenomenonDefinitions=None,arrayDescriptors=[],
2982                 featureCollection=None,*args,**kwargs):
2983        AbstractGML.__init__(self,*args,**kwargs)
2984        if unitDefinitions:
2985            self.unitDefinitions = unitDefinitions
2986        if referenceSystemDefinitions:
2987            self.referenceSystemDefinitions = referenceSystemDefinitions
2988        if phenomenonDefinitions:
2989            self.phenomenonDefinitions = phenomenonDefinitions
2990        if arrayDescriptors:
2991            self.arrayDescriptors = arrayDescriptors
2992        if featureCollection:
2993            self.featureCollection = featureCollection
2994    def fromXML(self,csmlFrag):
2995        AbstractGML.fromXML(self,csmlFrag)
2996        for frag in csmlFrag.getchildren():
2997            if frag.tag == CSML('UnitDefinitions'):
2998                self.unitDefinitions = UnitDefinitions()
2999                self.unitDefinitions.fromXML(frag)
3000            elif frag.tag == CSML('ReferenceSystemDefinitions'):
3001                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
3002                self.referenceSystemDefinitions.fromXML(frag)
3003            elif frag.tag == CSML('PhenomenonDefinitions'):
3004                self.phenomenonDefinitions = PhenomenonDefinitions()
3005                self.phenomenonDefinitions.fromXML(frag)
3006            elif frag.tag == GML('FeatureCollection'):
3007                self.featureCollection = FeatureCollection()
3008                self.featureCollection.fromXML(frag)
3009            elif frag.tag == CSML('AggregatedArray'):
3010                checkArrayAttrib(self,'arrayDescriptors')
3011                self.arrayDescriptors.append(AggregatedArray())
3012                self.arrayDescriptors[-1].fromXML(frag)
3013            elif frag.tag == CSML('InlineArray'):
3014                checkArrayAttrib(self,'arrayDescriptors')
3015                self.arrayDescriptors.append(InlineArray())
3016                self.arrayDescriptors[-1].fromXML(frag)
3017            elif frag.tag == CSML('ArrayGenerator'):
3018                checkArrayAttrib(self,'arrayDescriptors')
3019                self.arrayDescriptors.append(ArrayGenerator())
3020                self.arrayDescriptors[-1].fromXML(frag)
3021            elif frag.tag == CSML('NASAAmesExtract'):
3022                checkArrayAttrib(self,'arrayDescriptors')
3023                self.arrayDescriptors.append(NASAAmesExtract())
3024                self.arrayDescriptors[-1].fromXML(frag)
3025            elif frag.tag == CSML('NetCDFExtract'):
3026                checkArrayAttrib(self,'arrayDescriptors')
3027                self.arrayDescriptors.append(NetCDFExtract())
3028                self.arrayDescriptors[-1].fromXML(frag)
3029            elif frag.tag == CSML('GRIBExtract'):
3030                checkArrayAttrib(self,'arrayDescriptors')
3031                self.arrayDescriptors.append(GRIBExtract())
3032                self.arrayDescriptors[-1].fromXML(frag)
3033##            else:
3034##                raise Exception('Unexpected element: "'+frag.tag+'"')
3035    def toXML(self,csmlFrag=None):
3036        if csmlFrag is None:
3037            csmlFrag = Element('Dataset')
3038        csmlFrag = AbstractGML.toXML(self,csmlFrag)
3039        if hasattr(self,'unitDefinitions'):
3040            frag = Element(CSML('UnitDefinitions'))
3041            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
3042            csmlFrag.append(frag)
3043        if hasattr(self,'referenceSystemDefinitions'):
3044            frag = Element(CSML('ReferenceSystemDefinitions'))
3045            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
3046            csmlFrag.append(frag)
3047        if hasattr(self,'phenomenonDefinitions'):
3048            frag = Element(CSML('PhenomenonDefinitions'))
3049            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
3050            csmlFrag.append(frag)
3051        if hasattr(self,'arrayDescriptors'):
3052            for arrayDesc in self.arrayDescriptors:
3053                if isinstance(arrayDesc,AggregatedArray):
3054                    frag = Element(CSML('AggregatedArray'))
3055                    frag = AggregatedArray.toXML(arrayDesc,frag)
3056                elif isinstance(arrayDesc,InlineArray):
3057                    frag = Element(CSML('InlineArray'))
3058                    frag = InlineArray.toXML(arrayDesc,frag)
3059                elif isinstance(arrayDesc,ArrayGenerator):
3060                    frag = Element(CSML('ArrayGenerator'))
3061                    frag = ArrayGenerator.toXML(arrayDesc,frag)
3062                elif isinstance(arrayDesc,NASAAmesExtract):
3063                    frag = Element(CSML('NASAAmesExtract'))
3064                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
3065                elif isinstance(arrayDesc,NetCDFExtract):
3066                    frag = Element(CSML('NetCDFExtract'))
3067                    frag = NetCDFExtract.toXML(arrayDesc,frag)
3068                elif isinstance(arrayDesc,GRIBExtract):
3069                    frag = Element(CSML('GRIBExtract'))
3070                    frag = GRIBExtract.toXML(arrayDesc,frag)
3071                csmlFrag.append(frag)
3072        if hasattr(self,'featureCollection'):
3073            frag = Element(GML('FeatureCollection'))
3074            frag = FeatureCollection.toXML(self.featureCollection,frag)
3075            csmlFrag.append(frag)
3076            #csmlFrag=fixNameSpaces(csmlFrag)
3077        return csmlFrag
Note: See TracBrowser for help on using the repository browser.