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

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

added MeasureOrNullListType?

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                    self.parameter=Definition()
913                    self.parameter.fromXML(frag)
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                    self.parameter.fromXML(subFrag)
923                       
924    def toXML(self,csmlFrag):
925        AbstractDiscreteCoverage.toXML(self,csmlFrag)
926        if hasattr(self,'parameter'):
927            frag = Element(CSML('parameter'))
928            if isinstance(self.parameter,ParameterisedPhenomenon):
929                subFrag=Element(OM('ParameterisedPhenomenon'))
930                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
931                frag.append(subFrag)
932                csmlFrag.append(frag)
933            elif isinstance(self.parameter,CompositePhenomenon):
934                subFrag=Element(OM('CompositePhenomenon'))
935                CompositePhenomenon.toXML(self.parameter,subFrag)
936                frag.append(subFrag)
937                csmlFrag.append(frag)
938            elif isinstance(self.parameter,Phenomenon):
939                subFrag=Element(OM('Phenomenon'))
940                Phenomenon.toXML(self.parameter,subFrag)
941                frag.append(subFrag)
942                csmlFrag.append(frag)
943            #if hasattr(self, 'href'):
944            elif isinstance(self.parameter,Definition):
945                Definition.toXML(self.parameter,frag)
946                csmlFrag.append(frag)
947               
948                #frag.attrib[XLINK('href')] = self.href
949
950        return csmlFrag
951
952   
953class AbstractStaticCoverageFeature(AbstractCoverageFeature):
954    #CSML Abstract Static Coverage FT class
955    def __init__(self,*args,**kwargs):
956        AbstractCoverageFeature.__init__(self,*args,**kwargs)
957    def fromXML(self,csmlFrag):
958        AbstractCoverageFeature.fromXML(self,csmlFrag)
959    def toXML(self,csmlFrag):
960        AbstractCoverageFeature.toXML(self,csmlFrag)
961        return csmlFrag
962   
963class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
964    #CSML Abstract Series Coverage FT class
965    def __init__(self,*args,**kwargs):
966        AbstractCoverageFeature.__init__(self,*args,**kwargs)
967    def fromXML(self,csmlFrag):
968        AbstractCoverageFeature.fromXML(self,csmlFrag)
969    def toXML(self,csmlFrag):
970        AbstractCoverageFeature.toXML(self,csmlFrag)
971        return csmlFrag
972   
973class AbstractDomain:
974    #CSML AbstractDomain class
975    #   AbstractDomain()
976    #   +csml:domainReference
977    #   +csml:domainComplement [0...1]
978       
979    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
980        if domainReference:
981            self.domainReference=domainReference
982        if domainComplement:
983            self.domainComplement=domainComplement
984    def fromXML(self,csmlFrag):
985        for frag in csmlFrag.getchildren():
986            if frag.tag == CSML('domainReference'):
987                subfrag=frag.getchildren()[0]
988                if subfrag.tag==CSML('Position'):
989                    self.domainReference=Position()
990                elif subfrag.tag == CSML('Trajectory'):
991                    self.domainReference=Trajectory()
992                elif subfrag.tag==CSML('OrientedPosition'):
993                    self.domainReference=OrientedPosition()
994                elif subfrag.tag == CSML('OrientedTrajectory'):
995                    self.domainReference=OrientedTrajectory()
996                elif subfrag.tag == GML('TimeInstant'):
997                    self.domainReference=TimeInstant()
998                elif subfrag.tag == GML('TimePositionList'):
999                    self.domainReference=TimePositionList()
1000                self.domainReference.fromXML(subfrag)
1001               
1002            if frag.tag == CSML('domainComplement'):
1003                subfrag=frag.getchildren()[0]
1004                if subfrag.tag==CSML('DirectPositionList'):
1005                    self.domainComplement=DirectPositionList()
1006                    self.domainComplement.fromXML(subfrag)
1007                elif subfrag.tag==CSML('Grid'):
1008                    self.domainComplement=Grid()
1009                    self.domainComplement.fromXML(subfrag)
1010    def toXML(self,csmlFrag):
1011        if hasattr(self,'domainReference'):
1012            frag = Element(CSML('domainReference'))
1013            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
1014            #self.domainReference.toXML(frag)
1015            if isinstance(self.domainReference,OrientedPosition):
1016                subFrag=Element(CSML('OrientedPosition'))
1017                self.domainReference.toXML(subFrag)
1018                frag.append(subFrag)
1019                csmlFrag.append(frag)
1020            elif isinstance(self.domainReference,OrientedTrajectory):
1021                subFrag=Element(CSML('OrientedTrajectory'))
1022                self.domainReference.toXML(subFrag)
1023                frag.append(subFrag)
1024                csmlFrag.append(frag)       
1025            elif isinstance(self.domainReference,Position):
1026                subFrag=Element(CSML('Position'))
1027                self.domainReference.toXML(subFrag)
1028                frag.append(subFrag)
1029                csmlFrag.append(frag)
1030            elif isinstance(self.domainReference,Trajectory):
1031                subFrag=Element(CSML('Trajectory'))
1032                self.domainReference.toXML(subFrag)
1033                frag.append(subFrag)
1034                csmlFrag.append(frag)
1035            elif isinstance(self.domainReference,TimeInstant):
1036                subFrag=Element(GML('TimeInstant'))
1037                self.domainReference.toXML(subFrag)
1038                frag.append(subFrag)
1039                csmlFrag.append(frag)
1040            elif isinstance(self.domainReference,TimePositionList):
1041                subFrag=Element(GML('TimePositionList'))
1042                self.domainReference.toXML(subFrag)
1043                frag.append(subFrag)
1044                csmlFrag.append(frag)   
1045        if hasattr(self,'domainComplement'):
1046            frag = Element(CSML('domainComplement'))
1047            if isinstance(self.domainComplement,DirectPositionList):
1048                    subFrag=Element(CSML('DirectPositionList'))
1049                    self.domainComplement.toXML(subFrag)
1050                    frag.append(subFrag)
1051                    csmlFrag.append(frag)
1052            elif isinstance(self.domainComplement,Grid):
1053                    subFrag=Element(CSML('Grid'))
1054                    self.domainComplement.toXML(subFrag)
1055                    frag.append(subFrag)
1056                    csmlFrag.append(frag)
1057        return csmlFrag
1058
1059
1060class EnvelopeWithTimePeriod:
1061    # CSML EnvelopeWithTimePeriod class
1062    # EnvelopeWithTimePeriod():
1063        # +gml:lowerCorner
1064        # +gml:upperCorner
1065        # +gml:timePosition [2] ?
1066       
1067    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
1068        if srsName:
1069            self.srsName=srsName
1070        if lowerCorner:
1071            self.lowerCorner=lowerCorner
1072        if upperCorner:
1073            self.upperCorner=upperCorner
1074        if timePosition:
1075            self.timePosition=timePosition
1076        if timePosition2:
1077            self.timePosition2=timePosition2
1078    def fromXML(self,csmlFrag):
1079        EnvTPfrag=csmlFrag.getchildren()[0]
1080        for frag in EnvTPfrag.getchildren():
1081            if frag.attrib.has_key('srsName'):
1082                self.srsName=frag.attrib['srsName']
1083            if frag.tag == GML('lowerCorner'):
1084                self.lowerCorner=frag.text
1085            if frag.tag == GML('upperCorner'):
1086                self.upperCorner=frag.text
1087            if frag.tag == GML('timePosition'):
1088                if hasattr(self, 'timePosition'):
1089                    self.timePosition2=frag.text
1090                else:
1091                    self.timePosition=frag.text
1092    def toXML(self,csmlFrag):
1093        if hasattr(self,'srsName'):
1094            csmlFrag.attrib['srsName'] = self.srsName
1095        if hasattr(self,'lowerCorner'):
1096            frag=Element(GML('lowerCorner'))
1097            frag.text=self.lowerCorner
1098            csmlFrag.append(frag)
1099        if hasattr(self,'upperCorner'):
1100            frag=Element(GML('upperCorner'))
1101            frag.text=self.upperCorner
1102            csmlFrag.append(frag)
1103        if hasattr(self,'timePosition'):
1104            frag=Element(GML('timePosition'))
1105            frag.text=self.timePosition
1106            csmlFrag.append(frag)
1107        if hasattr(self,'timePosition2'):
1108            frag=Element(GML('timePosition'))
1109            frag.text=self.timePosition2
1110            csmlFrag.append(frag)
1111        return csmlFrag
1112
1113       
1114class DirectionVectorList:
1115    def __init__(self, horizontalAngle=None, verticalAngle=None):
1116        if horizontalAngle:
1117            self.horizontalAngle=horizontalAngle
1118        if verticalAngle:
1119            self.verticalAngle=verticalAngle
1120    def fromXML(self, csmlFrag):
1121        for frag in csmlFrag.getchildren():
1122            if frag.tag==GML('horizontalAngle'):
1123                self.horizontalAngle=frag.text
1124                if frag.attrib.has_key('uom'):
1125                    self.uom_H=frag.attrib['uom']
1126            elif frag.tag==GML('verticalAngle'):
1127                self.verticalAngle=frag.text
1128                if frag.attrib.has_key('uom'):
1129                    self.uom_V=frag.attrib['uom']
1130    def toXML(self,csmlFrag):
1131         if hasattr(self,'horizontalAngle'):
1132            frag = Element(GML('horizontalAngle'))
1133            frag.text=self.horizontalAngle
1134            if hasattr(self,'uom_H'):
1135                frag.attrib['uom'] = self.uom_H
1136            csmlFrag.append(frag)
1137           
1138         if hasattr(self,'verticalAngle'):
1139            frag = Element(GML('verticalAngle'))
1140            frag.text=self.verticalAngle
1141            if hasattr(self,'uom_V'):
1142                frag.attrib['uom'] = self.uom_V
1143            csmlFrag.append(frag)
1144
1145       
1146class Position:
1147    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
1148        if srsName:
1149            self.srsName=srsName
1150        if axisLabels:
1151            self.axisLabels=axisLabels
1152        if uomLabels:
1153            self.uomLabels=uomLabels
1154        if location:
1155            self.location=location
1156        if time:
1157            self.time = time
1158    def fromXML(self,csmlFrag):
1159        if csmlFrag.attrib.has_key('srsName'):           
1160            self.srsName = csmlFrag.attrib['srsName']
1161        if csmlFrag.attrib.has_key('axisLabels'):
1162            self.axisLabels = csmlFrag.attrib['axisLabels']
1163            if csmlFrag.attrib.has_key('uomLabels'):
1164                self.uomLabels = csmlFrag.attrib['uomLabels']
1165        for frag in csmlFrag.getchildren():
1166            print frag.tag
1167            if frag.tag==CSML('location'):
1168                self.location=frag.text
1169            if frag.tag==CSML('time'):
1170                self.time=frag.text
1171    def toXML(self,csmlFrag):
1172        #subFrag = Element(CSML('Position'))
1173        if hasattr(self,'uomLabels'):
1174            csmlFrag.attrib['uomLabels'] = self.uomLabels
1175        if hasattr(self,'axisLabels'):
1176            csmlFrag.attrib['axisLabels'] = self.axisLabels
1177        if hasattr(self,'srsName'):
1178            csmlFrag.attrib['srsName'] = self.srsName
1179        if hasattr(self,'location'):
1180            frag = Element(CSML('location'))
1181            frag.text=self.location
1182            csmlFrag.append(frag)
1183        if hasattr(self,'time'):
1184            frag = Element(CSML('time'))
1185            frag.text=self.time
1186            csmlFrag.append(frag)
1187        return csmlFrag
1188
1189class OrientedPosition(Position):
1190    def __init__(self, direction=None, *args,**kwargs):
1191        Position.__init__(self, *args,**kwargs)
1192        if direction:
1193            self.direction=direction
1194    def fromXML(self,csmlFrag):
1195        Position.fromXML(self, csmlFrag)
1196        for frag in csmlFrag.getchildren():
1197            if frag.tag==CSML('direction'):
1198                self.direction=DirectionVectorList()
1199                DirectionVectorList.fromXML(self.direction,frag)
1200    def toXML(self, csmlFrag):
1201        Position.toXML(self,csmlFrag)
1202        if hasattr(self,'direction'):
1203            frag = Element(CSML('direction'))
1204            DirectionVectorList.toXML(self.direction,frag)
1205            csmlFrag.append(frag)
1206        return csmlFrag
1207       
1208
1209
1210class Trajectory:
1211    def __init__(self,srsName=None,locations=None,times=None):
1212        if srsName:
1213            self.srsName=srsName
1214        if locations:
1215            self.locations=locations
1216        if times:
1217            self.times = times
1218
1219    def fromXML(self,csmlFrag):
1220        if csmlFrag.attrib.has_key('srsName'):
1221            self.srsName = csmlFrag.attrib['srsName']
1222        for frag in csmlFrag.getchildren():
1223            print frag.tag
1224            if frag.tag==CSML('locations'):
1225                self.locations=frag.text
1226            if frag.tag==CSML('times'):
1227                self.times=frag.text
1228    def toXML(self,csmlFrag):
1229        if hasattr(self,'srsName'):
1230            csmlFrag.attrib['srsName'] = self.srsName
1231        if hasattr(self,'locations'):
1232            frag = Element(CSML('locations'))
1233            frag.text=self.locations
1234            csmlFrag.append(frag)
1235        if hasattr(self,'times'):
1236            frag = Element(CSML('times'))
1237            frag.text=self.times
1238            csmlFrag.append(frag)
1239        return csmlFrag
1240
1241class OrientedTrajectory(Trajectory):
1242    def __init__(self, direction=None, *args,**kwargs):
1243        Trajectory.__init__(self, *args,**kwargs)
1244        if direction:
1245             self.direction=direction
1246    def fromXML(self,csmlFrag):
1247        Trajectory.fromXML(self, csmlFrag)
1248        for frag in csmlFrag.getchildren():
1249            if frag.tag==CSML('direction'):
1250                self.direction=DirectionVectorList()
1251                DirectionVectorList.fromXML(self.direction,frag)
1252    def toXML(self, csmlFrag):
1253        Trajectory.toXML(self,csmlFrag)
1254        if hasattr(self,'direction'):
1255            frag = Element(CSML('direction'))
1256            DirectionVectorList.toXML(self.direction,frag)
1257            csmlFrag.append(frag)
1258        return csmlFrag
1259
1260class AbstractGeometryType(AbstractGML):
1261    def __init__(self, low=None, high=None):
1262        AbstractGML.__init__(self)
1263        if low:
1264            self.low=low
1265        if high:
1266            self.high=high
1267    def fromXML(self, csmlFrag):
1268        AbstractGML.fromXML(self,csmlFrag)
1269    def toXML(self,csmlFrag):
1270        AbstractGML.toXML(self,csmlFrag)
1271        return csmlFrag
1272
1273class GridEnvelope:
1274    def __init__(self, low=None, high = None):
1275        if low:
1276            self.low = low
1277        if high:
1278            self.high = high
1279    def fromXML(self, csmlFrag):
1280        print csmlFrag
1281        frag = csmlFrag.getchildren()[0]
1282        for subFrag in frag.getchildren():
1283            if subFrag.tag == GML('low'):
1284                self.low=subFrag.text
1285            elif subFrag.tag == GML('high'):
1286                self.high=subFrag.text
1287    def toXML(self,csmlFrag):
1288        if hasattr(self, 'low'):
1289            frag=Element(GML('low'))
1290            frag.text=self.low
1291            csmlFrag.append(frag)
1292        if hasattr(self, 'high'):
1293            frag=Element(GML('high'))
1294            frag.text=self.high
1295            csmlFrag.append(frag)
1296        return csmlFrag
1297
1298class GmlGrid(AbstractGeometryType):
1299    #Class GmlGrid, representing a gml:Grid element.
1300    #  +dimension positiveInteger [1]
1301    # +gml:limits  (gml:GridLimitsType) </gml:limits> [1]
1302    #+gml:axisName  (string) [1..*]
1303    def __init__(self,dimension=None,limits=None,axisName=None):
1304        AbstractGeometryType.__init__(self)
1305        if dimension:
1306            self.dimension=dimension
1307        if limits:
1308            self.limits=limits
1309        if axisName:
1310            self.axisName=axisName
1311    def fromXML(self, csmlFrag):
1312        AbstractGeometryType.fromXML(self,csmlFrag)
1313        for frag in csmlFrag.getchildren():
1314            print frag
1315        for frag in csmlFrag.getchildren():
1316            if frag.tag == GML('limits'):
1317                self.limits=GridEnvelope()
1318                GridEnvelope.fromXML(self.limits,frag)
1319            elif frag.tag == GML('axisName'):
1320                checkArrayAttrib(self,'axisNames')
1321                self.axisNames.append(frag.text)
1322    def toXML(self,csmlFrag):
1323        AbstractGeometryType.toXML(self,csmlFrag)
1324        if hasattr(self, 'limits'):
1325            frag=Element(GML('limits'))
1326            subFrag =Element(GML('GridEnvelope'))
1327            GridEnvelope.toXML(self.limits, subFrag)
1328            frag.append(subFrag)
1329            csmlFrag.append(frag)
1330        if hasattr(self, 'axisNames'):
1331            for axis in self.axisNames:
1332                frag=Element(GML('axisName'))
1333                frag.text =axis
1334                csmlFrag.append(frag)
1335        return csmlFrag
1336           
1337class GridOrdinateDescription:
1338    #Class GridOrdinateDescription:
1339        #+gridAxesSpanned
1340        #+sequenceRule
1341        #+definesAxis,attrib -href
1342        #+axisValues
1343
1344    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
1345        if gridAxesSpanned:
1346            self.gridAxesSpanned=gridAxesSpanned
1347        if sequenceRule:
1348            self.sequenceRule=sequenceRule
1349        if definesAxis:
1350            self.definesAxis=definesAxis
1351            if href:
1352                self.href = href
1353        if axisValues:
1354            self.axisValues=axisValues
1355       
1356    def fromXML(self,csmlFrag):
1357        for frag in csmlFrag.getchildren():
1358            if frag.tag ==CSML('gridAxesSpanned'):
1359                self.gridAxesSpanned=frag.text
1360            elif frag.tag ==CSML('sequenceRule'):
1361                self.sequenceRule=frag.text
1362            elif frag.tag ==CSML('definesAxis'):
1363                self.definesAxis=frag.text
1364                if frag.attrib.has_key(XLINK('href')):
1365                        self.href = frag.attrib[XLINK('href')]
1366            elif frag.tag ==CSML('axisValues'):
1367                self.axisValues=frag.text
1368               
1369    def toXML(self, csmlFrag):
1370        if hasattr(self, 'gridAxesSpanned'):
1371            frag=Element(CSML('gridAxesSpanned'))
1372            frag.text = self.gridAxesSpanned
1373            csmlFrag.append(frag)
1374        if hasattr(self, 'sequenceRule'):
1375            frag=Element(CSML('sequenceRule'))
1376            frag.text = self.sequenceRule
1377            csmlFrag.append(frag)
1378        if hasattr(self, 'definesAxis'):
1379            frag=Element(CSML('definesAxis'))
1380            frag.text = self.definesAxis
1381            if hasattr(self, 'href'):
1382                frag.attrib[XLINK('href')] = self.href
1383            csmlFrag.append(frag)
1384        if hasattr(self, 'axisValues'):
1385            frag=Element(CSML('axisValues'))
1386            frag.text = self.axisValues
1387            csmlFrag.append(frag)
1388        return csmlFrag
1389   
1390
1391class Grid(GmlGrid):
1392#Class GmlGrid representing a gml:Grid
1393# + dimension(attrib) [1]
1394#  +ordinate [1..*]
1395    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
1396        GmlGrid.__init__(self)
1397        if srsName:
1398            self.srsName=srsName
1399        if srsDimension:
1400            self.srsDimension=srsDimension
1401        if dimension:
1402            self.dimension=dimension
1403        if ordinates:
1404            self.ordinates=ordinates
1405    def fromXML(self, csmlFrag):
1406        GmlGrid.fromXML(self,csmlFrag)
1407        if csmlFrag.attrib.has_key('srsName'):
1408            self.srsName = csmlFrag.attrib['srsName']
1409        if csmlFrag.attrib.has_key('srsDimension'):
1410            self.srsDimension = csmlFrag.attrib['srsDimension']
1411        if csmlFrag.attrib.has_key('dimension'):
1412            self.dimension = csmlFrag.attrib['dimension']
1413        for frag in csmlFrag:
1414            if frag.tag==CSML('ordinate'):
1415                checkArrayAttrib(self,'ordinates')
1416                ordinate=GridOrdinateDescription()
1417                GridOrdinateDescription.fromXML(ordinate, frag)
1418                self.ordinates.append(ordinate)
1419    def toXML(self,csmlFrag):
1420        GmlGrid.toXML(self,csmlFrag)
1421        if hasattr(self, 'srsName'):
1422            csmlFrag.attrib['srsName'] = self.srsName
1423        if hasattr(self, 'srsDimension'):
1424            csmlFrag.attrib['srsDimension'] = self.srsDimension
1425        if hasattr(self, 'dimension'):
1426            csmlFrag.attrib['dimension'] = self.dimension
1427       
1428        if hasattr(self, 'ordinates'):
1429            for ordinate in self.ordinates:
1430                frag=Element(CSML('ordinate'))
1431                GridOrdinateDescription.toXML(ordinate, frag)
1432                csmlFrag.append(frag)
1433        return csmlFrag
1434
1435class TimeInstant:
1436   
1437    def __init__(self, timePosition=None):
1438        if timePosition:
1439            self.timePosition=timePosition
1440    def fromXML(self,csmlFrag):
1441        for frag in csmlFrag.getchildren():
1442            print frag.tag
1443            if frag.tag==GML('timePosition'):
1444                self.timePosition=frag.text
1445    def toXML(self,csmlFrag):
1446         if hasattr(self,'timePosition'):
1447            frag = Element(GML('timePosition'))
1448            frag.text=self.timePosition
1449            csmlFrag.append(frag)
1450         return csmlFrag
1451
1452class TimePositionList:
1453    def __init__(self, timePositions=None):
1454        if timePositions:
1455            self.timePositions=timePositions
1456    def fromXML(self,csmlFrag):
1457        self.timePositions=csmlFrag.text
1458    def toXML(self,csmlFrag):
1459         if hasattr(self,'timePositions'):
1460            csmlFrag.text=self.timePositions
1461         return csmlFrag
1462             
1463class Measure:
1464    def __init__(self, uom=None):
1465        if uom:
1466            self.uom=uom
1467    def fromXML(self,csmlFrag):
1468        self.measure=csmlFrag.text
1469        if csmlFrag.attrib.has_key('uom'):
1470            self.uom = csmlFrag.attrib['uom']
1471    def toXML(self, csmlFrag):
1472        if hasattr(self,'measure'):
1473            frag = Element(GML('measure'))
1474            frag.text = self.measure
1475            if hasattr(self,'uom'):
1476                frag.attrib[('uom')] = self.uom
1477            csmlFrag.append(frag)
1478        return csmlFrag
1479
1480class MeasureOrNullList:
1481    #class MeasureOrNullList:
1482    # +uom[1]:anyURI
1483    #Actually based on doubleOrNullList, but not modelled to that level of detail.
1484   
1485    def __init__(self, uom=None, val=None):
1486        if uom:
1487            self.uom=uom
1488        if val:
1489            self.val=val
1490    def fromXML(self,csmlFrag):
1491        self.val=csmlFrag.text
1492        if csmlFrag.attrib.has_key('uom'):
1493            self.uom = csmlFrag.attrib['uom']
1494    def toXML(self, csmlFrag):
1495        if hasattr(self,'val'):
1496            csmlFrag.text = self.val
1497        if hasattr(self,'uom'):
1498           csmlFrag.attrib[('uom')] = self.uom
1499        return csmlFrag
1500   
1501class CompositeValue:
1502    def __init__(self, valueComponents=None):
1503        if valueComponents:
1504            self.valueComponents=valueComponents
1505    def fromXML(self,csmlFrag):
1506       
1507        for frag in csmlFrag.getchildren():
1508            if frag.tag == GML('valueComponents'):
1509                self.valueComponents = []
1510                for subFrag in frag.getchildren():                   
1511                    if subFrag.tag == GML('measure'):
1512                        self.valueComponents.append(Measure())
1513                        self.valueComponents[-1].fromXML(subFrag)
1514
1515    def toXML(self, csmlFrag):
1516         if hasattr(self,'valueComponents'):
1517            frag=Element(GML('valueComponents'))
1518            for valueComponent in self.valueComponents:
1519                if isinstance(valueComponent,Measure):
1520                    Measure.toXML(valueComponent,frag)
1521            csmlFrag.append(frag)
1522         return csmlFrag
1523   
1524
1525   
1526class DataBlock:
1527    #class GML DataBlock
1528   
1529    #DataBlock()
1530    #+gml:rangeParameters
1531    def __init__(self,rangeParameters=None):
1532        if rangeParameters:
1533            self.rangeParameters=rangeParameters
1534    def fromXML(self,csmlFrag):
1535        for frag in csmlFrag.getchildren():
1536            if frag.tag == GML('rangeParameters'):
1537                for subFrag in frag.getchildren():
1538                    if subFrag.tag==GML('CompositeValue'):
1539                        self.rangeParameters=CompositeValue()
1540                        CompositeValue.fromXML(self.rangeParameters,subFrag)
1541            if frag.tag == GML('doubleOrNullTupleList'):
1542                self.doubleOrNullTupleList=frag.text
1543    def toXML(self,csmlFrag):
1544        if hasattr(self, 'rangeParameters'):
1545            frag=Element(GML('rangeParameters'))
1546            subFrag=Element(GML('CompositeValue'))
1547            CompositeValue.toXML(self.rangeParameters, subFrag)
1548            frag.append(subFrag)
1549            csmlFrag.append(frag)
1550        if hasattr(self,'doubleOrNullTupleList'):
1551            frag=Element(GML('doubleOrNullTupleList'))
1552            frag.text=self.doubleOrNullTupleList
1553            csmlFrag.append(frag)
1554        return csmlFrag
1555
1556
1557
1558class TypedCategory:
1559#class om:TypedCategory
1560    # +axis (attrib)
1561    # + codeSpace (attrib)
1562    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
1563        if axis:
1564            self.axis=axis
1565        if codeSpace:
1566            self.codeSpace=codeSpace
1567        if text:
1568            self.text=text
1569    def fromXML(self,csmlFrag):
1570        if csmlFrag.attrib.has_key('axis'):
1571            self.axis=csmlFrag.attrib['axis']
1572        if csmlFrag.attrib.has_key('codeSpace'):
1573            self.codeSpace=csmlFrag.attrib['codeSpace']
1574        self.text=csmlFrag.text
1575    def toXML(self,csmlFrag):
1576        if hasattr(self,'axis'):
1577            csmlFrag.attrib[('axis')] =self.axis
1578        if hasattr(self,'codeSpace'):
1579            csmlFrag.attrib[('codeSpace')] =self.codeSpace
1580        csmlFrag.text=self.text
1581        return csmlFrag
1582
1583   
1584class Phenomenon(Definition):
1585    #class Obs& Measures: PhenomenonProperty
1586    #Note, in this does not really inherit from AbstractGML, but for CMSL
1587    #purposes it is used  to pick up the basic description, id, name attributes
1588    def __init__(self,*args,**kwargs):
1589         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
1590        self.MetaDataProperty=None
1591        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
1592    def fromXML(self,csmlFrag):
1593        Definition.fromXML(self,csmlFrag)
1594    def toXML(self,csmlFrag):
1595        csmlFrag=Definition.toXML(self,csmlFrag)
1596        return csmlFrag
1597
1598
1599class CompositePhenomenon(Phenomenon):
1600    #Class om:CompositePhenomenon
1601    # + om:componentPhenomenon [1...*]
1602    def __init__(self,componentPhenomenon=None,*args,**kwargs):
1603        Phenomenon.__init__(self,*args,**kwargs)
1604        if componentPhenomenon:
1605            self.componentPhenomenon=componentPhenomenon
1606    def fromXML(self,csmlFrag):
1607        Phenomenon.fromXML(self,csmlFrag)
1608        for frag in csmlFrag.getchildren():
1609            if frag.tag == OM('componentPhenomenon'):
1610                checkArrayAttrib(self,'componentPhenomenon')
1611                self.componentPhenomenon.append(frag.attrib)
1612    def toXML(self,csmlFrag):
1613        Phenomenon.toXML(self,csmlFrag)
1614        for cp in self.componentPhenomenon:
1615            frag=Element(OM('componentPhenomenon'))
1616            frag.attrib= cp
1617            csmlFrag.append(frag)
1618        return csmlFrag
1619   
1620class ParameterisedPhenomenon(Phenomenon):
1621    #Class ParameterisedPhenomenon:
1622        # + basePhenomenon
1623        # + constraint
1624        # + href (attrib)
1625    def __init__(self,*args,**kwargs):
1626        Phenomenon.__init__(self,*args,**kwargs)
1627    def fromXML(self,csmlFrag):
1628        Phenomenon.fromXML(self,csmlFrag)
1629        for frag in csmlFrag.getchildren():
1630            if frag.tag == OM('basePhenomenon'):
1631                self.basePhenomenon=frag.text
1632                if frag.attrib.has_key(XLINK('href')):
1633                    self.href = frag.attrib[XLINK('href')]
1634            if frag.tag == OM('constraint'):
1635                subFrag=frag.getchildren()[0]
1636                if subFrag.tag== OM('TypedCategory'):
1637                    self.constraint = TypedCategory()
1638                #TO DO: what other types are valid?
1639                elif subFrag.tag== OM('??'):
1640                    self.constraint = 123
1641                self.constraint.fromXML(subFrag)
1642    def toXML(self,csmlFrag):
1643        csmlFrag=Phenomenon.toXML(self,csmlFrag)
1644        if hasattr(self,'basePhenomenon'):
1645            frag=Element(OM('basePhenomenon'))
1646            frag.text=self.basePhenomenon
1647            if hasattr(self, 'href'):
1648                frag.attrib[XLINK('href')] = self.href
1649            csmlFrag.append(frag)
1650        if hasattr(self, 'constraint'):
1651            frag=Element(OM('constraint'))
1652            subFrag=Element(OM('TypedCategory'))
1653            subFrag=self.constraint.toXML(subFrag)
1654            frag.append(subFrag)
1655            csmlFrag.append(frag)
1656        return csmlFrag
1657
1658class RangeSet:
1659#class GML RangeSet 
1660
1661        # RangeSet()
1662        # +gml:ValueArray
1663        # +gml:_ScalarValueList
1664        # +gml:DataBlock
1665        # +gml:File
1666    #class GML RangeSet
1667    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None):
1668        if quantityList:
1669            self.quantityList=quantityList
1670        if dataBlock:
1671            self.dataBlock=dataBlock
1672        if arrayDescriptor:
1673            self.arrayDescriptor=arrayDescriptor
1674        if aggregatedArray:
1675            self.aggregatedArray=aggregatedArray
1676           
1677    def fromXML(self,csmlFrag):
1678        for frag in csmlFrag.getchildren():
1679            if frag.tag==GML('QuantityList'):
1680                self.quantityList=MeasureOrNullList()
1681                MeasureOrNullList.fromXML(self.quantityList,frag)
1682            elif frag.tag==GML('DataBlock'):
1683                self.dataBlock=DataBlock()
1684                DataBlock.fromXML(self.dataBlock, frag)
1685            elif frag.tag == CSML('NetCDFExtract'):
1686                self.arrayDescriptor=NetCDFExtract()
1687                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
1688            elif frag.tag == CSML('NASAmesExtract'):
1689                self.arrayDescriptor=NASAAmesExtract()
1690                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
1691            elif frag.tag == CSML('GRIBExtract'):
1692                self.arrayDescriptor=GRIBExtract()
1693                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
1694            elif frag.tag == CSML('AggregatedArray'):
1695                self.aggregatedArray=AggregatedArray()
1696                AggregatedArray.fromXML(self.aggregatedArray,frag)
1697    def toXML(self, csmlFrag):
1698        if hasattr(self,'quantityList'):
1699            frag = Element(GML('QuantityList'))
1700            MeasureOrNullList.toXML(self.quantityList,frag)
1701            csmlFrag.append(frag)
1702        if hasattr(self,'dataBlock'):
1703            frag=Element(GML('DataBlock'))
1704            DataBlock.toXML(self.dataBlock,frag)
1705            csmlFrag.append(frag)
1706        if hasattr(self,'aggregatedArray'):
1707            frag=Element(GML('AggregatedArray'))
1708            AggregatedArray.toXML(self.aggregatedArray,frag)
1709            csmlFrag.append(frag)
1710        if hasattr(self,'arrayDescriptor'):
1711            if isinstance(self.arrayDescriptor,NetCDFExtract):
1712                frag=Element(CSML('NetCDFExtract'))
1713                NetCDFExtract.toXML(self.arrayDescriptor,frag)
1714                csmlFrag.append(frag)
1715            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
1716                frag=Element(CSML('NASAAmesExtract'))
1717                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
1718                csmlFrag.append(frag)
1719            elif isinstance(self.arrayDescriptor,GRIBExtract):
1720                frag=Element(CSML('GRIBExtract'))
1721                GRIBAmesExtract.toXML(self.arrayDescriptor,frag)
1722                csmlFrag.append(frag)
1723               
1724        return csmlFrag
1725
1726class PointDomain(AbstractDomain):
1727    def __init__(self,*args,**kwargs):
1728        AbstractDomain.__init__(self,*args,**kwargs)
1729    def fromXML(self,csmlFrag):
1730        AbstractDomain.fromXML(self,csmlFrag)
1731    def toXML(self,csmlFrag):
1732        AbstractDomain.toXML(self,csmlFrag)
1733        return csmlFrag
1734   
1735class ProfileDomain(AbstractDomain):
1736    def __init__(self,*args,**kwargs):
1737        AbstractDomain.__init__(self,*args,**kwargs)
1738    def fromXML(self,csmlFrag):
1739        AbstractDomain.fromXML(self,csmlFrag)
1740    def toXML(self,csmlFrag):
1741        AbstractDomain.toXML(self,csmlFrag)
1742        return csmlFrag
1743
1744class GridDomain(AbstractDomain):
1745    def __init__(self,*args,**kwargs):
1746        AbstractDomain.__init__(self,*args,**kwargs)
1747    def fromXML(self,csmlFrag):
1748        AbstractDomain.fromXML(self,csmlFrag)
1749    def toXML(self,csmlFrag):
1750        AbstractDomain.toXML(self,csmlFrag)
1751        return csmlFrag
1752   
1753class PointSeriesDomain(AbstractDomain):
1754    def __init__(self,*args,**kwargs):
1755        AbstractDomain.__init__(self,*args,**kwargs)
1756    def fromXML(self,csmlFrag):
1757        AbstractDomain.fromXML(self,csmlFrag)
1758    def toXML(self,csmlFrag):
1759        AbstractDomain.toXML(self,csmlFrag)
1760        return csmlFrag
1761   
1762class ProfileSeriesDomain(AbstractDomain):
1763    def __init__(self,*args,**kwargs):
1764        AbstractDomain.__init__(self,*args,**kwargs)
1765    def fromXML(self,csmlFrag):
1766        AbstractDomain.fromXML(self,csmlFrag)
1767    def toXML(self,csmlFrag):
1768        AbstractDomain.toXML(self,csmlFrag)
1769        return csmlFrag
1770   
1771class GridSeriesDomain(AbstractDomain):
1772    def __init__(self,*args,**kwargs):
1773        AbstractDomain.__init__(self,*args,**kwargs)
1774    def fromXML(self,csmlFrag):
1775        AbstractDomain.fromXML(self,csmlFrag)
1776    def toXML(self,csmlFrag):
1777        AbstractDomain.toXML(self,csmlFrag)
1778        return csmlFrag
1779
1780class PointFeature(AbstractStaticCoverageFeature):
1781    #CSML PointFeature class
1782    #       PointFeature(AbstractStaticCoverageFeatureType):
1783    #      +PointDomain
1784    def __init__(self, pointDomain=None,*args,**kwargs):
1785        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1786        if pointDomain:
1787            self.pointDomain=pointDomain
1788    def fromXML(self,csmlFrag):
1789        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1790        for frag in csmlFrag.getchildren():
1791            if frag.tag == CSML('PointDomain'):
1792                self.pointDomain = PointDomain()
1793                self.pointDomain.fromXML(frag)
1794    def toXML(self,csmlFrag):
1795        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1796        if hasattr(self,'pointDomain'):
1797            frag = Element(CSML('PointDomain'))
1798            PointDomain.toXML(self.pointDomain,frag)
1799            if hasattr(self,'href'):
1800                frag.attrib[XLINK('href')] = self.href
1801            csmlFrag.append(frag)
1802        return csmlFrag
1803
1804   
1805class PointSeriesFeature(AbstractSeriesCoverageFeature):
1806    #CSML PointSeriesFeature class
1807    #       PointSeriesFeature(AbstractStaticCoverageFeatureType):
1808    #      +PointSeriesDomain
1809
1810    def __init__(self,PointSeriesDomain=None,*args,**kwargs):
1811        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
1812        if PointSeriesDomain:
1813            self.PointSeriesDomain=PointSeriesDomain
1814    def fromXML(self,csmlFrag):
1815        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
1816        for frag in csmlFrag.getchildren():
1817            if frag.tag == CSML('PointSeriesDomain'):
1818                self.PointSeriesDomain = PointSeriesDomain()
1819                self.PointSeriesDomain.fromXML(frag)
1820    def toXML(self,csmlFrag):
1821        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
1822        if hasattr(self,'PointSeriesDomain'):
1823             frag = Element(CSML('PointSeriesDomain'))
1824             PointSeriesDomain.toXML(self.PointSeriesDomain,frag)
1825             csmlFrag.append(frag)
1826        return csmlFrag
1827
1828class ProfileFeature(AbstractStaticCoverageFeature):
1829     #CSML ProfileFeature class
1830    #       ProfileFeature(AbstractStaticCoverageFeature):
1831    #      +ProfileDomain
1832
1833    def __init__(self,ProfileDomain=None,*args,**kwargs):
1834        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1835        if ProfileDomain:
1836            self.ProfileDomain=ProfileDomain
1837    def fromXML(self,csmlFrag):
1838        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1839        for frag in csmlFrag.getchildren():
1840            if frag.tag == CSML('ProfileDomain'):
1841                self.ProfileDomain = ProfileDomain()
1842                self.ProfileDomain.fromXML(frag)
1843    def toXML(self,csmlFrag):
1844        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1845        if hasattr(self,'ProfileDomain'):
1846             frag = Element(CSML('ProfileDomain'))
1847             ProfileDomain.toXML(self.ProfileDomain,frag)
1848             csmlFrag.append(frag)
1849        return csmlFrag
1850
1851
1852class ProfileSeriesFeature(AbstractStaticCoverageFeature):
1853#CSML ProfileSeriesFeature class
1854    #       ProfileSeriesFeature(AbstractStaticCoverageFeature):
1855    #      +ProfileSeriesDomain
1856
1857    def __init__(self,ProfileSeriesDomain=None,*args,**kwargs):
1858        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1859        if ProfileSeriesDomain:
1860            self.ProfileSeriesDomain=ProfileSeriesDomain
1861    def fromXML(self,csmlFrag):
1862        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1863        for frag in csmlFrag.getchildren():
1864            if frag.tag == CSML('ProfileSeriesDomain'):
1865                self.ProfileSeriesDomain = ProfileSeriesDomain()
1866                self.ProfileSeriesDomain.fromXML(frag)
1867    def toXML(self,csmlFrag):
1868        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1869        if hasattr(self,'ProfileSeriesDomain'):
1870             frag = Element(CSML('ProfileSeriesDomain'))
1871             ProfileSeriesDomain.toXML(self.ProfileSeriesDomain,frag)
1872             csmlFrag.append(frag)
1873        return csmlFrag
1874
1875
1876class GridFeature(AbstractStaticCoverageFeature):
1877#CSML GridFeature class
1878    #       GridFeature(AbstractStaticCoverageFeature):
1879    #      +GridDomain
1880
1881    def __init__(self,GridDomain=None,*args,**kwargs):
1882        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1883        if GridDomain:
1884            self.GridDomain=GridDomain
1885    def fromXML(self,csmlFrag):
1886        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1887        for frag in csmlFrag.getchildren():
1888            if frag.tag == CSML('GridDomain'):
1889                self.GridDomain = GridDomain()
1890                self.GridDomain.fromXML(frag)
1891    def toXML(self,csmlFrag):
1892        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1893        if hasattr(self,'GridDomain'):
1894             frag = Element(CSML('GridDomain'))
1895             GridDomain.toXML(self.GridDomain,frag)
1896             csmlFrag.append(frag)
1897        return csmlFrag
1898
1899
1900class GridSeriesFeature(AbstractStaticCoverageFeature):
1901    def __init__(self,GridSeriesDomain=None,*args,**kwargs):
1902        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
1903        if GridSeriesDomain:
1904            self.GridSeriesDomain=GridSeriesDomain
1905    def fromXML(self,csmlFrag):
1906        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
1907        for frag in csmlFrag.getchildren():
1908            if frag.tag == CSML('GridSeriesDomain'):
1909                self.GridSeriesDomain = GridSeriesDomain()
1910                self.GridSeriesDomain.fromXML(frag)
1911    def toXML(self,csmlFrag):
1912        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
1913        if hasattr(self,'GridSeriesDomain'):
1914             frag = Element(CSML('GridSeriesDomain'))
1915             GridSeriesDomain.toXML(self.GridSeriesDomain,frag)
1916             csmlFrag.append(frag)
1917        return csmlFrag
1918
1919class TrajectoryFeature:
1920    def __init__(self):
1921        pass
1922    def fromXML(self,csmlFrag):
1923        pass
1924    def toXML(self,csmlFrag):
1925        return csmlFrag
1926   
1927class AbstractFeature(AbstractGML):
1928    def __init__(self,boundedBy=None,*args,**kwargs):
1929        AbstractGML.__init__(self,*args,**kwargs)
1930        if boundedBy:
1931            self.boundedBy=boundedBy
1932    def fromXML(self,csmlFrag):
1933        AbstractGML.fromXML(self,csmlFrag)
1934        for frag in csmlFrag.getchildren():
1935            if frag.tag == GML('boundedBy'):
1936                self.boundedBy = EnvelopeWithTimePeriod()
1937                self.boundedBy.fromXML(frag)
1938    def toXML(self,csmlFrag):
1939        AbstractGML.toXML(self,csmlFrag)
1940        if hasattr(self,'boundedBy'):
1941             superfrag = Element(GML('boundedBy'))
1942             frag = Element (GML('EnvelopeWithTimePeriod'))
1943             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
1944             superfrag.append(frag)
1945             csmlFrag.append(superfrag)
1946        return csmlFrag
1947
1948 
1949
1950class AbstractFeatureCollection(AbstractFeature):
1951    """GML AbstractFeatureCollection class
1952
1953    AbstractFeatureCollection(AbstractFeature):
1954     +featureMember[0..*]: AbstractFeature
1955     +featureMembers[0..1]: FeatureArray
1956    """
1957    def __init__(self,members=[]):
1958        if members:
1959            self.members=members
1960    def fromXML(self,csmlFrag):
1961        AbstractFeature.fromXML(self,csmlFrag)
1962        for frag in csmlFrag.getchildren():
1963            if frag.tag == GML('featureMember'):
1964                checkArrayAttrib(self,'members')
1965                featureFrag = frag.getchildren()[0]
1966                if featureFrag.tag == CSML('PointFeature'):
1967                    self.members.append(PointFeature())
1968                    self.members[-1].fromXML(featureFrag)
1969                if featureFrag.tag == CSML('ProfileFeature'):
1970                    self.members.append(ProfileFeature())
1971                    self.members[-1].fromXML(featureFrag)
1972                if featureFrag.tag == CSML('GridFeature'):
1973                    self.members.append(GridFeature())
1974                    self.members[-1].fromXML(featureFrag)
1975                if featureFrag.tag == CSML('PointSeriesFeature'):
1976                    self.members.append(PointSeriesFeature())
1977                    self.members[-1].fromXML(featureFrag)
1978                if featureFrag.tag == CSML('ProfileSeriesFeature'):
1979                    self.members.append(ProfileSeriesFeature())
1980                    self.members[-1].fromXML(featureFrag)
1981                if featureFrag.tag == CSML('GridSeriesFeature'):
1982                    self.members.append(GridSeriesFeature())
1983                    self.members[-1].fromXML(featureFrag)
1984                if featureFrag.tag == CSML('TrajectoryFeature'):
1985                    self.members.append(TrajectoryFeature())
1986                    self.members[-1].fromXML(featureFrag)
1987    def toXML(self,csmlFrag):
1988        AbstractFeature.toXML(self,csmlFrag)
1989        for member in self.members:
1990            if isinstance(member,PointFeature):
1991                superFrag=Element(GML('FeatureMember'))
1992                frag=Element(CSML('PointFeature'))
1993                PointFeature.toXML(member,frag)
1994                superFrag.append(frag)
1995                csmlFrag.append(superFrag)
1996            if isinstance(member,ProfileFeature):
1997                superFrag=Element(GML('FeatureMember'))
1998                frag=Element(CSML('ProfileFeature'))
1999                ProfileFeature.toXML(member,frag)
2000                superFrag.append(frag)
2001                csmlFrag.append(superFrag)
2002            if isinstance(member,GridFeature):
2003                superFrag=Element(GML('FeatureMember'))
2004                frag=Element(CSML('GridFeature'))
2005                GridFeature.toXML(member,frag)
2006                superFrag.append(frag)
2007                csmlFrag.append(superFrag)
2008            if isinstance(member,PointSeriesFeature):
2009                superFrag=Element(GML('FeatureMember'))
2010                frag=Element(CSML('PointSeriesFeature'))
2011                PointSeriesFeature.toXML(member,frag)
2012                superFrag.append(frag)
2013                csmlFrag.append(superFrag)
2014            if isinstance(member,ProfileSeriesFeature):
2015                superFrag=Element(GML('FeatureMember'))
2016                frag=Element(CSML('ProfileSeriesFeature'))
2017                ProfileSeriesFeature.toXML(member,frag)
2018                superFrag.append(frag)
2019                csmlFrag.append(superFrag)
2020            if isinstance(member,GridSeriesFeature):
2021                superFrag=Element(GML('FeatureMember'))
2022                frag=Element(CSML('GridSeriesFeature'))
2023                GridSeriesFeature.toXML(member,frag)
2024                superFrag.append(frag)
2025                csmlFrag.append(superFrag)
2026            if isinstance(member,TrajectoryFeature):
2027                superFrag=Element(GML('FeatureMember'))
2028                frag=Element(CSML('TrajectoryFeature'))
2029                TrajectoryFeature.toXML(member,frag)
2030                superFrag.append(frag)
2031                csmlFrag.append(superFrag)
2032       
2033        return csmlFrag
2034
2035class FeatureCollection(AbstractFeatureCollection):
2036    """GML FeatureCollection class
2037        FeatureCollection()
2038        +FeatureMembers[0..*]
2039    """
2040    def __init__(self,*args,**kwargs):
2041        AbstractFeatureCollection.__init__(self,*args,**kwargs)
2042    def fromXML(self,csmlFrag):
2043        AbstractFeatureCollection.fromXML(self,csmlFrag)
2044    def toXML(self,csmlFrag):
2045        AbstractFeatureCollection.toXML(self,csmlFrag)
2046        return csmlFrag
2047
2048class Dataset(AbstractGML):
2049    """CSML Dataset class
2050
2051    Dataset(AbstractGML):
2052     +unitDefinitions[0..*]: UnitDefinitions
2053     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
2054     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
2055     +arrayDescriptors[0..*]: AbstractArrayDescriptor
2056     +featureCollection[0..1]: FeatureCollection
2057    """
2058    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
2059                 phenomenonDefinitions=None,arrayDescriptors=[],
2060                 featureCollection=None,*args,**kwargs):
2061        AbstractGML.__init__(self,*args,**kwargs)
2062        if unitDefinitions:
2063            self.unitDefinitions = unitDefinitions
2064        if referenceSystemDefinitions:
2065            self.referenceSystemDefinitions = referenceSystemDefinitions
2066        if phenomenonDefinitions:
2067            self.phenomenonDefinitions = phenomenonDefinitions
2068        if arrayDescriptors:
2069            self.arrayDescriptors = arrayDescriptors
2070        if featureCollection:
2071            self.featureCollection = featureCollection
2072    def fromXML(self,csmlFrag):
2073        AbstractGML.fromXML(self,csmlFrag)
2074       
2075        for frag in csmlFrag.getchildren():
2076            if frag.tag == CSML('UnitDefinitions'):
2077                self.unitDefinitions = UnitDefinitions()
2078                self.unitDefinitions.fromXML(frag)
2079            elif frag.tag == CSML('ReferenceSystemDefinitions'):
2080                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
2081                self.referenceSystemDefinitions.fromXML(frag)
2082            elif frag.tag == CSML('PhenomenonDefinitions'):
2083                self.phenomenonDefinitions = PhenomenonDefinitions()
2084                self.phenomenonDefinitions.fromXML(frag)
2085            elif frag.tag == GML('FeatureCollection'):
2086                self.featureCollection = FeatureCollection()
2087                self.featureCollection.fromXML(frag)
2088            elif frag.tag == CSML('AggregatedArray'):
2089                checkArrayAttrib(self,'arrayDescriptors')
2090                self.arrayDescriptors.append(AggregatedArray())
2091                self.arrayDescriptors[-1].fromXML(frag)
2092            elif frag.tag == CSML('InlineArray'):
2093                checkArrayAttrib(self,'arrayDescriptors')
2094                self.arrayDescriptors.append(InlineArray())
2095                self.arrayDescriptors[-1].fromXML(frag)
2096            elif frag.tag == CSML('ArrayGenerator'):
2097                checkArrayAttrib(self,'arrayDescriptors')
2098                self.arrayDescriptors.append(ArrayGenerator())
2099                self.arrayDescriptors[-1].fromXML(frag)
2100            elif frag.tag == CSML('NASAAmesExtract'):
2101                checkArrayAttrib(self,'arrayDescriptors')
2102                self.arrayDescriptors.append(NASAAmesExtract())
2103                self.arrayDescriptors[-1].fromXML(frag)
2104            elif frag.tag == CSML('NetCDFExtract'):
2105                checkArrayAttrib(self,'arrayDescriptors')
2106                self.arrayDescriptors.append(NetCDFExtract())
2107                self.arrayDescriptors[-1].fromXML(frag)
2108            elif frag.tag == CSML('GRIBExtract'):
2109                checkArrayAttrib(self,'arrayDescriptors')
2110                self.arrayDescriptors.append(GRIBExtract())
2111                self.arrayDescriptors[-1].fromXML(frag)
2112##            else:
2113##                raise Exception('Unexpected element: "'+frag.tag+'"')
2114    def toXML(self,csmlFrag=None):
2115        if csmlFrag is None:
2116            csmlFrag = Element('Dataset')
2117        csmlFrag = AbstractGML.toXML(self,csmlFrag)
2118        if hasattr(self,'unitDefinitions'):
2119            frag = Element(CSML('UnitDefinitions'))
2120            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
2121            csmlFrag.append(frag)
2122        if hasattr(self,'referenceSystemDefinitions'):
2123            frag = Element(CSML('ReferenceSystemDefinitions'))
2124            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
2125            csmlFrag.append(frag)
2126        if hasattr(self,'phenomenonDefinitions'):
2127            frag = Element(CSML('PhenomenonDefinitions'))
2128            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
2129            csmlFrag.append(frag)
2130        if hasattr(self,'arrayDescriptors'):
2131            for arrayDesc in self.arrayDescriptors:
2132                if isinstance(arrayDesc,AggregatedArray):
2133                    frag = Element(CSML('AggregatedArray'))
2134                    frag = AggregatedArray.toXML(arrayDesc,frag)
2135                elif isinstance(arrayDesc,InlineArray):
2136                    frag = Element(CSML('InlineArray'))
2137                    frag = InlineArray.toXML(arrayDesc,frag)
2138                elif isinstance(arrayDesc,ArrayGenerator):
2139                    frag = Element(CSML('ArrayGenerator'))
2140                    frag = ArrayGenerator.toXML(arrayDesc,frag)
2141                elif isinstance(arrayDesc,NASAAmesExtract):
2142                    frag = Element(CSML('NASAAmesExtract'))
2143                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
2144                elif isinstance(arrayDesc,NetCDFExtract):
2145                    frag = Element(CSML('NetCDFExtract'))
2146                    frag = NetCDFExtract.toXML(arrayDesc,frag)
2147                elif isinstance(arrayDesc,GRIBExtract):
2148                    frag = Element(CSML('GRIBExtract'))
2149                    frag = GRIBExtract.toXML(arrayDesc,frag)
2150                csmlFrag.append(frag)
2151        if hasattr(self,'featureCollection'):
2152            frag = Element(GML('FeatureCollection'))
2153            frag = FeatureCollection.toXML(self.featureCollection,frag)
2154            csmlFrag.append(frag)
2155            #csmlFrag=fixNameSpaces(csmlFrag)
2156        return csmlFrag
Note: See TracBrowser for help on using the repository browser.