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

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

more changes to allow full use of ArrayGenerator class, including change and some corrections to parser code

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