source: TI02-CSML/trunk/newparser/Parser.py @ 678

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

GridSeriesFeatures? done

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
76##class TemplateClass(Base):
77##    def __init__(self,myarg=None,*args,**kwargs):
78##        Base.__init__(self,*args,**kwargs)
79##        # code specific to TemplateClass
80##    def fromXML(self,csmlFrag):
81##        Base.fromXML(self,csmlFrag)
82##        # code specific to TemplateClass
83##    def toXML(self,csmlFrag):
84##        csmlFrag = Base.toXML(self,csmlFrag)
85##        # code specific to TemplateClass
86##        return csmlFrag
87
88class MetaDataProperty:
89    """Class representing metadata property (gmlBase.xsd)
90
91    MetaDataProperty:
92     +href: URI
93    """
94    def __init__(self,href=None):
95        if href:
96            self.href = href
97    def fromXML(self,csmlFrag):
98        if csmlFrag.attrib.has_key(XLINK('href')):
99            #print "METADATA PROPERTY FOUND"
100            #print (csmlFrag.attrib[XLINK('href')])
101            self.href = csmlFrag.attrib[XLINK('href')]
102    def toXML(self,csmlFrag):
103        if hasattr(self,'href'):
104            csmlFrag.attrib[XLINK('href')] = self.href
105        return csmlFrag
106
107class Description(MutableString):
108    """Class representing a GML description element
109    Description(string):
110    """
111    def __init__(self,val=''):
112        MutableString.__init__(self,val)
113    def fromXML(self,csmlFrag):
114        self.data = csmlFrag.text
115    def toXML(self,csmlFrag):
116        csmlFrag.text = self.data
117        return csmlFrag
118
119class Name(MutableString):
120    """Class representing a GML name element
121
122    Name(string):
123     +codeSpace[0..1]: anyURI
124    """
125    def __init__(self,val='',codeSpace=None):
126        MutableString.__init__(self,val)
127        if codeSpace:
128            self.codeSpace = codeSpace
129    def fromXML(self,csmlFrag):
130        self.data = csmlFrag.text
131#Andrew:
132## For some reason, namespace on 'codeSpace' attribute not being picked up...
133##        if csmlFrag.attrib.has_key(GML('codeSpace')):
134##            self.codeSpace = csmlFrag.attrib[GML('codeSpace')]
135#Dominic:
136##  I think this is because it has no explicit namespace in the XML doc eg.: <gml:name codeSpace="http://ndg.nerc....
137## unlike say: gml:id which has the gml: prefix explicitly e.g. <gml:UnitDefinition gml:id="psu">
138
139        if csmlFrag.attrib.has_key('codeSpace'):
140            self.codeSpace = csmlFrag.attrib['codeSpace']
141    def toXML(self,csmlFrag):
142        csmlFrag.text = self.data
143        if hasattr(self,'codeSpace'):
144##            csmlFrag.attrib[GML('codeSpace')] = self.codeSpace
145            csmlFrag.attrib['codeSpace'] = self.codeSpace
146        return csmlFrag
147
148class AbstractGML:
149    """Base abstract GML type
150
151    AbstractGML:
152     +id[0..1]: ID
153     +metaDataProperty[0..*]: MetaDataProperty
154     +description[0..1]: Description
155     +name[0..*]: Name
156    """
157    def __init__(self,gmlid=None,metaDataProperty=[],description=None,name=[],*args,**kwargs):
158        if gmlid:
159            self.id = gmlid
160        if metaDataProperty:
161            self.metaDataProperty = metaDataProperty
162        if description:
163            self.description = description
164        if name:
165            self.name = name
166    def fromXML(self,csmlFrag):
167        if csmlFrag.attrib.has_key(GML('id')):
168            self.id = csmlFrag.attrib[GML('id')]
169        for frag in csmlFrag.getchildren():
170            if frag.tag == GML('metaDataProperty'):
171                checkArrayAttrib(self,'metaDataProperty')
172                self.metaDataProperty.append(MetaDataProperty())
173                self.metaDataProperty[-1].fromXML(frag)
174            elif frag.tag == GML('description'):
175                self.description = Description()
176                self.description.fromXML(frag)
177            elif frag.tag == GML('name'):
178                checkArrayAttrib(self,'name')
179                self.name.append(Name())
180                self.name[-1].fromXML(frag)
181    def toXML(self,csmlFrag):
182        if hasattr(self,'id'):
183            csmlFrag.attrib[GML('id')] = self.id
184        if hasattr(self,'metaDataProperty'):
185            for md in self.metaDataProperty:
186                frag = Element(GML('metaDataProperty'))
187                frag = MetaDataProperty.toXML(md,frag)
188                csmlFrag.append(frag)
189        if hasattr(self,'description'):
190            frag = Element(GML('description'))
191            frag = Description.toXML(self.description,frag)
192            csmlFrag.append(frag)
193        if hasattr(self,'name'):
194            for name in self.name:
195                frag = Element(GML('name'))
196                frag = Name.toXML(name,frag)
197                csmlFrag.append(frag)
198        return csmlFrag
199
200class UnitDefinitions:
201    def __init__(self):
202        pass
203    def fromXML(self,csmlFrag):
204        pass
205    def toXML(self,csmlFrag):
206        return csmlFrag
207
208class ReferenceSystemDefinitions:
209    def __init__(self):
210        pass
211    def fromXML(self,csmlFrag):
212        pass
213    def toXML(self,csmlFrag):
214        return csmlFrag
215
216class PhenomenonDefinitions:
217    def __init__(self):
218        pass
219    def fromXML(self,csmlFrag):
220        pass
221    def toXML(self,csmlFrag):
222        return csmlFrag
223
224class AbstractArrayDescriptor(AbstractGML):
225    """Base abstract class for CSML array descriptors
226
227    AbstractArrayDescriptor(AbstractGML):
228     +arraySize[1..*]: int
229     +uom[0..1]: anyURI
230     +numericType[0..1]: string
231     +regExpTransform[0..1]: string
232     +numericTransform[0..1]: string
233    """
234    def __init__(self,arraySize=None,uom=None,numericType=None,
235                 regExpTransform=None,numericTransform=None,*args,**kwargs):
236        AbstractGML.__init__(self,*args,**kwargs)
237        if arraySize:
238            self.arraySize = arraySize
239        if uom:
240            self.uom = uom
241        if numericType:
242            self.numericType = numericType
243        if regExpTransform:
244            self.regExpTransform = regExpTransform
245        if numericTransform:
246            self.numericTransform = numericTransform
247    def fromXML(self,csmlFrag):
248        AbstractGML.fromXML(self,csmlFrag)
249        for frag in csmlFrag.getchildren():
250            if frag.tag == CSML('arraySize'):
251                self.arraySize = map(int,frag.text.split())
252            elif frag.tag == CSML('uom'):
253                self.uom = frag.text
254            elif frag.tag == CSML('numericType'):
255                self.numericType = frag.text
256            elif frag.tag == CSML('regExpTransform'):
257                self.regExpTransform = frag.text
258            elif frag.tag == CSML('numericTransform'):
259                self.numericTransform = frag.text
260    def toXML(self,csmlFrag):
261        csmlFrag = AbstractGML.toXML(self,csmlFrag)
262        if hasattr(self,'arraySize'):
263            frag = Element(CSML('arraySize'))
264            frag.text = ' '.join(map(str,self.arraySize))
265            csmlFrag.append(frag)
266        if hasattr(self,'uom'):
267            frag = Element(CSML('uom'))
268            frag.text = self.uom
269            csmlFrag.append(frag)
270        if hasattr(self,'numericType'):
271            frag = Element(CSML('numericType'))
272            frag.text  = self.numericType
273            csmlFrag.append(frag)
274        if hasattr(self,'regExpTransform'):
275            frag = Element(CSML('regExpTransform'))
276            frag.text = self.regExpTransform
277            csmlFrag.append(frag)
278        if hasattr(self,'numericTransform'):
279            frag = Element(CSML('numericTransform'))
280            frag.text = self.numericTransform
281            csmlFrag.append(frag)
282        return csmlFrag
283
284class AggregatedArray(AbstractArrayDescriptor):
285    """CSML class for aggregated array
286
287    AggregatedArray(AbstractArrayDescriptor):
288     +aggType: string
289     +aggIndex: int
290     +component[1..*]: AbstractArrayDescriptor
291    """
292    def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs):
293        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
294        if aggType:
295            self.aggType = aggType
296        if aggIndex:
297            self.aggIndex = aggIndex
298        if component:
299            self.component = component
300    def fromXML(self,csmlFrag):
301        AbstractArrayDescriptor.fromXML(self,csmlFrag)
302        for frag in csmlFrag.getchildren():
303            if frag.tag == CSML('aggType'):
304                self.aggType = frag.text
305            elif frag.tag == CSML('aggIndex'):
306                self.aggIndex = int(frag.text)
307            elif frag.tag == CSML('component'):
308                checkArrayAttrib(self,'component')
309                componentFrag = frag[0]
310                if componentFrag.tag == CSML('AggregatedArray'):
311                    self.component.append(AggregatedArray())
312                elif componentFrag.tag == CSML('InlineArray'):
313                    self.component.append(InlineArray())
314                elif componentFrag.tag == CSML('ArrayGenerator'):
315                    self.component.append(ArrayGenerator())
316                elif componentFrag.tag == CSML('NASAAmesExtract'):
317                    self.component.append(NASAAmesExtract())
318                elif componentFrag.tag == CSML('NetCDFExtract'):
319                    self.component.append(NetCDFExtract())
320                elif componentFrag.tag == CSML('GRIBExtract'):
321                    self.component.append(GRIBExtract())
322##                else:
323##                    raise Exception('Unexpected element: "'+componentFrag.tag+'"')
324                self.component[-1].fromXML(componentFrag)
325    def toXML(self,csmlFrag):
326        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
327        if hasattr(self,'aggType'):
328            frag = Element(CSML('aggType'))
329            frag.text = self.aggType
330            csmlFrag.append(frag)
331        if hasattr(self,'aggIndex'):
332            frag = Element(CSML('aggIndex'))
333            frag.text = str(self.aggIndex)
334            csmlFrag.append(frag)
335        if hasattr(self,'component'):
336            compFrag = Element(CSML('component'))
337            for comp in self.component:
338                if isinstance(comp,AggregatedArray):
339                    frag = Element(CSML('AggregatedArray'))
340                    frag = AggregatedArray.toXML(comp,frag)
341                elif isinstance(comp,InlineArray):
342                    frag = Element(CSML('InlineArray'))
343                    frag = InlineArray.toXML(comp,frag)
344                elif isinstance(comp,ArrayGenerator):
345                    frag = Element(CSML('ArrayGenerator'))
346                    frag = ArrayGenerator.toXML(comp,frag)
347                elif isinstance(comp,NASAAmesExtract):
348                    frag = Element(CSML('NASAAmesExtract'))
349                    frag = NASAAmesExtract.toXML(comp,frag)
350                elif isinstance(comp,NetCDFExtract):
351                    frag = Element(CSML('NetCDFExtract'))
352                    frag = NetCDFExtract.toXML(comp,frag)
353                elif isinstance(comp,GRIBExtract):
354                    frag = Element(CSML('GRIBExtract'))
355                    frag = NASAAmesExtract.toXML(comp,frag)
356                compFrag.append(frag)
357            csmlFrag.append(compFrag)
358        return csmlFrag
359
360class InlineArray(AbstractArrayDescriptor):
361    pass
362
363class ArrayGenerator(AbstractArrayDescriptor):
364    pass
365
366class AbstractFileExtract(AbstractArrayDescriptor):
367    """Base abstract clas for CSML file array extract
368
369    AbstractFileExtract(AbstractArrayDescriptor):
370     +fileName: string
371    """
372    def __init__(self,fileName=None,*args,**kwargs):
373        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
374        if fileName:
375            self.fileName = fileName
376    def fromXML(self,csmlFrag):
377        AbstractArrayDescriptor.fromXML(self,csmlFrag)
378        for frag in csmlFrag.getchildren():
379            if frag.tag == CSML('fileName'):
380                self.fileName = frag.text
381##        else:
382##            raise Exception('Unexpected element: "'+frag.tag+'"')
383    def toXML(self,csmlFrag):
384        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
385        if hasattr(self,'fileName'):
386            frag = Element(CSML('fileName'))
387            frag.text = self.fileName
388            csmlFrag.append(frag)
389        return csmlFrag
390
391class NASAAmesExtract(AbstractFileExtract):
392    """CSML class for NASA Ames file extract
393
394    NASAAmesExtract(AbstractFileExtract):
395     +variableName: string
396     +index[0..1]: int
397    """
398    def __init__(self,variableName=None,index=None,*args,**kwargs):
399        AbstractFileExtract.__init__(self,*args,**kwargs)
400        if variableName:
401            self.variableName = variableName
402        if index:
403            self.index = index
404    def fromXML(self,csmlFrag):
405        AbstractFileExtract.fromXML(self,csmlFrag)
406        for frag in csmlFrag.getchildren():
407            if frag.tag == CSML('variableName'):
408                self.variableName = frag.text
409            elif frag.tag == CSML('index'):
410                self.index = int(frag.text)
411##            else:
412##                raise Exception('Unexpected element: "'+frag.tag+'"')
413    def toXML(self,csmlFrag):
414        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
415        frag = Element(CSML('variableName'))
416        frag.text = self.variableName
417        csmlFrag.append(frag)
418        if hasattr(self,'index'):
419            frag = Element(CSML('index'))
420            frag.text = str(self.index)
421            csmlFrag.append(frag)
422        return csmlFrag
423
424class NetCDFExtract(AbstractFileExtract):
425    """CSML class for netCDF file extract
426
427    NetCDFExtract(AbstractFileExtract):
428     +variableName: string
429    """
430    def __init__(self,variableName=None,*args,**kwargs):
431        AbstractFileExtract.__init__(self,*args,**kwargs)
432        if variableName:
433            self.variableName = variableName
434    def fromXML(self,csmlFrag):
435        AbstractFileExtract.fromXML(self,csmlFrag)
436        for frag in csmlFrag.getchildren():
437            if frag.tag == CSML('variableName'):
438                self.variableName = frag.text
439##        else:
440##            raise Exception('Unexpected element: "'+frag.tag+'"')
441    def toXML(self,csmlFrag):
442        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
443        if hasattr(self, 'variableName'):
444            frag = Element(CSML('variableName'))
445            frag.text = self.variableName
446            csmlFrag.append(frag)
447        return csmlFrag
448
449class GRIBExtract(AbstractFileExtract):
450    """CSML class for GRIB file extract
451
452    GRIBExtract(AbstractFileExtract):
453     +parameterCode: int
454     +recordNumber[0..1]: int
455     +fileOffset[0..1]: int
456    """
457    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, *args,**kwargs):
458        AbstractFileExtract.__init__(self,*args,**kwargs)
459        if parameterCode:
460            self.parameterCode = parameterCode
461        if recordNumber:
462            self.recordNumber = recordNumber
463        if fileOffset:
464            self.fileOffset = fileOffset
465    def fromXML(self,csmlFrag):
466        AbstractFileExtract.fromXML(self,csmlFrag)
467        for frag in csmlFrag.getchildren():
468            if frag.tag == CSML('parameterCode'):
469                self.parameterCode = int(frag.text)
470            elif frag.tag == CSML('recordNumber'):
471                self.recordNumber = int(frag.text)
472            elif frag.tag == CSML('fileOffset'):
473                self.fileOffset = int(frag.text)
474##            else:
475##                raise Exception('Unexpected element: "'+frag.tag+'"')
476    def toXML(self,csmlFrag):
477        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
478        frag = Element(CSML('parameterCode'))
479        frag.text = str(self.parameterCode)
480        csmlFrag.append(frag)
481        if hasattr(self,'recordNumber'):
482            frag = Element(CSML('recordNumber'))
483            frag.text = str(self.recordNumber)
484            csmlFrag.append(frag)
485        if hasattr(self,'fileOffset'):
486            frag = Element(CSML('fileOffset'))
487            frag.text = str(self.fileOffset)
488            csmlFrag.append(frag)
489        return csmlFrag
490
491class DirectPositionList:
492    #class representing a DirectPositionList
493    def __init__(self):
494        pass
495    def fromXML(self,csmlFrag):
496        self.text=csmlFrag.text
497        if csmlFrag.attrib.has_key('srsName'):
498            self.srsName=csmlFrag.attrib['srsName']
499    def toXML(self,csmlFrag): 
500        csmlFrag.text=self.text
501        if hasattr(self,'srsName'):
502            csmlFrag.attrib['srsName']=self.srsName
503        return csmlFrag
504       
505class MappingRule(MutableString):
506    """Class representing a GML MappingRule element(string):
507    """
508    def __init__(self,val=''):
509        MutableString.__init__(self,val)
510    def fromXML(self,csmlFrag):
511        self.data = csmlFrag.text
512        if csmlFrag.attrib.has_key('scanOrder'):
513            self.scanOrder=csmlFrag.attrib['scanOrder']
514    def toXML(self,csmlFrag):
515        csmlFrag.text = self.data
516        if hasattr(self,'scanOrder'):
517            csmlFrag.attrib['scanOrder']=self.scanOrder
518        return csmlFrag
519
520   
521   
522   
523   
524class AbstractDiscreteCoverage(AbstractGML):
525     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
526    #GML AbstractDiscreteCoverage Class
527    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs):
528        AbstractGML.__init__(self,*args,**kwargs)
529        if rangeSet:
530            self.rangeSet=rangeSet
531        if coverageFunction:
532            self.coverageFunction=coverageFunction
533
534    def fromXML(self,csmlFrag):
535        AbstractGML.fromXML(self,csmlFrag)
536        for frag in csmlFrag.getchildren():
537            if frag.tag == GML('rangeSet'):
538                self.rangeSet=RangeSet()
539                self.rangeSet.fromXML(frag)
540            if frag.tag == GML('coverageFunction'):
541                self.coverageFunction=MappingRule()
542                for subFrag in frag.getchildren():
543                    if subFrag.tag==CSML('MappingRule'):
544                        self.coverageFunction.fromXML(subFrag)
545
546
547    def toXML(self,csmlFrag):
548        AbstractGML.toXML(self,csmlFrag)
549        if hasattr(self,'rangeSet'):
550            frag = Element(GML('rangeSet'))
551            RangeSet.toXML(self.rangeSet,frag)
552            csmlFrag.append(frag)
553        if hasattr(self,'coverageFunction'):
554            frag = Element(GML('coverageFunction'))
555            subFrag=Element(CSML('MappingRule'))
556            MappingRule.toXML(self.coverageFunction,subFrag)
557            frag.append(subFrag)
558            csmlFrag.append(frag)
559        return csmlFrag
560       
561class AbstractCoverageFeature(AbstractDiscreteCoverage):
562    #CSML Abstract Coverage FT class
563    #     AbstractCoverageFeature(AbstractDiscreteCoverage)
564    #       + om:parameter:PhenomenonPropertyType
565   
566    def __init__(self, parameter=None, *args,**kwargs):
567        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
568        if parameter:
569            self.parameter=parameter
570    def fromXML(self,csmlFrag):
571        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
572        for frag in csmlFrag.getchildren():
573            if frag.tag == CSML('parameter'):
574                self.parameter=None
575                if frag.getchildren() == []:
576                    if frag.attrib.has_key(XLINK('href')):
577                        self.href = frag.attrib[XLINK('href')]
578                else:
579                    subFrag=frag.getchildren()[0]
580                    if subFrag.tag == OM('Phenomenon'):
581                        self.parameter = Phenomenon()
582                    elif subFrag.tag == OM('CompositePhenomenon'):
583                        self.parameter = CompositePhenomenon()
584                    elif subFrag.tag == OM('ParameterisedPhenomenon'):
585                        self.parameter = ParameterisedPhenomenon()
586                if hasattr(self,'parameter'):
587                    if self.parameter is not None:
588                        self.parameter.fromXML(subFrag)
589                       
590    def toXML(self,csmlFrag):
591        AbstractDiscreteCoverage.toXML(self,csmlFrag)
592        if hasattr(self,'parameter'):
593            frag = Element(CSML('parameter'))
594            if isinstance(self.parameter,ParameterisedPhenomenon):
595                subFrag=Element(OM('ParameterisedPhenomenon'))
596                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
597                frag.append(subFrag)
598                csmlFrag.append(frag)
599            elif isinstance(self.parameter,CompositePhenomenon):
600                subFrag=Element(OM('CompositePhenomenon'))
601                CompositePhenomenon.toXML(self.parameter,subFrag)
602                frag.append(subFrag)
603                csmlFrag.append(frag)
604            elif isinstance(self.parameter,Phenomenon):
605                subFrag=Element(OM('Phenomenon'))
606                Phenomenon.toXML(self.parameter,subFrag)
607                frag.append(subFrag)
608                csmlFrag.append(frag)
609
610            if hasattr(self, 'href'):
611                frag.attrib[XLINK('href')] = self.href
612
613        return csmlFrag
614
615   
616class AbstractStaticCoverageFeature(AbstractCoverageFeature):
617    #CSML Abstract Static Coverage FT class
618    def __init__(self,*args,**kwargs):
619        AbstractCoverageFeature.__init__(self,*args,**kwargs)
620    def fromXML(self,csmlFrag):
621        AbstractCoverageFeature.fromXML(self,csmlFrag)
622    def toXML(self,csmlFrag):
623        AbstractCoverageFeature.toXML(self,csmlFrag)
624        return csmlFrag
625   
626class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
627    #CSML Abstract Series Coverage FT class
628    def __init__(self,*args,**kwargs):
629        AbstractCoverageFeature.__init__(self,*args,**kwargs)
630    def fromXML(self,csmlFrag):
631        AbstractCoverageFeature.fromXML(self,csmlFrag)
632    def toXML(self,csmlFrag):
633        AbstractCoverageFeature.toXML(self,csmlFrag)
634        return csmlFrag
635   
636class AbstractDomain:
637    #CSML AbstractDomain class
638    #   AbstractDomain()
639    #   +csml:domainReference
640    #   +csml:domainComplement [0...1]
641       
642    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
643        if domainReference:
644            self.domainReference=domainReference
645        if domainComplement:
646            self.domainComplement=domainComplement
647    def fromXML(self,csmlFrag):
648        for frag in csmlFrag.getchildren():
649            if frag.tag == CSML('domainReference'):
650                subfrag=frag.getchildren()[0]
651                if subfrag.tag==CSML('Position'):
652                    self.domainReference=Position()
653                elif subfrag.tag == CSML('Trajectory'):
654                    self.domainReference=Trajectory()
655                elif subfrag.tag==CSML('OrientedPosition'):
656                    self.domainReference=OrientedPosition()
657                elif subfrag.tag == CSML('OrientedTrajectory'):
658                    self.domainReference=OrientedTrajectory()
659                elif subfrag.tag == GML('TimeInstant'):
660                    self.domainReference=TimeInstant()
661                elif subfrag.tag == GML('TimePositionList'):
662                    self.domainReference=TimePositionList()
663                self.domainReference.fromXML(subfrag)
664               
665            if frag.tag == CSML('domainComplement'):
666                subfrag=frag.getchildren()[0]
667                if subfrag.tag==CSML('DirectPositionList'):
668                    self.domainComplement=DirectPositionList()
669                    self.domainComplement.fromXML(subfrag)
670                elif subfrag.tag==CSML('Grid'):
671                    self.domainComplement=Grid()
672                    self.domainComplement.fromXML(subfrag)
673    def toXML(self,csmlFrag):
674        if hasattr(self,'domainReference'):
675            frag = Element(CSML('domainReference'))
676            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
677            #self.domainReference.toXML(frag)
678            if isinstance(self.domainReference,OrientedPosition):
679                subFrag=Element(CSML('OrientedPosition'))
680                self.domainReference.toXML(subFrag)
681                frag.append(subFrag)
682                csmlFrag.append(frag)
683            elif isinstance(self.domainReference,OrientedTrajectory):
684                subFrag=Element(CSML('OrientedTrajectory'))
685                self.domainReference.toXML(subFrag)
686                frag.append(subFrag)
687                csmlFrag.append(frag)       
688            elif isinstance(self.domainReference,Position):
689                subFrag=Element(CSML('Position'))
690                self.domainReference.toXML(subFrag)
691                frag.append(subFrag)
692                csmlFrag.append(frag)
693            elif isinstance(self.domainReference,Trajectory):
694                subFrag=Element(CSML('Trajectory'))
695                self.domainReference.toXML(subFrag)
696                frag.append(subFrag)
697                csmlFrag.append(frag)
698            elif isinstance(self.domainReference,TimeInstant):
699                subFrag=Element(GML('TimeInstant'))
700                self.domainReference.toXML(subFrag)
701                frag.append(subFrag)
702                csmlFrag.append(frag)
703            elif isinstance(self.domainReference,TimePositionList):
704                subFrag=Element(GML('TimePositionList'))
705                self.domainReference.toXML(subFrag)
706                frag.append(subFrag)
707                csmlFrag.append(frag)   
708        if hasattr(self,'domainComplement'):
709            frag = Element(CSML('domainComplement'))
710            if isinstance(self.domainComplement,DirectPositionList):
711                    subFrag=Element(CSML('DirectPositionList'))
712                    self.domainComplement.toXML(subFrag)
713                    frag.append(subFrag)
714                    csmlFrag.append(frag)
715            elif isinstance(self.domainComplement,Grid):
716                    subFrag=Element(CSML('Grid'))
717                    self.domainComplement.toXML(subFrag)
718                    frag.append(subFrag)
719                    csmlFrag.append(frag)
720        return csmlFrag
721
722
723class EnvelopeWithTimePeriod:
724    # CSML EnvelopeWithTimePeriod class
725    # EnvelopeWithTimePeriod():
726        # +gml:lowerCorner
727        # +gml:upperCorner
728        # +gml:timePosition [2] ?
729       
730    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
731        if srsName:
732            self.srsName=srsName
733        if lowerCorner:
734            self.lowerCorner=lowerCorner
735        if upperCorner:
736            self.upperCorner=upperCorner
737        if timePosition:
738            self.timePosition=timePosition
739        if timePosition2:
740            self.timePosition2=timePosition2
741    def fromXML(self,csmlFrag):
742        EnvTPfrag=csmlFrag.getchildren()[0]
743        for frag in EnvTPfrag.getchildren():
744            if frag.attrib.has_key('srsName'):
745                self.srsName=frag.attrib['srsName']
746            if frag.tag == GML('lowerCorner'):
747                self.lowerCorner=frag.text
748            if frag.tag == GML('upperCorner'):
749                self.upperCorner=frag.text
750            if frag.tag == GML('timePosition'):
751                if hasattr(self, 'timePosition'):
752                    self.timePosition2=frag.text
753                else:
754                    self.timePosition=frag.text
755    def toXML(self,csmlFrag):
756        if hasattr(self,'srsName'):
757            csmlFrag.attrib['srsName'] = self.srsName
758        if hasattr(self,'lowerCorner'):
759            frag=Element(GML('lowerCorner'))
760            frag.text=self.lowerCorner
761            csmlFrag.append(frag)
762        if hasattr(self,'upperCorner'):
763            frag=Element(GML('upperCorner'))
764            frag.text=self.upperCorner
765            csmlFrag.append(frag)
766        if hasattr(self,'timePosition'):
767            frag=Element(GML('timePosition'))
768            frag.text=self.timePosition
769            csmlFrag.append(frag)
770        if hasattr(self,'timePosition2'):
771            frag=Element(GML('timePosition'))
772            frag.text=self.timePosition2
773            csmlFrag.append(frag)
774        return csmlFrag
775
776       
777class DirectionVectorList:
778    def __init__(self, horizontalAngle=None, verticalAngle=None):
779        if horizontalAngle:
780            self.horizontalAngle=horizontalAngle
781        if verticalAngle:
782            self.verticalAngle=verticalAngle
783    def fromXML(self, csmlFrag):
784        for frag in csmlFrag.getchildren():
785            if frag.tag==GML('horizontalAngle'):
786                self.horizontalAngle=frag.text
787                if frag.attrib.has_key('uom'):
788                    self.uom_H=frag.attrib['uom']
789            elif frag.tag==GML('verticalAngle'):
790                self.verticalAngle=frag.text
791                if frag.attrib.has_key('uom'):
792                    self.uom_V=frag.attrib['uom']
793    def toXML(self,csmlFrag):
794         if hasattr(self,'horizontalAngle'):
795            frag = Element(GML('horizontalAngle'))
796            frag.text=self.horizontalAngle
797            if hasattr(self,'uom_H'):
798                frag.attrib['uom'] = self.uom_H
799            csmlFrag.append(frag)
800           
801         if hasattr(self,'verticalAngle'):
802            frag = Element(GML('verticalAngle'))
803            frag.text=self.verticalAngle
804            if hasattr(self,'uom_V'):
805                frag.attrib['uom'] = self.uom_V
806            csmlFrag.append(frag)
807
808       
809class Position:
810    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
811        if srsName:
812            self.srsName=srsName
813        if axisLabels:
814            self.axisLabels=axisLabels
815        if uomLabels:
816            self.uomLabels=uomLabels
817        if location:
818            self.location=location
819        if time:
820            self.time = time
821    def fromXML(self,csmlFrag):
822        if csmlFrag.attrib.has_key('srsName'):           
823            self.srsName = csmlFrag.attrib['srsName']
824        if csmlFrag.attrib.has_key('axisLabels'):
825            self.axisLabels = csmlFrag.attrib['axisLabels']
826            if csmlFrag.attrib.has_key('uomLabels'):
827                self.uomLabels = csmlFrag.attrib['uomLabels']
828        for frag in csmlFrag.getchildren():
829            print frag.tag
830            if frag.tag==CSML('location'):
831                self.location=frag.text
832            if frag.tag==CSML('time'):
833                self.time=frag.text
834    def toXML(self,csmlFrag):
835        #subFrag = Element(CSML('Position'))
836        if hasattr(self,'uomLabels'):
837            csmlFrag.attrib['uomLabels'] = self.uomLabels
838        if hasattr(self,'axisLabels'):
839            csmlFrag.attrib['axisLabels'] = self.axisLabels
840        if hasattr(self,'srsName'):
841            csmlFrag.attrib['srsName'] = self.srsName
842        if hasattr(self,'location'):
843            frag = Element(CSML('location'))
844            frag.text=self.location
845            csmlFrag.append(frag)
846        if hasattr(self,'time'):
847            frag = Element(CSML('time'))
848            frag.text=self.time
849            csmlFrag.append(frag)
850        return csmlFrag
851
852class OrientedPosition(Position):
853    def __init__(self, direction=None, *args,**kwargs):
854        Position.__init__(self, *args,**kwargs)
855        if direction:
856            self.direction=direction
857    def fromXML(self,csmlFrag):
858        Position.fromXML(self, csmlFrag)
859        for frag in csmlFrag.getchildren():
860            if frag.tag==CSML('direction'):
861                self.direction=DirectionVectorList()
862                DirectionVectorList.fromXML(self.direction,frag)
863    def toXML(self, csmlFrag):
864        Position.toXML(self,csmlFrag)
865        if hasattr(self,'direction'):
866            frag = Element(CSML('direction'))
867            DirectionVectorList.toXML(self.direction,frag)
868            csmlFrag.append(frag)
869        return csmlFrag
870       
871
872
873class Trajectory:
874    def __init__(self,srsName=None,locations=None,times=None):
875        if srsName:
876            self.srsName=srsName
877        if locations:
878            self.locations=locations
879        if times:
880            self.times = times
881
882    def fromXML(self,csmlFrag):
883        if csmlFrag.attrib.has_key('srsName'):
884            self.srsName = csmlFrag.attrib['srsName']
885        for frag in csmlFrag.getchildren():
886            print frag.tag
887            if frag.tag==CSML('locations'):
888                self.locations=frag.text
889            if frag.tag==CSML('times'):
890                self.times=frag.text
891    def toXML(self,csmlFrag):
892        if hasattr(self,'srsName'):
893            csmlFrag.attrib['srsName'] = self.srsName
894        if hasattr(self,'locations'):
895            frag = Element(CSML('locations'))
896            frag.text=self.locations
897            csmlFrag.append(frag)
898        if hasattr(self,'times'):
899            frag = Element(CSML('times'))
900            frag.text=self.times
901            csmlFrag.append(frag)
902        return csmlFrag
903
904class OrientedTrajectory(Trajectory):
905    def __init__(self, direction=None, *args,**kwargs):
906        Trajectory.__init__(self, *args,**kwargs)
907        if direction:
908             self.direction=direction
909    def fromXML(self,csmlFrag):
910        Trajectory.fromXML(self, csmlFrag)
911        for frag in csmlFrag.getchildren():
912            if frag.tag==CSML('direction'):
913                self.direction=DirectionVectorList()
914                DirectionVectorList.fromXML(self.direction,frag)
915    def toXML(self, csmlFrag):
916        Trajectory.toXML(self,csmlFrag)
917        if hasattr(self,'direction'):
918            frag = Element(CSML('direction'))
919            DirectionVectorList.toXML(self.direction,frag)
920            csmlFrag.append(frag)
921        return csmlFrag
922
923class AbstractGeometryType(AbstractGML):
924    def __init__(self, low=None, high=None):
925        AbstractGML.__init__(self)
926        if low:
927            self.low=low
928        if high:
929            self.high=high
930    def fromXML(self, csmlFrag):
931        AbstractGML.fromXML(self,csmlFrag)
932    def toXML(self,csmlFrag):
933        AbstractGML.toXML(self,csmlFrag)
934        return csmlFrag
935
936class GridEnvelope:
937    def __init__(self, low=None, high = None):
938        if low:
939            self.low = low
940        if high:
941            self.high = high
942    def fromXML(self, csmlFrag):
943        print csmlFrag
944        frag = csmlFrag.getchildren()[0]
945        for subFrag in frag.getchildren():
946            if subFrag.tag == GML('low'):
947                self.low=subFrag.text
948            elif subFrag.tag == GML('high'):
949                self.high=subFrag.text
950    def toXML(self,csmlFrag):
951        if hasattr(self, 'low'):
952            frag=Element(GML('low'))
953            frag.text=self.low
954            csmlFrag.append(frag)
955        if hasattr(self, 'high'):
956            frag=Element(GML('high'))
957            frag.text=self.high
958            csmlFrag.append(frag)
959        return csmlFrag
960
961class GmlGrid(AbstractGeometryType):
962    #Class GmlGrid, representing a gml:Grid element.
963    #  +dimension positiveInteger [1]
964    # +gml:limits  (gml:GridLimitsType) </gml:limits> [1]
965    #+gml:axisName  (string) [1..*]
966    def __init__(self,dimension=None,limits=None,axisName=None):
967        AbstractGeometryType.__init__(self)
968        if dimension:
969            self.dimension=dimension
970        if limits:
971            self.limits=limits
972        if axisName:
973            self.axisName=axisName
974    def fromXML(self, csmlFrag):
975        AbstractGeometryType.fromXML(self,csmlFrag)
976        for frag in csmlFrag.getchildren():
977            print frag
978        for frag in csmlFrag.getchildren():
979            if frag.tag == GML('limits'):
980                self.limits=GridEnvelope()
981                GridEnvelope.fromXML(self.limits,frag)
982            elif frag.tag == GML('axisName'):
983                checkArrayAttrib(self,'axisNames')
984                self.axisNames.append(frag.text)
985    def toXML(self,csmlFrag):
986        AbstractGeometryType.toXML(self,csmlFrag)
987        if hasattr(self, 'limits'):
988            frag=Element(GML('limits'))
989            subFrag =Element(GML('GridEnvelope'))
990            GridEnvelope.toXML(self.limits, subFrag)
991            frag.append(subFrag)
992            csmlFrag.append(frag)
993        if hasattr(self, 'axisNames'):
994            for axis in self.axisNames:
995                frag=Element(GML('axisName'))
996                frag.text =axis
997                csmlFrag.append(frag)
998        return csmlFrag
999           
1000class GridOrdinateDescription:
1001    #Class GridOrdinateDescription:
1002        #+gridAxesSpanned
1003        #+sequenceRule
1004        #+definesAxis,attrib -href
1005        #+axisValues
1006
1007    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
1008        if gridAxesSpanned:
1009            self.gridAxesSpanned=gridAxesSpanned
1010        if sequenceRule:
1011            self.sequenceRule=sequenceRule
1012        if definesAxis:
1013            self.definesAxis=definesAxis
1014            if href:
1015                self.href = href
1016        if axisValues:
1017            self.axisValues=axisValues
1018       
1019    def fromXML(self,csmlFrag):
1020        for frag in csmlFrag.getchildren():
1021            if frag.tag ==CSML('gridAxesSpanned'):
1022                self.gridAxesSpanned=frag.text
1023            elif frag.tag ==CSML('sequenceRule'):
1024                self.sequenceRule=frag.text
1025            elif frag.tag ==CSML('definesAxis'):
1026                self.definesAxis=frag.text
1027                if frag.attrib.has_key(XLINK('href')):
1028                        self.href = frag.attrib[XLINK('href')]
1029            elif frag.tag ==CSML('axisValues'):
1030                self.axisValues=frag.text
1031               
1032    def toXML(self, csmlFrag):
1033        if hasattr(self, 'gridAxesSpanned'):
1034            frag=Element(CSML('gridAxesSpanned'))
1035            frag.text = self.gridAxesSpanned
1036            csmlFrag.append(frag)
1037        if hasattr(self, 'sequenceRule'):
1038            frag=Element(CSML('sequenceRule'))
1039            frag.text = self.sequenceRule
1040            csmlFrag.append(frag)
1041        if hasattr(self, 'definesAxis'):
1042            frag=Element(CSML('definesAxis'))
1043            frag.text = self.definesAxis
1044            if hasattr(self, 'href'):
1045                frag.attrib[XLINK('href')] = self.href
1046            csmlFrag.append(frag)
1047        if hasattr(self, 'axisValues'):
1048            frag=Element(CSML('axisValues'))
1049            frag.text = self.axisValues
1050            csmlFrag.append(frag)
1051        return csmlFrag
1052   
1053
1054class Grid(GmlGrid):
1055#Class GmlGrid representing a gml:Grid
1056# + dimension(attrib) [1]
1057#  +ordinate [1..*]
1058    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
1059        GmlGrid.__init__(self)
1060        if srsName:
1061            self.srsName=srsName
1062        if srsDimension:
1063            self.srsDimension=srsDimension
1064        if dimension:
1065            self.dimension=dimension
1066        if ordinates:
1067            self.ordinates=ordinates
1068    def fromXML(self, csmlFrag):
1069        GmlGrid.fromXML(self,csmlFrag)
1070        if csmlFrag.attrib.has_key('srsName'):
1071            self.srsName = csmlFrag.attrib['srsName']
1072        if csmlFrag.attrib.has_key('srsDimension'):
1073            self.srsDimension = csmlFrag.attrib['srsDimension']
1074        if csmlFrag.attrib.has_key('dimension'):
1075            self.dimension = csmlFrag.attrib['dimension']
1076        for frag in csmlFrag:
1077            if frag.tag==CSML('ordinate'):
1078                checkArrayAttrib(self,'ordinates')
1079                ordinate=GridOrdinateDescription()
1080                GridOrdinateDescription.fromXML(ordinate, frag)
1081                self.ordinates.append(ordinate)
1082    def toXML(self,csmlFrag):
1083        GmlGrid.toXML(self,csmlFrag)
1084        if hasattr(self, 'srsName'):
1085            csmlFrag.attrib['srsName'] = self.srsName
1086        if hasattr(self, 'srsDimension'):
1087            csmlFrag.attrib['srsDimension'] = self.srsDimension
1088        if hasattr(self, 'dimension'):
1089            csmlFrag.attrib['dimension'] = self.dimension
1090       
1091        if hasattr(self, 'ordinates'):
1092            for ordinate in self.ordinates:
1093                frag=Element(CSML('ordinate'))
1094                GridOrdinateDescription.toXML(ordinate, frag)
1095                csmlFrag.append(frag)
1096        return csmlFrag
1097
1098class TimeInstant:
1099   
1100    def __init__(self, timePosition=None):
1101        if timePosition:
1102            self.timePosition=timePosition
1103    def fromXML(self,csmlFrag):
1104        for frag in csmlFrag.getchildren():
1105            print frag.tag
1106            if frag.tag==GML('timePosition'):
1107                self.timePosition=frag.text
1108    def toXML(self,csmlFrag):
1109         if hasattr(self,'timePosition'):
1110            frag = Element(GML('timePosition'))
1111            frag.text=self.timePosition
1112            csmlFrag.append(frag)
1113         return csmlFrag
1114
1115class TimePositionList:
1116    def __init__(self, timePositions=None):
1117        if timePositions:
1118            self.timePositions=timePositions
1119    def fromXML(self,csmlFrag):
1120        self.timePositions=csmlFrag.text
1121    def toXML(self,csmlFrag):
1122         if hasattr(self,'timePositions'):
1123            csmlFrag.text=self.timePositions
1124         return csmlFrag
1125             
1126class Measure:
1127    def __init__(self, uom=None):
1128        if uom:
1129            self.uom=uom
1130    def fromXML(self,csmlFrag):
1131                self.measure=csmlFrag.text
1132                if csmlFrag.attrib.has_key('uom'):
1133                    self.uom = csmlFrag.attrib['uom']
1134    def toXML(self, csmlFrag):
1135        if hasattr(self,'measure'):
1136            frag = Element(GML('measure'))
1137            frag.text = self.measure
1138            if hasattr(self,'uom'):
1139                frag.attrib[('uom')] = self.uom
1140            csmlFrag.append(frag)
1141        return csmlFrag
1142
1143
1144   
1145class CompositeValue:
1146    def __init__(self, valueComponents=None):
1147        if valueComponents:
1148            self.valueComponents=valueComponents
1149    def fromXML(self,csmlFrag):
1150       
1151        for frag in csmlFrag.getchildren():
1152            if frag.tag == GML('valueComponents'):
1153                self.valueComponents = []
1154                for subFrag in frag.getchildren():                   
1155                    if subFrag.tag == GML('measure'):
1156                        self.valueComponents.append(Measure())
1157                        self.valueComponents[-1].fromXML(subFrag)
1158
1159    def toXML(self, csmlFrag):
1160         if hasattr(self,'valueComponents'):
1161            frag=Element(GML('valueComponents'))
1162            for valueComponent in self.valueComponents:
1163                if isinstance(valueComponent,Measure):
1164                    Measure.toXML(valueComponent,frag)
1165            csmlFrag.append(frag)
1166         return csmlFrag
1167   
1168
1169   
1170class DataBlock:
1171    #class GML DataBlock
1172   
1173    #DataBlock()
1174    #+gml:rangeParameters
1175    def __init__(self,rangeParameters=None):
1176        if rangeParameters:
1177            self.rangeParameters=rangeParameters
1178    def fromXML(self,csmlFrag):
1179        for frag in csmlFrag.getchildren():
1180            if frag.tag == GML('rangeParameters'):
1181                for subFrag in frag.getchildren():
1182                    if subFrag.tag==GML('CompositeValue'):
1183                        self.rangeParameters=CompositeValue()
1184                        CompositeValue.fromXML(self.rangeParameters,subFrag)
1185            if frag.tag == GML('doubleOrNullTupleList'):
1186                self.doubleOrNullTupleList=frag.text
1187    def toXML(self,csmlFrag):
1188        if hasattr(self, 'rangeParameters'):
1189            frag=Element(GML('rangeParameters'))
1190            subFrag=Element(GML('CompositeValue'))
1191            CompositeValue.toXML(self.rangeParameters, subFrag)
1192            frag.append(subFrag)
1193            csmlFrag.append(frag)
1194        if hasattr(self,'doubleOrNullTupleList'):
1195            frag=Element(GML('doubleOrNullTupleList'))
1196            frag.text=self.doubleOrNullTupleList
1197            csmlFrag.append(frag)
1198        return csmlFrag
1199
1200class Definition(AbstractGML):
1201    #Class definition, restricts AbstractGML
1202    #gml:id is mandatory.
1203    def __init__(self,*args,**kwargs):
1204        AbstractGML.__init__(self,*args,**kwargs)
1205    def fromXML(self,csmlFrag):
1206        AbstractGML.fromXML(self,csmlFrag)
1207        #TO DO: how  best to handle this?
1208        if not hasattr(self,'id'):
1209            print 'gml:id mandatory value missing in ' + csmlFrag.tag
1210            sys.exit()
1211    def toXML(self,csmlFrag):
1212        csmlFrag=AbstractGML.toXML(self,csmlFrag)
1213        return csmlFrag
1214
1215class TypedCategory:
1216#class om:TypedCategory
1217    # +axis (attrib)
1218    # + codeSpace (attrib)
1219    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
1220        if axis:
1221            self.axis=axis
1222        if codeSpace:
1223            self.codeSpace=codeSpace
1224        if text:
1225            self.text=text
1226    def fromXML(self,csmlFrag):
1227        if csmlFrag.attrib.has_key('axis'):
1228            self.axis=csmlFrag.attrib['axis']
1229        if csmlFrag.attrib.has_key('codeSpace'):
1230            self.codeSpace=csmlFrag.attrib['codeSpace']
1231        self.text=csmlFrag.text
1232    def toXML(self,csmlFrag):
1233        if hasattr(self,'axis'):
1234            csmlFrag.attrib[('axis')] =self.axis
1235        if hasattr(self,'codeSpace'):
1236            csmlFrag.attrib[('codeSpace')] =self.codeSpace
1237        csmlFrag.text=self.text
1238        return csmlFrag
1239
1240   
1241class Phenomenon(Definition):
1242    #class Obs& Measures: PhenomenonProperty
1243    #Note, in this does not really inherit from AbstractGML, but for CMSL
1244    #purposes it is used  to pick up the basic description, id, name attributes
1245    def __init__(self,*args,**kwargs):
1246         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
1247        self.MetaDataProperty=None
1248        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
1249    def fromXML(self,csmlFrag):
1250        Definition.fromXML(self,csmlFrag)
1251    def toXML(self,csmlFrag):
1252        csmlFrag=Definition.toXML(self,csmlFrag)
1253        return csmlFrag
1254
1255
1256class CompositePhenomenon(Phenomenon):
1257    #Class om:CompositePhenomenon
1258    # + om:componentPhenomenon [1...*]
1259    def __init__(self,componentPhenomenon=None,*args,**kwargs):
1260        Phenomenon.__init__(self,*args,**kwargs)
1261        if componentPhenomenon:
1262            self.componentPhenomenon=componentPhenomenon
1263    def fromXML(self,csmlFrag):
1264        Phenomenon.fromXML(self,csmlFrag)
1265        for frag in csmlFrag.getchildren():
1266            if frag.tag == OM('componentPhenomenon'):
1267                checkArrayAttrib(self,'componentPhenomenon')
1268                self.componentPhenomenon.append(frag.attrib)
1269    def toXML(self,csmlFrag):
1270        Phenomenon.toXML(self,csmlFrag)
1271        for cp in self.componentPhenomenon:
1272            frag=Element(OM('componentPhenomenon'))
1273            frag.attrib= cp
1274            csmlFrag.append(frag)
1275        return csmlFrag
1276   
1277class ParameterisedPhenomenon(Phenomenon):
1278    #Class ParameterisedPhenomenon:
1279        # + basePhenomenon
1280        # + constraint
1281        # + href (attrib)
1282    def __init__(self,*args,**kwargs):
1283        Phenomenon.__init__(self,*args,**kwargs)
1284    def fromXML(self,csmlFrag):
1285        Phenomenon.fromXML(self,csmlFrag)
1286        for frag in csmlFrag.getchildren():
1287            if frag.tag == OM('basePhenomenon'):
1288                self.basePhenomenon=frag.text
1289                if frag.attrib.has_key(XLINK('href')):
1290                    self.href = frag.attrib[XLINK('href')]
1291            if frag.tag == OM('constraint'):
1292                subFrag=frag.getchildren()[0]
1293                if subFrag.tag== OM('TypedCategory'):
1294                    self.constraint = TypedCategory()
1295                #TO DO: what other types are valid?
1296                elif subFrag.tag== OM('??'):
1297                    self.constraint = 123
1298                self.constraint.fromXML(subFrag)
1299    def toXML(self,csmlFrag):
1300        csmlFrag=Phenomenon.toXML(self,csmlFrag)
1301        if hasattr(self,'basePhenomenon'):
1302            frag=Element(OM('basePhenomenon'))
1303            frag.text=self.basePhenomenon
1304            if hasattr(self, 'href'):
1305                frag.attrib[XLINK('href')] = self.href
1306            csmlFrag.append(frag)
1307        if hasattr(self, 'constraint'):
1308            frag=Element(OM('constraint'))
1309            subFrag=Element(OM('TypedCategory'))
1310            subFrag=self.constraint.toXML(subFrag)
1311            frag.append(subFrag)
1312            csmlFrag.append(frag)
1313        return csmlFrag
1314
1315class RangeSet:
1316#class GML RangeSet 
1317
1318        # RangeSet()
1319        # +gml:ValueArray
1320        # +gml:_ScalarValueList
1321        # +gml:DataBlock
1322        # +gml:File
1323    #class GML RangeSet
1324    def __init__(self,QuantityList=None, DataBlock=None, ArrayDescriptor=None):
1325        if QuantityList:
1326            self.QuantityList=QuantityList
1327        if DataBlock:
1328            self.DataBlock=DataBlock
1329        if ArrayDescriptor:
1330            self.ArrayDescriptor=ArrayDescriptor
1331           
1332    def fromXML(self,csmlFrag):
1333        for frag in csmlFrag.getchildren():
1334            if frag.tag==GML('QuantityList'):
1335                self.QuantityList=frag.text
1336                if frag.attrib.has_key('uom'):
1337                    self.uom = frag.attrib['uom']
1338            elif frag.tag==GML('DataBlock'):
1339                self.DataBlock=DataBlock()
1340                DataBlock.fromXML(self.DataBlock, frag)
1341            elif frag.tag == CSML('NetCDFExtract'):
1342                self.ArrayDescriptor=NetCDFExtract()
1343                NetCDFExtract.fromXML(self.ArrayDescriptor,frag)
1344            elif frag.tag == CSML('NASAmesExtract'):
1345                self.ArrayDescriptor=NASAAmesExtract()
1346                NASAAmesExtract.fromXML(self.ArrayDescriptor,frag)
1347            elif frag.tag == CSML('GRIBExtract'):
1348                self.ArrayDescriptor=GRIBExtract()
1349                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
1350            elif frag.tag == CSML('AggregatedArray'):
1351                self.AggregatedArray=AggregatedArray()
1352                AggregatedArray.fromXML(self.AggregatedArray,frag)
1353    def toXML(self, csmlFrag):
1354        if hasattr(self,'QuantityList'):
1355            frag = Element(GML('QuantityList'))
1356            frag.text=self.QuantityList
1357            if hasattr(self,'uom'):
1358                frag.attrib['uom'] = self.uom
1359            csmlFrag.append(frag)
1360        if hasattr(self,'DataBlock'):
1361            frag=Element(GML('DataBlock'))
1362            DataBlock.toXML(self.DataBlock,frag)
1363            csmlFrag.append(frag)
1364        if hasattr(self,'AggregatedArray'):
1365            frag=Element(GML('AggregatedArray'))
1366            AggregatedArray.toXML(self.AggregatedArray,frag)
1367            csmlFrag.append(frag)
1368        if hasattr(self,'ArrayDescriptor'):
1369            if isinstance(self.ArrayDescriptor,NetCDFExtract):
1370                frag=Element(CSML('NetCDFExtract'))
1371                NetCDFExtract.toXML(self.ArrayDescriptor,frag)
1372                csmlFrag.append(frag)
1373            elif isinstance(self.ArrayDescriptor,NASAAmesExtract):
1374                frag=Element(CSML('NASAAmesExtract'))
1375                NASAAmesExtract.toXML(self.ArrayDescriptor,frag)
1376                csmlFrag.append(frag)
1377            elif isinstance(self.ArrayDescriptor,GRIBExtract):
1378                frag=Element(CSML('GRIBExtract'))
1379                GRIBAmesExtract.toXML(self.ArrayDescriptor,frag)
1380                csmlFrag.append(frag)
1381               
1382        return csmlFrag
1383
1384class PointDomain(AbstractDomain):
1385    def __init__(self,*args,**kwargs):
1386        AbstractDomain.__init__(self,*args,**kwargs)
1387    def fromXML(self,csmlFrag):
1388        AbstractDomain.fromXML(self,csmlFrag)
1389    def toXML(self,csmlFrag):
1390        AbstractDomain.toXML(self,csmlFrag)
1391        return csmlFrag
1392   
1393class ProfileDomain(AbstractDomain):
1394    def __init__(self,*args,**kwargs):
1395        AbstractDomain.__init__(self,*args,**kwargs)
1396    def fromXML(self,csmlFrag):
1397        AbstractDomain.fromXML(self,csmlFrag)
1398    def toXML(self,csmlFrag):
1399        AbstractDomain.toXML(self,csmlFrag)
1400        return csmlFrag
1401
1402class GridDomain(AbstractDomain):
1403    def __init__(self,*args,**kwargs):
1404        AbstractDomain.__init__(self,*args,**kwargs)
1405    def fromXML(self,csmlFrag):
1406        AbstractDomain.fromXML(self,csmlFrag)
1407    def toXML(self,csmlFrag):
1408        AbstractDomain.toXML(self,csmlFrag)
1409        return csmlFrag
1410   
1411class PointSeriesDomain(AbstractDomain):
1412    def __init__(self,*args,**kwargs):
1413        AbstractDomain.__init__(self,*args,**kwargs)
1414    def fromXML(self,csmlFrag):
1415        AbstractDomain.fromXML(self,csmlFrag)
1416    def toXML(self,csmlFrag):
1417        AbstractDomain.toXML(self,csmlFrag)
1418        return csmlFrag
1419   
1420class ProfileSeriesDomain(AbstractDomain):
1421    def __init__(self,*args,**kwargs):
1422        AbstractDomain.__init__(self,*args,**kwargs)
1423    def fromXML(self,csmlFrag):
1424        AbstractDomain.fromXML(self,csmlFrag)
1425    def toXML(self,csmlFrag):
1426        AbstractDomain.toXML(self,csmlFrag)
1427        return csmlFrag
1428   
1429class GridSeriesDomain(AbstractDomain):
1430    def __init__(self,*args,**kwargs):
1431        AbstractDomain.__init__(self,*args,**kwargs)
1432    def fromXML(self,csmlFrag):
1433        AbstractDomain.fromXML(self,csmlFrag)
1434    def toXML(self,csmlFrag):
1435        AbstractDomain.toXML(self,csmlFrag)
1436        return csmlFrag
1437
1438class PointFeature(AbstractStaticCoverageFeature):
1439    #CSML PointFeature class
1440    #       PointFeature(AbstractStaticCoverageFeatureType):
1441    #      +PointDomain
1442    def __init__(self, PointDomain=None,*args,**kwargs):
1443        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1444        if PointDomain:
1445            self.PointDomain=PointDomain
1446    def fromXML(self,csmlFrag):
1447        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1448        for frag in csmlFrag.getchildren():
1449            if frag.tag == CSML('PointDomain'):
1450                self.PointDomain = PointDomain()
1451                self.PointDomain.fromXML(frag)
1452    def toXML(self,csmlFrag):
1453        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1454        if hasattr(self,'PointDomain'):
1455            frag = Element(CSML('PointDomain'))
1456            PointDomain.toXML(self.PointDomain,frag)
1457            if hasattr(self,'href'):
1458                frag.attrib[XLINK('href')] = self.href
1459            csmlFrag.append(frag)
1460        return csmlFrag
1461
1462   
1463class PointSeriesFeature(AbstractSeriesCoverageFeature):
1464    #CSML PointSeriesFeature class
1465    #       PointSeriesFeature(AbstractStaticCoverageFeatureType):
1466    #      +PointSeriesDomain
1467
1468    def __init__(self,PointSeriesDomain=None,*args,**kwargs):
1469        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
1470        if PointSeriesDomain:
1471            self.PointSeriesDomain=PointSeriesDomain
1472    def fromXML(self,csmlFrag):
1473        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
1474        for frag in csmlFrag.getchildren():
1475            if frag.tag == CSML('PointSeriesDomain'):
1476                self.PointSeriesDomain = PointSeriesDomain()
1477                self.PointSeriesDomain.fromXML(frag)
1478    def toXML(self,csmlFrag):
1479        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
1480        if hasattr(self,'PointSeriesDomain'):
1481             frag = Element(CSML('PointSeriesDomain'))
1482             PointSeriesDomain.toXML(self.PointSeriesDomain,frag)
1483             csmlFrag.append(frag)
1484        return csmlFrag
1485
1486class ProfileFeature(AbstractStaticCoverageFeature):
1487     #CSML ProfileFeature class
1488    #       ProfileFeature(AbstractStaticCoverageFeature):
1489    #      +ProfileDomain
1490
1491    def __init__(self,ProfileDomain=None,*args,**kwargs):
1492        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1493        if ProfileDomain:
1494            self.ProfileDomain=ProfileDomain
1495    def fromXML(self,csmlFrag):
1496        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1497        for frag in csmlFrag.getchildren():
1498            if frag.tag == CSML('ProfileDomain'):
1499                self.ProfileDomain = ProfileDomain()
1500                self.ProfileDomain.fromXML(frag)
1501    def toXML(self,csmlFrag):
1502        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1503        if hasattr(self,'ProfileDomain'):
1504             frag = Element(CSML('ProfileDomain'))
1505             ProfileDomain.toXML(self.ProfileDomain,frag)
1506             csmlFrag.append(frag)
1507        return csmlFrag
1508
1509
1510class ProfileSeriesFeature(AbstractStaticCoverageFeature):
1511#CSML ProfileSeriesFeature class
1512    #       ProfileSeriesFeature(AbstractStaticCoverageFeature):
1513    #      +ProfileSeriesDomain
1514
1515    def __init__(self,ProfileSeriesDomain=None,*args,**kwargs):
1516        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1517        if ProfileSeriesDomain:
1518            self.ProfileSeriesDomain=ProfileSeriesDomain
1519    def fromXML(self,csmlFrag):
1520        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1521        for frag in csmlFrag.getchildren():
1522            if frag.tag == CSML('ProfileSeriesDomain'):
1523                self.ProfileSeriesDomain = ProfileSeriesDomain()
1524                self.ProfileSeriesDomain.fromXML(frag)
1525    def toXML(self,csmlFrag):
1526        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1527        if hasattr(self,'ProfileSeriesDomain'):
1528             frag = Element(CSML('ProfileSeriesDomain'))
1529             ProfileSeriesDomain.toXML(self.ProfileSeriesDomain,frag)
1530             csmlFrag.append(frag)
1531        return csmlFrag
1532
1533
1534class GridFeature(AbstractStaticCoverageFeature):
1535#CSML GridFeature class
1536    #       GridFeature(AbstractStaticCoverageFeature):
1537    #      +GridDomain
1538
1539    def __init__(self,GridDomain=None,*args,**kwargs):
1540        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1541        if GridDomain:
1542            self.GridDomain=GridDomain
1543    def fromXML(self,csmlFrag):
1544        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1545        for frag in csmlFrag.getchildren():
1546            if frag.tag == CSML('GridDomain'):
1547                self.GridDomain = GridDomain()
1548                self.GridDomain.fromXML(frag)
1549    def toXML(self,csmlFrag):
1550        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1551        if hasattr(self,'GridDomain'):
1552             frag = Element(CSML('GridDomain'))
1553             GridDomain.toXML(self.GridDomain,frag)
1554             csmlFrag.append(frag)
1555        return csmlFrag
1556
1557
1558class GridSeriesFeature(AbstractStaticCoverageFeature):
1559    def __init__(self,GridSeriesDomain=None,*args,**kwargs):
1560        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1561        if GridSeriesDomain:
1562            self.GridSeriesDomain=GridSeriesDomain
1563    def fromXML(self,csmlFrag):
1564        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1565        for frag in csmlFrag.getchildren():
1566            if frag.tag == CSML('GridSeriesDomain'):
1567                self.GridSeriesDomain = GridSeriesDomain()
1568                self.GridSeriesDomain.fromXML(frag)
1569    def toXML(self,csmlFrag):
1570        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1571        if hasattr(self,'GridSeriesDomain'):
1572             frag = Element(CSML('GridSeriesDomain'))
1573             GridSeriesDomain.toXML(self.GridSeriesDomain,frag)
1574             csmlFrag.append(frag)
1575        return csmlFrag
1576
1577class TrajectoryFeature:
1578    def __init__(self):
1579        pass
1580    def fromXML(self,csmlFrag):
1581        pass
1582    def toXML(self,csmlFrag):
1583        return csmlFrag
1584   
1585class AbstractFeature(AbstractGML):
1586    def __init__(self,boundedBy=None,*args,**kwargs):
1587        AbstractGML.__init__(self,*args,**kwargs)
1588        if boundedBy:
1589            self.boundedBy=boundedBy
1590    def fromXML(self,csmlFrag):
1591        AbstractGML.fromXML(self,csmlFrag)
1592        for frag in csmlFrag.getchildren():
1593            if frag.tag == GML('boundedBy'):
1594                self.boundedBy = EnvelopeWithTimePeriod()
1595                self.boundedBy.fromXML(frag)
1596    def toXML(self,csmlFrag):
1597        AbstractGML.toXML(self,csmlFrag)
1598        if hasattr(self,'boundedBy'):
1599             superfrag = Element(GML('boundedBy'))
1600             frag = Element (GML('EnvelopeWithTimePeriod'))
1601             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
1602             superfrag.append(frag)
1603             csmlFrag.append(superfrag)
1604        return csmlFrag
1605
1606 
1607
1608class AbstractFeatureCollection(AbstractFeature):
1609    """GML AbstractFeatureCollection class
1610
1611    AbstractFeatureCollection(AbstractFeature):
1612     +featureMember[0..*]: AbstractFeature
1613     +featureMembers[0..1]: FeatureArray
1614    """
1615    def __init__(self,members=[]):
1616        if members:
1617            self.members=members
1618    def fromXML(self,csmlFrag):
1619        AbstractFeature.fromXML(self,csmlFrag)
1620        for frag in csmlFrag.getchildren():
1621            if frag.tag == GML('featureMember'):
1622                checkArrayAttrib(self,'members')
1623                featureFrag = frag.getchildren()[0]
1624                if featureFrag.tag == CSML('PointFeature'):
1625                    self.members.append(PointFeature())
1626                    self.members[-1].fromXML(featureFrag)
1627                if featureFrag.tag == CSML('ProfileFeature'):
1628                    self.members.append(ProfileFeature())
1629                    self.members[-1].fromXML(featureFrag)
1630                if featureFrag.tag == CSML('GridFeature'):
1631                    self.members.append(GridFeature())
1632                    self.members[-1].fromXML(featureFrag)
1633                if featureFrag.tag == CSML('PointSeriesFeature'):
1634                    self.members.append(PointSeriesFeature())
1635                    self.members[-1].fromXML(featureFrag)
1636                if featureFrag.tag == CSML('ProfileSeriesFeature'):
1637                    self.members.append(ProfileSeriesFeature())
1638                    self.members[-1].fromXML(featureFrag)
1639                if featureFrag.tag == CSML('GridSeriesFeature'):
1640                    self.members.append(GridSeriesFeature())
1641                    self.members[-1].fromXML(featureFrag)
1642                if featureFrag.tag == CSML('TrajectoryFeature'):
1643                    self.members.append(TrajectoryFeature())
1644                    self.members[-1].fromXML(featureFrag)
1645    def toXML(self,csmlFrag):
1646        AbstractFeature.toXML(self,csmlFrag)
1647        for member in self.members:
1648            if isinstance(member,PointFeature):
1649                superFrag=Element(GML('FeatureMember'))
1650                frag=Element(CSML('PointFeature'))
1651                PointFeature.toXML(member,frag)
1652                superFrag.append(frag)
1653                csmlFrag.append(superFrag)
1654            if isinstance(member,ProfileFeature):
1655                superFrag=Element(GML('FeatureMember'))
1656                frag=Element(CSML('ProfileFeature'))
1657                ProfileFeature.toXML(member,frag)
1658                superFrag.append(frag)
1659                csmlFrag.append(superFrag)
1660            if isinstance(member,GridFeature):
1661                superFrag=Element(GML('FeatureMember'))
1662                frag=Element(CSML('GridFeature'))
1663                GridFeature.toXML(member,frag)
1664                superFrag.append(frag)
1665                csmlFrag.append(superFrag)
1666            if isinstance(member,PointSeriesFeature):
1667                superFrag=Element(GML('FeatureMember'))
1668                frag=Element(CSML('PointSeriesFeature'))
1669                PointSeriesFeature.toXML(member,frag)
1670                superFrag.append(frag)
1671                csmlFrag.append(superFrag)
1672            if isinstance(member,ProfileSeriesFeature):
1673                superFrag=Element(GML('FeatureMember'))
1674                frag=Element(CSML('ProfileSeriesFeature'))
1675                ProfileSeriesFeature.toXML(member,frag)
1676                superFrag.append(frag)
1677                csmlFrag.append(superFrag)
1678            if isinstance(member,GridSeriesFeature):
1679                superFrag=Element(GML('FeatureMember'))
1680                frag=Element(CSML('GridSeriesFeature'))
1681                GridSeriesFeature.toXML(member,frag)
1682                superFrag.append(frag)
1683                csmlFrag.append(superFrag)
1684            if isinstance(member,TrajectoryFeature):
1685                superFrag=Element(GML('FeatureMember'))
1686                frag=Element(CSML('TrajectoryFeature'))
1687                TrajectoryFeature.toXML(member,frag)
1688                superFrag.append(frag)
1689                csmlFrag.append(superFrag)
1690       
1691        return csmlFrag
1692
1693class FeatureCollection(AbstractFeatureCollection):
1694    """GML FeatureCollection class
1695        FeatureCollection()
1696        +FeatureMembers[0..*]
1697    """
1698    def __init__(self):
1699        AbstractFeatureCollection.__init__(self)
1700    def fromXML(self,csmlFrag):
1701        AbstractFeatureCollection.fromXML(self,csmlFrag)
1702    def toXML(self,csmlFrag):
1703        AbstractFeatureCollection.toXML(self,csmlFrag)
1704        return csmlFrag
1705
1706class Dataset(AbstractGML):
1707    """CSML Dataset class
1708
1709    Dataset(AbstractGML):
1710     +unitDefinitions[0..*]: UnitDefinitions
1711     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
1712     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
1713     +arrayDescriptors[0..*]: AbstractArrayDescriptor
1714     +featureCollection[0..1]: FeatureCollection
1715    """
1716    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
1717                 phenomenonDefinitions=None,arrayDescriptors=[],
1718                 featureCollection=None,*args,**kwargs):
1719        AbstractGML.__init__(self,*args,**kwargs)
1720        if unitDefinitions:
1721            self.unitDefinitions = unitDefinitions
1722        if referenceSystemDefinitions:
1723            self.referenceSystemDefinitions = referenceSystemDefinitions
1724        if phenomenonDefinitions:
1725            self.phenomenonDefinitions = phenomenonDefinitions
1726        if arrayDescriptors:
1727            self.arrayDescriptors = arrayDescriptors
1728        if featureCollection:
1729            self.featureCollection = featureCollection
1730    def fromXML(self,csmlFrag):
1731        AbstractGML.fromXML(self,csmlFrag)
1732       
1733        for frag in csmlFrag.getchildren():
1734            if frag.tag == CSML('UnitDefinitions'):
1735                self.unitDefinitions = UnitDefinitions()
1736                self.unitDefinitions.fromXML(frag)
1737            elif frag.tag == CSML('ReferenceSystemDefinitions'):
1738                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
1739                self.referenceSystemDefinitions.fromXML(frag)
1740            elif frag.tag == CSML('PhenomenonDefinitions'):
1741                self.phenomenonDefinitions = PhenomenonDefinitions()
1742                self.phenomenonDefinitions.fromXML(frag)
1743            elif frag.tag == GML('FeatureCollection'):
1744                self.featureCollection = FeatureCollection()
1745                self.featureCollection.fromXML(frag)
1746            elif frag.tag == CSML('AggregatedArray'):
1747                checkArrayAttrib(self,'arrayDescriptors')
1748                self.arrayDescriptors.append(AggregatedArray())
1749                self.arrayDescriptors[-1].fromXML(frag)
1750            elif frag.tag == CSML('InlineArray'):
1751                checkArrayAttrib(self,'arrayDescriptors')
1752                self.arrayDescriptors.append(InlineArray())
1753                self.arrayDescriptors[-1].fromXML(frag)
1754            elif frag.tag == CSML('ArrayGenerator'):
1755                checkArrayAttrib(self,'arrayDescriptors')
1756                self.arrayDescriptors.append(ArrayGenerator())
1757                self.arrayDescriptors[-1].fromXML(frag)
1758            elif frag.tag == CSML('NASAAmesExtract'):
1759                checkArrayAttrib(self,'arrayDescriptors')
1760                self.arrayDescriptors.append(NASAAmesExtract())
1761                self.arrayDescriptors[-1].fromXML(frag)
1762            elif frag.tag == CSML('NetCDFExtract'):
1763                checkArrayAttrib(self,'arrayDescriptors')
1764                self.arrayDescriptors.append(NetCDFExtract())
1765                self.arrayDescriptors[-1].fromXML(frag)
1766            elif frag.tag == CSML('GRIBExtract'):
1767                checkArrayAttrib(self,'arrayDescriptors')
1768                self.arrayDescriptors.append(GRIBExtract())
1769                self.arrayDescriptors[-1].fromXML(frag)
1770##            else:
1771##                raise Exception('Unexpected element: "'+frag.tag+'"')
1772    def toXML(self,csmlFrag=None):
1773        if csmlFrag is None:
1774            csmlFrag = Element('Dataset')
1775        csmlFrag = AbstractGML.toXML(self,csmlFrag)
1776        if hasattr(self,'unitDefinitions'):
1777            frag = Element(CSML('UnitDefinitions'))
1778            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
1779            csmlFrag.append(frag)
1780        if hasattr(self,'referenceSystemDefinitions'):
1781            frag = Element(CSML('ReferenceSystemDefinitions'))
1782            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
1783            csmlFrag.append(frag)
1784        if hasattr(self,'phenomenonDefinitions'):
1785            frag = Element(CSML('PhenomenonDefinitions'))
1786            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
1787            csmlFrag.append(frag)
1788        if hasattr(self,'arrayDescriptors'):
1789            for arrayDesc in self.arrayDescriptors:
1790                if isinstance(arrayDesc,AggregatedArray):
1791                    frag = Element(CSML('AggregatedArray'))
1792                    frag = AggregatedArray.toXML(arrayDesc,frag)
1793                elif isinstance(arrayDesc,InlineArray):
1794                    frag = Element(CSML('InlineArray'))
1795                    frag = InlineArray.toXML(arrayDesc,frag)
1796                elif isinstance(arrayDesc,ArrayGenerator):
1797                    frag = Element(CSML('ArrayGenerator'))
1798                    frag = ArrayGenerator.toXML(arrayDesc,frag)
1799                elif isinstance(arrayDesc,NASAAmesExtract):
1800                    frag = Element(CSML('NASAAmesExtract'))
1801                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
1802                elif isinstance(arrayDesc,NetCDFExtract):
1803                    frag = Element(CSML('NetCDFExtract'))
1804                    frag = NetCDFExtract.toXML(arrayDesc,frag)
1805                elif isinstance(arrayDesc,GRIBExtract):
1806                    frag = Element(CSML('GRIBExtract'))
1807                    frag = GRIBExtract.toXML(arrayDesc,frag)
1808                csmlFrag.append(frag)
1809        if hasattr(self,'featureCollection'):
1810            frag = Element(GML('FeatureCollection'))
1811            frag = FeatureCollection.toXML(self.featureCollection,frag)
1812            csmlFrag.append(frag)
1813            #csmlFrag=fixNameSpaces(csmlFrag)
1814        return csmlFrag
Note: See TracBrowser for help on using the repository browser.