source: TI02-CSML/trunk/csml/parser.py @ 1503

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/csml/parser.py@1594
Revision 1503, 143.4 KB checked in by domlowe, 14 years ago (diff)

fixed problem with srsName attribute in EnvelopeWithTimePeriod?

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(object):
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(object):
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(object):
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(object):
247    """ gml:SRSInformationGroup
248    SRSReferenceGroup:
249    +uomLabels[0...]:NCNameList
250    +axisLabels[0...]:NCNameList
251    """
252    def __init__(self,uomLabels=None,axisLabels=None, *args,**kwargs):
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(object):
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,*args,**kwargs):
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(object):
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(object):
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(object):
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        if EnvTPfrag.attrib.has_key('srsName'):
2118            self.srsName=EnvTPfrag.attrib['srsName']
2119        for frag in EnvTPfrag.getchildren():
2120            if frag.tag == GML('lowerCorner'):
2121                self.lowerCorner=DirectPosition()
2122                DirectPosition.fromXML(self.lowerCorner, frag)
2123            if frag.tag == GML('upperCorner'):
2124                self.upperCorner=DirectPosition()
2125                DirectPosition.fromXML(self.upperCorner, frag)
2126            if frag.tag == GML('timePosition'):
2127                if hasattr(self, 'timePosition'):
2128                    self.timePosition2=frag.text
2129                else:
2130                    self.timePosition=frag.text
2131    def toXML(self,csmlFrag):
2132        if hasattr(self,'srsName'):
2133            csmlFrag.attrib['srsName'] = self.srsName
2134        if hasattr(self,'lowerCorner'):
2135            frag=Element(GML('lowerCorner'))
2136           # frag.text=self.lowerCorner
2137            DirectPosition.toXML(self.lowerCorner,frag)
2138            csmlFrag.append(frag)
2139        if hasattr(self,'upperCorner'):
2140            frag=Element(GML('upperCorner'))
2141            #frag.text=self.upperCorner
2142            DirectPosition.toXML(self.upperCorner,frag)
2143            csmlFrag.append(frag)
2144        if hasattr(self,'timePosition'):
2145            frag=Element(GML('timePosition'))
2146            frag.text=self.timePosition
2147            csmlFrag.append(frag)
2148        if hasattr(self,'timePosition2'):
2149            frag=Element(GML('timePosition'))
2150            frag.text=self.timePosition2
2151            csmlFrag.append(frag)
2152        return csmlFrag
2153
2154
2155       
2156class AngleList(object):
2157   
2158    """AngleList
2159    +uom[0..1]:anyURI
2160    +double[0...1]:string
2161    Note, should really inherit from MeasureList, but not implemented.
2162    """
2163    def __init__(self,uom=None, vals=None):
2164        if uom:
2165            self.uom=uom
2166        if vals:
2167            self.vals=vals
2168    def fromXML(self,csmlFrag):
2169        self.vals=csmlFrag.text
2170        if csmlFrag.attrib.has_key('uom'):
2171            self.uom = csmlFrag.attrib['uom']
2172        checkMandatory(self,'uom')
2173    def toXML(self, csmlFrag):
2174        if hasattr(self,'vals'):
2175            csmlFrag.text = self.vals
2176        if hasattr(self,'uom'):
2177            csmlFrag.attrib[('uom')] = self.uom
2178        return csmlFrag
2179       
2180class DirectionVectorList(object):
2181    """ DirectionVectorList
2182         +horizontalAngle[0..1]:AngleList
2183         +verticalAngle[0..1]:AngleList
2184    """
2185    def __init__(self, horizontalAngle=None, verticalAngle=None):
2186        if horizontalAngle:
2187            self.horizontalAngle=horizontalAngle
2188        if verticalAngle:
2189            self.verticalAngle=verticalAngle
2190    def fromXML(self, csmlFrag):
2191        for frag in csmlFrag.getchildren():
2192            if frag.tag==GML('horizontalAngle'):
2193                self.horizontalAngle=AngleList()
2194                AngleList.fromXML(self.horizontalAngle,frag)
2195            elif frag.tag==GML('verticalAngle'):
2196                self.verticalAngle=AngleList()
2197                AngleList.fromXML(self.verticalAngle,frag)
2198    def toXML(self,csmlFrag):
2199         if hasattr(self,'horizontalAngle'):
2200            frag = Element(GML('horizontalAngle'))
2201            AngleList.toXML(self.horizontalAngle,frag)
2202            csmlFrag.append(frag)
2203         if hasattr(self,'verticalAngle'):
2204            frag = Element(GML('verticalAngle'))
2205            AngleList.toXML(self.verticalAngle,frag)
2206            csmlFrag.append(frag)
2207         return csmlFrag
2208
2209       
2210class Position(object):
2211    """ Position
2212         +srsName[0..1]:string
2213         +axisLabels[0..1]:string
2214         +uomLabels[0..1]:string
2215         +location[0..1]:string
2216         +time[0..1]:string
2217    """
2218   
2219    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
2220        if srsName:
2221            self.srsName=srsName
2222        if axisLabels:
2223            self.axisLabels=axisLabels
2224        if uomLabels:
2225            self.uomLabels=uomLabels
2226        if location:
2227            self.location=location
2228        if time:
2229            self.time = time
2230    def fromXML(self,csmlFrag):
2231        if csmlFrag.attrib.has_key('srsName'):           
2232            self.srsName = csmlFrag.attrib['srsName']
2233        if csmlFrag.attrib.has_key('axisLabels'):
2234            self.axisLabels = csmlFrag.attrib['axisLabels']
2235            if csmlFrag.attrib.has_key('uomLabels'):
2236                self.uomLabels = csmlFrag.attrib['uomLabels']
2237        for frag in csmlFrag.getchildren():
2238            if frag.tag==CSML('location'):
2239                self.location=frag.text
2240            if frag.tag==CSML('time'):
2241                self.time=frag.text
2242    def toXML(self,csmlFrag):
2243        #subFrag = Element(CSML('Position'))
2244        if hasattr(self,'uomLabels'):
2245            csmlFrag.attrib['uomLabels'] = self.uomLabels
2246        if hasattr(self,'axisLabels'):
2247            csmlFrag.attrib['axisLabels'] = self.axisLabels
2248        if hasattr(self,'srsName'):
2249            csmlFrag.attrib['srsName'] = self.srsName
2250        if hasattr(self,'location'):
2251            frag = Element(CSML('location'))
2252            frag.text=self.location
2253            csmlFrag.append(frag)
2254        if hasattr(self,'time'):
2255            frag = Element(CSML('time'))
2256            frag.text=self.time
2257            csmlFrag.append(frag)
2258        return csmlFrag
2259
2260class OrientedPosition(Position):
2261    """OrientedPosition(Position)
2262        +direction[0..*]:DirectionVectorList
2263    """
2264    def __init__(self, direction=None, *args,**kwargs):
2265        Position.__init__(self, *args,**kwargs)
2266        if direction:
2267            self.direction=direction
2268    def fromXML(self,csmlFrag):
2269        Position.fromXML(self, csmlFrag)
2270        for frag in csmlFrag.getchildren():
2271            if frag.tag==CSML('direction'):
2272                self.direction=DirectionVectorList()
2273                DirectionVectorList.fromXML(self.direction,frag)
2274    def toXML(self, csmlFrag):
2275        Position.toXML(self,csmlFrag)
2276        if hasattr(self,'direction'):
2277            frag = Element(CSML('direction'))
2278            DirectionVectorList.toXML(self.direction,frag)
2279            csmlFrag.append(frag)
2280        return csmlFrag
2281       
2282
2283
2284class Trajectory(SRSReferenceGroup):
2285    """Trajectory(SRSReferenceGroup)
2286        +locations[0..*]:DirectPositionList
2287        +times[0..*]:TimePositionList
2288    """
2289    def __init__(self,locations=None,times=None,*args,**kwargs):
2290
2291        if locations:
2292            self.locations=locations
2293        if times:
2294            self.times = times
2295        SRSReferenceGroup.__init__(self,*args,**kwargs)
2296    def fromXML(self,csmlFrag):
2297        SRSReferenceGroup.fromXML(self,csmlFrag)
2298        for frag in csmlFrag.getchildren():
2299            if frag.tag==CSML('locations'):
2300                self.locations=DirectPositionList()
2301                DirectPositionList.fromXML(self.locations,frag)
2302            if frag.tag==CSML('times'):
2303                self.times=TimePositionList()
2304                TimePositionList.fromXML(self.times,frag)
2305    def toXML(self,csmlFrag):
2306        SRSReferenceGroup.toXML(self,csmlFrag)
2307        if hasattr(self,'srsName'):
2308            csmlFrag.attrib['srsName'] = self.srsName
2309        if hasattr(self,'locations'):
2310            frag = Element(CSML('locations'))
2311            frag=DirectPositionList.toXML(self.locations,frag)
2312            csmlFrag.append(frag)
2313        if hasattr(self,'times'):
2314            frag = Element(CSML('times'))
2315            TimePositionList.toXML(self.times, frag)
2316            csmlFrag.append(frag)
2317        return csmlFrag
2318
2319class OrientedTrajectory(Trajectory):
2320    """ OrientedTrajectory(Trajectory)
2321        +direction[0..*]:DirectionVectorList
2322    """
2323    def __init__(self, direction=None, *args,**kwargs):
2324        Trajectory.__init__(self, *args,**kwargs)
2325        if direction:
2326             self.direction=direction
2327    def fromXML(self,csmlFrag):
2328        Trajectory.fromXML(self, csmlFrag)
2329        for frag in csmlFrag.getchildren():
2330            if frag.tag==CSML('direction'):
2331                self.direction=DirectionVectorList()
2332                DirectionVectorList.fromXML(self.direction,frag)
2333    def toXML(self, csmlFrag):
2334        Trajectory.toXML(self,csmlFrag)
2335        if hasattr(self,'direction'):
2336            frag = Element(CSML('direction'))
2337            DirectionVectorList.toXML(self.direction,frag)
2338            csmlFrag.append(frag)
2339        return csmlFrag
2340
2341class AbstractGeometryType(AbstractGML):
2342    """AbstractGeometryType(AbstractGML)
2343        +low[0..1]:string
2344        +high[0..1]:string
2345    """
2346    def __init__(self, low=None, high=None):
2347        AbstractGML.__init__(self)
2348        if low:
2349            self.low=low
2350        if high:
2351            self.high=high
2352    def fromXML(self, csmlFrag):
2353        AbstractGML.fromXML(self,csmlFrag)
2354    def toXML(self,csmlFrag):
2355        AbstractGML.toXML(self,csmlFrag)
2356        return csmlFrag
2357
2358class GridEnvelope(object):
2359    """GridEnvelope
2360        +low[0..1]:string
2361        +high[0..1]:string
2362    """
2363    def __init__(self, low=None, high = None):
2364        if low:
2365            self.low = low
2366        if high:
2367            self.high = high
2368    def fromXML(self, csmlFrag):
2369        frag = csmlFrag.getchildren()[0]
2370        for subFrag in frag.getchildren():
2371            if subFrag.tag == GML('low'):
2372                self.low=subFrag.text
2373            elif subFrag.tag == GML('high'):
2374                self.high=subFrag.text
2375    def toXML(self,csmlFrag):
2376        if hasattr(self, 'low'):
2377            frag=Element(GML('low'))
2378            frag.text=self.low
2379            csmlFrag.append(frag)
2380        if hasattr(self, 'high'):
2381            frag=Element(GML('high'))
2382            frag.text=self.high
2383            csmlFrag.append(frag)
2384        return csmlFrag
2385
2386class GmlGrid(AbstractGeometryType):
2387    """GmlGrid, representing a gml:Grid element.
2388        GmlGrid(): 
2389        +dimension positiveInteger [1]
2390        +limits[0..1]:GridLimits
2391        +axisNames[1..*]:string
2392    """
2393    def __init__(self,dimension=None,limits=None,axisNames=None):
2394        AbstractGeometryType.__init__(self)
2395        if dimension:
2396            self.dimension=dimension
2397        if limits:
2398            self.limits=limits
2399        if axisNames:
2400            self.axisNames=axisNames
2401    def fromXML(self, csmlFrag):
2402        AbstractGeometryType.fromXML(self,csmlFrag)
2403        for frag in csmlFrag.getchildren():
2404            if frag.tag == GML('limits'):
2405                self.limits=GridEnvelope()
2406                GridEnvelope.fromXML(self.limits,frag)
2407            elif frag.tag == GML('axisName'):
2408                checkArrayAttrib(self,'axisNames')
2409                self.axisNames.append(frag.text)
2410    def toXML(self,csmlFrag):
2411        AbstractGeometryType.toXML(self,csmlFrag)
2412        if hasattr(self, 'limits'):
2413            frag=Element(GML('limits'))
2414            subFrag =Element(GML('GridEnvelope'))
2415            GridEnvelope.toXML(self.limits, subFrag)
2416            frag.append(subFrag)
2417            csmlFrag.append(frag)
2418        if hasattr(self, 'axisNames'):
2419            for axis in self.axisNames:
2420                frag=Element(GML('axisName'))
2421                frag.text =axis
2422                csmlFrag.append(frag)
2423        return csmlFrag
2424           
2425class GridOrdinateDescription(object):
2426    """GridOrdinateDescription:
2427        +gridAxesSpanned[0..*]:string
2428        +sequenceRule[0..1]:string
2429        +definesAxis[0..*]:string
2430        +axisValues: string or AbstractFileExtract
2431    """
2432    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
2433        if gridAxesSpanned:
2434            self.gridAxesSpanned=gridAxesSpanned
2435        if sequenceRule:
2436            self.sequenceRule=sequenceRule
2437        if definesAxis:
2438            self.definesAxis=definesAxis
2439            if href:
2440                self.href = href
2441        if axisValues:
2442            self.axisValues=axisValues
2443       
2444    def fromXML(self,csmlFrag):
2445        for frag in csmlFrag.getchildren():
2446            if frag.tag ==CSML('gridAxesSpanned'):
2447                self.gridAxesSpanned=frag.text
2448            elif frag.tag ==CSML('sequenceRule'):
2449                self.sequenceRule=frag.text
2450            elif frag.tag ==CSML('definesAxis'):
2451                self.definesAxis=frag.text
2452                if frag.attrib.has_key(XLINK('href')):
2453                        self.href = frag.attrib[XLINK('href')]
2454            elif frag.tag ==CSML('axisValues'):
2455                if frag.getchildren() !=[]:
2456                    subFrag= frag.getchildren()[0]
2457                    if subFrag.tag == CSML ('NetCDFExtract'):
2458                        self.axisValues=NetCDFExtract()
2459                        NetCDFExtract.fromXML(self.axisValues, subFrag)
2460                    elif subFrag.tag == CSML ('NASAAmesExtract'):
2461                        self.axisValues=NASAAmesExtract()
2462                        NASAAmesExtract.fromXML(self.axisValues, subFrag)
2463                    elif subFrag.tag == CSML ('GRIBExtract'):
2464                        self.axisValues=GRIBExtract()
2465                        GRIBExtract.fromXML(self.axisValues, subFrag)
2466                    elif subFrag.tag == CSML ('PPExtract'):
2467                        self.axisValues=PPExtract()
2468                        PPExtract.fromXML(self.axisValues, subFrag)
2469                else:
2470                    self.axisValues=frag.text
2471                   
2472               
2473    def toXML(self, csmlFrag):
2474        if hasattr(self, 'gridAxesSpanned'):
2475            frag=Element(CSML('gridAxesSpanned'))
2476            frag.text = self.gridAxesSpanned
2477            csmlFrag.append(frag)
2478        if hasattr(self, 'sequenceRule'):
2479            frag=Element(CSML('sequenceRule'))
2480            frag.text = self.sequenceRule
2481            csmlFrag.append(frag)
2482        if hasattr(self, 'definesAxis'):
2483            frag=Element(CSML('definesAxis'))
2484            frag.text = self.definesAxis
2485            if hasattr(self, 'href'):
2486                frag.attrib[XLINK('href')] = self.href
2487            csmlFrag.append(frag)
2488        if hasattr(self, 'axisValues'):
2489            frag=Element(CSML('axisValues'))
2490            if isinstance(self.axisValues,NetCDFExtract):
2491                subFrag=Element(CSML('NetCDFExtract'))
2492                NetCDFExtract.toXML(self.axisValues,subFrag)
2493                frag.append(subFrag)
2494            elif isinstance(self.axisValues,NASAAmesExtract):
2495                subFrag=Element(CSML('NASAAmesExtract'))
2496                NASAAmesExtract.toXML(self.axisValues,subFrag)
2497                frag.append(subFrag)
2498            elif isinstance(self.axisValues,GRIBExtract):
2499                subFrag=Element(CSML('GRIBExtract'))
2500                GRIBExtract.toXML(self.axisValues,subFrag)
2501                frag.append(subFrag)
2502            elif isinstance(self.axisValues,PPExtract):
2503                subFrag=Element(CSML('PPExtract'))
2504                PPExtract.toXML(self.axisValues,subFrag)
2505                frag.append(subFrag)
2506            else:
2507                frag.text = self.axisValues
2508            csmlFrag.append(frag)
2509        return csmlFrag
2510
2511
2512class Grid(GmlGrid):
2513    """#Class GmlGrid representing a gml:Grid
2514    Grid(GmlGrid)
2515    +srsName[0..1]:string
2516    +srsdimension[0..1]:string
2517    +dimension[0..1]:string
2518    +ordinates [0..1]:GridOrdinateDescription
2519    """
2520
2521    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
2522        GmlGrid.__init__(self)
2523        if srsName:
2524            self.srsName=srsName
2525        if srsDimension:
2526            self.srsDimension=srsDimension
2527        if dimension:
2528            self.dimension=dimension
2529        if ordinates:
2530            self.ordinates=ordinates
2531    def fromXML(self, csmlFrag):
2532        GmlGrid.fromXML(self,csmlFrag)
2533        if csmlFrag.attrib.has_key('srsName'):
2534            self.srsName = csmlFrag.attrib['srsName']
2535        if csmlFrag.attrib.has_key('srsDimension'):
2536            self.srsDimension = csmlFrag.attrib['srsDimension']
2537        if csmlFrag.attrib.has_key('dimension'):
2538            self.dimension = csmlFrag.attrib['dimension']
2539        for frag in csmlFrag:
2540            if frag.tag==CSML('ordinate'):
2541                checkArrayAttrib(self,'ordinates')
2542                ordinate=GridOrdinateDescription()
2543                GridOrdinateDescription.fromXML(ordinate, frag)
2544                self.ordinates.append(ordinate)
2545    def toXML(self,csmlFrag):
2546        GmlGrid.toXML(self,csmlFrag)
2547        if hasattr(self, 'srsName'):
2548            csmlFrag.attrib['srsName'] = self.srsName
2549        if hasattr(self, 'srsDimension'):
2550            csmlFrag.attrib['srsDimension'] = self.srsDimension
2551        if hasattr(self, 'dimension'):
2552            csmlFrag.attrib['dimension'] = self.dimension
2553       
2554        if hasattr(self, 'ordinates'):
2555            for ordinate in self.ordinates:
2556                frag=Element(CSML('ordinate'))
2557                GridOrdinateDescription.toXML(ordinate, frag)
2558                csmlFrag.append(frag)
2559        return csmlFrag
2560
2561class TimeInstant(object):
2562    """TimeInstant
2563    +timePosition[0..1]:string
2564    """
2565    def __init__(self, timePosition=None):
2566        if timePosition:
2567            self.timePosition=timePosition
2568    def fromXML(self,csmlFrag):
2569        for frag in csmlFrag.getchildren():
2570            if frag.tag==GML('timePosition'):
2571                self.timePosition=frag.text
2572    def toXML(self,csmlFrag):
2573         if hasattr(self,'timePosition'):
2574            frag = Element(GML('timePosition'))
2575            frag.text=self.timePosition
2576            csmlFrag.append(frag)
2577         return csmlFrag
2578
2579class TimePositionList(AssociationAttributeGroup):
2580    """TimePositionList(AssociationAttributeGroup)
2581        +frame[0..1]:anyURI
2582        +calendarEraName [0..1]:string (not implemented)
2583        +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType  (not implemented)
2584    """   
2585    def __init__(self, frame=None, timePositions=None,*args, **kwargs):
2586        if frame:
2587            self.frame=frame
2588        if timePositions:
2589            self.timePositions=timePositions
2590        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2591    def fromXML(self,csmlFrag):
2592        for frag in csmlFrag.getchildren():
2593            if frag.tag == CSML('NetCDFExtract'):
2594                self.timePositions=NetCDFExtract()
2595                NetCDFExtract.fromXML(self.timePositions,frag)
2596            elif frag.tag == CSML('NASAAmesExtract'):
2597                self.timePositions=NASAAmesExtract()
2598                NASAAmesExtract.fromXML(self.timePositions,frag)
2599            elif frag.tag == CSML('GRIBExtract'):
2600                self.timePositions=GRIBExtract()
2601                GRIBExtract.fromXML(self.timePositions,frag)
2602            elif frag.tag == CSML('PPExtract'):
2603                self.timePositions=PPExtract()
2604                PPExtract.fromXML(self.timePositions,frag)
2605            elif frag.tag == CSML('AggregatedArray'):
2606                self.timePositions=AggregatedArray()
2607                AggregatedArray.fromXML(self.timePositions,frag)
2608            elif frag.tag == CSML('ArrayGenerator'):
2609                self.timePositions=ArrayGenerator()
2610                ArrayGenerator.fromXML(self.timePositions,frag)
2611        if not csmlFrag.getchildren():
2612            self.timePositions=csmlFrag.text
2613        if csmlFrag.attrib.has_key('frame'):
2614            self.frame = csmlFrag.attrib['frame']
2615        AssociationAttributeGroup.fromXML(self,csmlFrag)
2616    def toXML(self,csmlFrag):
2617         if hasattr(self,'timePositions'):
2618            if  isinstance(self.timePositions, NASAAmesExtract):
2619                subFrag=Element(CSML('NASAAmesExtract'))
2620                NASAAmesExtract.toXML(self.timePositions,subFrag)
2621                csmlFrag.append(subFrag)
2622            elif  isinstance(self.timePositions, NetCDFExtract):
2623                subFrag=Element(CSML('NetCDFExtract'))
2624                NetCDFExtract.toXML(self.timePositions,subFrag)
2625                csmlFrag.append(subFrag)
2626            elif  isinstance(self.timePositions, GRIBExtract):
2627                subFrag=Element(CSML('GRIBExtract'))
2628                GRIBExtract.toXML(self.timePositions,subFrag)
2629                csmlFrag.append(subFrag)
2630            elif  isinstance(self.timePositions, PPExtract):
2631                subFrag=Element(CSML('PPExtract'))
2632                PPExtract.toXML(self.timePositions,subFrag)
2633                csmlFrag.append(subFrag)
2634            elif  isinstance(self.timePositions, AggregatedArray):
2635                subFrag=Element(CSML('AggregatedArray'))
2636                AggregatedArray.toXML(self.timePositions,subFrag)
2637                csmlFrag.append(subFrag)
2638            elif  isinstance(self.timePositions, ArrayGenerator):
2639                subFrag=Element(CSML('ArrayGenerator'))
2640                ArrayGenerator.toXML(self.timePositions,subFrag)
2641                csmlFrag.append(subFrag)
2642            else:
2643                csmlFrag.text=self.timePositions
2644         if hasattr(self,'frame'):
2645             csmlFrag.attrib['frame']=self.frame
2646         AssociationAttributeGroup.toXML(self,csmlFrag)
2647         return csmlFrag
2648             
2649class Measure(object):
2650    """ Measure
2651        +uom[0..1]:anyURI
2652        +vals[0..1]:string
2653    """
2654    def __init__(self, uom=None, vals=None):
2655        if uom:
2656            self.uom=uom
2657        if vals:
2658            self.vals=vals
2659    def fromXML(self,csmlFrag):
2660        self.vals=csmlFrag.text
2661        if csmlFrag.attrib.has_key('uom'):
2662            self.uom = csmlFrag.attrib['uom']
2663    def toXML(self, csmlFrag):
2664        frag = Element(GML('measure'))
2665        if hasattr(self, 'vals'):
2666            frag.text = self.vals
2667        if hasattr(self,'uom'):
2668            frag.attrib[('uom')] = self.uom
2669        csmlFrag.append(frag)
2670        return csmlFrag
2671
2672class MeasureOrNullList(object):
2673    """MeasureOrNullList:
2674    +uom[0..1]:anyURI
2675    #Actually based on doubleOrNullList, but not modelled to that level of detail.
2676    """
2677    def __init__(self, uom=None, val=None):
2678        if uom:
2679            self.uom=uom
2680        if val:
2681            self.val=val
2682    def fromXML(self,csmlFrag):
2683        for frag in csmlFrag.getchildren():
2684            if frag.tag == CSML('NetCDFExtract'):
2685                self.val=NetCDFExtract()
2686                NetCDFExtract.fromXML(self.val,frag)
2687            elif frag.tag == CSML('NASAAmesExtract'):
2688                self.val=NASAAmesExtract()
2689                NASAAmesExtract.fromXML(self.val,frag)
2690            elif frag.tag == CSML('GRIBExtract'):
2691                self.val=GRIBExtract()
2692                GRIBExtract.fromXML(self.val,frag)
2693            elif frag.tag == CSML('PPExtract'):
2694                self.val=PPExtract()
2695                PPExtract.fromXML(self.val,frag)
2696            elif frag.tag == CSML('AggregatedArray'):
2697                self.val=AggregatedArray()
2698                AggregatedArray.fromXML(self.val,frag)
2699            elif frag.tag == CSML('ArrayGenerator'):
2700                self.val=ArrayGenerator()
2701                ArrayGenerator.fromXML(self.val,frag)
2702            else:
2703                self.val=csmlFrag.text
2704            if csmlFrag.attrib.has_key('uom'):
2705                self.uom = csmlFrag.attrib['uom']
2706    def toXML(self, csmlFrag):
2707        if hasattr(self,'val'):
2708            if  isinstance(self.val, NASAAmesExtract):
2709                subFrag=Element(CSML('NASAAmesExtract'))
2710                NASAAmesExtract.toXML(self.val,subFrag)
2711                csmlFrag.append(subFrag)
2712            elif  isinstance(self.val, NetCDFExtract):
2713                subFrag=Element(CSML('NetCDFExtract'))
2714                NetCDFExtract.toXML(self.val,subFrag)
2715                csmlFrag.append(subFrag)
2716            elif  isinstance(self.val, GRIBExtract):
2717                subFrag=Element(CSML('GRIBExtract'))
2718                GRIBExtract.toXML(self.val,subFrag)
2719                csmlFrag.append(subFrag)
2720            elif  isinstance(self.val, PPExtract):
2721                subFrag=Element(CSML('PPExtract'))
2722                PPExtract.toXML(self.val,subFrag)
2723                csmlFrag.append(subFrag)
2724            elif  isinstance(self.val, ArrayGenerator):
2725                subFrag=Element(CSML('ArrayGenerator'))
2726                ArrayGenerator.toXML(self.val,subFrag)
2727                csmlFrag.append(subFrag)
2728            elif  isinstance(self.val, AggregatedArray):
2729                subFrag=Element(CSML('AggregatedArray'))
2730                AggregatedArray.toXML(self.val,subFrag)
2731                csmlFrag.append(subFrag)
2732            else:
2733                csmlFrag.text = self.val
2734        if hasattr(self,'uom'):
2735           csmlFrag.attrib[('uom')] = self.uom
2736        return csmlFrag
2737   
2738class CompositeValue(object):
2739    """ CompositeValue
2740        +valueComponents[0..*]:Measure
2741    """
2742    def __init__(self, valueComponents=None):
2743        if valueComponents:
2744            self.valueComponents=valueComponents
2745    def fromXML(self,csmlFrag):
2746        for frag in csmlFrag.getchildren():
2747            if frag.tag == GML('valueComponents'):
2748                self.valueComponents = []
2749                for subFrag in frag.getchildren():                   
2750                    if subFrag.tag == GML('measure'):
2751                        self.valueComponents.append(Measure())
2752                        self.valueComponents[-1].fromXML(subFrag)
2753
2754    def toXML(self, csmlFrag):
2755         if hasattr(self,'valueComponents'):
2756            frag=Element(GML('valueComponents'))
2757            for valueComponent in self.valueComponents:
2758                if isinstance(valueComponent,Measure):
2759                    subFrag=Element(GML('measure'))
2760                    Measure.toXML(valueComponent,subFrag)
2761                    frag.append(subFrag)
2762            csmlFrag.append(frag)
2763         return csmlFrag
2764   
2765
2766   
2767class DataBlock(object):
2768    """class GML DataBlock
2769   
2770    DataBlock()
2771    +rangeParameters[0..*]:string
2772    +doubleOrNullTupleList[0..*]:string
2773    """
2774    def __init__(self,rangeParameters=None, doubleOrNullTupleList=None):
2775        if rangeParameters:
2776            self.rangeParameters=rangeParameters
2777        if doubleOrNullTupleList:
2778            self.doubleOrNullTupleList=doubleOrNullTupleList
2779    def fromXML(self,csmlFrag):
2780        for frag in csmlFrag.getchildren():
2781            if frag.tag == GML('rangeParameters'):
2782                for subFrag in frag.getchildren():
2783                    if subFrag.tag==GML('CompositeValue'):
2784                        self.rangeParameters=CompositeValue()
2785                        CompositeValue.fromXML(self.rangeParameters,subFrag)
2786            if frag.tag == GML('doubleOrNullTupleList'):
2787                self.doubleOrNullTupleList=frag.text
2788    def toXML(self,csmlFrag):
2789        if hasattr(self, 'rangeParameters'):
2790            frag=Element(GML('rangeParameters'))
2791            subFrag=Element(GML('CompositeValue'))
2792            CompositeValue.toXML(self.rangeParameters, subFrag)
2793            frag.append(subFrag)
2794            csmlFrag.append(frag)
2795        if hasattr(self,'doubleOrNullTupleList'):
2796            frag=Element(GML('doubleOrNullTupleList'))
2797            frag.text=self.doubleOrNullTupleList
2798            csmlFrag.append(frag)
2799        return csmlFrag
2800
2801
2802
2803class TypedCategory(object):
2804    """class om:TypedCategory
2805        TypedCategory
2806         +axis[0..1]:anyURI
2807        + codeSpace[0..1]:anyURI
2808    """
2809    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
2810        if axis:
2811            self.axis=axis
2812        if codeSpace:
2813            self.codeSpace=codeSpace
2814        if text:
2815            self.text=text
2816    def fromXML(self,csmlFrag):
2817        if csmlFrag.attrib.has_key('axis'):
2818            self.axis=csmlFrag.attrib['axis']
2819        if csmlFrag.attrib.has_key('codeSpace'):
2820            self.codeSpace=csmlFrag.attrib['codeSpace']
2821        self.text=csmlFrag.text
2822    def toXML(self,csmlFrag):
2823        if hasattr(self,'axis'):
2824            csmlFrag.attrib[('axis')] =self.axis
2825        if hasattr(self,'codeSpace'):
2826            csmlFrag.attrib[('codeSpace')] =self.codeSpace
2827        csmlFrag.text=self.text
2828        return csmlFrag
2829
2830class Phenomenon(Definition,AssociationAttributeGroup):
2831    """class Obs& Measures: PhenomenonProperty
2832        Phenomenon(Definition,AssociationAttributeGroup)
2833    """
2834    #Note, in this does not really inherit from AbstractGML, but for CMSL
2835    #purposes it is used  to pick up the basic description, id, name attributes
2836    def __init__(self,*args,**kwargs):
2837         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
2838        self.MetaDataProperty=None
2839        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
2840        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2841    def fromXML(self,csmlFrag):
2842        Definition.fromXML(self,csmlFrag)
2843        AssociationAttributeGroup.fromXML(self,csmlFrag)
2844       
2845    def toXML(self,csmlFrag):
2846        csmlFrag=Definition.toXML(self,csmlFrag)
2847        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2848        return csmlFrag
2849
2850
2851class CompositePhenomenon(Phenomenon):
2852    """ CompositePhenomenon(Phenomenon)
2853        +componentPhenomena [1...*]:Phenomenon
2854    """
2855    def __init__(self,componentPhenomena=None,*args,**kwargs):
2856        Phenomenon.__init__(self,*args,**kwargs)
2857        if componentPhenomena:
2858            self.componentPhenomena=componentPhenomena
2859    def fromXML(self,csmlFrag):
2860        Phenomenon.fromXML(self,csmlFrag)
2861        self.componentPhenomena=[]
2862        for frag in csmlFrag.getchildren():
2863            if frag.tag == OM('componentPhenomenon'):
2864                componentPhenomenon=Phenomenon()
2865                Phenomenon.fromXML(componentPhenomenon,frag)
2866                self.componentPhenomena.append(componentPhenomenon)
2867    def toXML(self,csmlFrag):
2868        Phenomenon.toXML(self,csmlFrag)
2869        if hasattr(self, 'componentPhenomena'):
2870            for phenomenon in self.componentPhenomena:
2871                frag=Element(OM('componentPhenomenon'))
2872                Phenomenon.toXML(phenomenon,frag)
2873                csmlFrag.append(frag)
2874        return csmlFrag
2875           
2876               
2877class ParameterisedPhenomenon(Phenomenon):
2878    """Class ParameterisedPhenomenon:
2879        +basePhenomenon[0..1]
2880         + constraint[0..1]:string
2881         + href[0..1]:anyURI
2882    """
2883    def __init__(self,basePhenomenon=None,constraint=None,*args,**kwargs):
2884        Phenomenon.__init__(self,*args,**kwargs)
2885        if basePhenomenon:
2886            self.basePhenomenon=basePhenomenon
2887        if constraint:
2888            self.constraint=constraint
2889    def fromXML(self,csmlFrag):
2890        Phenomenon.fromXML(self,csmlFrag)
2891        for frag in csmlFrag.getchildren():
2892            if frag.tag == OM('basePhenomenon'):
2893                self.basePhenomenon=frag.text
2894                if frag.attrib.has_key(XLINK('href')):
2895                    self.href = frag.attrib[XLINK('href')]
2896            if frag.tag == OM('constraint'):
2897                subFrag=frag.getchildren()[0]
2898                if subFrag.tag== OM('TypedCategory'):
2899                    self.constraint = TypedCategory()
2900                #TO DO: what other types are valid?
2901                elif subFrag.tag== OM('??'):
2902                    self.constraint = 123
2903                self.constraint.fromXML(subFrag)
2904    def toXML(self,csmlFrag):
2905        csmlFrag=Phenomenon.toXML(self,csmlFrag)
2906        if hasattr(self,'basePhenomenon'):
2907            frag=Element(OM('basePhenomenon'))
2908            frag.text=self.basePhenomenon
2909            if hasattr(self, 'href'):
2910                frag.attrib[XLINK('href')] = self.href
2911            csmlFrag.append(frag)
2912        if hasattr(self, 'constraint'):
2913            frag=Element(OM('constraint'))
2914            subFrag=Element(OM('TypedCategory'))
2915            subFrag=self.constraint.toXML(subFrag)
2916            frag.append(subFrag)
2917            csmlFrag.append(frag)
2918        return csmlFrag
2919
2920class RangeSet(AssociationAttributeGroup):
2921    """class GML RangeSet 
2922
2923         RangeSet()
2924        +quantityList[0..1]:MeasureOrNullList
2925        +dataBlock[0..1]:DataBlock
2926        +arrayDescriptor[0..1]:arrayDescriptor
2927        +aggregatedArray[0..1]:AggregatedArray
2928    """
2929   
2930    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None,*args,**kwargs):
2931        if quantityList:
2932            self.quantityList=quantityList
2933        if dataBlock:
2934            self.dataBlock=dataBlock
2935        if arrayDescriptor:
2936            self.arrayDescriptor=arrayDescriptor
2937        if aggregatedArray:
2938            self.aggregatedArray=aggregatedArray
2939        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2940           
2941    def fromXML(self,csmlFrag):
2942        for frag in csmlFrag.getchildren():
2943            if frag.tag==GML('QuantityList'):
2944                self.quantityList=MeasureOrNullList()
2945                MeasureOrNullList.fromXML(self.quantityList,frag)
2946            elif frag.tag==GML('DataBlock'):
2947                self.dataBlock=DataBlock()
2948                DataBlock.fromXML(self.dataBlock, frag)
2949            elif frag.tag == CSML('NetCDFExtract'):
2950                self.arrayDescriptor=NetCDFExtract()
2951                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
2952            elif frag.tag == CSML('NASAAmesExtract'):
2953                self.arrayDescriptor=NASAAmesExtract()
2954                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
2955            elif frag.tag == CSML('GRIBExtract'):
2956                self.arrayDescriptor=GRIBExtract()
2957                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
2958            elif frag.tag == CSML('PPExtract'):
2959                self.arrayDescriptor=PPExtract()
2960                PPExtract.fromXML(self.ArrayDescriptor,frag)
2961            elif frag.tag == CSML('AggregatedArray'):
2962                self.aggregatedArray=AggregatedArray()
2963                AggregatedArray.fromXML(self.aggregatedArray,frag)
2964        AssociationAttributeGroup.fromXML(self,csmlFrag)
2965
2966    def toXML(self, csmlFrag):
2967        if hasattr(self,'quantityList'):
2968            frag = Element(GML('QuantityList'))
2969            MeasureOrNullList.toXML(self.quantityList,frag)
2970            csmlFrag.append(frag)
2971        if hasattr(self,'dataBlock'):
2972            frag=Element(GML('DataBlock'))
2973            DataBlock.toXML(self.dataBlock,frag)
2974            csmlFrag.append(frag)
2975        if hasattr(self,'aggregatedArray'):
2976            frag=Element(CSML('AggregatedArray'))
2977            AggregatedArray.toXML(self.aggregatedArray,frag)
2978            csmlFrag.append(frag)
2979        if hasattr(self,'arrayDescriptor'):
2980            if isinstance(self.arrayDescriptor,NetCDFExtract):
2981                frag=Element(CSML('NetCDFExtract'))
2982                NetCDFExtract.toXML(self.arrayDescriptor,frag)
2983                csmlFrag.append(frag)
2984            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
2985                frag=Element(CSML('NASAAmesExtract'))
2986                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
2987                csmlFrag.append(frag)
2988            elif isinstance(self.arrayDescriptor,GRIBExtract):
2989                frag=Element(CSML('GRIBExtract'))
2990                GRIBExtract.toXML(self.arrayDescriptor,frag)
2991                csmlFrag.append(frag)
2992            elif isinstance(self.arrayDescriptor,PPExtract):
2993                frag=Element(CSML('PPExtract'))
2994                PPAmesExtract.toXML(self.arrayDescriptor,frag)
2995                csmlFrag.append(frag)
2996        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2997        return csmlFrag
2998
2999class PointDomain(AbstractDomain):
3000    """ PointDomain(AbstractDomain)
3001    """
3002    def __init__(self,*args,**kwargs):
3003        AbstractDomain.__init__(self,*args,**kwargs)
3004    def fromXML(self,csmlFrag):
3005        AbstractDomain.fromXML(self,csmlFrag)
3006    def toXML(self,csmlFrag):
3007        AbstractDomain.toXML(self,csmlFrag)
3008        return csmlFrag
3009   
3010class ProfileDomain(AbstractDomain):
3011    """ ProfileDomain(AbstractDomain)
3012    """
3013    def __init__(self,*args,**kwargs):
3014        AbstractDomain.__init__(self,*args,**kwargs)
3015    def fromXML(self,csmlFrag):
3016        AbstractDomain.fromXML(self,csmlFrag)
3017    def toXML(self,csmlFrag):
3018        AbstractDomain.toXML(self,csmlFrag)
3019        return csmlFrag
3020
3021class GridDomain(AbstractDomain):
3022    """ GridDomain(AbstractDomain)
3023    """
3024    def __init__(self,*args,**kwargs):
3025        AbstractDomain.__init__(self,*args,**kwargs)
3026    def fromXML(self,csmlFrag):
3027        AbstractDomain.fromXML(self,csmlFrag)
3028    def toXML(self,csmlFrag):
3029        AbstractDomain.toXML(self,csmlFrag)
3030        return csmlFrag
3031   
3032class PointSeriesDomain(AbstractDomain):
3033    """ PointSeriesDomain(AbstractDomain)
3034    """
3035    def __init__(self,*args,**kwargs):
3036        AbstractDomain.__init__(self,*args,**kwargs)
3037    def fromXML(self,csmlFrag):
3038        AbstractDomain.fromXML(self,csmlFrag)
3039    def toXML(self,csmlFrag):
3040        AbstractDomain.toXML(self,csmlFrag)
3041        return csmlFrag
3042   
3043class ProfileSeriesDomain(AbstractDomain):
3044    """ ProfileSeriesDomain(AbstractDomain)
3045    """
3046    def __init__(self,*args,**kwargs):
3047        AbstractDomain.__init__(self,*args,**kwargs)
3048    def fromXML(self,csmlFrag):
3049        AbstractDomain.fromXML(self,csmlFrag)
3050    def toXML(self,csmlFrag):
3051        AbstractDomain.toXML(self,csmlFrag)
3052        return csmlFrag
3053   
3054class GridSeriesDomain(AbstractDomain):
3055    """ GridSeriesDomain(AbstractDomain)
3056    """
3057    def __init__(self,*args,**kwargs):
3058        AbstractDomain.__init__(self,*args,**kwargs)
3059    def fromXML(self,csmlFrag):
3060        AbstractDomain.fromXML(self,csmlFrag)
3061    def toXML(self,csmlFrag):
3062        AbstractDomain.toXML(self,csmlFrag)
3063        return csmlFrag
3064
3065class PointFeature(AbstractStaticCoverageFeature):
3066    """PointFeature(AbstractStaticCoverageFeature)
3067        +domain[0..1]:PointDomain
3068    """
3069    def __init__(self, domain=None,*args,**kwargs):
3070        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3071        if domain:
3072            self.domain=domain
3073    def __str__(self):
3074        return 'PointFeature'
3075    def fromXML(self,csmlFrag):
3076        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3077        for frag in csmlFrag.getchildren():
3078            if frag.tag == CSML('PointDomain'):
3079                self.domain = PointDomain()
3080                self.domain.fromXML(frag)
3081    def toXML(self,csmlFrag):
3082        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3083        if hasattr(self,'domain'):
3084            frag = Element(CSML('PointDomain'))
3085            PointDomain.toXML(self.domain,frag)
3086#             if hasattr(self,'href'):
3087#                 frag.attrib[XLINK('href')] = self.href
3088            csmlFrag.append(frag)
3089        return csmlFrag
3090
3091   
3092class PointSeriesFeature(AbstractSeriesCoverageFeature):
3093    """PointFeature(AbstractStaticCoverageFeature)
3094        +domain[0..1]:PointSeriesDomain
3095    """
3096
3097    def __init__(self,domain=None,*args,**kwargs):
3098        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
3099        if domain:
3100            self.domain=domain
3101    def __str__(self):
3102        return 'PointSeriesFeature'
3103    def fromXML(self,csmlFrag):
3104        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
3105        for frag in csmlFrag.getchildren():
3106            if frag.tag == CSML('PointSeriesDomain'):
3107                self.domain = PointSeriesDomain()
3108                self.domain.fromXML(frag)
3109    def toXML(self,csmlFrag):
3110        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
3111        if hasattr(self,'domain'):
3112             frag = Element(CSML('PointSeriesDomain'))
3113             PointSeriesDomain.toXML(self.domain,frag)
3114             csmlFrag.append(frag)
3115        return csmlFrag
3116
3117class ProfileFeature(AbstractStaticCoverageFeature):
3118    """ProfileFeature(AbstractStaticCoverageFeature)
3119        +domain[0..1]:ProfileDomain
3120    """
3121    def __init__(self,domain=None,*args,**kwargs):
3122        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3123        if domain:
3124            self.domain=domain
3125    def __str__(self):
3126        return 'ProfileFeature'
3127    def fromXML(self,csmlFrag):
3128        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3129        for frag in csmlFrag.getchildren():
3130            if frag.tag == CSML('ProfileDomain'):
3131                self.domain = ProfileDomain()
3132                ProfileDomain.fromXML(self.domain,frag)
3133    def toXML(self,csmlFrag):
3134        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3135        if hasattr(self,'domain'):
3136             frag = Element(CSML('ProfileDomain'))
3137             ProfileDomain.toXML(self.domain,frag)
3138             csmlFrag.append(frag)
3139        return csmlFrag
3140
3141
3142class ProfileSeriesFeature(AbstractStaticCoverageFeature):
3143    """ProfileSeriesFeature(AbstractStaticCoverageFeature)
3144        +domain[0..1]:ProfileSeriesDomain
3145    """
3146    def __init__(self,domain=None,*args,**kwargs):
3147        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3148        if domain:
3149            self.domain=domain
3150    def __str__(self):
3151        return 'ProfileSeriesFeature'
3152    def fromXML(self,csmlFrag):
3153        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3154        for frag in csmlFrag.getchildren():
3155            if frag.tag == CSML('ProfileSeriesDomain'):
3156                self.domain = ProfileSeriesDomain()
3157                ProfileSeriesDomain.fromXML(self.domain,frag)
3158    def toXML(self,csmlFrag):
3159        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3160        if hasattr(self,'domain'):
3161             frag = Element(CSML('ProfileSeriesDomain'))
3162             ProfileSeriesDomain.toXML(self.domain,frag)
3163             csmlFrag.append(frag)
3164        return csmlFrag
3165
3166
3167class GridFeature(AbstractStaticCoverageFeature):
3168    """GridFeature(AbstractStaticCoverageFeature)
3169        +domain[0..1]:GridDomain
3170    """
3171
3172    def __init__(self,domain=None,*args,**kwargs):
3173        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3174        if domain:
3175            self.domain=domain
3176    def __str__(self):
3177        return 'GridFeature'
3178    def fromXML(self,csmlFrag):
3179        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3180        for frag in csmlFrag.getchildren():
3181            if frag.tag == CSML('GridDomain'):
3182                self.domain = GridDomain()
3183                self.domain.fromXML(frag)
3184    def toXML(self,csmlFrag):
3185        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3186        if hasattr(self,'domain'):
3187             frag = Element(CSML('GridDomain'))
3188             GridDomain.toXML(self.domain,frag)
3189             csmlFrag.append(frag)
3190        return csmlFrag
3191
3192
3193class GridSeriesFeature(AbstractStaticCoverageFeature):
3194    """GridSeriesFeature(AbstractStaticCoverageFeature)
3195        +domain[0..1]:GridSeriesDomain
3196    """
3197    def __init__(self,domain=None,*args,**kwargs):
3198        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3199        if domain:
3200            self.domain=domain
3201    def __str__(self):
3202        return 'GridSeriesFeature'
3203    def fromXML(self,csmlFrag):
3204        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3205        for frag in csmlFrag.getchildren():
3206            if frag.tag == CSML('GridSeriesDomain'):
3207                self.domain = GridSeriesDomain()
3208                self.domain.fromXML(frag)
3209    def toXML(self,csmlFrag):
3210        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3211        if hasattr(self,'domain'):
3212             frag = Element(CSML('GridSeriesDomain'))
3213             GridSeriesDomain.toXML(self.domain,frag)
3214             csmlFrag.append(frag)
3215        return csmlFrag
3216
3217
3218   
3219class AbstractFeature(AbstractGML):
3220    """AbstractFeature(AbstractStaticCoverageFeature)
3221        +boundedBy[0..1]:EnvelopeWithTimePeriod
3222    """
3223    def __init__(self,boundedBy=None,*args,**kwargs):
3224        AbstractGML.__init__(self,*args,**kwargs)
3225        if boundedBy:
3226            self.boundedBy=boundedBy
3227    def fromXML(self,csmlFrag):
3228        AbstractGML.fromXML(self,csmlFrag)
3229        for frag in csmlFrag.getchildren():
3230            if frag.tag == GML('boundedBy'):
3231                self.boundedBy = EnvelopeWithTimePeriod()
3232                self.boundedBy.fromXML(frag)
3233    def toXML(self,csmlFrag):
3234        AbstractGML.toXML(self,csmlFrag)
3235        if hasattr(self,'boundedBy'):
3236             superfrag = Element(GML('boundedBy'))
3237             frag = Element (GML('EnvelopeWithTimePeriod'))
3238             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
3239             superfrag.append(frag)
3240             csmlFrag.append(superfrag)
3241        return csmlFrag
3242
3243class AbstractGeometryFeature(AbstractFeature):
3244    """ AbstractGeometryFeature(AbstractFeature)
3245    """
3246    def __init__(self,*args,**kwargs):
3247        AbstractFeature.__init__(self,*args,**kwargs)
3248    def fromXML(self,csmlFrag):
3249        AbstractFeature.fromXML(self,csmlFrag)
3250    def toXML(self, csmlFrag):
3251        AbstractFeature.toXML(self,csmlFrag)
3252        return csmlFrag
3253
3254
3255class TrajectoryFeature(AbstractGeometryFeature):
3256    """ TrajectoryFeature(AbstractGeometryFeature)   
3257    +track[0..1]:Trajectory
3258    """
3259    def __init__(self,track=None, *args, **kwargs):
3260        AbstractGeometryFeature.__init__(self,*args,**kwargs)
3261        if track:
3262            self.track=track
3263    def __str__(self):
3264        return 'TrajectoryFeature'
3265    def fromXML(self,csmlFrag):
3266        AbstractGeometryFeature.fromXML(self,csmlFrag)
3267        for frag in csmlFrag.getchildren():
3268            if frag.tag == CSML('track'):
3269                self.track=Trajectory()
3270                Trajectory.fromXML(self.track,frag)
3271    def toXML(self,csmlFrag):
3272        AbstractGeometryFeature.toXML(self,csmlFrag)
3273        if hasattr(self, 'track'):
3274            frag = Element(CSML('track'))
3275            subFrag=Element(CSML('Trajectory'))
3276            Trajectory.toXML(self.track,subFrag)
3277            frag.append(subFrag)
3278            csmlFrag.append(frag)
3279        return csmlFrag
3280       
3281class AbstractFeatureCollection(AbstractFeature):
3282    """GML AbstractFeatureCollection class
3283
3284    AbstractFeatureCollection(AbstractFeature):
3285     +featureMember[0..*]: AbstractFeature
3286     +featureMembers[0..1]: FeatureArray
3287    """
3288    def __init__(self,members=[]):
3289        if members:
3290            self.members=members
3291    def fromXML(self,csmlFrag):
3292        AbstractFeature.fromXML(self,csmlFrag)
3293        for frag in csmlFrag.getchildren():
3294            if frag.tag == GML('featureMember'):
3295                checkArrayAttrib(self,'members')
3296                featureFrag = frag.getchildren()[0]
3297                if featureFrag.tag == CSML('PointFeature'):
3298                    self.members.append(PointFeature())
3299                    self.members[-1].fromXML(featureFrag)
3300                if featureFrag.tag == CSML('ProfileFeature'):
3301                    self.members.append(ProfileFeature())
3302                    self.members[-1].fromXML(featureFrag)
3303                if featureFrag.tag == CSML('GridFeature'):
3304                    self.members.append(GridFeature())
3305                    self.members[-1].fromXML(featureFrag)
3306                if featureFrag.tag == CSML('PointSeriesFeature'):
3307                    self.members.append(PointSeriesFeature())
3308                    self.members[-1].fromXML(featureFrag)
3309                if featureFrag.tag == CSML('ProfileSeriesFeature'):
3310                    self.members.append(ProfileSeriesFeature())
3311                    self.members[-1].fromXML(featureFrag)
3312                if featureFrag.tag == CSML('GridSeriesFeature'):
3313                    self.members.append(GridSeriesFeature())
3314                    self.members[-1].fromXML(featureFrag)
3315                if featureFrag.tag == CSML('TrajectoryFeature'):
3316                    self.members.append(TrajectoryFeature())
3317                    self.members[-1].fromXML(featureFrag)
3318    def toXML(self,csmlFrag):
3319        AbstractFeature.toXML(self,csmlFrag)
3320        for member in self.members:
3321            if isinstance(member,PointFeature):
3322                superFrag=Element(GML('featureMember'))
3323                frag=Element(CSML('PointFeature'))
3324                PointFeature.toXML(member,frag)
3325                superFrag.append(frag)
3326                csmlFrag.append(superFrag)
3327            if isinstance(member,ProfileFeature):
3328                superFrag=Element(GML('featureMember'))
3329                frag=Element(CSML('ProfileFeature'))
3330                ProfileFeature.toXML(member,frag)
3331                superFrag.append(frag)
3332                csmlFrag.append(superFrag)
3333            if isinstance(member,GridFeature):
3334                superFrag=Element(GML('featureMember'))
3335                frag=Element(CSML('GridFeature'))
3336                GridFeature.toXML(member,frag)
3337                superFrag.append(frag)
3338                csmlFrag.append(superFrag)
3339            if isinstance(member,PointSeriesFeature):
3340                superFrag=Element(GML('featureMember'))
3341                frag=Element(CSML('PointSeriesFeature'))
3342                PointSeriesFeature.toXML(member,frag)
3343                superFrag.append(frag)
3344                csmlFrag.append(superFrag)
3345            if isinstance(member,ProfileSeriesFeature):
3346                superFrag=Element(GML('featureMember'))
3347                frag=Element(CSML('ProfileSeriesFeature'))
3348                ProfileSeriesFeature.toXML(member,frag)
3349                superFrag.append(frag)
3350                csmlFrag.append(superFrag)
3351            if isinstance(member,GridSeriesFeature):
3352                superFrag=Element(GML('featureMember'))
3353                frag=Element(CSML('GridSeriesFeature'))
3354                GridSeriesFeature.toXML(member,frag)
3355                superFrag.append(frag)
3356                csmlFrag.append(superFrag)
3357            if isinstance(member,TrajectoryFeature):
3358                superFrag=Element(GML('featureMember'))
3359                frag=Element(CSML('TrajectoryFeature'))
3360                TrajectoryFeature.toXML(member,frag)
3361                superFrag.append(frag)
3362                csmlFrag.append(superFrag)
3363       
3364        return csmlFrag
3365
3366class FeatureCollection(AbstractFeatureCollection):
3367    """GML FeatureCollection class
3368        FeatureCollection()
3369        +featureMembers[0..*]
3370    """
3371    def __init__(self,*args,**kwargs):
3372        AbstractFeatureCollection.__init__(self,*args,**kwargs)
3373    def fromXML(self,csmlFrag):
3374        AbstractFeatureCollection.fromXML(self,csmlFrag)
3375    def toXML(self,csmlFrag):
3376        AbstractFeatureCollection.toXML(self,csmlFrag)
3377        return csmlFrag
3378
3379
3380class SimpleCondition(object):
3381        """ SimpleCondition (security)
3382        SimpleCondition():
3383        dgAttributeAuthority[0..*]:string
3384        attrauthRole[0..*]:string
3385        """
3386        def __init__(self,dgAttributeAuthority=None,attrauthRole=None,*args,**kwargs):
3387            if dgAttributeAuthority:
3388                self.dgAttributeAuthority=dgAttributeAuthority
3389            if attrauthRole:
3390                self.attrauthRole=attrauthRole
3391        def fromXML(self,csmlFrag):
3392            for frag in csmlFrag.getchildren():
3393                if frag.tag == MOLES('dgAttributeAuthority'):
3394                    self.dgAttributeAuthority=frag.text
3395                if frag.tag == MOLES('attrauthRole'):
3396                    self.attrauthRole=frag.text
3397        def toXML(self,csmlFrag):
3398            if hasattr(self,'dgAttributeAuthority'):
3399                frag=Element(MOLES('dgAttributeAuthority'))
3400                frag.text=self.dgAttributeAuthority
3401                csmlFrag.append(frag)
3402            if hasattr(self,'attrauthRole'):
3403                frag=Element(MOLES('attrauthRole'))
3404                frag.text=self.attrauthRole
3405                csmlFrag.append(frag)
3406            return csmlFrag
3407   
3408class DGSecurityCondition(object):
3409        """ DGSecurityCondition():
3410             +effect[0..1]:string
3411             +simpleCondition[0..1]:SimpleCondition
3412             +complexCondition[0..1]:ComplexCondition (not implemented)
3413             +conditionExplanationText[0..1]:string
3414        """
3415        def __init__(self,effect=None,simpleCondition=None, complexCondition=None, conditionExplanationText=None,*args,**kwargs):
3416            if effect:
3417                self.effect=effect
3418            if simpleCondition:
3419                self.simpleCondition=simpleCondition
3420            if complexCondition:
3421                self.complexCondition=complexCondition
3422            if conditionExplanationText:
3423                self.conditionExplanationText=conditionExplanationText
3424        def fromXML(self,csmlFrag):
3425            for frag in csmlFrag.getchildren():
3426                if frag.tag == MOLES('effect'):
3427                    self.effect=frag.text
3428                elif frag.tag == MOLES('conditionExplanationText'):
3429                    self.conditionExplanationText=frag.text
3430                elif frag.tag == MOLES('simpleCondition'):
3431                    simpleCondition=SimpleCondition()
3432                    simpleCondition.fromXML(frag)
3433                    self.simpleCondition=simpleCondition
3434        def toXML(self,csmlFrag):
3435            if hasattr(self,'effect'):
3436                frag=Element(MOLES('effect'))
3437                frag.text=self.effect
3438                csmlFrag.append(frag)
3439            if hasattr(self,'simpleCondition'):
3440                frag=Element(MOLES('simpleCondition'))
3441                frag = SimpleCondition.toXML(self.simpleCondition,frag)
3442                csmlFrag.append(frag)
3443            return csmlFrag
3444       
3445class AccessControlPolicy(object):
3446        """ AccessControlPolicy():
3447            +dgSecurityConditions[0..*]:DGSecurityCondition
3448            +accessControlPolicyText[0..1]:string
3449            +accessControlPolicyURL[0..1]:anyURI
3450        """
3451        def __init__(self,dgSecurityConditions=None,accessControlPolicyText=None,accessControlPolicyURL=None,*args,**kwargs):
3452            if dgSecurityConditions:
3453                self.dgSecurityConditions=dgSecurityConditions
3454            if accessControlPolicyText:
3455                self.accessControlPolicyText= accessControlPolicyText
3456            if accessControlPolicyURL:
3457                self.accessControlPolicyURL= accessControlPolicyURL
3458        def fromXML(self,csmlFrag):
3459           
3460            for frag in csmlFrag.getchildren():
3461                if frag.tag == MOLES('dgSecurityCondition'):
3462                    checkArrayAttrib(self, 'dgSecurityConditions')
3463                    dgSecurityCondition=DGSecurityCondition()
3464                    dgSecurityCondition.fromXML(frag)
3465                    self.dgSecurityConditions.append(dgSecurityCondition)
3466                elif frag.tag == MOLES('accessControlPolicyText'):
3467                    checkArrayAttrib(self,'accessControlPolicyText')
3468                    self.accessControlPolicyText.append(frag.text)
3469                elif frag.tag == MOLES('accessControlPolicyURL'):
3470                    checkArrayAttrib(self,'accessControlPolicyURL')
3471                    self.accessControlPolicyURL.append(frag.text)
3472        def toXML(self,csmlFrag):
3473            if hasattr(self,'dgSecurityConditions'):
3474                for condition in self.dgSecurityConditions:
3475                    frag = Element(MOLES('dgSecurityCondition'))
3476                    frag = DGSecurityCondition.toXML(condition,frag)
3477                    csmlFrag.append(frag)
3478            if hasattr(self,'accessControlPolicyText'):     
3479                for txt in self.accessControlPolicyText:
3480                    frag=Element(MOLES('accessControlPolicyText'))
3481                    frag.text=txt
3482                    csmlFrag.append(frag)
3483            if hasattr(self,'accessControlPolicyURL'):     
3484                for policyURL in self.accessControlPolicyURL:
3485                    frag=Element(MOLES('accessControlPolicyURL'))
3486                    frag.text=policyURL
3487                    csmlFrag.append(frag)
3488            return csmlFrag
3489       
3490class Dataset(AbstractGML):
3491    """CSML Dataset class
3492
3493    Dataset(AbstractGML):
3494     + accessControlPolicy[0...1]:AccessControlPolicy
3495     +unitDefinitions[0..*]: UnitDefinitions
3496     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
3497     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
3498     +arrayDescriptors[0..*]: AbstractArrayDescriptor
3499     +featureCollection[0..1]: FeatureCollection
3500    """
3501    def __init__(self,accessControlPolicy=None, unitDefinitions=None,referenceSystemDefinitions=None,
3502                 phenomenonDefinitions=None,arrayDescriptors=[],
3503                 featureCollection=None,*args,**kwargs):
3504        AbstractGML.__init__(self,*args,**kwargs)
3505        if accessControlPolicy:
3506            self.accessControlPolicy=accessControlPolicy
3507        if unitDefinitions:
3508            self.unitDefinitions = unitDefinitions
3509        if referenceSystemDefinitions:
3510            self.referenceSystemDefinitions = referenceSystemDefinitions
3511        if phenomenonDefinitions:
3512            self.phenomenonDefinitions = phenomenonDefinitions
3513        if arrayDescriptors:
3514            self.arrayDescriptors = arrayDescriptors
3515        if featureCollection:
3516            self.featureCollection = featureCollection
3517    def fromXML(self,csmlFrag):
3518        if csmlFrag.tag != CSML('Dataset'):
3519            print 'This does not appear to be a CSML file. Does not contain a root Dataset element.'
3520            print ' '
3521            sys.exit()
3522        AbstractGML.fromXML(self,csmlFrag)
3523        for frag in csmlFrag.getchildren():
3524            if frag.tag == CSML('AccessControlPolicy'):
3525                self.accessControlPolicy = AccessControlPolicy()
3526                self.accessControlPolicy.fromXML(frag)
3527            elif frag.tag == CSML('UnitDefinitions'):
3528                self.unitDefinitions = UnitDefinitions()
3529                self.unitDefinitions.fromXML(frag)
3530            elif frag.tag == CSML('ReferenceSystemDefinitions'):
3531                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
3532                self.referenceSystemDefinitions.fromXML(frag)
3533            elif frag.tag == CSML('PhenomenonDefinitions'):
3534                self.phenomenonDefinitions = PhenomenonDefinitions()
3535                self.phenomenonDefinitions.fromXML(frag)
3536            elif frag.tag == GML('FeatureCollection'):
3537                self.featureCollection = FeatureCollection()
3538                self.featureCollection.fromXML(frag)
3539            elif frag.tag == CSML('AggregatedArray'):
3540                checkArrayAttrib(self,'arrayDescriptors')
3541                self.arrayDescriptors.append(AggregatedArray())
3542                self.arrayDescriptors[-1].fromXML(frag)
3543            elif frag.tag == CSML('InlineArray'):
3544                checkArrayAttrib(self,'arrayDescriptors')
3545                self.arrayDescriptors.append(InlineArray())
3546                self.arrayDescriptors[-1].fromXML(frag)
3547            elif frag.tag == CSML('ArrayGenerator'):
3548                checkArrayAttrib(self,'arrayDescriptors')
3549                self.arrayDescriptors.append(ArrayGenerator())
3550                self.arrayDescriptors[-1].fromXML(frag)
3551            elif frag.tag == CSML('NASAAmesExtract'):
3552                checkArrayAttrib(self,'arrayDescriptors')
3553                self.arrayDescriptors.append(NASAAmesExtract())
3554                self.arrayDescriptors[-1].fromXML(frag)
3555            elif frag.tag == CSML('NetCDFExtract'):
3556                checkArrayAttrib(self,'arrayDescriptors')
3557                self.arrayDescriptors.append(NetCDFExtract())
3558                self.arrayDescriptors[-1].fromXML(frag)
3559            elif frag.tag == CSML('GRIBExtract'):
3560                checkArrayAttrib(self,'arrayDescriptors')
3561                self.arrayDescriptors.append(GRIBExtract())
3562                self.arrayDescriptors[-1].fromXML(frag)
3563            elif frag.tag == CSML('PPExtract'):
3564                checkArrayAttrib(self,'arrayDescriptors')
3565                self.arrayDescriptors.append(PPExtract())
3566                self.arrayDescriptors[-1].fromXML(frag)
3567##            else:
3568##                raise Exception('Unexpected element: "'+frag.tag+'"')
3569    def toXML(self,csmlFrag=None):
3570        if csmlFrag is None:
3571            csmlFrag = Element('Dataset')
3572        csmlFrag = AbstractGML.toXML(self,csmlFrag)
3573        if hasattr(self,'accessControlPolicy'):
3574            frag = Element(CSML('AccessControlPolicy'))
3575            frag = AccessControlPolicy.toXML(self.accessControlPolicy,frag)
3576            csmlFrag.append(frag)
3577        if hasattr(self,'unitDefinitions'):
3578            frag = Element(CSML('UnitDefinitions'))
3579            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
3580            csmlFrag.append(frag)
3581        if hasattr(self,'referenceSystemDefinitions'):
3582            frag = Element(CSML('ReferenceSystemDefinitions'))
3583            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
3584            csmlFrag.append(frag)
3585        if hasattr(self,'phenomenonDefinitions'):
3586            frag = Element(CSML('PhenomenonDefinitions'))
3587            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
3588            csmlFrag.append(frag)
3589        if hasattr(self,'arrayDescriptors'):
3590            for arrayDesc in self.arrayDescriptors:
3591                if isinstance(arrayDesc,AggregatedArray):
3592                    frag = Element(CSML('AggregatedArray'))
3593                    frag = AggregatedArray.toXML(arrayDesc,frag)
3594                elif isinstance(arrayDesc,InlineArray):
3595                    frag = Element(CSML('InlineArray'))
3596                    frag = InlineArray.toXML(arrayDesc,frag)
3597                elif isinstance(arrayDesc,ArrayGenerator):
3598                    frag = Element(CSML('ArrayGenerator'))
3599                    frag = ArrayGenerator.toXML(arrayDesc,frag)
3600                elif isinstance(arrayDesc,NASAAmesExtract):
3601                    frag = Element(CSML('NASAAmesExtract'))
3602                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
3603                elif isinstance(arrayDesc,NetCDFExtract):
3604                    frag = Element(CSML('NetCDFExtract'))
3605                    frag = NetCDFExtract.toXML(arrayDesc,frag)
3606                elif isinstance(arrayDesc,GRIBExtract):
3607                    frag = Element(CSML('GRIBExtract'))
3608                    frag = GRIBExtract.toXML(arrayDesc,frag)
3609                elif isinstance(arrayDesc,PPExtract):
3610                    frag = Element(CSML('PPExtract'))
3611                    frag = PPExtract.toXML(arrayDesc,frag)
3612                csmlFrag.append(frag)
3613        if hasattr(self,'featureCollection'):
3614            frag = Element(GML('FeatureCollection'))
3615            frag = FeatureCollection.toXML(self.featureCollection,frag)
3616            csmlFrag.append(frag)
3617            #csmlFrag=fixNameSpaces(csmlFrag)
3618        return csmlFrag
Note: See TracBrowser for help on using the repository browser.