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

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

UnitDefinition?(s), Dictionary, TimeCoordinateSystem? added

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