source: TI02-CSML/trunk/parser/Parser.py @ 1433

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

fixing init method in ParametrisedPhenomenon class

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