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

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

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