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

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

Properly documented all classes in CSML parser for use with PyDoc?

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    pass
1667
1668class AbstractFileExtract(AbstractArrayDescriptor):
1669    """Base abstract clas for CSML file array extract
1670
1671    AbstractFileExtract(AbstractArrayDescriptor):
1672     +fileName: string
1673    """
1674    def __init__(self,fileName=None,*args,**kwargs):
1675        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1676        if fileName:
1677            self.fileName = fileName
1678    def fromXML(self,csmlFrag):
1679        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1680        for frag in csmlFrag.getchildren():
1681            if frag.tag == CSML('fileName'):
1682                self.fileName = frag.text
1683##        else:
1684##            raise Exception('Unexpected element: "'+frag.tag+'"')
1685    def toXML(self,csmlFrag):
1686        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1687        if hasattr(self,'fileName'):
1688            frag = Element(CSML('fileName'))
1689            frag.text = self.fileName
1690            csmlFrag.append(frag)
1691        return csmlFrag
1692
1693class NASAAmesExtract(AbstractFileExtract):
1694    """CSML class for NASA Ames file extract
1695
1696    NASAAmesExtract(AbstractFileExtract):
1697     +variableName: string
1698     +index[0..1]: int
1699    """
1700    def __init__(self,variableName=None,index=None,*args,**kwargs):
1701        AbstractFileExtract.__init__(self,*args,**kwargs)
1702        if variableName:
1703            self.variableName = variableName
1704        if index:
1705            self.index = index
1706    def fromXML(self,csmlFrag):
1707        AbstractFileExtract.fromXML(self,csmlFrag)
1708        for frag in csmlFrag.getchildren():
1709            if frag.tag == CSML('variableName'):
1710                self.variableName = frag.text
1711            elif frag.tag == CSML('index'):
1712                self.index = int(frag.text)
1713##            else:
1714##                raise Exception('Unexpected element: "'+frag.tag+'"')
1715    def toXML(self,csmlFrag):
1716        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1717        frag = Element(CSML('variableName'))
1718        frag.text = self.variableName
1719        csmlFrag.append(frag)
1720        if hasattr(self,'index'):
1721            frag = Element(CSML('index'))
1722            frag.text = str(self.index)
1723            csmlFrag.append(frag)
1724        return csmlFrag
1725
1726class NetCDFExtract(AbstractFileExtract):
1727    """CSML class for netCDF file extract
1728
1729    NetCDFExtract(AbstractFileExtract):
1730     +variableName: string
1731    """
1732    def __init__(self,variableName=None,*args,**kwargs):
1733        AbstractFileExtract.__init__(self,*args,**kwargs)
1734        if variableName:
1735            self.variableName = variableName
1736    def fromXML(self,csmlFrag):
1737        AbstractFileExtract.fromXML(self,csmlFrag)
1738        for frag in csmlFrag.getchildren():
1739            if frag.tag == CSML('variableName'):
1740                self.variableName = frag.text
1741##        else:
1742##            raise Exception('Unexpected element: "'+frag.tag+'"')
1743        checkMandatory(self, 'variableName')
1744    def toXML(self,csmlFrag):
1745        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1746        if hasattr(self, 'variableName'):
1747            frag = Element(CSML('variableName'))
1748            frag.text = self.variableName
1749            csmlFrag.append(frag)
1750        return csmlFrag
1751
1752class PPExtract(AbstractFileExtract):
1753    """CSML class for PPExtract file extract
1754    same as NetCDFExtract
1755    PPExtract(AbstractFileExtract):
1756     +variableName: string
1757    """
1758    def __init__(self,variableName=None,*args,**kwargs):
1759        AbstractFileExtract.__init__(self,*args,**kwargs)
1760        if variableName:
1761            self.variableName = variableName
1762    def fromXML(self,csmlFrag):
1763        AbstractFileExtract.fromXML(self,csmlFrag)
1764        for frag in csmlFrag.getchildren():
1765            if frag.tag == CSML('variableName'):
1766                self.variableName = frag.text
1767##        else:
1768##            raise Exception('Unexpected element: "'+frag.tag+'"')
1769        checkMandatory(self, 'variableName')
1770    def toXML(self,csmlFrag):
1771        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1772        if hasattr(self, 'variableName'):
1773            frag = Element(CSML('variableName'))
1774            frag.text = self.variableName
1775            csmlFrag.append(frag)
1776        return csmlFrag
1777       
1778class GRIBExtract(AbstractFileExtract):
1779    """CSML class for GRIB file extract
1780
1781    GRIBExtract(AbstractFileExtract):
1782     +parameterCode: int
1783     +recordNumber[0..1]: int
1784     +fileOffset[0..1]: int
1785     
1786     temporary addition of 'variableName' attribute
1787    """
1788    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, variableName=None, *args,**kwargs):
1789        AbstractFileExtract.__init__(self,*args,**kwargs)
1790        if parameterCode:
1791            self.parameterCode = parameterCode
1792        if recordNumber:
1793            self.recordNumber = recordNumber
1794        if fileOffset:
1795            self.fileOffset = fileOffset
1796        if variableName:
1797            self.variableName=variableName
1798    def fromXML(self,csmlFrag):
1799        AbstractFileExtract.fromXML(self,csmlFrag)
1800        for frag in csmlFrag.getchildren():
1801            if frag.tag == CSML('parameterCode'):
1802                self.parameterCode = int(frag.text)
1803            elif frag.tag == CSML('recordNumber'):
1804                self.recordNumber = int(frag.text)
1805            elif frag.tag == CSML('fileOffset'):
1806                self.fileOffset = int(frag.text)
1807            elif frag.tag == CSML('variableName'):
1808                self.variableName = frag.text
1809##            else:
1810##                raise Exception('Unexpected element: "'+frag.tag+'"')
1811    def toXML(self,csmlFrag):
1812        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1813        if hasattr(self,'parameterCode'):
1814            frag = Element(CSML('parameterCode'))
1815            frag.text = str(self.parameterCode)
1816            csmlFrag.append(frag)
1817        if hasattr(self,'recordNumber'):
1818            frag = Element(CSML('recordNumber'))
1819            frag.text = str(self.recordNumber)
1820            csmlFrag.append(frag)
1821        if hasattr(self,'fileOffset'):
1822            frag = Element(CSML('fileOffset'))
1823            frag.text = str(self.fileOffset)
1824            csmlFrag.append(frag)
1825        if hasattr(self,'variableName'):
1826            frag = Element(CSML('variableName'))
1827            frag.text = self.variableName
1828            csmlFrag.append(frag)
1829        return csmlFrag
1830
1831class DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup,SRSInformationGroup):
1832    """ DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup,SRSInformationGroup)
1833    +order[0..1]:string
1834    +vals[0..1]:string
1835    """
1836    def __init__(self, order=None, vals=None,*args,**kwargs):
1837        if order:
1838            self.order=order
1839        if vals:
1840            self.vals=vals
1841        AssociationAttributeGroup.__init__(self,*args,**kwargs)
1842        SRSReferenceGroup.__init__(self,*args,**kwargs)
1843        SRSInformationGroup.__init__(self,*args,**kwargs)
1844    def fromXML(self,csmlFrag):
1845        AssociationAttributeGroup.fromXML(self,csmlFrag)
1846        SRSReferenceGroup.fromXML(self,csmlFrag)
1847        SRSInformationGroup.fromXML(self,csmlFrag)       
1848        self.vals=csmlFrag.text
1849        if csmlFrag.attrib.has_key('order'):
1850            self.order=csmlFrag.attrib['order']
1851    def toXML(self,csmlFrag): 
1852        AssociationAttributeGroup.toXML(self,csmlFrag)
1853        SRSReferenceGroup.toXML(self,csmlFrag)
1854        SRSInformationGroup.toXML(self,csmlFrag)
1855        csmlFrag.text=self.vals
1856        if hasattr(self,'order'):
1857            csmlFrag.attrib['order']=self.order
1858        return csmlFrag
1859       
1860class MappingRule(MutableString):
1861    """Class representing a GML MappingRule element(string):
1862         MappingRule(MutableString)
1863         val[0..1]:string
1864         scanOrder[0..1]:string
1865    """
1866    def __init__(self,val='',scanOrder=None):
1867        if scanOrder:
1868            self.scanOrder=scanOrder
1869        MutableString.__init__(self,val)
1870    def fromXML(self,csmlFrag):
1871        self.data = csmlFrag.text
1872        if csmlFrag.attrib.has_key('scanOrder'):
1873            self.scanOrder=csmlFrag.attrib['scanOrder']
1874    def toXML(self,csmlFrag):
1875        csmlFrag.text = self.data
1876        if hasattr(self,'scanOrder'):
1877            csmlFrag.attrib['scanOrder']=self.scanOrder
1878        return csmlFrag
1879
1880   
1881class AbstractDiscreteCoverage(AbstractGML):
1882     
1883    """AbstractDiscreteCoverage(AbstractGML)
1884        +coverageFunction[0..1]:MappingRule
1885        +rangeSet[0..1]:RangeSet
1886    note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
1887    """
1888    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs):
1889        AbstractGML.__init__(self,*args,**kwargs)
1890        if rangeSet:
1891            self.rangeSet=rangeSet
1892        if coverageFunction:
1893            self.coverageFunction=coverageFunction
1894
1895    def fromXML(self,csmlFrag):
1896        AbstractGML.fromXML(self,csmlFrag)
1897        for frag in csmlFrag.getchildren():
1898            if frag.tag == GML('rangeSet'):
1899                self.rangeSet=RangeSet()
1900                self.rangeSet.fromXML(frag)
1901            if frag.tag == GML('coverageFunction'):
1902                self.coverageFunction=MappingRule()
1903                for subFrag in frag.getchildren():
1904                    if subFrag.tag==CSML('MappingRule'):
1905                        self.coverageFunction.fromXML(subFrag)
1906
1907
1908    def toXML(self,csmlFrag):
1909        AbstractGML.toXML(self,csmlFrag)
1910        if hasattr(self,'rangeSet'):
1911            frag = Element(GML('rangeSet'))
1912            RangeSet.toXML(self.rangeSet,frag)
1913            csmlFrag.append(frag)
1914        if hasattr(self,'coverageFunction'):
1915            frag = Element(GML('coverageFunction'))
1916            subFrag=Element(CSML('MappingRule'))
1917            MappingRule.toXML(self.coverageFunction,subFrag)
1918            frag.append(subFrag)
1919            csmlFrag.append(frag)
1920        return csmlFrag
1921       
1922class AbstractCoverageFeature(AbstractDiscreteCoverage):
1923    """ AbstractCoverageFeature(AbstractDiscreteCoverage)
1924         + om:parameter:PhenomenonPropertyType
1925    """
1926    def __init__(self, parameter=None, *args,**kwargs):
1927        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
1928        if parameter:
1929            self.parameter=parameter
1930    def fromXML(self,csmlFrag):
1931        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
1932        for frag in csmlFrag.getchildren():
1933            if frag.tag == CSML('parameter'):
1934                self.parameter=None
1935                if frag.getchildren() == []:
1936                    self.parameter=Phenomenon()
1937                    self.parameter.fromXML(frag)
1938                else:
1939                    subFrag=frag.getchildren()[0]
1940                    if subFrag.tag == OM('Phenomenon'):
1941                        self.parameter = Phenomenon()
1942                    elif subFrag.tag == OM('CompositePhenomenon'):
1943                        self.parameter = CompositePhenomenon()
1944                    elif subFrag.tag == OM('ParameterisedPhenomenon'):
1945                        self.parameter = ParameterisedPhenomenon()
1946                    self.parameter.fromXML(subFrag)
1947                       
1948    def toXML(self,csmlFrag):
1949        AbstractDiscreteCoverage.toXML(self,csmlFrag)
1950        if hasattr(self,'parameter'):
1951            frag = Element(CSML('parameter'))
1952            if isinstance(self.parameter,ParameterisedPhenomenon):
1953                subFrag=Element(OM('ParameterisedPhenomenon'))
1954                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
1955                frag.append(subFrag)
1956                csmlFrag.append(frag)
1957            elif isinstance(self.parameter,CompositePhenomenon):
1958                subFrag=Element(OM('CompositePhenomenon'))
1959                CompositePhenomenon.toXML(self.parameter,subFrag)
1960                frag.append(subFrag)
1961                csmlFrag.append(frag)
1962            elif isinstance(self.parameter,Phenomenon):
1963                Phenomenon.toXML(self.parameter,frag)
1964                subFrag=Element(OM('Phenomenon'))
1965                Phenomenon.toXML(self.parameter,subFrag)
1966                if subFrag.attrib != frag.attrib:
1967                    frag.append(subFrag)
1968                csmlFrag.append(frag)
1969               
1970               
1971                #frag.attrib[XLINK('href')] = self.href
1972
1973        return csmlFrag
1974
1975   
1976class AbstractStaticCoverageFeature(AbstractCoverageFeature):
1977    """AbstractStaticCoverageFeature(AbstractCoverageFeature)
1978    """
1979    def __init__(self,*args,**kwargs):
1980        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1981    def fromXML(self,csmlFrag):
1982        AbstractCoverageFeature.fromXML(self,csmlFrag)
1983    def toXML(self,csmlFrag):
1984        AbstractCoverageFeature.toXML(self,csmlFrag)
1985        return csmlFrag
1986   
1987class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
1988    """AbstractSeriesCoverageFeature(AbstractCoverageFeature)
1989    """
1990    def __init__(self,*args,**kwargs):
1991        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1992    def fromXML(self,csmlFrag):
1993        AbstractCoverageFeature.fromXML(self,csmlFrag)
1994    def toXML(self,csmlFrag):
1995        AbstractCoverageFeature.toXML(self,csmlFrag)
1996        return csmlFrag
1997   
1998class AbstractDomain:
1999    """AbstractDomain
2000    +domainReference[0..1]:_DomainReference
2001    +domainComplement [0...1]:_DomainComplement
2002    """
2003    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
2004        if domainReference:
2005            self.domainReference=domainReference
2006        if domainComplement:
2007            self.domainComplement=domainComplement
2008    def fromXML(self,csmlFrag):
2009        for frag in csmlFrag.getchildren():
2010            if frag.tag == CSML('domainReference'):
2011                subfrag=frag.getchildren()[0]
2012                if subfrag.tag==CSML('Position'):
2013                    self.domainReference=Position()
2014                elif subfrag.tag == CSML('Trajectory'):
2015                    self.domainReference=Trajectory()
2016                elif subfrag.tag==CSML('OrientedPosition'):
2017                    self.domainReference=OrientedPosition()
2018                elif subfrag.tag == CSML('OrientedTrajectory'):
2019                    self.domainReference=OrientedTrajectory()
2020                elif subfrag.tag == GML('TimeInstant'):
2021                    self.domainReference=TimeInstant()
2022                elif subfrag.tag == GML('TimePositionList'):
2023                    self.domainReference=TimePositionList()
2024                self.domainReference.fromXML(subfrag)
2025               
2026            if frag.tag == CSML('domainComplement'):
2027                subfrag=frag.getchildren()[0]
2028                if subfrag.tag==CSML('DirectPositionList'):
2029                    self.domainComplement=DirectPositionList()
2030                    self.domainComplement.fromXML(subfrag)
2031                elif subfrag.tag==CSML('Grid'):
2032                    self.domainComplement=Grid()
2033                    self.domainComplement.fromXML(subfrag)
2034    def toXML(self,csmlFrag):
2035        if hasattr(self,'domainReference'):
2036            frag = Element(CSML('domainReference'))
2037            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
2038            #self.domainReference.toXML(frag)
2039            if isinstance(self.domainReference,OrientedPosition):
2040                subFrag=Element(CSML('OrientedPosition'))
2041                self.domainReference.toXML(subFrag)
2042                frag.append(subFrag)
2043                csmlFrag.append(frag)
2044            elif isinstance(self.domainReference,OrientedTrajectory):
2045                subFrag=Element(CSML('OrientedTrajectory'))
2046                self.domainReference.toXML(subFrag)
2047                frag.append(subFrag)
2048                csmlFrag.append(frag)       
2049            elif isinstance(self.domainReference,Position):
2050                subFrag=Element(CSML('Position'))
2051                self.domainReference.toXML(subFrag)
2052                frag.append(subFrag)
2053                csmlFrag.append(frag)
2054            elif isinstance(self.domainReference,Trajectory):
2055                subFrag=Element(CSML('Trajectory'))
2056                self.domainReference.toXML(subFrag)
2057                frag.append(subFrag)
2058                csmlFrag.append(frag)
2059            elif isinstance(self.domainReference,TimeInstant):
2060                subFrag=Element(GML('TimeInstant'))
2061                self.domainReference.toXML(subFrag)
2062                frag.append(subFrag)
2063                csmlFrag.append(frag)
2064            elif isinstance(self.domainReference,TimePositionList):
2065                subFrag=Element(GML('TimePositionList'))
2066                self.domainReference.toXML(subFrag)
2067                frag.append(subFrag)
2068                csmlFrag.append(frag)   
2069        if hasattr(self,'domainComplement'):
2070            frag = Element(CSML('domainComplement'))
2071            if isinstance(self.domainComplement,DirectPositionList):
2072                    subFrag=Element(CSML('DirectPositionList'))
2073                    self.domainComplement.toXML(subFrag)
2074                    frag.append(subFrag)
2075                    csmlFrag.append(frag)
2076            elif isinstance(self.domainComplement,Grid):
2077                    subFrag=Element(CSML('Grid'))
2078                    self.domainComplement.toXML(subFrag)
2079                    frag.append(subFrag)
2080                    csmlFrag.append(frag)
2081        return csmlFrag
2082
2083
2084class EnvelopeWithTimePeriod:
2085    """ EnvelopeWithTimePeriod():
2086        +lowerCorner:DirectPosition
2087        +upperCorner:DirectPosition
2088        +gml:timePosition [2] ?
2089    """
2090       
2091    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
2092        if srsName:
2093            self.srsName=srsName
2094        if lowerCorner:
2095            self.lowerCorner=lowerCorner
2096        if upperCorner:
2097            self.upperCorner=upperCorner
2098        if timePosition:
2099            self.timePosition=timePosition
2100        if timePosition2:
2101            self.timePosition2=timePosition2
2102    def fromXML(self,csmlFrag):
2103        EnvTPfrag=csmlFrag.getchildren()[0]
2104        for frag in EnvTPfrag.getchildren():
2105            if frag.attrib.has_key('srsName'):
2106                self.srsName=frag.attrib['srsName']
2107            if frag.tag == GML('lowerCorner'):
2108                #self.lowerCorner=frag.text
2109                self.lowerCorner=DirectPosition()
2110                DirectPosition.fromXML(self.lowerCorner, frag)
2111            if frag.tag == GML('upperCorner'):
2112                #self.upperCorner=frag.text
2113                self.upperCorner=DirectPosition()
2114                DirectPosition.fromXML(self.upperCorner, frag)
2115            if frag.tag == GML('timePosition'):
2116                if hasattr(self, 'timePosition'):
2117                    self.timePosition2=frag.text
2118                else:
2119                    self.timePosition=frag.text
2120    def toXML(self,csmlFrag):
2121        if hasattr(self,'srsName'):
2122            csmlFrag.attrib['srsName'] = self.srsName
2123        if hasattr(self,'lowerCorner'):
2124            frag=Element(GML('lowerCorner'))
2125           # frag.text=self.lowerCorner
2126            DirectPosition.toXML(self.lowerCorner,frag)
2127            csmlFrag.append(frag)
2128        if hasattr(self,'upperCorner'):
2129            frag=Element(GML('upperCorner'))
2130            #frag.text=self.upperCorner
2131            DirectPosition.toXML(self.upperCorner,frag)
2132            csmlFrag.append(frag)
2133        if hasattr(self,'timePosition'):
2134            frag=Element(GML('timePosition'))
2135            frag.text=self.timePosition
2136            csmlFrag.append(frag)
2137        if hasattr(self,'timePosition2'):
2138            frag=Element(GML('timePosition'))
2139            frag.text=self.timePosition2
2140            csmlFrag.append(frag)
2141        return csmlFrag
2142
2143
2144       
2145class AngleList:
2146   
2147    """AngleList
2148    +uom[0..1]:anyURI
2149    +double[0...1]:string
2150    Note, should really inherit from MeasureList, but not implemented.
2151    """
2152    def __init__(self,uom=None, vals=None):
2153        if uom:
2154            self.uom=uom
2155        if vals:
2156            self.vals=vals
2157    def fromXML(self,csmlFrag):
2158        self.vals=csmlFrag.text
2159        if csmlFrag.attrib.has_key('uom'):
2160            self.uom = csmlFrag.attrib['uom']
2161        checkMandatory(self,'uom')
2162    def toXML(self, csmlFrag):
2163        if hasattr(self,'vals'):
2164            csmlFrag.text = self.vals
2165        if hasattr(self,'uom'):
2166            csmlFrag.attrib[('uom')] = self.uom
2167        return csmlFrag
2168       
2169class DirectionVectorList:
2170    """ DirectionVectorList
2171         +horizontalAngle[0..1]:AngleList
2172         +verticalAngle[0..1]:AngleList
2173    """
2174    def __init__(self, horizontalAngle=None, verticalAngle=None):
2175        if horizontalAngle:
2176            self.horizontalAngle=horizontalAngle
2177        if verticalAngle:
2178            self.verticalAngle=verticalAngle
2179    def fromXML(self, csmlFrag):
2180        for frag in csmlFrag.getchildren():
2181            if frag.tag==GML('horizontalAngle'):
2182                self.horizontalAngle=AngleList()
2183                AngleList.fromXML(self.horizontalAngle,frag)
2184            elif frag.tag==GML('verticalAngle'):
2185                self.verticalAngle=AngleList()
2186                AngleList.fromXML(self.verticalAngle,frag)
2187    def toXML(self,csmlFrag):
2188         if hasattr(self,'horizontalAngle'):
2189            frag = Element(GML('horizontalAngle'))
2190            AngleList.toXML(self.horizontalAngle,frag)
2191            csmlFrag.append(frag)
2192         if hasattr(self,'verticalAngle'):
2193            frag = Element(GML('verticalAngle'))
2194            AngleList.toXML(self.verticalAngle,frag)
2195            csmlFrag.append(frag)
2196         return csmlFrag
2197
2198       
2199class Position:
2200    """ Position
2201         +srsName[0..1]:string
2202         +axisLabels[0..1]:string
2203         +uomLabels[0..1]:string
2204         +location[0..1]:string
2205         +time[0..1]:string
2206    """
2207   
2208    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
2209        if srsName:
2210            self.srsName=srsName
2211        if axisLabels:
2212            self.axisLabels=axisLabels
2213        if uomLabels:
2214            self.uomLabels=uomLabels
2215        if location:
2216            self.location=location
2217        if time:
2218            self.time = time
2219    def fromXML(self,csmlFrag):
2220        if csmlFrag.attrib.has_key('srsName'):           
2221            self.srsName = csmlFrag.attrib['srsName']
2222        if csmlFrag.attrib.has_key('axisLabels'):
2223            self.axisLabels = csmlFrag.attrib['axisLabels']
2224            if csmlFrag.attrib.has_key('uomLabels'):
2225                self.uomLabels = csmlFrag.attrib['uomLabels']
2226        for frag in csmlFrag.getchildren():
2227            if frag.tag==CSML('location'):
2228                self.location=frag.text
2229            if frag.tag==CSML('time'):
2230                self.time=frag.text
2231    def toXML(self,csmlFrag):
2232        #subFrag = Element(CSML('Position'))
2233        if hasattr(self,'uomLabels'):
2234            csmlFrag.attrib['uomLabels'] = self.uomLabels
2235        if hasattr(self,'axisLabels'):
2236            csmlFrag.attrib['axisLabels'] = self.axisLabels
2237        if hasattr(self,'srsName'):
2238            csmlFrag.attrib['srsName'] = self.srsName
2239        if hasattr(self,'location'):
2240            frag = Element(CSML('location'))
2241            frag.text=self.location
2242            csmlFrag.append(frag)
2243        if hasattr(self,'time'):
2244            frag = Element(CSML('time'))
2245            frag.text=self.time
2246            csmlFrag.append(frag)
2247        return csmlFrag
2248
2249class OrientedPosition(Position):
2250    """OrientedPosition(Position)
2251        +direction[0..*]:DirectionVectorList
2252    """
2253    def __init__(self, direction=None, *args,**kwargs):
2254        Position.__init__(self, *args,**kwargs)
2255        if direction:
2256            self.direction=direction
2257    def fromXML(self,csmlFrag):
2258        Position.fromXML(self, csmlFrag)
2259        for frag in csmlFrag.getchildren():
2260            if frag.tag==CSML('direction'):
2261                self.direction=DirectionVectorList()
2262                DirectionVectorList.fromXML(self.direction,frag)
2263    def toXML(self, csmlFrag):
2264        Position.toXML(self,csmlFrag)
2265        if hasattr(self,'direction'):
2266            frag = Element(CSML('direction'))
2267            DirectionVectorList.toXML(self.direction,frag)
2268            csmlFrag.append(frag)
2269        return csmlFrag
2270       
2271
2272
2273class Trajectory(SRSReferenceGroup):
2274    """Trajectory(SRSReferenceGroup)
2275        +locations[0..*]:DirectPositionList
2276        +times[0..*]:TimePositionList
2277    """
2278    def __init__(self,locations=None,times=None,*args,**kwargs):
2279
2280        if locations:
2281            self.locations=locations
2282        if times:
2283            self.times = times
2284        SRSReferenceGroup.__init__(self,*args,**kwargs)
2285    def fromXML(self,csmlFrag):
2286        SRSReferenceGroup.fromXML(self,csmlFrag)
2287        for frag in csmlFrag.getchildren():
2288            if frag.tag==CSML('locations'):
2289                self.locations=DirectPositionList()
2290                DirectPositionList.fromXML(self.locations,frag)
2291            if frag.tag==CSML('times'):
2292                self.times=TimePositionList()
2293                TimePositionList.fromXML(self.times,frag)
2294    def toXML(self,csmlFrag):
2295        SRSReferenceGroup.toXML(self,csmlFrag)
2296        if hasattr(self,'srsName'):
2297            csmlFrag.attrib['srsName'] = self.srsName
2298        if hasattr(self,'locations'):
2299            frag = Element(CSML('locations'))
2300            frag=DirectPositionList.toXML(self.locations,frag)
2301            csmlFrag.append(frag)
2302        if hasattr(self,'times'):
2303            frag = Element(CSML('times'))
2304            TimePositionList.toXML(self.times, frag)
2305            csmlFrag.append(frag)
2306        return csmlFrag
2307
2308class OrientedTrajectory(Trajectory):
2309    """ OrientedTrajectory(Trajectory)
2310        +direction[0..*]:DirectionVectorList
2311    """
2312    def __init__(self, direction=None, *args,**kwargs):
2313        Trajectory.__init__(self, *args,**kwargs)
2314        if direction:
2315             self.direction=direction
2316    def fromXML(self,csmlFrag):
2317        Trajectory.fromXML(self, csmlFrag)
2318        for frag in csmlFrag.getchildren():
2319            if frag.tag==CSML('direction'):
2320                self.direction=DirectionVectorList()
2321                DirectionVectorList.fromXML(self.direction,frag)
2322    def toXML(self, csmlFrag):
2323        Trajectory.toXML(self,csmlFrag)
2324        if hasattr(self,'direction'):
2325            frag = Element(CSML('direction'))
2326            DirectionVectorList.toXML(self.direction,frag)
2327            csmlFrag.append(frag)
2328        return csmlFrag
2329
2330class AbstractGeometryType(AbstractGML):
2331    """AbstractGeometryType(AbstractGML)
2332        +low[0..1]:string
2333        +high[0..1]:string
2334    """
2335    def __init__(self, low=None, high=None):
2336        AbstractGML.__init__(self)
2337        if low:
2338            self.low=low
2339        if high:
2340            self.high=high
2341    def fromXML(self, csmlFrag):
2342        AbstractGML.fromXML(self,csmlFrag)
2343    def toXML(self,csmlFrag):
2344        AbstractGML.toXML(self,csmlFrag)
2345        return csmlFrag
2346
2347class GridEnvelope:
2348    """GridEnvelope
2349        +low[0..1]:string
2350        +high[0..1]:string
2351    """
2352    def __init__(self, low=None, high = None):
2353        if low:
2354            self.low = low
2355        if high:
2356            self.high = high
2357    def fromXML(self, csmlFrag):
2358        frag = csmlFrag.getchildren()[0]
2359        for subFrag in frag.getchildren():
2360            if subFrag.tag == GML('low'):
2361                self.low=subFrag.text
2362            elif subFrag.tag == GML('high'):
2363                self.high=subFrag.text
2364    def toXML(self,csmlFrag):
2365        if hasattr(self, 'low'):
2366            frag=Element(GML('low'))
2367            frag.text=self.low
2368            csmlFrag.append(frag)
2369        if hasattr(self, 'high'):
2370            frag=Element(GML('high'))
2371            frag.text=self.high
2372            csmlFrag.append(frag)
2373        return csmlFrag
2374
2375class GmlGrid(AbstractGeometryType):
2376    """GmlGrid, representing a gml:Grid element.
2377        GmlGrid(): 
2378        +dimension positiveInteger [1]
2379        +limits[0..1]:GridLimits
2380        +axisNames[1..*]:string
2381    """
2382    def __init__(self,dimension=None,limits=None,axisNames=None):
2383        AbstractGeometryType.__init__(self)
2384        if dimension:
2385            self.dimension=dimension
2386        if limits:
2387            self.limits=limits
2388        if axisNames:
2389            self.axisNames=axisNames
2390    def fromXML(self, csmlFrag):
2391        AbstractGeometryType.fromXML(self,csmlFrag)
2392        for frag in csmlFrag.getchildren():
2393            if frag.tag == GML('limits'):
2394                self.limits=GridEnvelope()
2395                GridEnvelope.fromXML(self.limits,frag)
2396            elif frag.tag == GML('axisName'):
2397                checkArrayAttrib(self,'axisNames')
2398                self.axisNames.append(frag.text)
2399    def toXML(self,csmlFrag):
2400        AbstractGeometryType.toXML(self,csmlFrag)
2401        if hasattr(self, 'limits'):
2402            frag=Element(GML('limits'))
2403            subFrag =Element(GML('GridEnvelope'))
2404            GridEnvelope.toXML(self.limits, subFrag)
2405            frag.append(subFrag)
2406            csmlFrag.append(frag)
2407        if hasattr(self, 'axisNames'):
2408            for axis in self.axisNames:
2409                frag=Element(GML('axisName'))
2410                frag.text =axis
2411                csmlFrag.append(frag)
2412        return csmlFrag
2413           
2414class GridOrdinateDescription:
2415    """GridOrdinateDescription:
2416        +gridAxesSpanned[0..*]:string
2417        +sequenceRule[0..1]:string
2418        +definesAxis[0..*]:string
2419        +axisValues: string or AbstractFileExtract
2420    """
2421    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
2422        if gridAxesSpanned:
2423            self.gridAxesSpanned=gridAxesSpanned
2424        if sequenceRule:
2425            self.sequenceRule=sequenceRule
2426        if definesAxis:
2427            self.definesAxis=definesAxis
2428            if href:
2429                self.href = href
2430        if axisValues:
2431            self.axisValues=axisValues
2432       
2433    def fromXML(self,csmlFrag):
2434        for frag in csmlFrag.getchildren():
2435            if frag.tag ==CSML('gridAxesSpanned'):
2436                self.gridAxesSpanned=frag.text
2437            elif frag.tag ==CSML('sequenceRule'):
2438                self.sequenceRule=frag.text
2439            elif frag.tag ==CSML('definesAxis'):
2440                self.definesAxis=frag.text
2441                if frag.attrib.has_key(XLINK('href')):
2442                        self.href = frag.attrib[XLINK('href')]
2443            elif frag.tag ==CSML('axisValues'):
2444                if frag.getchildren() !=[]:
2445                    subFrag= frag.getchildren()[0]
2446                    if subFrag.tag == CSML ('NetCDFExtract'):
2447                        self.axisValues=NetCDFExtract()
2448                        NetCDFExtract.fromXML(self.axisValues, subFrag)
2449                    elif subFrag.tag == CSML ('NASAAmesExtract'):
2450                        self.axisValues=NASAAmesExtract()
2451                        NASAAmesExtract.fromXML(self.axisValues, subFrag)
2452                    elif subFrag.tag == CSML ('GRIBExtract'):
2453                        self.axisValues=GRIBExtract()
2454                        GRIBExtract.fromXML(self.axisValues, subFrag)
2455                    elif subFrag.tag == CSML ('PPExtract'):
2456                        self.axisValues=PPExtract()
2457                        PPExtract.fromXML(self.axisValues, subFrag)
2458                else:
2459                    self.axisValues=frag.text
2460                   
2461               
2462    def toXML(self, csmlFrag):
2463        if hasattr(self, 'gridAxesSpanned'):
2464            frag=Element(CSML('gridAxesSpanned'))
2465            frag.text = self.gridAxesSpanned
2466            csmlFrag.append(frag)
2467        if hasattr(self, 'sequenceRule'):
2468            frag=Element(CSML('sequenceRule'))
2469            frag.text = self.sequenceRule
2470            csmlFrag.append(frag)
2471        if hasattr(self, 'definesAxis'):
2472            frag=Element(CSML('definesAxis'))
2473            frag.text = self.definesAxis
2474            if hasattr(self, 'href'):
2475                frag.attrib[XLINK('href')] = self.href
2476            csmlFrag.append(frag)
2477        if hasattr(self, 'axisValues'):
2478            frag=Element(CSML('axisValues'))
2479            if isinstance(self.axisValues,NetCDFExtract):
2480                subFrag=Element(CSML('NetCDFExtract'))
2481                NetCDFExtract.toXML(self.axisValues,subFrag)
2482                frag.append(subFrag)
2483            elif isinstance(self.axisValues,NASAAmesExtract):
2484                subFrag=Element(CSML('NASAAmesExtract'))
2485                NASAAmesExtract.toXML(self.axisValues,subFrag)
2486                frag.append(subFrag)
2487            elif isinstance(self.axisValues,GRIBExtract):
2488                subFrag=Element(CSML('GRIBExtract'))
2489                GRIBExtract.toXML(self.axisValues,subFrag)
2490                frag.append(subFrag)
2491            elif isinstance(self.axisValues,PPExtract):
2492                subFrag=Element(CSML('PPExtract'))
2493                PPExtract.toXML(self.axisValues,subFrag)
2494                frag.append(subFrag)
2495            else:
2496                frag.text = self.axisValues
2497            csmlFrag.append(frag)
2498        return csmlFrag
2499
2500
2501class Grid(GmlGrid):
2502    """#Class GmlGrid representing a gml:Grid
2503    Grid(GmlGrid)
2504    +srsName[0..1]:string
2505    +srsdimension[0..1]:string
2506    +dimension[0..1]:string
2507    +ordinates [0..1]:GridOrdinateDescription
2508    """
2509
2510    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
2511        GmlGrid.__init__(self)
2512        if srsName:
2513            self.srsName=srsName
2514        if srsDimension:
2515            self.srsDimension=srsDimension
2516        if dimension:
2517            self.dimension=dimension
2518        if ordinates:
2519            self.ordinates=ordinates
2520    def fromXML(self, csmlFrag):
2521        GmlGrid.fromXML(self,csmlFrag)
2522        if csmlFrag.attrib.has_key('srsName'):
2523            self.srsName = csmlFrag.attrib['srsName']
2524        if csmlFrag.attrib.has_key('srsDimension'):
2525            self.srsDimension = csmlFrag.attrib['srsDimension']
2526        if csmlFrag.attrib.has_key('dimension'):
2527            self.dimension = csmlFrag.attrib['dimension']
2528        for frag in csmlFrag:
2529            if frag.tag==CSML('ordinate'):
2530                checkArrayAttrib(self,'ordinates')
2531                ordinate=GridOrdinateDescription()
2532                GridOrdinateDescription.fromXML(ordinate, frag)
2533                self.ordinates.append(ordinate)
2534    def toXML(self,csmlFrag):
2535        GmlGrid.toXML(self,csmlFrag)
2536        if hasattr(self, 'srsName'):
2537            csmlFrag.attrib['srsName'] = self.srsName
2538        if hasattr(self, 'srsDimension'):
2539            csmlFrag.attrib['srsDimension'] = self.srsDimension
2540        if hasattr(self, 'dimension'):
2541            csmlFrag.attrib['dimension'] = self.dimension
2542       
2543        if hasattr(self, 'ordinates'):
2544            for ordinate in self.ordinates:
2545                frag=Element(CSML('ordinate'))
2546                GridOrdinateDescription.toXML(ordinate, frag)
2547                csmlFrag.append(frag)
2548        return csmlFrag
2549
2550class TimeInstant:
2551    """TimeInstant
2552    +timePosition[0..1]:string
2553    """
2554    def __init__(self, timePosition=None):
2555        if timePosition:
2556            self.timePosition=timePosition
2557    def fromXML(self,csmlFrag):
2558        for frag in csmlFrag.getchildren():
2559            if frag.tag==GML('timePosition'):
2560                self.timePosition=frag.text
2561    def toXML(self,csmlFrag):
2562         if hasattr(self,'timePosition'):
2563            frag = Element(GML('timePosition'))
2564            frag.text=self.timePosition
2565            csmlFrag.append(frag)
2566         return csmlFrag
2567
2568class TimePositionList(AssociationAttributeGroup):
2569    """TimePositionList(AssociationAttributeGroup)
2570        +frame[0..1]:anyURI
2571        +calendarEraName [0..1]:string (not implemented)
2572        +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType  (not implemented)
2573    """   
2574    def __init__(self, frame=None, timePositions=None,*args, **kwargs):
2575        if frame:
2576            self.frame=frame
2577        if timePositions:
2578            self.timePositions=timePositions
2579        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2580    def fromXML(self,csmlFrag):
2581        self.timePositions=csmlFrag.text
2582        if csmlFrag.attrib.has_key('frame'):
2583            self.frame = csmlFrag.attrib['frame']
2584        AssociationAttributeGroup.fromXML(self,csmlFrag)
2585    def toXML(self,csmlFrag):
2586         if hasattr(self,'timePositions'):
2587            if  isinstance(self.timePositions, NASAAmesExtract):
2588                subFrag=Element(CSML('NASAAmesExtract'))
2589                NASAAmesExtract.toXML(self.timePositions,subFrag)
2590                csmlFrag.append(subFrag)
2591            elif  isinstance(self.timePositions, NetCDFExtract):
2592                subFrag=Element(CSML('NetCDFExtract'))
2593                NetCDFExtract.toXML(self.timePositions,subFrag)
2594                csmlFrag.append(subFrag)
2595            elif  isinstance(self.timePositions, GRIBExtract):
2596                subFrag=Element(CSML('GRIBExtract'))
2597                GRIBExtract.toXML(self.timePositions,subFrag)
2598                csmlFrag.append(subFrag)
2599            elif  isinstance(self.timePositions, PPExtract):
2600                subFrag=Element(CSML('PPExtract'))
2601                PPExtract.toXML(self.timePositions,subFrag)
2602                csmlFrag.append(subFrag)
2603            else:
2604                csmlFrag.text=self.timePositions
2605         if hasattr(self,'frame'):
2606             csmlFrag.attrib['frame']=self.frame
2607         AssociationAttributeGroup.toXML(self,csmlFrag)
2608         return csmlFrag
2609             
2610class Measure:
2611    """ Measure
2612        +uom[0..1]:anyURI
2613        +vals[0..1]:string
2614    """
2615    def __init__(self, uom=None, vals=None):
2616        if uom:
2617            self.uom=uom
2618        if vals:
2619            self.vals=vals
2620    def fromXML(self,csmlFrag):
2621        self.vals=csmlFrag.text
2622        if csmlFrag.attrib.has_key('uom'):
2623            self.uom = csmlFrag.attrib['uom']
2624    def toXML(self, csmlFrag):
2625        frag = Element(GML('measure'))
2626        if hasattr(self, 'vals'):
2627            frag.text = self.vals
2628        if hasattr(self,'uom'):
2629            frag.attrib[('uom')] = self.uom
2630        csmlFrag.append(frag)
2631        return csmlFrag
2632
2633class MeasureOrNullList:
2634    """MeasureOrNullList:
2635    +uom[0..1]:anyURI
2636    #Actually based on doubleOrNullList, but not modelled to that level of detail.
2637    """
2638    def __init__(self, uom=None, val=None):
2639        if uom:
2640            self.uom=uom
2641        if val:
2642            self.val=val
2643    def fromXML(self,csmlFrag):
2644        self.val=csmlFrag.text
2645        if csmlFrag.attrib.has_key('uom'):
2646            self.uom = csmlFrag.attrib['uom']
2647    def toXML(self, csmlFrag):
2648        if hasattr(self,'val'):
2649            if  isinstance(self.val, NASAAmesExtract):
2650                subFrag=Element(CSML('NASAAmesExtract'))
2651                NASAAmesExtract.toXML(self.val,subFrag)
2652                csmlFrag.append(subFrag)
2653            elif  isinstance(self.val, NetCDFExtract):
2654                subFrag=Element(CSML('NetCDFExtract'))
2655                NetCDFExtract.toXML(self.val,subFrag)
2656                csmlFrag.append(subFrag)
2657            elif  isinstance(self.val, GRIBExtract):
2658                subFrag=Element(CSML('GRIBExtract'))
2659                GRIBExtract.toXML(self.val,subFrag)
2660                csmlFrag.append(subFrag)
2661            elif  isinstance(self.val, PPExtract):
2662                subFrag=Element(CSML('PPExtract'))
2663                PPExtract.toXML(self.val,subFrag)
2664                csmlFrag.append(subFrag)
2665            else:
2666                csmlFrag.text = self.val
2667        if hasattr(self,'uom'):
2668           csmlFrag.attrib[('uom')] = self.uom
2669        return csmlFrag
2670   
2671class CompositeValue:
2672    """ CompositeValue
2673        +valueComponents[0..*]:Measure
2674    """
2675    def __init__(self, valueComponents=None):
2676        if valueComponents:
2677            self.valueComponents=valueComponents
2678    def fromXML(self,csmlFrag):
2679        for frag in csmlFrag.getchildren():
2680            if frag.tag == GML('valueComponents'):
2681                self.valueComponents = []
2682                for subFrag in frag.getchildren():                   
2683                    if subFrag.tag == GML('measure'):
2684                        self.valueComponents.append(Measure())
2685                        self.valueComponents[-1].fromXML(subFrag)
2686
2687    def toXML(self, csmlFrag):
2688         if hasattr(self,'valueComponents'):
2689            frag=Element(GML('valueComponents'))
2690            for valueComponent in self.valueComponents:
2691                if isinstance(valueComponent,Measure):
2692                    subFrag=Element(GML('measure'))
2693                    Measure.toXML(valueComponent,subFrag)
2694                    frag.append(subFrag)
2695            csmlFrag.append(frag)
2696         return csmlFrag
2697   
2698
2699   
2700class DataBlock:
2701    """class GML DataBlock
2702   
2703    DataBlock()
2704    +rangeParameters[0..*]:string
2705    +doubleOrNullTupleList[0..*]:string
2706    """
2707    def __init__(self,rangeParameters=None, doubleOrNullTupleList=None):
2708        if rangeParameters:
2709            self.rangeParameters=rangeParameters
2710        if doubleOrNullTupleList:
2711            self.doubleOrNullTupleList=doubleOrNullTupleList
2712    def fromXML(self,csmlFrag):
2713        for frag in csmlFrag.getchildren():
2714            if frag.tag == GML('rangeParameters'):
2715                for subFrag in frag.getchildren():
2716                    if subFrag.tag==GML('CompositeValue'):
2717                        self.rangeParameters=CompositeValue()
2718                        CompositeValue.fromXML(self.rangeParameters,subFrag)
2719            if frag.tag == GML('doubleOrNullTupleList'):
2720                self.doubleOrNullTupleList=frag.text
2721    def toXML(self,csmlFrag):
2722        if hasattr(self, 'rangeParameters'):
2723            frag=Element(GML('rangeParameters'))
2724            subFrag=Element(GML('CompositeValue'))
2725            CompositeValue.toXML(self.rangeParameters, subFrag)
2726            frag.append(subFrag)
2727            csmlFrag.append(frag)
2728        if hasattr(self,'doubleOrNullTupleList'):
2729            frag=Element(GML('doubleOrNullTupleList'))
2730            frag.text=self.doubleOrNullTupleList
2731            csmlFrag.append(frag)
2732        return csmlFrag
2733
2734
2735
2736class TypedCategory:
2737    """class om:TypedCategory
2738        TypedCategory
2739         +axis[0..1]:anyURI
2740        + codeSpace[0..1]:anyURI
2741    """
2742    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
2743        if axis:
2744            self.axis=axis
2745        if codeSpace:
2746            self.codeSpace=codeSpace
2747        if text:
2748            self.text=text
2749    def fromXML(self,csmlFrag):
2750        if csmlFrag.attrib.has_key('axis'):
2751            self.axis=csmlFrag.attrib['axis']
2752        if csmlFrag.attrib.has_key('codeSpace'):
2753            self.codeSpace=csmlFrag.attrib['codeSpace']
2754        self.text=csmlFrag.text
2755    def toXML(self,csmlFrag):
2756        if hasattr(self,'axis'):
2757            csmlFrag.attrib[('axis')] =self.axis
2758        if hasattr(self,'codeSpace'):
2759            csmlFrag.attrib[('codeSpace')] =self.codeSpace
2760        csmlFrag.text=self.text
2761        return csmlFrag
2762
2763class Phenomenon(Definition,AssociationAttributeGroup):
2764    """class Obs& Measures: PhenomenonProperty
2765        Phenomenon(Definition,AssociationAttributeGroup)
2766    """
2767    #Note, in this does not really inherit from AbstractGML, but for CMSL
2768    #purposes it is used  to pick up the basic description, id, name attributes
2769    def __init__(self,*args,**kwargs):
2770         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
2771        self.MetaDataProperty=None
2772        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
2773        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2774    def fromXML(self,csmlFrag):
2775        Definition.fromXML(self,csmlFrag)
2776        AssociationAttributeGroup.fromXML(self,csmlFrag)
2777       
2778    def toXML(self,csmlFrag):
2779        csmlFrag=Definition.toXML(self,csmlFrag)
2780        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2781        return csmlFrag
2782
2783
2784class CompositePhenomenon(Phenomenon):
2785    """ CompositePhenomenon(Phenomenon)
2786        +componentPhenomena [1...*]:Phenomenon
2787    """
2788    def __init__(self,componentPhenomena=None,*args,**kwargs):
2789        Phenomenon.__init__(self,*args,**kwargs)
2790        if componentPhenomena:
2791            self.componentPhenomena=componentPhenomena
2792    def fromXML(self,csmlFrag):
2793        Phenomenon.fromXML(self,csmlFrag)
2794        self.componentPhenomena=[]
2795        for frag in csmlFrag.getchildren():
2796            if frag.tag == OM('componentPhenomenon'):
2797                componentPhenomenon=Phenomenon()
2798                Phenomenon.fromXML(componentPhenomenon,frag)
2799                self.componentPhenomena.append(componentPhenomenon)
2800    def toXML(self,csmlFrag):
2801        Phenomenon.toXML(self,csmlFrag)
2802        if hasattr(self, 'componentPhenomena'):
2803            for phenomenon in self.componentPhenomena:
2804                frag=Element(OM('componentPhenomenon'))
2805                Phenomenon.toXML(phenomenon,frag)
2806                csmlFrag.append(frag)
2807        return csmlFrag
2808           
2809               
2810class ParameterisedPhenomenon(Phenomenon):
2811    """Class ParameterisedPhenomenon:
2812        +basePhenomenon[0..1]
2813         + constraint[0..1]:string
2814         + href[0..1]:anyURI
2815    """
2816    def __init__(self,*args,**kwargs):
2817        Phenomenon.__init__(self,*args,**kwargs)
2818    def fromXML(self,csmlFrag):
2819        Phenomenon.fromXML(self,csmlFrag)
2820        for frag in csmlFrag.getchildren():
2821            if frag.tag == OM('basePhenomenon'):
2822                self.basePhenomenon=frag.text
2823                if frag.attrib.has_key(XLINK('href')):
2824                    self.href = frag.attrib[XLINK('href')]
2825            if frag.tag == OM('constraint'):
2826                subFrag=frag.getchildren()[0]
2827                if subFrag.tag== OM('TypedCategory'):
2828                    self.constraint = TypedCategory()
2829                #TO DO: what other types are valid?
2830                elif subFrag.tag== OM('??'):
2831                    self.constraint = 123
2832                self.constraint.fromXML(subFrag)
2833    def toXML(self,csmlFrag):
2834        csmlFrag=Phenomenon.toXML(self,csmlFrag)
2835        if hasattr(self,'basePhenomenon'):
2836            frag=Element(OM('basePhenomenon'))
2837            frag.text=self.basePhenomenon
2838            if hasattr(self, 'href'):
2839                frag.attrib[XLINK('href')] = self.href
2840            csmlFrag.append(frag)
2841        if hasattr(self, 'constraint'):
2842            frag=Element(OM('constraint'))
2843            subFrag=Element(OM('TypedCategory'))
2844            subFrag=self.constraint.toXML(subFrag)
2845            frag.append(subFrag)
2846            csmlFrag.append(frag)
2847        return csmlFrag
2848
2849class RangeSet(AssociationAttributeGroup):
2850    """class GML RangeSet 
2851
2852         RangeSet()
2853        +quantityList[0..1]:MeasureOrNullList
2854        +dataBlock[0..1]:DataBlock
2855        +arrayDescriptor[0..1]:arrayDescriptor
2856        +aggregatedArray[0..1]:AggregatedArray
2857    """
2858   
2859    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None,*args,**kwargs):
2860        if quantityList:
2861            self.quantityList=quantityList
2862        if dataBlock:
2863            self.dataBlock=dataBlock
2864        if arrayDescriptor:
2865            self.arrayDescriptor=arrayDescriptor
2866        if aggregatedArray:
2867            self.aggregatedArray=aggregatedArray
2868        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2869           
2870    def fromXML(self,csmlFrag):
2871        for frag in csmlFrag.getchildren():
2872            if frag.tag==GML('QuantityList'):
2873                self.quantityList=MeasureOrNullList()
2874                MeasureOrNullList.fromXML(self.quantityList,frag)
2875            elif frag.tag==GML('DataBlock'):
2876                self.dataBlock=DataBlock()
2877                DataBlock.fromXML(self.dataBlock, frag)
2878            elif frag.tag == CSML('NetCDFExtract'):
2879                self.arrayDescriptor=NetCDFExtract()
2880                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
2881            elif frag.tag == CSML('NASAmesExtract'):
2882                self.arrayDescriptor=NASAAmesExtract()
2883                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
2884            elif frag.tag == CSML('GRIBExtract'):
2885                self.arrayDescriptor=GRIBExtract()
2886                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
2887            elif frag.tag == CSML('PPExtract'):
2888                self.arrayDescriptor=PPExtract()
2889                PPExtract.fromXML(self.ArrayDescriptor,frag)
2890            elif frag.tag == CSML('AggregatedArray'):
2891                self.aggregatedArray=AggregatedArray()
2892                AggregatedArray.fromXML(self.aggregatedArray,frag)
2893        AssociationAttributeGroup.fromXML(self,csmlFrag)
2894
2895    def toXML(self, csmlFrag):
2896        if hasattr(self,'quantityList'):
2897            frag = Element(GML('QuantityList'))
2898            MeasureOrNullList.toXML(self.quantityList,frag)
2899            csmlFrag.append(frag)
2900        if hasattr(self,'dataBlock'):
2901            frag=Element(GML('DataBlock'))
2902            DataBlock.toXML(self.dataBlock,frag)
2903            csmlFrag.append(frag)
2904        if hasattr(self,'aggregatedArray'):
2905            frag=Element(CSML('AggregatedArray'))
2906            AggregatedArray.toXML(self.aggregatedArray,frag)
2907            csmlFrag.append(frag)
2908        if hasattr(self,'arrayDescriptor'):
2909            if isinstance(self.arrayDescriptor,NetCDFExtract):
2910                frag=Element(CSML('NetCDFExtract'))
2911                NetCDFExtract.toXML(self.arrayDescriptor,frag)
2912                csmlFrag.append(frag)
2913            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
2914                frag=Element(CSML('NASAAmesExtract'))
2915                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
2916                csmlFrag.append(frag)
2917            elif isinstance(self.arrayDescriptor,GRIBExtract):
2918                frag=Element(CSML('GRIBExtract'))
2919                GRIBExtract.toXML(self.arrayDescriptor,frag)
2920                csmlFrag.append(frag)
2921            elif isinstance(self.arrayDescriptor,PPExtract):
2922                frag=Element(CSML('PPExtract'))
2923                PPAmesExtract.toXML(self.arrayDescriptor,frag)
2924                csmlFrag.append(frag)
2925        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2926        return csmlFrag
2927
2928class PointDomain(AbstractDomain):
2929    """ PointDomain(AbstractDomain)
2930    """
2931    def __init__(self,*args,**kwargs):
2932        AbstractDomain.__init__(self,*args,**kwargs)
2933    def fromXML(self,csmlFrag):
2934        AbstractDomain.fromXML(self,csmlFrag)
2935    def toXML(self,csmlFrag):
2936        AbstractDomain.toXML(self,csmlFrag)
2937        return csmlFrag
2938   
2939class ProfileDomain(AbstractDomain):
2940    """ ProfileDomain(AbstractDomain)
2941    """
2942    def __init__(self,*args,**kwargs):
2943        AbstractDomain.__init__(self,*args,**kwargs)
2944    def fromXML(self,csmlFrag):
2945        AbstractDomain.fromXML(self,csmlFrag)
2946    def toXML(self,csmlFrag):
2947        AbstractDomain.toXML(self,csmlFrag)
2948        return csmlFrag
2949
2950class GridDomain(AbstractDomain):
2951    """ GridDomain(AbstractDomain)
2952    """
2953    def __init__(self,*args,**kwargs):
2954        AbstractDomain.__init__(self,*args,**kwargs)
2955    def fromXML(self,csmlFrag):
2956        AbstractDomain.fromXML(self,csmlFrag)
2957    def toXML(self,csmlFrag):
2958        AbstractDomain.toXML(self,csmlFrag)
2959        return csmlFrag
2960   
2961class PointSeriesDomain(AbstractDomain):
2962    """ PointSeriesDomain(AbstractDomain)
2963    """
2964    def __init__(self,*args,**kwargs):
2965        AbstractDomain.__init__(self,*args,**kwargs)
2966    def fromXML(self,csmlFrag):
2967        AbstractDomain.fromXML(self,csmlFrag)
2968    def toXML(self,csmlFrag):
2969        AbstractDomain.toXML(self,csmlFrag)
2970        return csmlFrag
2971   
2972class ProfileSeriesDomain(AbstractDomain):
2973    """ ProfileSeriesDomain(AbstractDomain)
2974    """
2975    def __init__(self,*args,**kwargs):
2976        AbstractDomain.__init__(self,*args,**kwargs)
2977    def fromXML(self,csmlFrag):
2978        AbstractDomain.fromXML(self,csmlFrag)
2979    def toXML(self,csmlFrag):
2980        AbstractDomain.toXML(self,csmlFrag)
2981        return csmlFrag
2982   
2983class GridSeriesDomain(AbstractDomain):
2984    """ GridSeriesDomain(AbstractDomain)
2985    """
2986    def __init__(self,*args,**kwargs):
2987        AbstractDomain.__init__(self,*args,**kwargs)
2988    def fromXML(self,csmlFrag):
2989        AbstractDomain.fromXML(self,csmlFrag)
2990    def toXML(self,csmlFrag):
2991        AbstractDomain.toXML(self,csmlFrag)
2992        return csmlFrag
2993
2994class PointFeature(AbstractStaticCoverageFeature):
2995    """PointFeature(AbstractStaticCoverageFeature)
2996        +domain[0..1]:PointDomain
2997    """
2998    def __init__(self, domain=None,*args,**kwargs):
2999        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3000        if domain:
3001            self.domain=domain
3002    def __str__(self):
3003        return 'PointFeature'
3004    def fromXML(self,csmlFrag):
3005        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3006        for frag in csmlFrag.getchildren():
3007            if frag.tag == CSML('PointDomain'):
3008                self.domain = PointDomain()
3009                self.domain.fromXML(frag)
3010    def toXML(self,csmlFrag):
3011        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3012        if hasattr(self,'domain'):
3013            frag = Element(CSML('PointDomain'))
3014            PointDomain.toXML(self.domain,frag)
3015#             if hasattr(self,'href'):
3016#                 frag.attrib[XLINK('href')] = self.href
3017            csmlFrag.append(frag)
3018        return csmlFrag
3019
3020   
3021class PointSeriesFeature(AbstractSeriesCoverageFeature):
3022    """PointFeature(AbstractStaticCoverageFeature)
3023        +domain[0..1]:PointSeriesDomain
3024    """
3025
3026    def __init__(self,domain=None,*args,**kwargs):
3027        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
3028        if domain:
3029            self.domain=domain
3030    def __str__(self):
3031        return 'PointSeriesFeature'
3032    def fromXML(self,csmlFrag):
3033        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
3034        for frag in csmlFrag.getchildren():
3035            if frag.tag == CSML('PointSeriesDomain'):
3036                self.domain = PointSeriesDomain()
3037                self.domain.fromXML(frag)
3038    def toXML(self,csmlFrag):
3039        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
3040        if hasattr(self,'domain'):
3041             frag = Element(CSML('PointSeriesDomain'))
3042             PointSeriesDomain.toXML(self.domain,frag)
3043             csmlFrag.append(frag)
3044        return csmlFrag
3045
3046class ProfileFeature(AbstractStaticCoverageFeature):
3047    """ProfileFeature(AbstractStaticCoverageFeature)
3048        +domain[0..1]:ProfileDomain
3049    """
3050    def __init__(self,domain=None,*args,**kwargs):
3051        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3052        if domain:
3053            self.domain=domain
3054    def __str__(self):
3055        return 'ProfileFeature'
3056    def fromXML(self,csmlFrag):
3057        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3058        for frag in csmlFrag.getchildren():
3059            if frag.tag == CSML('ProfileDomain'):
3060                self.domain = ProfileDomain()
3061                ProfileDomain.fromXML(self.domain,frag)
3062    def toXML(self,csmlFrag):
3063        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3064        if hasattr(self,'domain'):
3065             frag = Element(CSML('ProfileDomain'))
3066             ProfileDomain.toXML(self.domain,frag)
3067             csmlFrag.append(frag)
3068        return csmlFrag
3069
3070
3071class ProfileSeriesFeature(AbstractStaticCoverageFeature):
3072    """ProfileSeriesFeature(AbstractStaticCoverageFeature)
3073        +domain[0..1]:ProfileSeriesDomain
3074    """
3075    def __init__(self,domain=None,*args,**kwargs):
3076        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3077        if domain:
3078            self.domain=domain
3079    def __str__(self):
3080        return 'ProfileSeriesFeature'
3081    def fromXML(self,csmlFrag):
3082        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3083        for frag in csmlFrag.getchildren():
3084            if frag.tag == CSML('ProfileSeriesDomain'):
3085                self.domain = ProfileSeriesDomain()
3086                ProfileSeriesDomain.fromXML(self.domain,frag)
3087    def toXML(self,csmlFrag):
3088        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3089        if hasattr(self,'domain'):
3090             frag = Element(CSML('ProfileSeriesDomain'))
3091             ProfileSeriesDomain.toXML(self.domain,frag)
3092             csmlFrag.append(frag)
3093        return csmlFrag
3094
3095
3096class GridFeature(AbstractStaticCoverageFeature):
3097    """GridFeature(AbstractStaticCoverageFeature)
3098        +domain[0..1]:GridDomain
3099    """
3100
3101    def __init__(self,domain=None,*args,**kwargs):
3102        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3103        if domain:
3104            self.domain=domain
3105    def __str__(self):
3106        return 'GridFeature'
3107    def fromXML(self,csmlFrag):
3108        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3109        for frag in csmlFrag.getchildren():
3110            if frag.tag == CSML('GridDomain'):
3111                self.domain = GridDomain()
3112                self.domain.fromXML(frag)
3113    def toXML(self,csmlFrag):
3114        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3115        if hasattr(self,'domain'):
3116             frag = Element(CSML('GridDomain'))
3117             GridDomain.toXML(self.domain,frag)
3118             csmlFrag.append(frag)
3119        return csmlFrag
3120
3121
3122class GridSeriesFeature(AbstractStaticCoverageFeature):
3123    """GridSeriesFeature(AbstractStaticCoverageFeature)
3124        +domain[0..1]:GridSeriesDomain
3125    """
3126    def __init__(self,domain=None,*args,**kwargs):
3127        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3128        if domain:
3129            self.domain=domain
3130    def __str__(self):
3131        return 'GridSeriesFeature'
3132    def fromXML(self,csmlFrag):
3133        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3134        for frag in csmlFrag.getchildren():
3135            if frag.tag == CSML('GridSeriesDomain'):
3136                self.domain = GridSeriesDomain()
3137                self.domain.fromXML(frag)
3138    def toXML(self,csmlFrag):
3139        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3140        if hasattr(self,'domain'):
3141             frag = Element(CSML('GridSeriesDomain'))
3142             GridSeriesDomain.toXML(self.domain,frag)
3143             csmlFrag.append(frag)
3144        return csmlFrag
3145
3146
3147   
3148class AbstractFeature(AbstractGML):
3149    """AbstractFeature(AbstractStaticCoverageFeature)
3150        +boundedBy[0..1]:EnvelopeWithTimePeriod
3151    """
3152    def __init__(self,boundedBy=None,*args,**kwargs):
3153        AbstractGML.__init__(self,*args,**kwargs)
3154        if boundedBy:
3155            self.boundedBy=boundedBy
3156    def fromXML(self,csmlFrag):
3157        AbstractGML.fromXML(self,csmlFrag)
3158        for frag in csmlFrag.getchildren():
3159            if frag.tag == GML('boundedBy'):
3160                self.boundedBy = EnvelopeWithTimePeriod()
3161                self.boundedBy.fromXML(frag)
3162    def toXML(self,csmlFrag):
3163        AbstractGML.toXML(self,csmlFrag)
3164        if hasattr(self,'boundedBy'):
3165             superfrag = Element(GML('boundedBy'))
3166             frag = Element (GML('EnvelopeWithTimePeriod'))
3167             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
3168             superfrag.append(frag)
3169             csmlFrag.append(superfrag)
3170        return csmlFrag
3171
3172class AbstractGeometryFeature(AbstractFeature):
3173    """ AbstractGeometryFeature(AbstractFeature)
3174    """
3175    def __init__(self,*args,**kwargs):
3176        AbstractFeature.__init__(self,*args,**kwargs)
3177    def fromXML(self,csmlFrag):
3178        AbstractFeature.fromXML(self,csmlFrag)
3179    def toXML(self, csmlFrag):
3180        AbstractFeature.toXML(self,csmlFrag)
3181        return csmlFrag
3182
3183
3184class TrajectoryFeature(AbstractGeometryFeature):
3185    """ TrajectoryFeature(AbstractGeometryFeature)   
3186    +track[0..1]:Trajectory
3187    """
3188    def __init__(self,track=None, *args, **kwargs):
3189        AbstractGeometryFeature.__init__(self,*args,**kwargs)
3190        if track:
3191            self.track=track
3192    def __str__(self):
3193        return 'TrajectoryFeature'
3194    def fromXML(self,csmlFrag):
3195        AbstractGeometryFeature.fromXML(self,csmlFrag)
3196        for frag in csmlFrag.getchildren():
3197            if frag.tag == CSML('track'):
3198                self.track=Trajectory()
3199                Trajectory.fromXML(self.track,frag)
3200    def toXML(self,csmlFrag):
3201        AbstractGeometryFeature.toXML(self,csmlFrag)
3202        if hasattr(self, 'track'):
3203            frag = Element(CSML('track'))
3204            subFrag=Element(CSML('Trajectory'))
3205            Trajectory.toXML(self.track,subFrag)
3206            frag.append(subFrag)
3207            csmlFrag.append(frag)
3208        return csmlFrag
3209       
3210class AbstractFeatureCollection(AbstractFeature):
3211    """GML AbstractFeatureCollection class
3212
3213    AbstractFeatureCollection(AbstractFeature):
3214     +featureMember[0..*]: AbstractFeature
3215     +featureMembers[0..1]: FeatureArray
3216    """
3217    def __init__(self,members=[]):
3218        if members:
3219            self.members=members
3220    def fromXML(self,csmlFrag):
3221        AbstractFeature.fromXML(self,csmlFrag)
3222        for frag in csmlFrag.getchildren():
3223            if frag.tag == GML('featureMember'):
3224                checkArrayAttrib(self,'members')
3225                featureFrag = frag.getchildren()[0]
3226                if featureFrag.tag == CSML('PointFeature'):
3227                    self.members.append(PointFeature())
3228                    self.members[-1].fromXML(featureFrag)
3229                if featureFrag.tag == CSML('ProfileFeature'):
3230                    self.members.append(ProfileFeature())
3231                    self.members[-1].fromXML(featureFrag)
3232                if featureFrag.tag == CSML('GridFeature'):
3233                    self.members.append(GridFeature())
3234                    self.members[-1].fromXML(featureFrag)
3235                if featureFrag.tag == CSML('PointSeriesFeature'):
3236                    self.members.append(PointSeriesFeature())
3237                    self.members[-1].fromXML(featureFrag)
3238                if featureFrag.tag == CSML('ProfileSeriesFeature'):
3239                    self.members.append(ProfileSeriesFeature())
3240                    self.members[-1].fromXML(featureFrag)
3241                if featureFrag.tag == CSML('GridSeriesFeature'):
3242                    self.members.append(GridSeriesFeature())
3243                    self.members[-1].fromXML(featureFrag)
3244                if featureFrag.tag == CSML('TrajectoryFeature'):
3245                    self.members.append(TrajectoryFeature())
3246                    self.members[-1].fromXML(featureFrag)
3247    def toXML(self,csmlFrag):
3248        AbstractFeature.toXML(self,csmlFrag)
3249        for member in self.members:
3250            if isinstance(member,PointFeature):
3251                superFrag=Element(GML('featureMember'))
3252                frag=Element(CSML('PointFeature'))
3253                PointFeature.toXML(member,frag)
3254                superFrag.append(frag)
3255                csmlFrag.append(superFrag)
3256            if isinstance(member,ProfileFeature):
3257                superFrag=Element(GML('featureMember'))
3258                frag=Element(CSML('ProfileFeature'))
3259                ProfileFeature.toXML(member,frag)
3260                superFrag.append(frag)
3261                csmlFrag.append(superFrag)
3262            if isinstance(member,GridFeature):
3263                superFrag=Element(GML('featureMember'))
3264                frag=Element(CSML('GridFeature'))
3265                GridFeature.toXML(member,frag)
3266                superFrag.append(frag)
3267                csmlFrag.append(superFrag)
3268            if isinstance(member,PointSeriesFeature):
3269                superFrag=Element(GML('featureMember'))
3270                frag=Element(CSML('PointSeriesFeature'))
3271                PointSeriesFeature.toXML(member,frag)
3272                superFrag.append(frag)
3273                csmlFrag.append(superFrag)
3274            if isinstance(member,ProfileSeriesFeature):
3275                superFrag=Element(GML('featureMember'))
3276                frag=Element(CSML('ProfileSeriesFeature'))
3277                ProfileSeriesFeature.toXML(member,frag)
3278                superFrag.append(frag)
3279                csmlFrag.append(superFrag)
3280            if isinstance(member,GridSeriesFeature):
3281                superFrag=Element(GML('featureMember'))
3282                frag=Element(CSML('GridSeriesFeature'))
3283                GridSeriesFeature.toXML(member,frag)
3284                superFrag.append(frag)
3285                csmlFrag.append(superFrag)
3286            if isinstance(member,TrajectoryFeature):
3287                superFrag=Element(GML('featureMember'))
3288                frag=Element(CSML('TrajectoryFeature'))
3289                TrajectoryFeature.toXML(member,frag)
3290                superFrag.append(frag)
3291                csmlFrag.append(superFrag)
3292       
3293        return csmlFrag
3294
3295class FeatureCollection(AbstractFeatureCollection):
3296    """GML FeatureCollection class
3297        FeatureCollection()
3298        +featureMembers[0..*]
3299    """
3300    def __init__(self,*args,**kwargs):
3301        AbstractFeatureCollection.__init__(self,*args,**kwargs)
3302    def fromXML(self,csmlFrag):
3303        AbstractFeatureCollection.fromXML(self,csmlFrag)
3304    def toXML(self,csmlFrag):
3305        AbstractFeatureCollection.toXML(self,csmlFrag)
3306        return csmlFrag
3307
3308
3309class SimpleCondition:
3310        """ SimpleCondition (security)
3311        SimpleCondition():
3312        dgAttributeAuthority[0..*]:string
3313        attrauthRole[0..*]:string
3314        """
3315        def __init__(self,dgAttributeAuthority=None,attrauthRole=None,*args,**kwargs):
3316            if dgAttributeAuthority:
3317                self.dgAttributeAuthority=dgAttributeAuthority
3318            if attrauthRole:
3319                self.attrauthRole=attrauthRole
3320        def fromXML(self,csmlFrag):
3321            for frag in csmlFrag.getchildren():
3322                if frag.tag == MOLES('dgAttributeAuthority'):
3323                    self.dgAttributeAuthority=frag.text
3324                if frag.tag == MOLES('attrauthRole'):
3325                    self.attrauthRole=frag.text
3326        def toXML(self,csmlFrag):
3327            if hasattr(self,'dgAttributeAuthority'):
3328                frag=Element(MOLES('dgAttributeAuthority'))
3329                frag.text=self.dgAttributeAuthority
3330                csmlFrag.append(frag)
3331            if hasattr(self,'attrauthRole'):
3332                frag=Element(MOLES('attrauthRole'))
3333                frag.text=self.attrauthRole
3334                csmlFrag.append(frag)
3335            return csmlFrag
3336   
3337class DGSecurityCondition:
3338        """ DGSecurityCondition():
3339             +effect[0..1]:string
3340             +simpleCondition[0..1]:SimpleCondition
3341             +complexCondition[0..1]:ComplexCondition (not implemented)
3342             +conditionExplanationText[0..1]:string
3343        """
3344        def __init__(self,effect=None,simpleCondition=None, complexCondition=None, conditionExplanationText=None,*args,**kwargs):
3345            if effect:
3346                self.effect=effect
3347            if simpleCondition:
3348                self.simpleCondition=simpleCondition
3349            if complexCondition:
3350                self.complexCondition=complexCondition
3351            if conditionExplanationText:
3352                self.conditionExplanationText=conditionExplanationText
3353        def fromXML(self,csmlFrag):
3354            for frag in csmlFrag.getchildren():
3355                if frag.tag == MOLES('effect'):
3356                    self.effect=frag.text
3357                elif frag.tag == MOLES('conditionExplanationText'):
3358                    self.conditionExplanationText=frag.text
3359                elif frag.tag == MOLES('simpleCondition'):
3360                    simpleCondition=SimpleCondition()
3361                    simpleCondition.fromXML(frag)
3362                    self.simpleCondition=simpleCondition
3363        def toXML(self,csmlFrag):
3364            if hasattr(self,'effect'):
3365                frag=Element(MOLES('effect'))
3366                frag.text=self.effect
3367                csmlFrag.append(frag)
3368            if hasattr(self,'simpleCondition'):
3369                frag=Element(MOLES('simpleCondition'))
3370                frag = SimpleCondition.toXML(self.simpleCondition,frag)
3371                csmlFrag.append(frag)
3372            return csmlFrag
3373       
3374class AccessControlPolicy:
3375        """ AccessControlPolicy():
3376            +dgSecurityConditions[0..*]:DGSecurityCondition
3377            +accessControlPolicyText[0..1]:string
3378            +accessControlPolicyURL[0..1]:anyURI
3379        """
3380        def __init__(self,dgSecurityConditions=None,accessControlPolicyText=None,accessControlPolicyURL=None,*args,**kwargs):
3381            if dgSecurityConditions:
3382                self.dgSecurityConditions=dgSecurityConditions
3383            if accessControlPolicyText:
3384                self.accessControlPolicyText= accessControlPolicyText
3385            if accessControlPolicyURL:
3386                self.accessControlPolicyURL= accessControlPolicyURL
3387        def fromXML(self,csmlFrag):
3388           
3389            for frag in csmlFrag.getchildren():
3390                if frag.tag == MOLES('dgSecurityCondition'):
3391                    checkArrayAttrib(self, 'dgSecurityConditions')
3392                    dgSecurityCondition=DGSecurityCondition()
3393                    dgSecurityCondition.fromXML(frag)
3394                    self.dgSecurityConditions.append(dgSecurityCondition)
3395                elif frag.tag == MOLES('accessControlPolicyText'):
3396                    checkArrayAttrib(self,'accessControlPolicyText')
3397                    self.accessControlPolicyText.append(frag.text)
3398                elif frag.tag == MOLES('accessControlPolicyURL'):
3399                    checkArrayAttrib(self,'accessControlPolicyURL')
3400                    self.accessControlPolicyURL.append(frag.text)
3401        def toXML(self,csmlFrag):
3402            if hasattr(self,'dgSecurityConditions'):
3403                for condition in self.dgSecurityConditions:
3404                    frag = Element(MOLES('dgSecurityCondition'))
3405                    frag = DGSecurityCondition.toXML(condition,frag)
3406                    csmlFrag.append(frag)
3407            if hasattr(self,'accessControlPolicyText'):     
3408                for txt in self.accessControlPolicyText:
3409                    frag=Element(MOLES('accessControlPolicyText'))
3410                    frag.text=txt
3411                    csmlFrag.append(frag)
3412            if hasattr(self,'accessControlPolicyURL'):     
3413                for policyURL in self.accessControlPolicyURL:
3414                    frag=Element(MOLES('accessControlPolicyURL'))
3415                    frag.text=policyURL
3416                    csmlFrag.append(frag)
3417            return csmlFrag
3418       
3419class Dataset(AbstractGML):
3420    """CSML Dataset class
3421
3422    Dataset(AbstractGML):
3423     + accessControlPolicy[0...1]:AccessControlPolicy
3424     +unitDefinitions[0..*]: UnitDefinitions
3425     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
3426     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
3427     +arrayDescriptors[0..*]: AbstractArrayDescriptor
3428     +featureCollection[0..1]: FeatureCollection
3429    """
3430    def __init__(self,accessControlPolicy=None, unitDefinitions=None,referenceSystemDefinitions=None,
3431                 phenomenonDefinitions=None,arrayDescriptors=[],
3432                 featureCollection=None,*args,**kwargs):
3433        AbstractGML.__init__(self,*args,**kwargs)
3434        if accessControlPolicy:
3435            self.accessControlPolicy=accessControlPolicy
3436        if unitDefinitions:
3437            self.unitDefinitions = unitDefinitions
3438        if referenceSystemDefinitions:
3439            self.referenceSystemDefinitions = referenceSystemDefinitions
3440        if phenomenonDefinitions:
3441            self.phenomenonDefinitions = phenomenonDefinitions
3442        if arrayDescriptors:
3443            self.arrayDescriptors = arrayDescriptors
3444        if featureCollection:
3445            self.featureCollection = featureCollection
3446    def fromXML(self,csmlFrag):
3447        if csmlFrag.tag != CSML('Dataset'):
3448            print 'This does not appear to be a CSML file. Does not contain a root Dataset element.'
3449            print ' '
3450            sys.exit()
3451        AbstractGML.fromXML(self,csmlFrag)
3452        for frag in csmlFrag.getchildren():
3453            if frag.tag == CSML('AccessControlPolicy'):
3454                self.accessControlPolicy = AccessControlPolicy()
3455                self.accessControlPolicy.fromXML(frag)
3456            elif frag.tag == CSML('UnitDefinitions'):
3457                self.unitDefinitions = UnitDefinitions()
3458                self.unitDefinitions.fromXML(frag)
3459            elif frag.tag == CSML('ReferenceSystemDefinitions'):
3460                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
3461                self.referenceSystemDefinitions.fromXML(frag)
3462            elif frag.tag == CSML('PhenomenonDefinitions'):
3463                self.phenomenonDefinitions = PhenomenonDefinitions()
3464                self.phenomenonDefinitions.fromXML(frag)
3465            elif frag.tag == GML('FeatureCollection'):
3466                self.featureCollection = FeatureCollection()
3467                self.featureCollection.fromXML(frag)
3468            elif frag.tag == CSML('AggregatedArray'):
3469                checkArrayAttrib(self,'arrayDescriptors')
3470                self.arrayDescriptors.append(AggregatedArray())
3471                self.arrayDescriptors[-1].fromXML(frag)
3472            elif frag.tag == CSML('InlineArray'):
3473                checkArrayAttrib(self,'arrayDescriptors')
3474                self.arrayDescriptors.append(InlineArray())
3475                self.arrayDescriptors[-1].fromXML(frag)
3476            elif frag.tag == CSML('ArrayGenerator'):
3477                checkArrayAttrib(self,'arrayDescriptors')
3478                self.arrayDescriptors.append(ArrayGenerator())
3479                self.arrayDescriptors[-1].fromXML(frag)
3480            elif frag.tag == CSML('NASAAmesExtract'):
3481                checkArrayAttrib(self,'arrayDescriptors')
3482                self.arrayDescriptors.append(NASAAmesExtract())
3483                self.arrayDescriptors[-1].fromXML(frag)
3484            elif frag.tag == CSML('NetCDFExtract'):
3485                checkArrayAttrib(self,'arrayDescriptors')
3486                self.arrayDescriptors.append(NetCDFExtract())
3487                self.arrayDescriptors[-1].fromXML(frag)
3488            elif frag.tag == CSML('GRIBExtract'):
3489                checkArrayAttrib(self,'arrayDescriptors')
3490                self.arrayDescriptors.append(GRIBExtract())
3491                self.arrayDescriptors[-1].fromXML(frag)
3492            elif frag.tag == CSML('PPExtract'):
3493                checkArrayAttrib(self,'arrayDescriptors')
3494                self.arrayDescriptors.append(PPExtract())
3495                self.arrayDescriptors[-1].fromXML(frag)
3496##            else:
3497##                raise Exception('Unexpected element: "'+frag.tag+'"')
3498    def toXML(self,csmlFrag=None):
3499        if csmlFrag is None:
3500            csmlFrag = Element('Dataset')
3501        csmlFrag = AbstractGML.toXML(self,csmlFrag)
3502        if hasattr(self,'accessControlPolicy'):
3503            frag = Element(CSML('AccessControlPolicy'))
3504            frag = AccessControlPolicy.toXML(self.accessControlPolicy,frag)
3505            csmlFrag.append(frag)
3506        if hasattr(self,'unitDefinitions'):
3507            frag = Element(CSML('UnitDefinitions'))
3508            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
3509            csmlFrag.append(frag)
3510        if hasattr(self,'referenceSystemDefinitions'):
3511            frag = Element(CSML('ReferenceSystemDefinitions'))
3512            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
3513            csmlFrag.append(frag)
3514        if hasattr(self,'phenomenonDefinitions'):
3515            frag = Element(CSML('PhenomenonDefinitions'))
3516            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
3517            csmlFrag.append(frag)
3518        if hasattr(self,'arrayDescriptors'):
3519            for arrayDesc in self.arrayDescriptors:
3520                if isinstance(arrayDesc,AggregatedArray):
3521                    frag = Element(CSML('AggregatedArray'))
3522                    frag = AggregatedArray.toXML(arrayDesc,frag)
3523                elif isinstance(arrayDesc,InlineArray):
3524                    frag = Element(CSML('InlineArray'))
3525                    frag = InlineArray.toXML(arrayDesc,frag)
3526                elif isinstance(arrayDesc,ArrayGenerator):
3527                    frag = Element(CSML('ArrayGenerator'))
3528                    frag = ArrayGenerator.toXML(arrayDesc,frag)
3529                elif isinstance(arrayDesc,NASAAmesExtract):
3530                    frag = Element(CSML('NASAAmesExtract'))
3531                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
3532                elif isinstance(arrayDesc,NetCDFExtract):
3533                    frag = Element(CSML('NetCDFExtract'))
3534                    frag = NetCDFExtract.toXML(arrayDesc,frag)
3535                elif isinstance(arrayDesc,GRIBExtract):
3536                    frag = Element(CSML('GRIBExtract'))
3537                    frag = GRIBExtract.toXML(arrayDesc,frag)
3538                elif isinstance(arrayDesc,PPExtract):
3539                    frag = Element(CSML('PPExtract'))
3540                    frag = PPExtract.toXML(arrayDesc,frag)
3541                csmlFrag.append(frag)
3542        if hasattr(self,'featureCollection'):
3543            frag = Element(GML('FeatureCollection'))
3544            frag = FeatureCollection.toXML(self.featureCollection,frag)
3545            csmlFrag.append(frag)
3546            #csmlFrag=fixNameSpaces(csmlFrag)
3547        return csmlFrag
Note: See TracBrowser for help on using the repository browser.