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

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

Some fixes to Parser and Scanner to enable scanning of GRIB files

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