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

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

Feature Member done. PointFeature? mostly supported, to do: rangeSet, parameter, coverageFunction

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 checkArrayAttrib(obj,attrib):
70    if not hasattr(obj,attrib) or not isinstance(getattr(obj,attrib),list):
71        setattr(obj,attrib,[])
72       
73def fixNameSpaces(csmlFrag):
74    #function to convert element tree namespaces from defaults such as
75    # ns0 to gml, csml etc.
76    for elem in csmlFrag.getiterator():
77        print str(elem.attrib)
78    return csmlFrag
79       
80##class TemplateClass(Base):
81##    def __init__(self,myarg=None,*args,**kwargs):
82##        Base.__init__(self,*args,**kwargs)
83##        # code specific to TemplateClass
84##    def fromXML(self,csmlFrag):
85##        Base.fromXML(self,csmlFrag)
86##        # code specific to TemplateClass
87##    def toXML(self,csmlFrag):
88##        csmlFrag = Base.toXML(self,csmlFrag)
89##        # code specific to TemplateClass
90##        return csmlFrag
91
92class MetaDataProperty:
93    """Class representing metadata property (gmlBase.xsd)
94
95    MetaDataProperty:
96     +href: URI
97    """
98    def __init__(self,href=None):
99        if href:
100            self.href = href
101    def fromXML(self,csmlFrag):
102        if csmlFrag.attrib.has_key(XLINK('href')):
103            #print "METADATA PROPERTY FOUND"
104            #print (csmlFrag.attrib[XLINK('href')])
105            self.href = csmlFrag.attrib[XLINK('href')]
106    def toXML(self,csmlFrag):
107        if hasattr(self,'href'):
108            csmlFrag.attrib[XLINK('href')] = self.href
109        return csmlFrag
110
111class Description(MutableString):
112    """Class representing a GML description element
113
114    Description(string):
115    """
116    def __init__(self,val=''):
117        MutableString.__init__(self,val)
118    def fromXML(self,csmlFrag):
119        self.data = csmlFrag.text
120    def toXML(self,csmlFrag):
121        csmlFrag.text = self.data
122        return csmlFrag
123
124class Name(MutableString):
125    """Class representing a GML name element
126
127    Name(string):
128     +codeSpace[0..1]: anyURI
129    """
130    def __init__(self,val='',codeSpace=None):
131        MutableString.__init__(self,val)
132        if codeSpace:
133            self.codeSpace = codeSpace
134    def fromXML(self,csmlFrag):
135        self.data = csmlFrag.text
136## For some reason, namespace on 'codeSpace' attribute not being picked up...
137##        if csmlFrag.attrib.has_key(GML('codeSpace')):
138##            self.codeSpace = csmlFrag.attrib[GML('codeSpace')]
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=[]):
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        frag = Element(CSML('fileName'))
386        frag.text = self.fileName
387        csmlFrag.append(frag)
388        return csmlFrag
389
390class NASAAmesExtract(AbstractFileExtract):
391    """CSML class for NASA Ames file extract
392
393    NASAAmesExtract(AbstractFileExtract):
394     +variableName: string
395     +index[0..1]: int
396    """
397    def __init__(self,variableName=None,index=None,*args,**kwargs):
398        AbstractFileExtract.__init__(self,*args,**kwargs)
399        if variableName:
400            self.variableName = variableName
401        if index:
402            self.index = index
403    def fromXML(self,csmlFrag):
404        AbstractFileExtract.fromXML(self,csmlFrag)
405        for frag in csmlFrag.getchildren():
406            if frag.tag == CSML('variableName'):
407                self.variableName = frag.text
408            elif frag.tag == CSML('index'):
409                self.index = int(frag.text)
410##            else:
411##                raise Exception('Unexpected element: "'+frag.tag+'"')
412    def toXML(self,csmlFrag):
413        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
414        frag = Element(CSML('variableName'))
415        frag.text = self.variableName
416        csmlFrag.append(frag)
417        if hasattr(self,'index'):
418            frag = Element(CSML('index'))
419            frag.text = str(self.index)
420            csmlFrag.append(frag)
421        return csmlFrag
422
423class NetCDFExtract(AbstractFileExtract):
424    """CSML class for netCDF file extract
425
426    NetCDFExtract(AbstractFileExtract):
427     +variableName: string
428    """
429    def __init__(self,variableName=None,*args,**kwargs):
430        AbstractFileExtract.__init__(self,*args,**kwargs)
431        if variableName:
432            self.variableName = variableName
433    def fromXML(self,csmlFrag):
434        AbstractFileExtract.fromXML(self,csmlFrag)
435        for frag in csmlFrag.getchildren():
436            if frag.tag == CSML('variableName'):
437                self.variableName = frag.text
438##        else:
439##            raise Exception('Unexpected element: "'+frag.tag+'"')
440    def toXML(self,csmlFrag):
441        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
442        frag = Element(CSML('variableName'))
443        frag.text = self.variableName
444        csmlFrag.append(frag)
445        return csmlFrag
446
447class GRIBExtract(AbstractFileExtract):
448    """CSML class for GRIB file extract
449
450    GRIBExtract(AbstractFileExtract):
451     +parameterCode: int
452     +recordNumber[0..1]: int
453     +fileOffset[0..1]: int
454    """
455    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None,
456                 *args,**kwargs):
457        AbstractFileExtract.__init__(self,*args,**kwargs)
458        if parameterCode:
459            self.parameterCode = parameterCode
460        if recordNumber:
461            self.recordNumber = recordNumber
462        if fileOffset:
463            self.fileOffset = fileOffset
464    def fromXML(self,csmlFrag):
465        AbstractFileExtract.fromXML(self,csmlFrag)
466        for frag in csmlFrag.getchildren():
467            if frag.tag == CSML('parameterCode'):
468                self.parameterCode = int(frag.text)
469            elif frag.tag == CSML('recordNumber'):
470                self.recordNumber = int(frag.text)
471            elif frag.tag == CSML('fileOffset'):
472                self.fileOffset = int(frag.text)
473##            else:
474##                raise Exception('Unexpected element: "'+frag.tag+'"')
475    def toXML(self,csmlFrag):
476        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
477        frag = Element(CSML('parameterCode'))
478        frag.text = str(self.parameterCode)
479        csmlFrag.append(frag)
480        if hasattr(self,'recordNumber'):
481            frag = Element(CSML('recordNumber'))
482            frag.text = str(self.recordNumber)
483            csmlFrag.append(frag)
484        if hasattr(self,'fileOffset'):
485            frag = Element(CSML('fileOffset'))
486            frag.text = str(self.fileOffset)
487            csmlFrag.append(frag)
488        return csmlFrag
489
490class AbstractDiscreteCoverage(AbstractGML):
491     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
492    #GML AbstractDiscreteCoverage
493    def __init__(self,*args,**kwargs):
494        AbstractGML.__init__(self,*args,**kwargs)
495    def fromXML(self,csmlFrag):
496        AbstractGML.fromXML(self,csmlFrag)
497    def toXML(self,csmlFrag):
498        AbstractGML.toXML(self,csmlFrag)
499        return csmlFrag
500       
501class AbstractCoverageFeature(AbstractDiscreteCoverage):
502    #CSML Abstract Coverage FT class
503    #     AbstractCoverageFeature():
504    #       +gml:boundedBy[0..*]: AbstractFeature
505    #       +csml:_Domain
506    #       + gml:rangeSet
507    #       + gml:coverageFunction[0..*]
508    #       + parameter:om:PhenomenonPropertyType
509    def __init__(self,boundedBy=None,_Domain=None,rangeSet=None, coverageFunction=None, parameter=None, *args,**kwargs):
510        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
511        if boundedBy:
512            self.boundedBy=boundedBy
513        if _Domain:
514            self._Domain=_Domain
515        if rangeSet:
516            self.rangeSet=rangeSet
517        if coverageFunction:
518            self.coverageFunction=coverageFunction
519        if parameter:
520            self.parameter=parameter
521    def fromXML(self,csmlFrag):
522        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
523        for frag in csmlFrag.getchildren():
524            if frag.tag == GML('boundedBy'):
525                #hmmm check this one is right.
526                checkArrayAttrib(self,'boundedBy')
527                self.boundedBy.append(frag.text)
528            if frag.tag == CSML('_Domain'):
529                self._Domain = _Domain()
530                self._Domain.fromXML(frag)
531    def toXML(self,csmlFrag):
532        AbstractDiscreteCoverage.toXML(self,csmlFrag)
533        return csmlFrag
534
535
536
537
538class AbstractStaticCoverageFeature(AbstractCoverageFeature):
539    #CSML Abstract Static Coverage FT class
540    def __init__(self,*args,**kwargs):
541        AbstractCoverageFeature.__init__(self,*args,**kwargs)
542    def fromXML(self,csmlFrag):
543        AbstractCoverageFeature.fromXML(self,csmlFrag)
544    def toXML(self,csmlFrag):
545        AbstractCoverageFeature.toXML(self,csmlFrag)
546        return csmlFrag
547
548class AbstractDomain:
549    def __init__(self):
550        pass
551    def fromXML(self,csmlFrag):
552        pass
553    def toXML(self,csmlFrag):
554        return csmlFrag
555
556class Position:
557    def __init__(self,srsName=None,axisLabels=None,uomLabels=None):
558        if srsName:
559            self.srsName=srsName
560        if axisLabels:
561            self.axisLabels=axisLabels
562        if uomLabels:
563            self.uomLabels=uomLabels
564    def fromXML(self,csmlFrag):
565        print csmlFrag.attrib
566        #sys.exit()   
567        if csmlFrag.attrib.has_key('srsName'):           
568            self.srsName = csmlFrag.attrib['srsName']
569        if csmlFrag.attrib.has_key('axisLabels'):
570            self.axisLabels = csmlFrag.attrib['axisLabels']
571        if csmlFrag.attrib.has_key('uomLabels'):
572            self.uomLabels = csmlFrag.attrib['uomLabels']
573        for frag in csmlFrag.getchildren():
574            print frag.tag
575            if frag.tag==CSML('location'):
576                self.location=frag.text
577            if frag.tag==CSML('time'):
578                self.time=frag.text
579    def toXML(self,csmlFrag):
580        if hasattr(self,'uomLabels'):
581            csmlFrag.attrib['uomLabels'] = self.uomLabels
582        if hasattr(self,'axisLabels'):
583            csmlFrag.attrib['axisLabels'] = self.axisLabels
584        if hasattr(self,'srsName'):
585            csmlFrag.attrib['srsName'] = self.srsName
586        if hasattr(self,'location'):
587            frag = Element(CSML('location'))
588            frag.text=self.location
589            csmlFrag.append(frag)
590        if hasattr(self,'time'):
591            frag = Element(CSML('time'))
592            frag.text=self.time
593            csmlFrag.append(frag)
594        return csmlFrag
595   
596class domainReference:
597    def __init__(self):
598        pass
599    def fromXML(self,csmlFrag):
600        for frag in csmlFrag.getchildren():
601            if frag.tag==CSML('Position'):
602                self.Position=Position()
603                self.Position.fromXML(frag)
604
605    def toXML(self,csmlFrag):
606        if hasattr(self,'Position'):
607             frag = Element(CSML('Position'))
608             Position.toXML(self.Position,frag)
609             csmlFrag.append(frag)
610        return csmlFrag
611
612class domainComplement:
613    def __init__(self):
614        pass
615    def fromXML(self,csmlFrag):
616        pass
617    def toXML(self,csmlFrag):
618        return csmlFrag
619   
620class PointDomain(AbstractDomain):
621    def __init__(self):
622        pass
623    def fromXML(self,csmlFrag):
624        AbstractDomain.fromXML(self,csmlFrag)
625        for frag in csmlFrag.getchildren():
626            if frag.tag == CSML('domainReference'):
627                self.domainReference = domainReference()
628                self.domainReference.fromXML(frag)
629
630            if frag.tag == CSML('domainComplement'):
631                self.domainComplement = frag.text
632    def toXML(self,csmlFrag):
633        AbstractDomain.toXML(self,csmlFrag)
634        if hasattr(self,'domainReference'):
635            frag = Element(CSML('domainReference'))
636            domainReference.toXML(self.domainReference,frag)
637            csmlFrag.append(frag)
638        if hasattr(self,'domainComplement'):
639             frag = Element(CSML('domainComplement'))
640             domainComplement.toXML(self.domainComplement,frag)
641             csmlFrag.append(frag)
642        return csmlFrag
643   
644class PointFeature(AbstractStaticCoverageFeature):
645#TODO:
646
647#Fiinish rangeSet, parameter and coverageFunction (23/02/06)
648           
649           
650    #CSML PointFeature class
651    #       PointFeature(AbstractStaticCoverageFeatureType):
652    #      +PointDomain
653    #      +gml:rangeSet
654    #      +gml:coverageFunction[0..*]
655    #      +parameter:om:PhenomenonPropertyType
656    def __init__(self,PointDomain=None,rangeSet=None,coverageFunction=None, parameter=None,*args,**kwargs):
657        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
658
659        if PointDomain:
660            self.PointDomain=PointDomain
661        if rangeSet:
662            self.rangeSet=rangeSet
663        if coverageFunction:
664            self.coverageFunction=coverageFunction
665        if parameter:
666            self.parameter=parameter
667    def fromXML(self,csmlFrag):
668        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
669
670        for frag in csmlFrag.getchildren():
671            if frag.tag == CSML('PointDomain'):
672                self.PointDomain = PointDomain()
673                self.PointDomain.fromXML(frag)
674#             if frag.tag == GML('rangeSet'):
675#                self.rangeSet=rangeSet()
676#                self.rangeSet.fromXML(frag)
677#             if frag.tag == GML('coverageFunction'):
678#                 checkArrayAttrib(self,'coverageFunction')
679#                 self.coverageFunction.append(frag.text)
680##        else:
681##            raise Exception('Unexpected element: "'+frag.tag+'"')
682    def toXML(self,csmlFrag):
683        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
684        if hasattr(self,'PointDomain'):
685             frag = Element(CSML('PointDomain'))
686             PointDomain.toXML(self.PointDomain,frag)
687             csmlFrag.append(frag)
688#         if hasattr(self,'rangeSet'):
689#              frag = Element(CSML('rangeSet'))
690#              PointDomain.toXML(self.PointDomain,frag)
691#              csmlFrag.append(frag)
692#         if hasattr(self,'parameter'):
693#              frag = Element(CSML('parameter'))
694#              frag.text=self.parameter
695#              csmlFrag.append(frag)
696        return csmlFrag
697
698class ProfileFeature:
699    def __init__(self):
700        pass
701    def fromXML(self,csmlFrag):
702        pass
703    def toXML(self,csmlFrag):
704        return csmlFrag
705class GridFeature:
706    def __init__(self):
707        pass
708    def fromXML(self,csmlFrag):
709        pass
710    def toXML(self,csmlFrag):
711        return csmlFrag
712class PointSeriesFeature:
713    def __init__(self):
714        pass
715    def fromXML(self,csmlFrag):
716        pass
717    def toXML(self,csmlFrag):
718        return csmlFrag
719class ProfileSeriesFeature:
720    def __init__(self):
721        pass
722    def fromXML(self,csmlFrag):
723        pass
724    def toXML(self,csmlFrag):
725        return csmlFrag
726class GridSeriesFeature:
727    def __init__(self):
728        pass
729    def fromXML(self,csmlFrag):
730        pass
731    def toXML(self,csmlFrag):
732        return csmlFrag
733class TrajectoryFeature:
734    def __init__(self):
735        pass
736    def fromXML(self,csmlFrag):
737        pass
738    def toXML(self,csmlFrag):
739        return csmlFrag
740   
741class AbstractFeature(AbstractGML):
742    def __init__(self):
743        pass
744    def fromXML(self,csmlFrag):
745        AbstractGML.fromXML(self,csmlFrag)
746    def toXML(self,csmlFrag):
747        AbstractGML.toXML(self,csmlFrag)
748        return csmlFrag
749
750
751class AbstractFeatureCollection(AbstractFeature):
752    """GML AbstractFeatureCollection class
753
754    AbstractFeatureCollection(AbstractFeature):
755     +featureMember[0..*]: AbstractFeature
756     +featureMembers[0..1]: FeatureArray
757    """
758    def __init__(self,members=[]):
759        if members:
760            self.members=members
761    def fromXML(self,csmlFrag):
762        AbstractFeature.fromXML(self,csmlFrag)
763        for frag in csmlFrag.getchildren():
764            if frag.tag == GML('featureMember'):
765                checkArrayAttrib(self,'members')
766                featureFrag = frag.getchildren()[0]
767                if featureFrag.tag == CSML('PointFeature'):
768                    self.members.append(PointFeature())
769                    self.members[-1].fromXML(featureFrag)
770                if featureFrag.tag == CSML('ProfileFeature'):
771                    self.members.append(ProfileFeature())
772                    self.members[-1].fromXML(featureFrag)
773                if featureFrag.tag == CSML('GridFeature'):
774                    self.members.append(GridFeature())
775                    self.members[-1].fromXML(featureFrag)
776                if featureFrag.tag == CSML('PointSeriesFeature'):
777                    self.members.append(PointSeriesFeature())
778                    self.members[-1].fromXML(featureFrag)
779                if featureFrag.tag == CSML('ProfileSeriesFeature'):
780                    self.members.append(ProfileSeriesFeature())
781                    self.members[-1].fromXML(featureFrag)
782                if featureFrag.tag == CSML('GridSeriesFeature'):
783                    self.members.append(GridSeriesFeature())
784                    self.members[-1].fromXML(featureFrag)
785                if featureFrag.tag == CSML('TrajectoryFeature'):
786                    self.members.append(TrajectoryFeature())
787                    self.members[-1].fromXML(featureFrag)
788    def toXML(self,csmlFrag):
789        AbstractFeature.toXML(self,csmlFrag)
790        i=0
791        for member in self.members:
792            if isinstance(member,PointFeature):
793                superFrag=Element(GML('FeatureMember'))
794                frag=Element(CSML('PointFeature'))
795                PointFeature.toXML(self.members[i],frag)
796                superFrag.append(frag)
797                csmlFrag.append(superFrag)
798            if isinstance(member,ProfileFeature):
799                superFrag=Element(GML('FeatureMember'))
800                frag=Element(CSML('ProfileFeature'))
801                ProfileFeature.toXML(self.members[i],frag)
802                superFrag.append(frag)
803                csmlFrag.append(superFrag)
804            if isinstance(member,GridFeature):
805                superFrag=Element(GML('FeatureMember'))
806                frag=Element(CSML('GridFeature'))
807                GridFeature.toXML(self.members[i],frag)
808                superFrag.append(frag)
809                csmlFrag.append(superFrag)
810            if isinstance(member,PointSeriesFeature):
811                superFrag=Element(GML('FeatureMember'))
812                frag=Element(CSML('PointSeriesFeature'))
813                PointSeriesFeature.toXML(self.members[i],frag)
814                superFrag.append(frag)
815                csmlFrag.append(superFrag)
816            if isinstance(member,ProfileSeriesFeature):
817                superFrag=Element(GML('FeatureMember'))
818                frag=Element(CSML('ProfileSeriesFeature'))
819                ProfileSeriesFeature.toXML(self.members[i],frag)
820                superFrag.append(frag)
821                csmlFrag.append(superFrag)
822            if isinstance(member,GridSeriesFeature):
823                superFrag=Element(GML('FeatureMember'))
824                frag=Element(CSML('GridSeriesFeature'))
825                GridSeriesFeature.toXML(self.members[i],frag)
826                superFrag.append(frag)
827                csmlFrag.append(superFrag)
828            if isinstance(member,TrajectoryFeature):
829                superFrag=Element(GML('FeatureMember'))
830                frag=Element(CSML('TrajectoryFeature'))
831                TrajectoryFeature.toXML(self.members[i],frag)
832                superFrag.append(frag)
833                csmlFrag.append(superFrag)
834            i=i+1
835       
836        return csmlFrag
837
838class FeatureCollection(AbstractFeatureCollection):
839    """GML FeatureCollection class
840    """
841    def __init__(self):
842        pass
843    def fromXML(self,csmlFrag):
844        AbstractFeatureCollection.fromXML(self,csmlFrag)
845    def toXML(self,csmlFrag):
846        AbstractFeatureCollection.toXML(self,csmlFrag)
847        return csmlFrag
848
849class Dataset(AbstractGML):
850    """CSML Dataset class
851
852    Dataset(AbstractGML):
853     +unitDefinitions[0..*]: UnitDefinitions
854     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
855     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
856     +arrayDescriptors[0..*]: AbstractArrayDescriptor
857     +featureCollection[0..1]: FeatureCollection
858    """
859    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
860                 phenomenonDefinitions=None,arrayDescriptors=[],
861                 featureCollection=None,*args,**kwargs):
862        AbstractGML.__init__(self,*args,**kwargs)
863        if unitDefinitions:
864            self.unitDefinitions = unitDefinitions
865        if referenceSystemDefinitions:
866            self.referenceSystemDefinitions = referenceSystemDefinitions
867        if phenomenonDefinitions:
868            self.phenomenonDefinitions = phenomenonDefinitions
869        if arrayDescriptors:
870            self.arrayDescriptors = arrayDescriptors
871        if featureCollection:
872            self.featureCollection = featureCollection
873    def fromXML(self,csmlFrag):
874        AbstractGML.fromXML(self,csmlFrag)
875        for frag in csmlFrag.getchildren():
876            if frag.tag == CSML('UnitDefinitions'):
877                self.unitDefinitions = UnitDefinitions()
878                self.unitDefinitions.fromXML(frag)
879            elif frag.tag == CSML('ReferenceSystemDefinitions'):
880                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
881                self.referenceSystemDefinitions.fromXML(frag)
882            elif frag.tag == CSML('PhenomenonDefinitions'):
883                self.phenomenonDefinitions = PhenomenonDefinitions()
884                self.phenomenonDefinitions.fromXML(frag)
885            elif frag.tag == GML('FeatureCollection'):
886                self.featureCollection = FeatureCollection()
887                self.featureCollection.fromXML(frag)
888            elif frag.tag == CSML('AggregatedArray'):
889                checkArrayAttrib(self,'arrayDescriptors')
890                self.arrayDescriptors.append(AggregatedArray())
891                self.arrayDescriptors[-1].fromXML(frag)
892            elif frag.tag == CSML('InlineArray'):
893                checkArrayAttrib(self,'arrayDescriptors')
894                self.arrayDescriptors.append(InlineArray())
895                self.arrayDescriptors[-1].fromXML(frag)
896            elif frag.tag == CSML('ArrayGenerator'):
897                checkArrayAttrib(self,'arrayDescriptors')
898                self.arrayDescriptors.append(ArrayGenerator())
899                self.arrayDescriptors[-1].fromXML(frag)
900            elif frag.tag == CSML('NASAAmesExtract'):
901                checkArrayAttrib(self,'arrayDescriptors')
902                self.arrayDescriptors.append(NASAAmesExtract())
903                self.arrayDescriptors[-1].fromXML(frag)
904            elif frag.tag == CSML('NetCDFExtract'):
905                checkArrayAttrib(self,'arrayDescriptors')
906                self.arrayDescriptors.append(NetCDFExtract())
907                self.arrayDescriptors[-1].fromXML(frag)
908            elif frag.tag == CSML('GRIBExtract'):
909                checkArrayAttrib(self,'arrayDescriptors')
910                self.arrayDescriptors.append(GRIBExtract())
911                self.arrayDescriptors[-1].fromXML(frag)
912##            else:
913##                raise Exception('Unexpected element: "'+frag.tag+'"')
914    def toXML(self,csmlFrag=None):
915        if csmlFrag is None:
916            csmlFrag = Element('Dataset')
917        csmlFrag = AbstractGML.toXML(self,csmlFrag)
918        if hasattr(self,'unitDefinitions'):
919            frag = Element(CSML('UnitDefinitions'))
920            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
921            csmlFrag.append(frag)
922        if hasattr(self,'referenceSystemDefinitions'):
923            frag = Element(CSML('ReferenceSystemDefinitions'))
924            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
925            csmlFrag.append(frag)
926        if hasattr(self,'phenomenonDefinitions'):
927            frag = Element(CSML('PhenomenonDefinitions'))
928            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
929            csmlFrag.append(frag)
930        if hasattr(self,'arrayDescriptors'):
931            for arrayDesc in self.arrayDescriptors:
932                if isinstance(arrayDesc,AggregatedArray):
933                    frag = Element(CSML('AggregatedArray'))
934                    frag = AggregatedArray.toXML(arrayDesc,frag)
935                elif isinstance(arrayDesc,InlineArray):
936                    frag = Element(CSML('InlineArray'))
937                    frag = InlineArray.toXML(arrayDesc,frag)
938                elif isinstance(arrayDesc,ArrayGenerator):
939                    frag = Element(CSML('ArrayGenerator'))
940                    frag = ArrayGenerator.toXML(arrayDesc,frag)
941                elif isinstance(arrayDesc,NASAAmesExtract):
942                    frag = Element(CSML('NASAAmesExtract'))
943                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
944                elif isinstance(arrayDesc,NetCDFExtract):
945                    frag = Element(CSML('NetCDFExtract'))
946                    frag = NetCDFExtract.toXML(arrayDesc,frag)
947                elif isinstance(arrayDesc,GRIBExtract):
948                    frag = Element(CSML('GRIBExtract'))
949                    frag = GRIBExtract.toXML(arrayDesc,frag)
950                csmlFrag.append(frag)
951        if hasattr(self,'featureCollection'):
952            frag = Element(GML('FeatureCollection'))
953            frag = FeatureCollection.toXML(self.featureCollection,frag)
954            csmlFrag.append(frag)
955            #csmlFrag=fixNameSpaces(csmlFrag)
956        return csmlFrag
Note: See TracBrowser for help on using the repository browser.