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

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

demoCreateCSML.py - example of creating CSML from scratch using parser

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