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

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

spatial temporal selection on any axis implemented (for netcdf)

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
76def checkMandatory(obj,*args):
77    #check mandatory attributes/elements are present.
78    #should be called at the *end* of each fromXML method
79    for arg in args:
80        if not hasattr(obj, arg):
81            objtype = str(obj)
82            print 'Parse error: Mandatory value missing: '  + str(arg)
83            if hasattr(obj,'id'):
84                print 'See element with gml:id = ' + obj.id
85            sys.exit()
86
87##class TemplateClass(Base):
88##    def __init__(self,myarg=None,*args,**kwargs):
89##        Base.__init__(self,*args,**kwargs)
90##        # code specific to TemplateClass
91##    def fromXML(self,csmlFrag):
92##        Base.fromXML(self,csmlFrag)
93##        # code specific to TemplateClass
94##    def toXML(self,csmlFrag):
95##        csmlFrag = Base.toXML(self,csmlFrag)
96##        # code specific to TemplateClass
97##        return csmlFrag
98
99class MetaDataProperty:
100    """Class representing metadata property (gmlBase.xsd)
101    MetaDataProperty:
102    +href: URI
103    """
104    def __init__(self,href=None):
105        if href:
106            self.href = href
107    def fromXML(self,csmlFrag):
108        if csmlFrag.attrib.has_key(XLINK('href')):
109             self.href = csmlFrag.attrib[XLINK('href')]
110    def toXML(self,csmlFrag):
111        if hasattr(self,'href'):
112            csmlFrag.attrib[XLINK('href')] = self.href
113        return csmlFrag
114
115class Description(MutableString):
116    """Class representing a GML description element
117    Description(string):
118    """
119    def __init__(self,val=''):
120        MutableString.__init__(self,val)
121    def fromXML(self,csmlFrag):
122        self.data = csmlFrag.text
123    def toXML(self,csmlFrag):
124        csmlFrag.text = self.data
125        return csmlFrag
126
127class Name(MutableString):
128    """Class representing a GML name element
129    Name(string):
130     +codeSpace[0..1]: anyURI
131    """
132    def __init__(self,val='',codeSpace=None):
133        MutableString.__init__(self,val)
134        if val:
135            self.val=val
136        if codeSpace:
137            self.codeSpace = codeSpace
138    def fromXML(self,csmlFrag):
139        self.val = csmlFrag.text
140        if csmlFrag.attrib.has_key('codeSpace'):
141            self.codeSpace = csmlFrag.attrib['codeSpace']
142    def toXML(self,csmlFrag):
143        if hasattr(self, 'codeSpace'):
144            csmlFrag.attrib['codeSpace'] = self.codeSpace
145        if hasattr(self, 'val'):
146            csmlFrag.text = self.val
147       
148        return csmlFrag
149
150class AbstractGML:
151    """Base abstract GML type
152
153    AbstractGML:
154     +id[0..1]: ID
155     +metaDataProperty[0..*]: MetaDataProperty
156     +description[0..1]: Description
157     +name[0..*]: Name
158    """
159    def __init__(self,gmlid=None,metaDataProperty=[],description=None,name=[],*args,**kwargs):
160        if gmlid:
161            self.id = gmlid
162        if metaDataProperty:
163            self.metaDataProperty = metaDataProperty
164        if description:
165            self.description = description
166        if name:
167            self.name = name
168    def fromXML(self,csmlFrag):
169        if csmlFrag.attrib.has_key(GML('id')):
170            self.id = csmlFrag.attrib[GML('id')]
171        for frag in csmlFrag.getchildren():
172            if frag.tag == GML('metaDataProperty'):
173                checkArrayAttrib(self,'metaDataProperty')
174                self.metaDataProperty.append(MetaDataProperty())
175                self.metaDataProperty[-1].fromXML(frag)
176            elif frag.tag == GML('description'):
177                self.description = Description()
178                self.description.fromXML(frag)
179            elif frag.tag == GML('name'):
180                checkArrayAttrib(self,'name')
181                self.name.append(Name())
182                self.name[-1].fromXML(frag)
183    def toXML(self,csmlFrag):
184        if hasattr(self,'id'):
185            csmlFrag.attrib[GML('id')] = self.id
186        if hasattr(self,'metaDataProperty'):
187            for md in self.metaDataProperty:
188                frag = Element(GML('metaDataProperty'))
189                frag = MetaDataProperty.toXML(md,frag)
190                csmlFrag.append(frag)
191        if hasattr(self,'description'):
192            frag = Element(GML('description'))
193            frag = Description.toXML(self.description,frag)
194            csmlFrag.append(frag)
195        if hasattr(self,'name'):
196            for name in self.name:
197                frag = Element(GML('name'))
198                frag = Name.toXML(name,frag)
199                csmlFrag.append(frag)
200        return csmlFrag
201
202
203class SRSReferenceGroup:
204# class to represeent gml:SRSReferenceGroup
205# class SRSReferenceGroup:
206#     +srsName[0...]:anyURI
207# #     +srsDimension[0...1]:positiveInteger
208    def __init__(self,srsName=None,srsDimension=None):
209        if srsName:
210            self.srsName=srsName
211        if srsDimension:
212            self.srsDimension=srsDimension
213    def fromXML(self,csmlFrag):
214        if csmlFrag.attrib.has_key('srsName'):
215            self.srsName=csmlFrag.attrib['srsName']
216        if csmlFrag.attrib.has_key('srsDimension'):
217            self.srsDimension=csmlFrag.attrib['srsDimension']
218    def toXML(self,csmlFrag):
219            if hasattr(self,'srsName'):
220                csmlFrag.attrib['srsName']= self.srsName
221            if hasattr(self,'srsDimension'):
222                csmlFrag.attrib['srsDimension']= self.srsDimension
223            return csmlFrag
224class AssociationAttributeGroup:
225    '''Class to represent gml:AssociationAttributeGroup which is based on the xlink 'simplelink' attribute group (not implemented)
226    #class AssociationAttributeGroup
227    +xlink:href[0..1]:string
228    +xlink:role[0..1]:string
229    +xlink:arcrole[0..1]:string
230    +xlink:title[0..1]:string
231    +xlink:show[0..1]:string
232    +xlink:actuate[0..1]:string '''
233    def __init__(self, href=None, role=None,arcrole=None,title=None,show=None,actuate=None):
234         if href:
235             self.href=href
236         if role:
237             self.role=role
238         if arcrole:
239             self.arcrole=arcrole
240         if title:
241             self.title=title
242         if show:
243             self.show=show
244         if actuate:
245             self.actuate=actuate
246    def fromXML(self,csmlFrag):
247        if csmlFrag.attrib.has_key(XLINK('href')):
248            self.href=csmlFrag.attrib[XLINK('href')]
249        if csmlFrag.attrib.has_key(XLINK('role')):
250            self.role=csmlFrag.attrib[XLINK('role')]
251        if csmlFrag.attrib.has_key(XLINK('arcrole')):
252            self.arcrole=csmlFrag.attrib[XLINK('arcrole')]
253        if csmlFrag.attrib.has_key(XLINK('title')):
254            self.title=csmlFrag.attrib[XLINK('title')]
255        if csmlFrag.attrib.has_key(XLINK('show')):
256            self.show=csmlFrag.attrib[XLINK('show')]
257        if csmlFrag.attrib.has_key(XLINK('actuate')):
258            self.actuate=csmlFrag.attrib[XLINK('actuate')]
259       
260    def toXML(self,csmlFrag):
261        if hasattr(self,'href'):
262            csmlFrag.attrib[XLINK('href')]= self.href
263        if hasattr(self,'role'):
264            csmlFrag.attrib[XLINK('role')]= self.role
265        if hasattr(self,'arcrole'):
266            csmlFrag.attrib[XLINK('arcrole')]= self.arcrole
267        if hasattr(self,'title'):
268            csmlFrag.attrib[XLINK('title')]= self.title
269        if hasattr(self,'show'):
270            csmlFrag.attrib[XLINK('show')]= self.show
271        if hasattr(self,'actuate'):
272            csmlFrag.attrib[XLINK('actuate')]= self.actuate
273       
274        return csmlFrag
275   
276           
277class Definition(AbstractGML):
278    #Class Definition(AbstractGML), restricts AbstractGML
279    #gml:id is mandatory
280    #
281    # Definition(AbstractGML):
282    # +id[1]: ID
283     
284    def __init__(self,*args,**kwargs):
285        AbstractGML.__init__(self,*args,**kwargs)
286    def fromXML(self,csmlFrag):
287        AbstractGML.fromXML(self,csmlFrag)
288        #TO DO: how  best to handle errors?
289        if not hasattr(self,'id'):
290            #print 'gml:id mandatory value missing in ' + csmlFrag.tag
291            pass
292    def toXML(self,csmlFrag):
293        csmlFrag=AbstractGML.toXML(self,csmlFrag)
294        return csmlFrag
295
296class CodeType(MutableString):
297        #Class for gml:CodeType element
298       
299        #CodeType(MutableString)
300        # +codeSpace[0..1]:anyURI
301    def __init__(self,val='',codeSpace=None):
302        MutableString.__init__(self,val)
303        if codeSpace:
304            self.codeSpace = codeSpace
305    def fromXML(self,csmlFrag):
306        self.data = csmlFrag.text
307        if csmlFrag.attrib.has_key('codeSpace'):
308            self.codeSpace = csmlFrag.attrib['codeSpace']
309    def toXML(self,csmlFrag):
310        csmlFrag.text = self.data
311        if hasattr(self,'codeSpace'):
312            csmlFrag.attrib['codeSpace'] = self.codeSpace
313        return csmlFrag
314
315       
316       
317class TimeIntervalLength:
318    # class for gml:TimeIntervalLength (decimal)
319    # n.b. have not implemented 'decimal' class
320    # +unit[1]: gml:UnitType
321    # +radix[0...1]: posint
322    # +factor[0...1] :int
323    def __init__(self, unit=None, radix=None, factor=None,data=None):
324        if unit:
325            self.unit =unit
326        if radix:
327            self.radix=radix
328        if factor:
329            self.factor=factor
330        if data:
331            self.data=data
332    def fromXML(self, csmlFrag):
333        self.data = csmlFrag.text
334        if csmlFrag.attrib.has_key('unit'):
335            self.unit=csmlFrag.attrib['unit']
336        if csmlFrag.attrib.has_key('radix'):
337            self.radix=csmlFrag.attrib['radix']
338        if csmlFrag.attrib.has_key('factor'):
339            self.factor=csmlFrag.attrib['factor']
340    def toXML(self,csmlFrag):
341        csmlFrag.text=self.data
342        if hasattr(self,'unit'):
343            csmlFrag.attrib['unit'] = self.unit
344        if hasattr(self,'radix'):
345            csmlFrag.attrib['radix'] = self.radix
346        if hasattr(self,'factor'):
347            csmlFrag.attrib['factor'] = self.factor
348        return csmlFrag   
349   
350class TimeCoordinateSystem(Definition):
351    #Class for csml:TimeCoordinateSystem(gml:Definition) element
352    # + originPosition
353    # + interval
354   
355    ### TO DO!
356    #This is wrong, interval should be of type TimeIntervalLength
357#     <element name="originPosition" type="gml:TimePositionType"/>
358#             <element name="origin" type="gml:TimeInstantPropertyType"/>
359#           </choice>
360#           <element name="interval" type="gml:TimeIntervalLengthType"/>
361#Or is it okay as is.??
362
363    def __init__(self,originPosition=None,interval=None,unit=None,*args,**kwargs):
364        Definition.__init__(self,*args,**kwargs)
365        if originPosition:
366            self.originPosition=originPosition
367        if interval:
368            self.interval=interval
369        if unit:
370            self.unit=unit
371    def fromXML(self,csmlFrag):
372        Definition.fromXML(self,csmlFrag)
373        for frag in csmlFrag.getchildren():
374            if frag.tag == GML('originPosition'):
375                self.originPosition=frag.text
376            elif frag.tag == GML('interval'):
377                self.interval=frag.text
378                self.unit = frag.attrib
379    def toXML(self,csmlFrag):
380        Definition.toXML(self,csmlFrag)
381        if hasattr(self, 'originPosition'):
382            frag=Element(GML('originPosition'))
383            frag.text=self.originPosition
384            csmlFrag.append(frag)
385        if hasattr(self, 'interval'):
386            frag=Element(GML('interval'))
387            frag.text=self.interval
388            if hasattr(self,'unit'):
389                frag.attrib=self.unit
390            csmlFrag.append(frag)
391        return csmlFrag
392
393
394class AbstractReferenceSystemBase(Definition):
395# AbstractReferenceSystemBase(Definition)
396# +gml:MetaDataProperty[0...*]:MetaDataProperty
397# +gml:remarks[0...1]
398# +gml:srsName [?]
399
400
401    def __init__(self,remarks=None,srsName=None,*args,**kwargs):
402        Definition.__init__(self, *args, **kwargs)
403        if remarks:
404            self.remarks=remarks
405        if srsName:
406            self.srsName=srsName
407    def fromXML(self,csmlFrag):
408        Definition.fromXML(self, csmlFrag)
409        for frag in csmlFrag.getchildren():
410            if frag.tag==GML('remarks'):
411                self.remarks=frag.text
412            if frag.tag==GML('srsName'):
413                self.srsName=frag.text
414    def toXML(self,csmlFrag):
415        Definition.toXML(self, csmlFrag)
416        if hasattr(self,'remarks'):
417            frag = Element(GML('remarks'))
418            frag.text=self.remarks
419            csmlFrag.append(frag)
420        if hasattr(self,'srsName'):
421            frag = Element(GML('srsName'))
422            frag.text=self.srsName
423            csmlFrag.append(frag)
424        return csmlFrag
425
426class AbstractReferenceSystem(AbstractReferenceSystemBase):
427#AbstractReferenceSystem(AbstractReferenceSystemBase):
428    def __init__(self,*args,**kwargs):
429        AbstractReferenceSystemBase.__init__(self, *args, **kwargs)
430    def fromXML(self,csmlFrag):
431        AbstractReferenceSystemBase.fromXML(self, csmlFrag)
432    def toXML(self,csmlFrag):
433        AbstractReferenceSystemBase.toXML(self, csmlFrag)
434        return csmlFrag
435
436           
437class AbstractCRS(AbstractReferenceSystem):
438#AbstractCRS(AbstractReferenceSystem):
439
440    def __init__(self,*args,**kwargs):
441        AbstractReferenceSystem.__init__(self, *args, **kwargs)
442    def fromXML(self,csmlFrag):
443        AbstractReferenceSystem.fromXML(self, csmlFrag)
444    def toXML(self,csmlFrag):
445        AbstractReferenceSystem.toXML(self, csmlFrag)
446        return csmlFrag
447           
448
449class AbstractTimeReferenceSystem(Definition):
450    def __init__(self,*args,**kwargs):
451        Definition.__init__(self, *args, **kwargs)
452    def fromXML(self,csmlFrag):
453        Definition.fromXML(self, csmlFrag)
454    def toXML(self,csmlFrag):
455        Definition.toXML(self, csmlFrag)
456        return csmlFrag
457
458
459class AbstractCoordinateReferenceSystem(AbstractCRS):
460    def __init__(self,*args,**kwargs):
461        AbstractCRS.__init__(self, *args, **kwargs)
462    def fromXML(self,csmlFrag):
463        AbstractCRS.fromXML(self, csmlFrag)
464    def toXML(self,csmlFrag):
465        AbstractCRS.toXML(self, csmlFrag)
466        return csmlFrag
467
468   
469class DictionaryEntry(AssociationAttributeGroup,AbstractGML):
470    def __init__(self,*args,**kwargs):
471        pass
472    def fromXML(self,csmlFrag):
473        pass
474    def toXML(self,csmlFrag):
475        return csmlFrag
476   
477class DatumRef(DictionaryEntry):
478    def __init__(self,*args,**kwargs):
479        DictionaryEntry.__init__(self, *args, **kwargs)
480    def fromXML(self,csmlFrag):
481        DictionaryEntry.fromXML(self, csmlFrag)
482    def toXML(self,csmlFrag):
483        DictionaryEntry.toXML(self, csmlFrag)
484        return csmlFrag
485
486class AbstractDatumBase(Definition):
487#         <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
488#                                       <element ref="gml:remarks" minOccurs="0">
489#                                               <annotation>
490#                                                       <documentation>Comments on this reference system, including source information. </documentation>
491#                                               </annotation>
492#                                       </element>
493#                                       <element ref="gml:datumName"/>
494    def __init__(self,metaDataProperty=None,remarks=None,datumName=None,*args,**kwargs):
495        Definition.__init__(self,*args,**kwargs)
496        if metaDataProperty:
497            self.metaDataProperty=metaDataProperty
498        if remarks:
499            self.remarks=remarks
500        if datumName:
501            self.datumName=datumName
502    def fromXML(self,csmlFrag):
503        if csmlFrag.attrib.has_key(GML('metaDataProperty')):
504            self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')]
505        for frag in csmlFrag.getchildren():
506            if frag.tag==GML('remarks'):
507                self.remarks=frag.text
508            if frag.tag==GML('datumName'):
509                self.datumName=frag.text
510        Definition.fromXML(self,csmlFrag)
511    def toXML(self,csmlFrag):
512        Definition.toXML(self,csmlFrag)
513        if hasattr(self,'metaDataProperty'):
514            csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty
515        if hasattr(self, 'remarks'):
516            frag=Element(GML('remarks'))
517            frag.text=self.remarks
518            csmlFrag.append(frag)
519        if hasattr(self, 'datumName'):
520            frag=Element(GML('datumName'))
521            frag.text=self.datumName
522            csmlFrag.append(frag)
523        return csmlFrag
524   
525class AbstractDatum(AbstractDatumBase):
526#             <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded">
527#                                               <annotation>
528#                                                       <documentation>Set of alternative identifications of this datum. The first datumID, if any, is normally the primary identification code, and any others are aliases. </documentation>
529#                                               </annotation>
530#                                       </element>
531#                                       <element ref="gml:anchorPoint" minOccurs="0"/>
532#                                       <element ref="gml:realizationEpoch" minOccurs="0"/>
533#                                       <element ref="gml:validArea" minOccurs="0"/>
534#                                       <element ref="gml:scope" minOccurs="0"/>
535    def __init__(self,datumID=None,anchorPoint=None,realizationEpoch=None,validArea=None, scope=None,*args,**kwargs):
536        if datumID:
537            self.datumID=datumID
538        if anchorPoint:
539            self.anchorPoint=anchorPoint
540        if realizationEpoch:
541            self.realizationEpoch=realizationEpoch
542        if validArea:
543            self.validArea=validArea
544        AbstractDatumBase.__init__(self,*args,**kwargs)
545    def fromXML(self,csmlFrag):
546        AbstractDatumBase.fromXML(self,csmlFrag)
547        for frag in csmlFrag.getchildren():
548            if frag.tag==GML('datumID'):
549                self.datumID=frag.text
550            if frag.tag==GML('anchorPoint'):
551                self.anchorPoint=frag.text
552            if frag.tag==GML('realizationEpoch'):
553                self.realizationEpoch=frag.text
554            if frag.tag==GML('validArea'):
555                self.validArea=frag.text
556    def toXML(self,csmlFrag):
557        AbstractDatumBase.toXML(self,csmlFrag)
558        if hasattr(self, 'datumID'):
559            frag=Element(GML('datumID'))
560            frag.text=self.datumID
561            csmlFrag.append(frag)
562        if hasattr(self, 'anchorPoint'):
563            frag=Element(GML('anchorPoint'))
564            frag.text=self.anchorPoint
565            csmlFrag.append(frag)
566        if hasattr(self, 'realizationEpoch'):
567            frag=Element(GML('realizationEpoch'))
568            frag.text=self.realizationEpoch
569            csmlFrag.append(frag)
570        if hasattr(self, 'validArea'):
571            frag=Element(GML('validArea'))
572            frag.text=self.validArea
573            csmlFrag.append(frag)
574   
575        return csmlFrag
576   
577class EngineeringDatum(AbstractDatum):
578    def __init__(self,*args,**kwargs):
579        AbstractDatum.__init__(self,*args,**kwargs)
580    def fromXML(self,csmlFrag):
581        AbstractDatum.fromXML(self,csmlFrag)
582    def toXML(self,csmlFrag):
583        AbstractDatum.toXML(self,csmlFrag)
584        return csmlFrag
585
586class VerticalDatumType(CodeType):
587    def __init__(self,*args,**kwargs):
588        CodeType.__init__(self,*args,**kwargs)
589    def fromXML(self,csmlFrag):
590        CodeType.fromXML(self,csmlFrag)
591    def toXML(self,csmlFrag):
592        CodeType.toXML(self,csmlFrag)
593        return csmlFrag
594
595class VerticalDatum(AbstractDatum):
596    def __init__(self,verticalDatumType=None,*args,**kwargs):
597        AbstractDatum.__init__(self,*args,**kwargs)
598        #Note to Andrew, "Type" is part of the element name here. the element <VerticalDatumType> has type: VerticalDatumTypeType.
599        if verticalDatumType:
600            self.verticalDatumType=verticalDatumType
601    def fromXML(self,csmlFrag):
602        AbstractDatum.fromXML(self,csmlFrag)
603        for frag in csmlFrag.getchildren():
604            if frag.tag==GML('VerticalDatumType'):
605                self.verticalDatumType=VerticalDatumType()
606                VerticalDatumType.fromXML(self.verticalDatumType,frag)
607       
608    def toXML(self,csmlFrag):
609        AbstractDatum.toXML(self,csmlFrag)
610        if hasattr(self,'verticalDatumType'):
611            frag=Element(GML('VerticalDatumType'))
612            frag=VerticalDatumType.toXML(self.verticalDatumType,frag)
613        return csmlFrag
614
615class TemporalDatumBase(AbstractDatum):
616#       <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
617#                                       <element ref="gml:datumName"/>
618#                                       <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded"/>
619#                                       <element ref="gml:validArea" minOccurs="0"/>
620#                                       <element ref="gml:scope" minOccurs="0"/>
621    def __init__(self,datumName=None, datumID = None, validArea=None, scope=None,*args,**kwargs):
622        AbstractDatum.__init__(self,*args,**kwargs)
623    def fromXML(self,csmlFrag):
624        AbstractDatum.fromXML(self,csmlFrag)
625        for frag in csmlFrag.getchildren():
626            if frag.tag==GML('datumName'):
627                self.datumName=frag.text
628            if frag.tag==GML('datumID'):
629                self.datumID=frag.text
630            if frag.tag==GML('validArea'):
631                self.validArea=frag.text
632            if frag.tag==GML('scope'):
633                self.scope=frag.text
634    def toXML(self,csmlFrag):
635        AbstractDatum.toXML(self,csmlFrag)
636        if hasattr(self,'datumName'):
637            frag=Element(GML('datumName'))
638            frag.text=self.datumName
639        if hasattr(self,'datumID'):
640            frag=Element(GML('datumID'))
641            frag.text=self.datumID
642        if hasattr(self,'validArea'):
643            frag=Element(GML('validArea'))
644            frag.text=self.validArea
645        if hasattr(self,'scope'):
646            frag=Element(GML('scope'))
647            frag.text=self.scope
648        return csmlFrag
649
650
651class TemporalDatumType(TemporalDatumBase):
652    def __init__(self,*args,**kwargs):
653        CodeType.__init__(self,*args,**kwargs)
654    def fromXML(self,csmlFrag):
655        CodeType.fromXML(self,csmlFrag)
656    def toXML(self,csmlFrag):
657        CodeType.toXML(self,csmlFrag)
658        return csmlFrag
659
660class TemporalDatum(AbstractDatum):
661    def __init__(self,origin=None,*args,**kwargs):
662        AbstractDatum.__init__(self,*args,**kwargs)
663        #Note to Andrew, "Type" is part of the element name here. the element <TemporalDatumType> has type: TemporalDatumTypeType.
664        if origin:
665            self.origin=origin
666    def fromXML(self,csmlFrag):
667        AbstractDatum.fromXML(self,csmlFrag)
668        for frag in csmlFrag.getchildren():
669            if frag.tag==GML('TemporalDatumType'):
670                self.temporalDatumType=TemporalDatumType()
671                TemporalDatumType.fromXML(self.temporalDatumType,frag)
672    def toXML(self,csmlFrag):
673        AbstractDatum.toXML(self,csmlFrag)
674        if hasattr(self,'temporalDatumType'):
675            frag=Element(GML('TemporalDatumType'))
676            frag=TemporalDatumType.toXML(self.temporalDatumType,frag)
677        return csmlFrag
678       
679class PrimeMeridianBase(Definition):
680#                       <restriction base="gml:DefinitionType">
681#                               <sequence>
682#                                       <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
683#                                       <element ref="gml:remarks" minOccurs="0">
684#                                               <annotation>
685#                                                       <documentation>Comments on or information about this prime meridian, including source information. </documentation>
686#                                               </annotation>
687#                                       </element>
688#                                       <element ref="gml:meridianName"/>
689#                               </sequence>
690#                               <attribute ref="gml:id" use="required"/>
691#                       </restriction>
692    def __init__(self,metaDataProperty=None, remarks=None, meridianName=None, *args,**kwargs):
693        Definition.__init__(self,*args,**kwargs)
694        if metaDataProperty:
695            self.metaDataProperty=metaDataProperty
696        if remarks:
697            self.remarks=remarks
698        if meridianName:
699            self.meridianName=meridianName
700
701    def fromXML(self,csmlFrag):
702        Definition.fromXML(self,csmlFrag)
703        if csmlFrag.attrib.has_key(GML('metaDataProperty')):
704            self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')]
705        for frag in csmlFrag.getchildren():
706            if frag.tag==GML('remarks'):
707                self.remarks=frag.text
708            if frag.tag==GML('meridianName'):
709                self.meridianName=frag.text
710    def toXML(self,csmlFrag):
711        Definition.toXML(self,csmlFrag)
712        if hasattr(self,'metaDataProperty'):
713            csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty
714        if hasattr(self, 'remarks'):
715            frag=Element(GML('remarks'))
716            frag.text=self.remarks
717            csmlFrag.append(frag)
718        if hasattr(self, 'meridianName'):
719            frag=Element(GML('meridianName'))
720            frag.text=self.meridianName
721            csmlFrag.append(frag)
722        return csmlFrag
723
724
725   
726class PrimeMeridian(PrimeMeridianBase):
727#untested
728    def __init__(self,meridianID=None, greenwichLongitude=None, *args,**kwargs):
729        PrimeMeridianBase.__init__(self,*args,**kwargs)
730        if meridianID:
731            self.meridianID=meridianID
732        if greenwichLongitude:
733            self.greenwichLongitude=greenwichLongitude
734    def fromXML(self,csmlFrag):
735        PrimeMeridianBase.fromXML(self,csmlFrag)
736        if frag.tag==GML('meridianID'):
737            self.meridianID=frag.text
738        if frag.tag==GML('greenwichLongitude'):
739            self.greenwichLongitude=frag.text
740    def toXML(self,csmlFrag):
741        PrimeMeridianBase.toXML(self,csmlFrag)
742        if hasattr(self,'meridianID'):
743            frag=Element(GML('meridianID'))
744            frag.text=self.meridianID
745            csmlFrag.append(frag)
746        if hasattr(self,'greenwichLongitude'):
747            frag=Element(GML('greenwichLongitude'))
748            frag.text=self.greenwichLongitude
749        return csmlFrag
750
751class PrimeMeridianRef(DictionaryEntry):
752#untested
753    def __init__(self,primeMeridian=None,*args,**kwargs):
754        DictionaryEntry.__init__(self,*args,**kwargs)
755        if primeMeridian:
756            self.primeMeridian=primeMeridian
757    def fromXML(self,csmlFrag):
758        DictionaryEntry.fromXML(self,csmlFrag)
759        for frag in csmlFrag.getchildren():
760            if frag.tag==GML('PrimeMeridian'):
761                self.primeMeridian=PrimeMeridian()
762                PrimeMeridian.fromXML(self.primeMeridian,frag)
763    def toXML(self,csmlFrag):
764        DictionaryEntry.toXML(self,csmlFrag)
765        if hasattr(self,'primeMeridian'):
766            frag=Element(GML('PrimeMeridian'))
767            frag=PrimeMeridian.toXML(self.primeMeridian,frag)
768            csmlFrag.append(frag)
769        return csmlFrag
770   
771class GeodeticDatum(AbstractDatum):
772#untested
773        #<element ref="gml:usesPrimeMeridian"/>
774        #<element ref="gml:usesEllipsoid"/>
775    def __init__(self,usesPrimeMeridian=None,usesEllipsoid=None,*args,**kwargs):
776        AbstractDatum.__init__(self,*args,**kwargs)
777        if usesPrimeMeridian:
778            self.usesPrimeMeridian=usesPrimeMeridian
779        if usesEllipsoid:
780            self.usesEllipsoid=usesEllipsoid
781    def fromXML(self,csmlFrag):
782        AbstractDatum.fromXML(self,csmlFrag)
783        for frag in csmlFrag.getchildren():
784            if frag.tag==GML('usesPrimeMeridian'):
785                self.usesPrimeMeridian=PrimeMeridianRef()
786                PrimeMeridianRef.fromXML(self.usesPrimeMeridian,frag)
787        for frag in csmlFrag.getchildren():
788            if frag.tag==GML('usesEllipsoid'):
789                self.usesEllipsoid=EllipsoidRef()
790                EllipsoidRef.fromXML(self.usesEllipsoid,frag)
791    def toXML(self,csmlFrag):
792        AbstractDatum.toXML(self,csmlFrag)
793        if hasattr(self,'usesPrimeMeridian'):
794            frag=Element(GML('usesPrimeMeridian'))
795            frag=PrimeMeridianRef.toXML(self.usesPrimeMeridian,frag)
796            csmlFrag.append(frag)
797        if hasattr(self,'usesEllipsoid'):
798            frag=Element(GML('usesEllipsoid'))
799            frag=EllipsoidRef.toXML(self.usesEllipsoid,frag)
800        return csmlFrag
801   
802   
803class EngineeringDatumRef(DatumRef, AssociationAttributeGroup):
804    def __init__(self,engineeringDatum=None,*args,**kwargs):
805        DatumRef.__init__(self, *args, **kwargs)
806        AssociationAttributeGroup.__init__(self, *args, **kwargs)
807        if engineeringDatum:
808            self.engineeringDatum=engineeringDatum
809    def fromXML(self,csmlFrag):
810        DatumRef.fromXML(self, csmlFrag)
811        AssociationAttributeGroup.fromXML(self, csmlFrag)
812        for frag in csmlFrag.getchildren():
813            if frag.tag==GML('EngineeringDatum'):
814                self.engineeringDatum=EngineeringDatum()
815                EngineeringDatum.fromXML(self.engineeringDatum,frag)
816    def toXML(self,csmlFrag):
817        DatumRef.toXML(self, csmlFrag)
818        AssociationAttributeGroup.toXML(self, csmlFrag)
819        if hasattr(self,'engineeringDatum'):
820            frag=Element(GML('EngineeringDatum'))
821            frag=EngineeringDatum.toXML(self.engineeringDatum,frag)
822            csmlFrag.append(frag)
823        return csmlFrag
824
825class VerticalDatumRef(DatumRef, AssociationAttributeGroup):
826    def __init__(self,verticalDatum=None,*args,**kwargs):
827        DatumRef.__init__(self, *args, **kwargs)
828        AssociationAttributeGroup.__init__(self, *args, **kwargs)
829        if verticalDatum:
830            self.verticalDatum=verticalDatum
831    def fromXML(self,csmlFrag):
832        DatumRef.fromXML(self, csmlFrag)
833        AssociationAttributeGroup.fromXML(self, csmlFrag)
834        for frag in csmlFrag.getchildren():
835            if frag.tag==GML('VerticalDatum'):
836                self.verticalDatum=VerticalDatum()
837                VerticalDatum.fromXML(self.verticalDatum,frag)
838    def toXML(self,csmlFrag):
839        DatumRef.toXML(self, csmlFrag)
840        AssociationAttributeGroup.toXML(self, csmlFrag)
841        if hasattr(self,'verticalDatum'):
842            frag=Element(GML('VerticalDatum'))
843            frag=VerticalDatum.toXML(self.verticalDatum,frag)
844            csmlFrag.append(frag)
845        return csmlFrag
846
847class GeodeticDatumRef(DatumRef,AssociationAttributeGroup):
848    def __init__(self,geodeticDatum=None,*args,**kwargs):
849        DatumRef.__init__(self, *args, **kwargs)
850        AssociationAttributeGroup.__init__(self, *args, **kwargs)
851        if geodeticDatum:
852            self.geodeticDatum=geodeticDatum
853    def fromXML(self,csmlFrag):
854        DatumRef.fromXML(self, csmlFrag)
855        AssociationAttributeGroup.fromXML(self, csmlFrag)
856        for frag in csmlFrag.getchildren():
857            if frag.tag==GML('GeodeticDatum'):
858                self.geodeticDatum=GeodeticDatum()
859                GeodeticDatum.fromXML(self.geodeticDatum,frag)
860    def toXML(self,csmlFrag):
861        DatumRef.toXML(self, csmlFrag)
862        AssociationAttributeGroup.toXML(self, csmlFrag)
863        if hasattr(self,'geodeticDatum'):
864            frag=Element(GML('GeodeticDatum'))
865            frag=GeodeticDatum.toXML(self.geodeticDatum,frag)
866            csmlFrag.append(frag)
867        return csmlFrag
868
869class CoordinateSystemAxisBase(Definition):
870    def __init__(self,*args,**kwargs):
871        Definition.__init__(self, *args, **kwargs)
872    def fromXML(self,csmlFrag):
873        Definition.fromXML(self, csmlFrag)
874    def toXML(self,csmlFrag):
875        Definition.toXML(self, csmlFrag)
876        return csmlFrag
877   
878class CoordinateSystemAxis(CoordinateSystemAxisBase):
879    def __init__(self,uom=None,axisIDs=None,axisAbbrev=None, axisDirection=None, *args,**kwargs):
880        #gml:uom[1]
881        #gml:axisID[0..1]:identifier
882        #gml:axisAbbrev[0..1]:string
883        #gml:axisDirection[0...1]:string
884        CoordinateSystemAxisBase.__init__(self, *args, **kwargs)
885        if uom:
886            self.uom=uom
887        if axisIDs:
888            self.axisIDs=axisIDs
889        if axisAbbrev:
890            self.axisAbbrev=axisAbbrev
891        if axisDirection:
892            self.axisDirection=axisDirection
893
894    def fromXML(self,csmlFrag):
895        CoordinateSystemAxisBase.fromXML(self,csmlFrag)
896        if csmlFrag.attrib.has_key(GML('uom')):
897            self.uom=csmlFrag.attrib[GML('uom')]
898        for frag in csmlFrag.getchildren():
899            if frag.tag==GML('axisID'):
900                checkArrayAttrib(self,'axisIDs')
901                axisID=frag.text
902                self.axisIDs.append(axisID)
903            if frag.tag==GML('axisAbbrev'):
904                self.axisAbbrev=frag.text
905            if frag.tag==GML('axisDirection'):
906                self.axisDirection=frag.text
907    def toXML(self,csmlFrag):
908        CoordinateSystemAxisBase.toXML(self,csmlFrag)
909        if hasattr(self,'uom'):
910            csmlFrag.attrib[GML('uom')]=self.uom
911        if hasattr(self,'axisIDs'):
912            print 'do something'
913        if hasattr(self,'axisAbbrev'):
914            frag=Element(GML('axisAbbrev'))
915            frag.text=self.axisAbbrev
916            csmlFrag.append(frag)
917        if hasattr(self,'axisDirection'):
918            frag=Element(GML('axisDirection'))
919            frag.text=self.axisDirection
920            csmlFrag.append(frag)
921        return csmlFrag
922   
923class CoordinateSystemRef(DictionaryEntry):
924    def __init__(self,*args,**kwargs):
925        DictionaryEntry.__init__(self, *args, **kwargs)
926    def fromXML(self,csmlFrag):
927        DictionaryEntry.fromXML(self, csmlFrag)
928    def toXML(self,csmlFrag):
929        DictionaryEntry.toXML(self, csmlFrag)
930        return csmlFrag
931
932class AbstractCoordinateSystemBase(Definition):
933#         <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/>
934#                                       <element ref="gml:remarks" minOccurs="0">
935#                                               <annotation>
936#                                                       <documentation>Comments on or information about this coordinate system, including data source information. </documentation>
937#                                               </annotation>
938#                                       </element>
939#                                       <element ref="gml:csName"/>
940    def __init__(self,metaDataProperty=None,remarks=None,csName=None,*args,**kwargs):
941        Definition.__init__(self, *args, **kwargs)
942        if metaDataProperty:
943            self.metaDataProperty=metaDataProperty
944        if remarks:
945            self.remarks=remarks
946        if csName:
947            self.csName=csName
948    def fromXML(self,csmlFrag):
949        Definition.fromXML(self, csmlFrag)
950        for frag in csmlFrag.getchildren():
951            if frag.tag==GML('metaDataProperty'):
952                self.metaDataProperty=MetaDataProperty()
953                MetaDataProperty.fromXML(self.metaDataProperty, frag)
954            if frag.tag==GML('remarks'):
955                self.remarks=frag.text
956            if frag.tag==GML('csName'):
957                self.csName=frag.text
958
959    def toXML(self,csmlFrag):
960        Definition.toXML(self, csmlFrag)
961        return csmlFrag
962   
963class AbstractCoordinateSystem(AbstractCoordinateSystemBase):
964        #class AbstractCoordinateSystem
965        #+gml:csid[0...1]:string
966        #+gml:usesAxis[1...*]
967       
968    def __init__(self,csid=None,usesAxes=None,*args,**kwargs):
969        AbstractCoordinateSystemBase.__init__(self, *args, **kwargs)
970        if csid:
971            self.csid=csid
972        if usesAxes:
973            self.usesAxes=usesAxes
974            #usesAxes should be a list containing multiple gml:usesAxis
975    def fromXML(self,csmlFrag):
976        AbstractCoordinateSystemBase.fromXML(self, csmlFrag)
977        for frag in csmlFrag.getchildren():
978            if frag.tag==GML('csid'):
979                self.csid=frag.text
980            if frag.tag==GML('usesAxis'):
981                checkArrayAttrib(self,'usesAxes')
982                self.usesAxes.append(CoordinateSystemAxis())
983                self.usesAxes[-1].fromXML(frag.getchildren()[0])
984
985    def toXML(self,csmlFrag):
986        AbstractCoordinateSystemBase.toXML(self, csmlFrag)
987        if hasattr(self,'csid'):
988            frag=Element(GML('csid'))
989            frag.tag=self.csid
990            csmlFrag.append(frag)
991        if hasattr(self,'usesAxes'):
992            for axis in self.usesAxes:
993                frag=Element(GML('usesAxis'))
994                subFrag=Element(GML('CoordinateSystemAxis'))
995                subFrag=axis.toXML(subFrag)
996                frag.append(subFrag)
997                csmlFrag.append(frag)
998        return csmlFrag
999
1000class LinearCS(AbstractCoordinateSystem):
1001    def __init__(self,*args,**kwargs):
1002        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1003    def fromXML(self,csmlFrag):
1004        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1005    def toXML(self,csmlFrag):
1006        AbstractCoordinateSystem.toXML(self, csmlFrag)
1007        return csmlFrag
1008
1009
1010class EllipsoidalCS(AbstractCoordinateSystem):
1011    def __init__(self,*args,**kwargs):
1012        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1013    def fromXML(self,csmlFrag):
1014        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1015    def toXML(self,csmlFrag):
1016        AbstractCoordinateSystem.toXML(self, csmlFrag)
1017        return csmlFrag
1018
1019class VerticalCS(AbstractCoordinateSystem):
1020    def __init__(self,*args,**kwargs):
1021        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1022    def fromXML(self,csmlFrag):
1023        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1024    def toXML(self,csmlFrag):
1025        AbstractCoordinateSystem.toXML(self, csmlFrag)
1026        return csmlFrag
1027
1028class TemporalCS(AbstractCoordinateSystem):
1029    def __init__(self,*args,**kwargs):
1030        AbstractCoordinateSystem.__init__(self, *args, **kwargs)
1031    def fromXML(self,csmlFrag):
1032        AbstractCoordinateSystem.fromXML(self, csmlFrag)
1033    def toXML(self,csmlFrag):
1034        AbstractCoordinateSystem.toXML(self, csmlFrag)
1035        return csmlFrag
1036class EngineeringCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1037        #<element ref="gml:usesCS"/>type="gml:CoordinateSystemRefType">
1038        #<element ref="gml:usesEngineeringDatum"/>
1039    def __init__(self,usesCS=None, usesEngineeringDatum=None,*args,**kwargs):
1040        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1041        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1042        if usesCS:
1043            self.usesCS=usesCS
1044        if usesEngineeringDatum:
1045            self.usesEngineeringDatum=usesEngineeringDatum
1046    def fromXML(self,csmlFrag):
1047        AssociationAttributeGroup.fromXML(self, csmlFrag)
1048        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1049        for frag in csmlFrag.getchildren():
1050            if frag.tag == GML('usesCS'):
1051                subFrag=frag.getchildren()[0]
1052                if subFrag.tag==GML('LinearCS'):
1053                    self.usesCS=LinearCS()
1054                    LinearCS.fromXML(self.usesCS,subFrag)
1055                else:
1056                    print subFrag.tag + ' Coordinate System not supported'
1057            if frag.tag == GML('usesEngineeringDatum'):
1058                self.usesEngineeringDatum=EngineeringDatumRef()
1059                EngineeringDatumRef.fromXML(self.usesEngineeringDatum,frag)
1060    def toXML(self,csmlFrag):
1061        AssociationAttributeGroup.toXML(self, csmlFrag)
1062        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1063        if hasattr(self, 'usesCS'):
1064            frag=Element(GML('usesCS'))
1065            if isinstance(self.usesCS,LinearCS):
1066                subFrag=Element(GML('LinearCS'))
1067                LinearCS.toXML(self.usesCS,subFrag)
1068                frag.append(subFrag)
1069                csmlFrag.append(frag)
1070        if hasattr(self, 'usesEngineeringDatum'):
1071            frag=Element(GML('usesEngineeringDatum'))
1072            EngineeringDatumRef.toXML(self.usesEngineeringDatum, frag)
1073            csmlFrag.append(frag)
1074        return csmlFrag
1075
1076class VerticalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1077        #<element ref="gml:usesVerticalCS"/>type="gml:VerticalCSRefType">
1078        #<element ref="gml:usesVerticalDatum"/>type="gml:VerticalDatumRefType
1079    def __init__(self,usesVerticalCS=None, usesVerticalDatum=None,*args,**kwargs):
1080        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1081        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1082        if usesVerticalCS:
1083            self.usesVerticalCS=usesVerticalCS
1084        if usesVerticalDatum:
1085            self.usesVerticalDatum=usesVerticalDatum
1086    def fromXML(self,csmlFrag):
1087        AssociationAttributeGroup.fromXML(self, csmlFrag)
1088        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1089        for frag in csmlFrag.getchildren():
1090            if frag.tag == GML('usesVerticalCS'):
1091                subFrag=frag.getchildren()[0]
1092                if subFrag.tag==GML('VerticalCS'):
1093                    self.usesVerticalCS=VerticalCS()
1094                    VerticalCS.fromXML(self.usesVerticalCS,subFrag)
1095                else:
1096                    print subFrag.tag + ' Coordinate System not supported'
1097            if frag.tag == GML('usesVerticalDatum'):
1098                self.usesVerticalDatum=VerticalDatumRef()
1099                VerticalDatumRef.fromXML(self.usesVerticalDatum,frag)
1100    def toXML(self,csmlFrag):
1101        AssociationAttributeGroup.toXML(self, csmlFrag)
1102        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1103        if hasattr(self, 'usesVerticalCS'):
1104            frag=Element(GML('usesVerticalCS'))
1105            if isinstance(self.usesVerticalCS,VerticalCS):
1106                subFrag=Element(GML('VerticalCS'))
1107                VerticalCS.toXML(self.usesVerticalCS,subFrag)
1108                frag.append(subFrag)
1109                csmlFrag.append(frag)
1110        if hasattr(self, 'usesVerticalDatum'):
1111            frag=Element(GML('usesVerticalDatum'))
1112            VerticalDatumRef.toXML(self.usesVerticalDatum, frag)
1113            csmlFrag.append(frag)
1114        return csmlFrag
1115
1116class TemporalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1117        #<element ref="gml:usesTemporalCS"/>type="gml:TemporalCSRefType">
1118        #<element ref="gml:usesTemporalDatum"/>type="gml:TemporalDatumRefType
1119    def __init__(self,usesTemporalCS=None, usesTemporalDatum=None,*args,**kwargs):
1120        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1121        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1122        if usesTemporalCS:
1123            self.usesTemporalCS=usesTemporalCS
1124        if usesTemporalDatum:
1125            self.usesTemporalDatum=usesTemporalDatum
1126    def fromXML(self,csmlFrag):
1127        AssociationAttributeGroup.fromXML(self, csmlFrag)
1128        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1129        for frag in csmlFrag.getchildren():
1130            if frag.tag == GML('usesTemporalCS'):
1131                subFrag=frag.getchildren()[0]
1132                if subFrag.tag==GML('TemporalCS'):
1133                    self.usesTemporalCS=TemporalCS()
1134                    TemporalCS.fromXML(self.usesTemporalCS,subFrag)
1135                else:
1136                    print subFrag.tag + ' Coordinate System not supported'
1137            if frag.tag == GML('usesTemporalDatum'):
1138                self.usesTemporalDatum=TemporalDatumRef()
1139                TemporalDatumRef.fromXML(self.usesTemporalDatum,frag)
1140    def toXML(self,csmlFrag):
1141        AssociationAttributeGroup.toXML(self, csmlFrag)
1142        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1143        if hasattr(self, 'usesTemporalCS'):
1144            frag=Element(GML('usesTemporalCS'))
1145            if isinstance(self.usesTemporalCS,TemporalCS):
1146                subFrag=Element(GML('TemporalCS'))
1147                TemporalCS.toXML(self.usesTemporalCS,subFrag)
1148                frag.append(subFrag)
1149                csmlFrag.append(frag)
1150        if hasattr(self, 'usesTemporalDatum'):
1151            frag=Element(GML('usesTemporalDatum'))
1152            TemporalDatumRef.toXML(self.usesTemporalDatum, frag)
1153            csmlFrag.append(frag)
1154        return csmlFrag
1155class GeographicCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup):
1156            #<element ref="gml:usesEllipsoidalCS"/>
1157    #<element ref="gml:usesGeodeticDatum"/>
1158    def __init__(self,usesEllipsoidalCS=None, usesGeodeticDatum=None,*args,**kwargs):
1159        AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs)
1160        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1161        if usesEllipsoidalCS:
1162            self.usesEllipsoidalCS=usesEllipsoidalCS
1163        if usesGeodeticDatum:
1164            self.usesGeodeticDatum=usesGeodeticDatum
1165    def fromXML(self,csmlFrag):
1166        AssociationAttributeGroup.fromXML(self, csmlFrag)
1167        AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag)
1168        for frag in csmlFrag.getchildren():
1169            if frag.tag == GML('usesEllipsoidalCS'):
1170                subFrag=frag.getchildren()[0]
1171                if subFrag.tag==GML('EllipsoidalCS'):
1172                    self.usesEllipsoidalCS=EllipsoidalCS()
1173                    EllipsoidalCS.fromXML(self.usesEllipsoidalCS,subFrag)
1174                else:
1175                    print subFrag.tag + ' Coordinate System not supported'
1176            if frag.tag == GML('usesGeodeticDatum'):
1177                self.usesGeodeticDatum=GeodeticDatumRef()
1178                GeodeticDatumRef.fromXML(self.usesEngineeringDatum,frag)
1179    def toXML(self,csmlFrag):
1180        AssociationAttributeGroup.toXML(self, csmlFrag)
1181        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1182        if hasattr(self, 'usesEllipsoidalCS'):
1183            frag=Element(GML('usesEllipsoidalCS'))
1184            if isinstance(self.usesCS,LinearCS):
1185                subFrag=Element(GML('usesEllipsoidalCS'))
1186                EllipsoidalCS.toXML(self.usesEllipsoidalCS,subFrag)
1187                frag.append(subFrag)
1188                csmlFrag.append(frag)
1189        if hasattr(self, 'usesEngineeringDatum'):
1190            frag=Element(GML('usesGeodeticDatum'))
1191            GeodeticDatumRef.toXML(self.usesGeodeticDatum, frag)
1192            csmlFrag.append(frag)
1193        return csmlFrag
1194
1195class CompoundCRS(AbstractCRS,AssociationAttributeGroup):
1196    #untested
1197    def __init__(self, includes=None, *args,**kwargs):
1198        AbstractCRS.__init__(self, *args, **kwargs)
1199        AssociationAttributeGroup.__init__(self, *args, **kwargs)
1200        if includes:
1201            self.includes=includes
1202    def fromXML(self,csmlFrag):
1203        AssociationAttributeGroup.fromXML(self, csmlFrag)
1204        AbstractCRS.fromXML(self, csmlFrag)
1205        for frag in csmlFrag.getchildren():
1206            if frag.tag == GML('includesCRS'):
1207                checkArrayAttrib(self,'includes')
1208                if frag.getchildren()[1].tag==GML('EngineeringCRS'):
1209                    self.includes.append(EngineeringCRS())
1210                if frag.getchildren()[1].tag==GML('VerticalCRS'):
1211                    self.includes.append(VerticalCRS())
1212                if frag.getchildren()[1].tag==GML('GeographicCRS'):
1213                    self.includes.append(GeographicCRS())
1214                #if frag.getchildren()[1].tag==GML('TemporalCRS'):
1215                    #self.includes.append(TemporalCRS())
1216                self.includes[-1].fromXML(frag.getchildren()[0])
1217               
1218    def toXML(self,csmlFrag):
1219        AssociationAttributeGroup.toXML(self, csmlFrag)
1220        AbstractCoordinateReferenceSystem.toXML(self, csmlFrag)
1221        if hasattr(self,'includes'):
1222            for crs in self.includes:
1223                frag=Element(GML('includesCRS'))
1224                if isinstance(crs,EngineeringCRS):
1225                    subFrag=Element(GML('EngineeringCRS'))
1226                    subFrag=crs.toXML(subFrag)
1227                    frag.append(subFrag)
1228                    csmlFrag.append(frag)
1229                if isinstance(crs,VerticalCRS):
1230                    subFrag=Element(GML('VerticalCRS'))
1231                    subFrag=crs.toXML(subFrag)
1232                    frag.append(subFrag)
1233                    csmlFrag.append(frag)
1234                if isinstance(crs,GeographicCRS):
1235                    subFrag=Element(GML('GeographicCRS'))
1236                    subFrag=crs.toXML(subFrag)
1237                    frag.append(subFrag)
1238                    csmlFrag.append(frag)
1239#                 if isinstance(crs,TemporalCRS):
1240#                     subFrag=Element(GML('TemporalCRS'))
1241#                     subFrag=crs.toXML(subFrag)
1242#                     frag.append(subFrag)
1243#                     csmlFrag.append(frag)
1244        return csmlFrag
1245
1246class UnitDefinition(Definition):
1247        #Class gml:UnitDefinition
1248        # +quantityType
1249        # +catalogSymbol, codeSpace
1250    def __init__(self,quantityType=None,catalogSymbol=None,*args,**kwargs):
1251        Definition.__init__(self,*args,**kwargs)
1252        if quantityType:
1253            self.quantityType=quantityType
1254        if catalogSymbol:
1255            self.catalogSymbol=catalogSymbol
1256    def fromXML(self,csmlFrag):
1257        Definition.fromXML(self,csmlFrag)
1258        for frag in csmlFrag.getchildren():
1259            if frag.tag == GML('quantityType'):
1260                self.quantityType=frag.text
1261            elif frag.tag == GML('catalogSymbol'):
1262                self.catalogSymbol=CodeType()
1263                CodeType.fromXML(self.catalogSymbol, frag)
1264    def toXML(self,csmlFrag):
1265        Definition.toXML(self,csmlFrag)
1266        if hasattr(self, 'quantityType'):
1267            frag=Element(GML('quantityType'))
1268            frag.text=self.quantityType
1269            csmlFrag.append(frag)
1270        if hasattr(self, 'catalogSymbol'):
1271            frag=Element(GML('catalogSymbol'))
1272            CodeType.toXML(self.catalogSymbol,frag)
1273            csmlFrag.append(frag)
1274        return csmlFrag
1275   
1276class Dictionary(Definition):
1277    #Class for gml:Dictionary elements
1278    # + gml:definitionMembers [1....*]
1279    def __init__(self, definitionMembers=None,*args,**kwargs):
1280        Definition.__init__(self,*args,**kwargs)
1281        if definitionMembers:
1282            self.definitionMembers = definitionMembers
1283    def fromXML(self,csmlFrag):
1284        Definition.fromXML(self,csmlFrag)
1285        for frag in csmlFrag.getchildren():
1286            if frag.tag == GML('definitionMember'):
1287                checkArrayAttrib(self, 'definitionMembers')
1288                subFrag = frag.getchildren()[0]
1289                if subFrag.tag == GML('UnitDefinition'):
1290                    definitionMember=UnitDefinition()
1291                    definitionMember.fromXML(subFrag)
1292                    self.definitionMembers.append(definitionMember)
1293                elif subFrag.tag == CSML('TimeCoordinateSystem'):
1294                    definitionMember=TimeCoordinateSystem()
1295                    definitionMember.fromXML(subFrag)
1296                    self.definitionMembers.append(definitionMember)
1297                elif subFrag.tag == GML('EngineeringCRS'):
1298                    definitionMember=EngineeringCRS()
1299                    definitionMember.fromXML(subFrag)
1300                    self.definitionMembers.append(definitionMember)
1301                elif subFrag.tag == GML('GeographicCRS'):
1302                    definitionMember=GeographicCRS()
1303                    definitionMember.fromXML(subFrag)
1304                    self.definitionMembers.append(definitionMember)
1305                elif subFrag.tag == GML('VerticalCRS'):
1306                    definitionMember=VerticalCRS()
1307                    definitionMember.fromXML(subFrag)
1308                    self.definitionMembers.append(definitionMember)
1309                elif subFrag.tag == GML('TemporalCRS'):
1310                    definitionMember=TemporalCRS()
1311                    definitionMember.fromXML(subFrag)
1312                    self.definitionMembers.append(definitionMember)
1313                elif subFrag.tag == GML('CompoundCRS'):
1314                    definitionMember=CompoundCRS()
1315                    definitionMember.fromXML(subFrag)
1316                    self.definitionMembers.append(definitionMember)
1317                elif subFrag.tag == OM('Phenomenon'):
1318                    definitionMember=Phenomenon()
1319                    definitionMember.fromXML(subFrag)
1320                    self.definitionMembers.append(definitionMember)
1321    def toXML(self,csmlFrag):
1322        Definition.toXML(self,csmlFrag)
1323        if hasattr(self, 'definitionMembers'):
1324            for definitionMember in self.definitionMembers:
1325                if isinstance(definitionMember,UnitDefinition):
1326                    superFrag=Element(GML('definitionMember'))
1327                    frag=Element(GML('UnitDefinition'))
1328                    UnitDefinition.toXML(definitionMember,frag)
1329                    superFrag.append(frag)
1330                    csmlFrag.append(superFrag)
1331                if isinstance(definitionMember,TimeCoordinateSystem):
1332                    superFrag=Element(GML('definitionMember'))
1333                    frag=Element(CSML('TimeCoordinateSystem'))
1334                    TimeCoordinateSystem.toXML(definitionMember,frag)
1335                    superFrag.append(frag)
1336                    csmlFrag.append(superFrag)
1337                if isinstance(definitionMember,EngineeringCRS):
1338                    superFrag=Element(GML('definitionMember'))
1339                    frag=Element(GML('EngineeringCRS'))
1340                    EngineeringCRS.toXML(definitionMember,frag)
1341                    superFrag.append(frag)
1342                    csmlFrag.append(superFrag)
1343                if isinstance(definitionMember,Phenomenon):
1344                    superFrag=Element(GML('definitionMember'))
1345                    frag=Element(OM('Phenomenon'))
1346                    Phenomenon.toXML(definitionMember,frag)
1347                    superFrag.append(frag)
1348                    csmlFrag.append(superFrag)
1349        return csmlFrag
1350
1351
1352class UnitDefinitions(Dictionary):
1353        #Class for csml:UnitDefinitions(gml:Dictionary)
1354    def __init__(self,*args,**kwargs):
1355        Dictionary.__init__(self,*args,**kwargs)
1356    def fromXML(self,csmlFrag):
1357        Dictionary.fromXML(self,csmlFrag)
1358    def toXML(self,csmlFrag):
1359        Dictionary.toXML(self,csmlFrag)
1360        return csmlFrag
1361
1362class ReferenceSystemDefinitions(Dictionary):
1363    def __init__(self,*args,**kwargs):
1364        Dictionary.__init__(self,*args,**kwargs)
1365    def fromXML(self,csmlFrag):
1366        Dictionary.fromXML(self,csmlFrag)
1367    def toXML(self,csmlFrag):
1368        Dictionary.toXML(self,csmlFrag)
1369        return csmlFrag
1370
1371class PhenomenonDefinitions(Dictionary):
1372    def __init__(self,*args,**kwargs):
1373        Dictionary.__init__(self,*args,**kwargs)
1374    def fromXML(self,csmlFrag):
1375        Dictionary.fromXML(self,csmlFrag)
1376    def toXML(self,csmlFrag):
1377        Dictionary.toXML(self,csmlFrag)
1378        return csmlFrag
1379
1380class AbstractArrayDescriptor(AbstractGML):
1381    """Base abstract class for CSML array descriptors
1382
1383    AbstractArrayDescriptor(AbstractGML):
1384     +arraySize[1..*]: int
1385     +uom[0..1]: anyURI  #Amended to also take a 'UnitDefinition' - needed to resolve internal references
1386     +numericType[0..1]: string
1387     +regExpTransform[0..1]: string
1388     +numericTransform[0..1]: string
1389    """
1390    def __init__(self,arraySize=None,uom=None,numericType=None,
1391                 regExpTransform=None,numericTransform=None,*args,**kwargs):
1392        AbstractGML.__init__(self,*args,**kwargs)
1393        if arraySize:
1394            self.arraySize = arraySize
1395        if uom:
1396            self.uom = uom
1397        if numericType:
1398            self.numericType = numericType
1399        if regExpTransform:
1400            self.regExpTransform = regExpTransform
1401        if numericTransform:
1402            self.numericTransform = numericTransform
1403    def fromXML(self,csmlFrag):
1404        AbstractGML.fromXML(self,csmlFrag)
1405        for frag in csmlFrag.getchildren():
1406            if frag.tag == CSML('arraySize'):
1407                self.arraySize = map(int,frag.text.split())
1408                #self.arraySize = frag.text
1409            elif frag.tag == CSML('uom'):
1410                if frag.getchildren() !=[]:
1411                    subFrag= frag.getchildren()[0]
1412                    if subFrag.tag == GML ('UnitDefinition'):
1413                        self.uom=UnitDefinition()
1414                        UnitDefinition.fromXML(self.uom, subFrag)
1415                else:
1416                    self.uom=frag.text
1417            elif frag.tag == CSML('numericType'):
1418                self.numericType = frag.text
1419            elif frag.tag == CSML('regExpTransform'):
1420                self.regExpTransform = frag.text
1421            elif frag.tag == CSML('numericTransform'):
1422                self.numericTransform = frag.text
1423    def toXML(self,csmlFrag):
1424        csmlFrag = AbstractGML.toXML(self,csmlFrag)
1425        if hasattr(self,'arraySize'):
1426            frag = Element(CSML('arraySize'))
1427            frag.text = ' '.join(map(str,self.arraySize))
1428            #frag.text = self.arraySize
1429            csmlFrag.append(frag)
1430        if hasattr(self,'uom'):
1431            frag = Element(CSML('uom'))
1432            if isinstance(self.uom,UnitDefinition):
1433                subFrag=Element(GML('UnitDefinition'))
1434                UnitDefinition.toXML(self.uom,subFrag)
1435                frag.append(subFrag)
1436            else:
1437                frag.text = self.uom
1438            csmlFrag.append(frag)
1439        if hasattr(self,'numericType'):
1440            frag = Element(CSML('numericType'))
1441            frag.text  = self.numericType
1442            csmlFrag.append(frag)
1443        if hasattr(self,'regExpTransform'):
1444            frag = Element(CSML('regExpTransform'))
1445            frag.text = self.regExpTransform
1446            csmlFrag.append(frag)
1447        if hasattr(self,'numericTransform'):
1448            frag = Element(CSML('numericTransform'))
1449            frag.text = self.numericTransform
1450            csmlFrag.append(frag)
1451        return csmlFrag
1452
1453class AggregatedArray(AbstractArrayDescriptor):
1454    """CSML class for aggregated array
1455
1456    AggregatedArray(AbstractArrayDescriptor):
1457     +aggType: string
1458     +aggIndex: int
1459     +component[1..*]: AbstractArrayDescriptor
1460    """
1461    def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs):
1462        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1463        if aggType:
1464            self.aggType = aggType
1465        if aggIndex:
1466            self.aggIndex = aggIndex
1467        if component:
1468            self.component = component
1469    def fromXML(self,csmlFrag):
1470        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1471        for frag in csmlFrag.getchildren():
1472            if frag.tag == CSML('aggType'):
1473                self.aggType = frag.text
1474            elif frag.tag == CSML('aggIndex'):
1475                self.aggIndex = int(frag.text)
1476            elif frag.tag == CSML('component'):
1477                checkArrayAttrib(self,'component')
1478                componentFrag = frag[0]
1479                if componentFrag.tag == CSML('AggregatedArray'):
1480                    self.component.append(AggregatedArray())
1481                elif componentFrag.tag == CSML('InlineArray'):
1482                    self.component.append(InlineArray())
1483                elif componentFrag.tag == CSML('ArrayGenerator'):
1484                    self.component.append(ArrayGenerator())
1485                elif componentFrag.tag == CSML('NASAAmesExtract'):
1486                    self.component.append(NASAAmesExtract())
1487                elif componentFrag.tag == CSML('NetCDFExtract'):
1488                    self.component.append(NetCDFExtract())
1489                elif componentFrag.tag == CSML('GRIBExtract'):
1490                    self.component.append(GRIBExtract())
1491##                else:
1492##                    raise Exception('Unexpected element: "'+componentFrag.tag+'"')
1493                self.component[-1].fromXML(componentFrag)
1494    def toXML(self,csmlFrag):
1495        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1496        if hasattr(self,'aggType'):
1497            frag = Element(CSML('aggType'))
1498            frag.text = self.aggType
1499            csmlFrag.append(frag)
1500        if hasattr(self,'aggIndex'):
1501            frag = Element(CSML('aggIndex'))
1502            frag.text = str(self.aggIndex)
1503            csmlFrag.append(frag)
1504        if hasattr(self,'component'):
1505            compFrag = Element(CSML('component'))
1506            for comp in self.component:
1507                if isinstance(comp,AggregatedArray):
1508                    frag = Element(CSML('AggregatedArray'))
1509                    frag = AggregatedArray.toXML(comp,frag)
1510                elif isinstance(comp,InlineArray):
1511                    frag = Element(CSML('InlineArray'))
1512                    frag = InlineArray.toXML(comp,frag)
1513                elif isinstance(comp,ArrayGenerator):
1514                    frag = Element(CSML('ArrayGenerator'))
1515                    frag = ArrayGenerator.toXML(comp,frag)
1516                elif isinstance(comp,NASAAmesExtract):
1517                    frag = Element(CSML('NASAAmesExtract'))
1518                    frag = NASAAmesExtract.toXML(comp,frag)
1519                elif isinstance(comp,NetCDFExtract):
1520                    frag = Element(CSML('NetCDFExtract'))
1521                    frag = NetCDFExtract.toXML(comp,frag)
1522                elif isinstance(comp,GRIBExtract):
1523                    frag = Element(CSML('GRIBExtract'))
1524                    frag = NASAAmesExtract.toXML(comp,frag)
1525                compFrag.append(frag)
1526            csmlFrag.append(compFrag)
1527        return csmlFrag
1528
1529class InlineArray(AbstractArrayDescriptor):
1530    pass
1531
1532class ArrayGenerator(AbstractArrayDescriptor):
1533    pass
1534
1535class AbstractFileExtract(AbstractArrayDescriptor):
1536    """Base abstract clas for CSML file array extract
1537
1538    AbstractFileExtract(AbstractArrayDescriptor):
1539     +fileName: string
1540    """
1541    def __init__(self,fileName=None,*args,**kwargs):
1542        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1543        if fileName:
1544            self.fileName = fileName
1545    def fromXML(self,csmlFrag):
1546        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1547        for frag in csmlFrag.getchildren():
1548            if frag.tag == CSML('fileName'):
1549                self.fileName = frag.text
1550##        else:
1551##            raise Exception('Unexpected element: "'+frag.tag+'"')
1552    def toXML(self,csmlFrag):
1553        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1554        if hasattr(self,'fileName'):
1555            frag = Element(CSML('fileName'))
1556            frag.text = self.fileName
1557            csmlFrag.append(frag)
1558        return csmlFrag
1559
1560class NASAAmesExtract(AbstractFileExtract):
1561    """CSML class for NASA Ames file extract
1562
1563    NASAAmesExtract(AbstractFileExtract):
1564     +variableName: string
1565     +index[0..1]: int
1566    """
1567    def __init__(self,variableName=None,index=None,*args,**kwargs):
1568        AbstractFileExtract.__init__(self,*args,**kwargs)
1569        if variableName:
1570            self.variableName = variableName
1571        if index:
1572            self.index = index
1573    def fromXML(self,csmlFrag):
1574        AbstractFileExtract.fromXML(self,csmlFrag)
1575        for frag in csmlFrag.getchildren():
1576            if frag.tag == CSML('variableName'):
1577                self.variableName = frag.text
1578            elif frag.tag == CSML('index'):
1579                self.index = int(frag.text)
1580##            else:
1581##                raise Exception('Unexpected element: "'+frag.tag+'"')
1582    def toXML(self,csmlFrag):
1583        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1584        frag = Element(CSML('variableName'))
1585        frag.text = self.variableName
1586        csmlFrag.append(frag)
1587        if hasattr(self,'index'):
1588            frag = Element(CSML('index'))
1589            frag.text = str(self.index)
1590            csmlFrag.append(frag)
1591        return csmlFrag
1592
1593class NetCDFExtract(AbstractFileExtract):
1594    """CSML class for netCDF file extract
1595
1596    NetCDFExtract(AbstractFileExtract):
1597     +variableName: string
1598    """
1599    def __init__(self,variableName=None,*args,**kwargs):
1600        AbstractFileExtract.__init__(self,*args,**kwargs)
1601        if variableName:
1602            self.variableName = variableName
1603    def fromXML(self,csmlFrag):
1604        AbstractFileExtract.fromXML(self,csmlFrag)
1605        for frag in csmlFrag.getchildren():
1606            if frag.tag == CSML('variableName'):
1607                self.variableName = frag.text
1608##        else:
1609##            raise Exception('Unexpected element: "'+frag.tag+'"')
1610        checkMandatory(self, 'variableName')
1611    def toXML(self,csmlFrag):
1612        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1613        if hasattr(self, 'variableName'):
1614            frag = Element(CSML('variableName'))
1615            frag.text = self.variableName
1616            csmlFrag.append(frag)
1617        return csmlFrag
1618
1619class GRIBExtract(AbstractFileExtract):
1620    """CSML class for GRIB file extract
1621
1622    GRIBExtract(AbstractFileExtract):
1623     +parameterCode: int
1624     +recordNumber[0..1]: int
1625     +fileOffset[0..1]: int
1626    """
1627    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, *args,**kwargs):
1628        AbstractFileExtract.__init__(self,*args,**kwargs)
1629        if parameterCode:
1630            self.parameterCode = parameterCode
1631        if recordNumber:
1632            self.recordNumber = recordNumber
1633        if fileOffset:
1634            self.fileOffset = fileOffset
1635    def fromXML(self,csmlFrag):
1636        AbstractFileExtract.fromXML(self,csmlFrag)
1637        for frag in csmlFrag.getchildren():
1638            if frag.tag == CSML('parameterCode'):
1639                self.parameterCode = int(frag.text)
1640            elif frag.tag == CSML('recordNumber'):
1641                self.recordNumber = int(frag.text)
1642            elif frag.tag == CSML('fileOffset'):
1643                self.fileOffset = int(frag.text)
1644##            else:
1645##                raise Exception('Unexpected element: "'+frag.tag+'"')
1646    def toXML(self,csmlFrag):
1647        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1648        frag = Element(CSML('parameterCode'))
1649        frag.text = str(self.parameterCode)
1650        csmlFrag.append(frag)
1651        if hasattr(self,'recordNumber'):
1652            frag = Element(CSML('recordNumber'))
1653            frag.text = str(self.recordNumber)
1654            csmlFrag.append(frag)
1655        if hasattr(self,'fileOffset'):
1656            frag = Element(CSML('fileOffset'))
1657            frag.text = str(self.fileOffset)
1658            csmlFrag.append(frag)
1659        return csmlFrag
1660
1661class DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup):
1662    #class representing a DirectPositionList
1663    def __init__(self, order=None, vals=None,*args,**kwargs):
1664        if order:
1665            self.order=order
1666        if vals:
1667            self.vals=vals
1668        AssociationAttributeGroup.__init__(self,*args,**kwargs)
1669        SRSReferenceGroup.__init__(self,*args,**kwargs)
1670    def fromXML(self,csmlFrag):
1671        AssociationAttributeGroup.fromXML(self,csmlFrag)
1672        SRSReferenceGroup.fromXML(self,csmlFrag)
1673        self.vals=csmlFrag.text
1674        if csmlFrag.attrib.has_key('order'):
1675            self.order=csmlFrag.attrib['order']
1676    def toXML(self,csmlFrag): 
1677        AssociationAttributeGroup.toXML(self,csmlFrag)
1678        SRSReferenceGroup.toXML(self,csmlFrag)
1679        csmlFrag.text=self.vals
1680        if hasattr(self,'order'):
1681            csmlFrag.attrib['order']=self.order
1682        return csmlFrag
1683       
1684class MappingRule(MutableString):
1685    """Class representing a GML MappingRule element(string):
1686    """
1687    def __init__(self,val=''):
1688        MutableString.__init__(self,val)
1689    def fromXML(self,csmlFrag):
1690        self.data = csmlFrag.text
1691        if csmlFrag.attrib.has_key('scanOrder'):
1692            self.scanOrder=csmlFrag.attrib['scanOrder']
1693    def toXML(self,csmlFrag):
1694        csmlFrag.text = self.data
1695        if hasattr(self,'scanOrder'):
1696            csmlFrag.attrib['scanOrder']=self.scanOrder
1697        return csmlFrag
1698
1699   
1700   
1701   
1702   
1703class AbstractDiscreteCoverage(AbstractGML):
1704     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
1705    #GML AbstractDiscreteCoverage Class
1706    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs):
1707        AbstractGML.__init__(self,*args,**kwargs)
1708        if rangeSet:
1709            self.rangeSet=rangeSet
1710        if coverageFunction:
1711            self.coverageFunction=coverageFunction
1712
1713    def fromXML(self,csmlFrag):
1714        AbstractGML.fromXML(self,csmlFrag)
1715        for frag in csmlFrag.getchildren():
1716            if frag.tag == GML('rangeSet'):
1717                self.rangeSet=RangeSet()
1718                self.rangeSet.fromXML(frag)
1719            if frag.tag == GML('coverageFunction'):
1720                self.coverageFunction=MappingRule()
1721                for subFrag in frag.getchildren():
1722                    if subFrag.tag==CSML('MappingRule'):
1723                        self.coverageFunction.fromXML(subFrag)
1724
1725
1726    def toXML(self,csmlFrag):
1727        AbstractGML.toXML(self,csmlFrag)
1728        if hasattr(self,'rangeSet'):
1729            frag = Element(GML('rangeSet'))
1730            RangeSet.toXML(self.rangeSet,frag)
1731            csmlFrag.append(frag)
1732        if hasattr(self,'coverageFunction'):
1733            frag = Element(GML('coverageFunction'))
1734            subFrag=Element(CSML('MappingRule'))
1735            MappingRule.toXML(self.coverageFunction,subFrag)
1736            frag.append(subFrag)
1737            csmlFrag.append(frag)
1738        return csmlFrag
1739       
1740class AbstractCoverageFeature(AbstractDiscreteCoverage):
1741    #CSML Abstract Coverage FT class
1742    #     AbstractCoverageFeature(AbstractDiscreteCoverage)
1743    #       + om:parameter:PhenomenonPropertyType
1744   
1745    def __init__(self, parameter=None, *args,**kwargs):
1746        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
1747        if parameter:
1748            self.parameter=parameter
1749    def fromXML(self,csmlFrag):
1750        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
1751        for frag in csmlFrag.getchildren():
1752            if frag.tag == CSML('parameter'):
1753                self.parameter=None
1754                if frag.getchildren() == []:
1755                    self.parameter=Phenomenon()
1756                    self.parameter.fromXML(frag)
1757                else:
1758                    subFrag=frag.getchildren()[0]
1759                    if subFrag.tag == OM('Phenomenon'):
1760                        self.parameter = Phenomenon()
1761                    elif subFrag.tag == OM('CompositePhenomenon'):
1762                        self.parameter = CompositePhenomenon()
1763                    elif subFrag.tag == OM('ParameterisedPhenomenon'):
1764                        self.parameter = ParameterisedPhenomenon()
1765                    self.parameter.fromXML(subFrag)
1766                       
1767    def toXML(self,csmlFrag):
1768        AbstractDiscreteCoverage.toXML(self,csmlFrag)
1769        if hasattr(self,'parameter'):
1770            frag = Element(CSML('parameter'))
1771            if isinstance(self.parameter,ParameterisedPhenomenon):
1772                subFrag=Element(OM('ParameterisedPhenomenon'))
1773                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
1774                frag.append(subFrag)
1775                csmlFrag.append(frag)
1776            elif isinstance(self.parameter,CompositePhenomenon):
1777                subFrag=Element(OM('CompositePhenomenon'))
1778                CompositePhenomenon.toXML(self.parameter,subFrag)
1779                frag.append(subFrag)
1780                csmlFrag.append(frag)
1781            elif isinstance(self.parameter,Phenomenon):
1782                Phenomenon.toXML(self.parameter,frag)
1783                subFrag=Element(OM('Phenomenon'))
1784                Phenomenon.toXML(self.parameter,subFrag)
1785                if subFrag.attrib != frag.attrib:
1786                    frag.append(subFrag)
1787                csmlFrag.append(frag)
1788               
1789               
1790                #frag.attrib[XLINK('href')] = self.href
1791
1792        return csmlFrag
1793
1794   
1795class AbstractStaticCoverageFeature(AbstractCoverageFeature):
1796    #CSML Abstract Static Coverage FT class
1797    def __init__(self,*args,**kwargs):
1798        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1799    def fromXML(self,csmlFrag):
1800        AbstractCoverageFeature.fromXML(self,csmlFrag)
1801    def toXML(self,csmlFrag):
1802        AbstractCoverageFeature.toXML(self,csmlFrag)
1803        return csmlFrag
1804   
1805class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
1806    #CSML Abstract Series Coverage FT class
1807    def __init__(self,*args,**kwargs):
1808        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1809    def fromXML(self,csmlFrag):
1810        AbstractCoverageFeature.fromXML(self,csmlFrag)
1811    def toXML(self,csmlFrag):
1812        AbstractCoverageFeature.toXML(self,csmlFrag)
1813        return csmlFrag
1814   
1815class AbstractDomain:
1816    #CSML AbstractDomain class
1817    #   AbstractDomain()
1818    #   +csml:domainReference
1819    #   +csml:domainComplement [0...1]
1820       
1821    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
1822        if domainReference:
1823            self.domainReference=domainReference
1824        if domainComplement:
1825            self.domainComplement=domainComplement
1826    def fromXML(self,csmlFrag):
1827        for frag in csmlFrag.getchildren():
1828            if frag.tag == CSML('domainReference'):
1829                subfrag=frag.getchildren()[0]
1830                if subfrag.tag==CSML('Position'):
1831                    self.domainReference=Position()
1832                elif subfrag.tag == CSML('Trajectory'):
1833                    self.domainReference=Trajectory()
1834                elif subfrag.tag==CSML('OrientedPosition'):
1835                    self.domainReference=OrientedPosition()
1836                elif subfrag.tag == CSML('OrientedTrajectory'):
1837                    self.domainReference=OrientedTrajectory()
1838                elif subfrag.tag == GML('TimeInstant'):
1839                    self.domainReference=TimeInstant()
1840                elif subfrag.tag == GML('TimePositionList'):
1841                    self.domainReference=TimePositionList()
1842                self.domainReference.fromXML(subfrag)
1843               
1844            if frag.tag == CSML('domainComplement'):
1845                subfrag=frag.getchildren()[0]
1846                if subfrag.tag==CSML('DirectPositionList'):
1847                    self.domainComplement=DirectPositionList()
1848                    self.domainComplement.fromXML(subfrag)
1849                elif subfrag.tag==CSML('Grid'):
1850                    self.domainComplement=Grid()
1851                    self.domainComplement.fromXML(subfrag)
1852    def toXML(self,csmlFrag):
1853        if hasattr(self,'domainReference'):
1854            frag = Element(CSML('domainReference'))
1855            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
1856            #self.domainReference.toXML(frag)
1857            if isinstance(self.domainReference,OrientedPosition):
1858                subFrag=Element(CSML('OrientedPosition'))
1859                self.domainReference.toXML(subFrag)
1860                frag.append(subFrag)
1861                csmlFrag.append(frag)
1862            elif isinstance(self.domainReference,OrientedTrajectory):
1863                subFrag=Element(CSML('OrientedTrajectory'))
1864                self.domainReference.toXML(subFrag)
1865                frag.append(subFrag)
1866                csmlFrag.append(frag)       
1867            elif isinstance(self.domainReference,Position):
1868                subFrag=Element(CSML('Position'))
1869                self.domainReference.toXML(subFrag)
1870                frag.append(subFrag)
1871                csmlFrag.append(frag)
1872            elif isinstance(self.domainReference,Trajectory):
1873                subFrag=Element(CSML('Trajectory'))
1874                self.domainReference.toXML(subFrag)
1875                frag.append(subFrag)
1876                csmlFrag.append(frag)
1877            elif isinstance(self.domainReference,TimeInstant):
1878                subFrag=Element(GML('TimeInstant'))
1879                self.domainReference.toXML(subFrag)
1880                frag.append(subFrag)
1881                csmlFrag.append(frag)
1882            elif isinstance(self.domainReference,TimePositionList):
1883                subFrag=Element(GML('TimePositionList'))
1884                self.domainReference.toXML(subFrag)
1885                frag.append(subFrag)
1886                csmlFrag.append(frag)   
1887        if hasattr(self,'domainComplement'):
1888            frag = Element(CSML('domainComplement'))
1889            if isinstance(self.domainComplement,DirectPositionList):
1890                    subFrag=Element(CSML('DirectPositionList'))
1891                    self.domainComplement.toXML(subFrag)
1892                    frag.append(subFrag)
1893                    csmlFrag.append(frag)
1894            elif isinstance(self.domainComplement,Grid):
1895                    subFrag=Element(CSML('Grid'))
1896                    self.domainComplement.toXML(subFrag)
1897                    frag.append(subFrag)
1898                    csmlFrag.append(frag)
1899        return csmlFrag
1900
1901
1902class EnvelopeWithTimePeriod:
1903    # CSML EnvelopeWithTimePeriod class
1904    # EnvelopeWithTimePeriod():
1905        # +gml:lowerCorner
1906        # +gml:upperCorner
1907        # +gml:timePosition [2] ?
1908       
1909    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
1910        if srsName:
1911            self.srsName=srsName
1912        if lowerCorner:
1913            self.lowerCorner=lowerCorner
1914        if upperCorner:
1915            self.upperCorner=upperCorner
1916        if timePosition:
1917            self.timePosition=timePosition
1918        if timePosition2:
1919            self.timePosition2=timePosition2
1920    def fromXML(self,csmlFrag):
1921        EnvTPfrag=csmlFrag.getchildren()[0]
1922        for frag in EnvTPfrag.getchildren():
1923            if frag.attrib.has_key('srsName'):
1924                self.srsName=frag.attrib['srsName']
1925            if frag.tag == GML('lowerCorner'):
1926                self.lowerCorner=frag.text
1927            if frag.tag == GML('upperCorner'):
1928                self.upperCorner=frag.text
1929            if frag.tag == GML('timePosition'):
1930                if hasattr(self, 'timePosition'):
1931                    self.timePosition2=frag.text
1932                else:
1933                    self.timePosition=frag.text
1934    def toXML(self,csmlFrag):
1935        if hasattr(self,'srsName'):
1936            csmlFrag.attrib['srsName'] = self.srsName
1937        if hasattr(self,'lowerCorner'):
1938            frag=Element(GML('lowerCorner'))
1939            frag.text=self.lowerCorner
1940            csmlFrag.append(frag)
1941        if hasattr(self,'upperCorner'):
1942            frag=Element(GML('upperCorner'))
1943            frag.text=self.upperCorner
1944            csmlFrag.append(frag)
1945        if hasattr(self,'timePosition'):
1946            frag=Element(GML('timePosition'))
1947            frag.text=self.timePosition
1948            csmlFrag.append(frag)
1949        if hasattr(self,'timePosition2'):
1950            frag=Element(GML('timePosition'))
1951            frag.text=self.timePosition2
1952            csmlFrag.append(frag)
1953        return csmlFrag
1954
1955
1956       
1957class AngleList:
1958    #Should really inherit from MeasureList, but not implemented.
1959    #class AngleList
1960    #+uom[1]:anyURI
1961    #+double[0...1]
1962    def __init__(self,uom=None, vals=None):
1963        if uom:
1964            self.uom=uom
1965        if vals:
1966            self.vals=vals
1967    def fromXML(self,csmlFrag):
1968        self.vals=csmlFrag.text
1969        if csmlFrag.attrib.has_key('uom'):
1970            self.uom = csmlFrag.attrib['uom']
1971    def toXML(self, csmlFrag):
1972        if hasattr(self,'vals'):
1973            csmlFrag.text = self.vals
1974        if hasattr(self,'uom'):
1975            csmlFrag.attrib[('uom')] = self.uom
1976        return csmlFrag
1977       
1978class DirectionVectorList:
1979    def __init__(self, horizontalAngle=None, verticalAngle=None):
1980        if horizontalAngle:
1981            self.horizontalAngle=horizontalAngle
1982        if verticalAngle:
1983            self.verticalAngle=verticalAngle
1984    def fromXML(self, csmlFrag):
1985        for frag in csmlFrag.getchildren():
1986            if frag.tag==GML('horizontalAngle'):
1987                self.horizontalAngle=AngleList()
1988                AngleList.fromXML(self.horizontalAngle,frag)
1989            elif frag.tag==GML('verticalAngle'):
1990                self.verticalAngle=AngleList()
1991                AngleList.fromXML(self.verticalAngle,frag)
1992    def toXML(self,csmlFrag):
1993         if hasattr(self,'horizontalAngle'):
1994            frag = Element(GML('horizontalAngle'))
1995            AngleList.toXML(self.horizontalAngle,frag)
1996            csmlFrag.append(frag)
1997         if hasattr(self,'verticalAngle'):
1998            frag = Element(GML('verticalAngle'))
1999            AngleList.toXML(self.verticalAngle,frag)
2000            csmlFrag.append(frag)
2001         return csmlFrag
2002
2003       
2004class Position:
2005    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
2006        if srsName:
2007            self.srsName=srsName
2008        if axisLabels:
2009            self.axisLabels=axisLabels
2010        if uomLabels:
2011            self.uomLabels=uomLabels
2012        if location:
2013            self.location=location
2014        if time:
2015            self.time = time
2016    def fromXML(self,csmlFrag):
2017        if csmlFrag.attrib.has_key('srsName'):           
2018            self.srsName = csmlFrag.attrib['srsName']
2019        if csmlFrag.attrib.has_key('axisLabels'):
2020            self.axisLabels = csmlFrag.attrib['axisLabels']
2021            if csmlFrag.attrib.has_key('uomLabels'):
2022                self.uomLabels = csmlFrag.attrib['uomLabels']
2023        for frag in csmlFrag.getchildren():
2024            if frag.tag==CSML('location'):
2025                self.location=frag.text
2026            if frag.tag==CSML('time'):
2027                self.time=frag.text
2028    def toXML(self,csmlFrag):
2029        #subFrag = Element(CSML('Position'))
2030        if hasattr(self,'uomLabels'):
2031            csmlFrag.attrib['uomLabels'] = self.uomLabels
2032        if hasattr(self,'axisLabels'):
2033            csmlFrag.attrib['axisLabels'] = self.axisLabels
2034        if hasattr(self,'srsName'):
2035            csmlFrag.attrib['srsName'] = self.srsName
2036        if hasattr(self,'location'):
2037            frag = Element(CSML('location'))
2038            frag.text=self.location
2039            csmlFrag.append(frag)
2040        if hasattr(self,'time'):
2041            frag = Element(CSML('time'))
2042            frag.text=self.time
2043            csmlFrag.append(frag)
2044        return csmlFrag
2045
2046class OrientedPosition(Position):
2047    def __init__(self, direction=None, *args,**kwargs):
2048        Position.__init__(self, *args,**kwargs)
2049        if direction:
2050            self.direction=direction
2051    def fromXML(self,csmlFrag):
2052        Position.fromXML(self, csmlFrag)
2053        for frag in csmlFrag.getchildren():
2054            if frag.tag==CSML('direction'):
2055                self.direction=DirectionVectorList()
2056                DirectionVectorList.fromXML(self.direction,frag)
2057    def toXML(self, csmlFrag):
2058        Position.toXML(self,csmlFrag)
2059        if hasattr(self,'direction'):
2060            frag = Element(CSML('direction'))
2061            DirectionVectorList.toXML(self.direction,frag)
2062            csmlFrag.append(frag)
2063        return csmlFrag
2064       
2065
2066
2067class Trajectory(SRSReferenceGroup):
2068    def __init__(self,locations=None,times=None,*args,**kwargs):
2069
2070        if locations:
2071            self.locations=locations
2072        if times:
2073            self.times = times
2074        SRSReferenceGroup.__init__(self,*args,**kwargs)
2075    def fromXML(self,csmlFrag):
2076        SRSReferenceGroup.fromXML(self,csmlFrag)
2077        for frag in csmlFrag.getchildren():
2078            if frag.tag==CSML('locations'):
2079                self.locations=DirectPositionList()
2080                DirectPositionList.fromXML(self.locations,frag)
2081            if frag.tag==CSML('times'):
2082                self.times=TimePositionList()
2083                TimePositionList.fromXML(self.times,frag)
2084    def toXML(self,csmlFrag):
2085        SRSReferenceGroup.toXML(self,csmlFrag)
2086        if hasattr(self,'srsName'):
2087            csmlFrag.attrib['srsName'] = self.srsName
2088        if hasattr(self,'locations'):
2089            frag = Element(CSML('locations'))
2090            frag=DirectPositionList.toXML(self.locations,frag)
2091            csmlFrag.append(frag)
2092        if hasattr(self,'times'):
2093            frag = Element(CSML('times'))
2094            TimePositionList.toXML(self.times, frag)
2095            csmlFrag.append(frag)
2096        return csmlFrag
2097
2098class OrientedTrajectory(Trajectory):
2099    def __init__(self, direction=None, *args,**kwargs):
2100        Trajectory.__init__(self, *args,**kwargs)
2101        if direction:
2102             self.direction=direction
2103    def fromXML(self,csmlFrag):
2104        Trajectory.fromXML(self, csmlFrag)
2105        for frag in csmlFrag.getchildren():
2106            if frag.tag==CSML('direction'):
2107                self.direction=DirectionVectorList()
2108                DirectionVectorList.fromXML(self.direction,frag)
2109    def toXML(self, csmlFrag):
2110        Trajectory.toXML(self,csmlFrag)
2111        if hasattr(self,'direction'):
2112            frag = Element(CSML('direction'))
2113            DirectionVectorList.toXML(self.direction,frag)
2114            csmlFrag.append(frag)
2115        return csmlFrag
2116
2117class AbstractGeometryType(AbstractGML):
2118    def __init__(self, low=None, high=None):
2119        AbstractGML.__init__(self)
2120        if low:
2121            self.low=low
2122        if high:
2123            self.high=high
2124    def fromXML(self, csmlFrag):
2125        AbstractGML.fromXML(self,csmlFrag)
2126    def toXML(self,csmlFrag):
2127        AbstractGML.toXML(self,csmlFrag)
2128        return csmlFrag
2129
2130class GridEnvelope:
2131    def __init__(self, low=None, high = None):
2132        if low:
2133            self.low = low
2134        if high:
2135            self.high = high
2136    def fromXML(self, csmlFrag):
2137        frag = csmlFrag.getchildren()[0]
2138        for subFrag in frag.getchildren():
2139            if subFrag.tag == GML('low'):
2140                self.low=subFrag.text
2141            elif subFrag.tag == GML('high'):
2142                self.high=subFrag.text
2143    def toXML(self,csmlFrag):
2144        if hasattr(self, 'low'):
2145            frag=Element(GML('low'))
2146            frag.text=self.low
2147            csmlFrag.append(frag)
2148        if hasattr(self, 'high'):
2149            frag=Element(GML('high'))
2150            frag.text=self.high
2151            csmlFrag.append(frag)
2152        return csmlFrag
2153
2154class GmlGrid(AbstractGeometryType):
2155    #Class GmlGrid, representing a gml:Grid element.
2156    #  +dimension positiveInteger [1]
2157    # +gml:limits  (gml:GridLimitsType) </gml:limits> [1]
2158    #+gml:axisNames  (string) [1..*]
2159    def __init__(self,dimension=None,limits=None,axisNames=None):
2160        AbstractGeometryType.__init__(self)
2161        if dimension:
2162            self.dimension=dimension
2163        if limits:
2164            self.limits=limits
2165        if axisNames:
2166            self.axisNames=axisNames
2167    def fromXML(self, csmlFrag):
2168        AbstractGeometryType.fromXML(self,csmlFrag)
2169        for frag in csmlFrag.getchildren():
2170            if frag.tag == GML('limits'):
2171                self.limits=GridEnvelope()
2172                GridEnvelope.fromXML(self.limits,frag)
2173            elif frag.tag == GML('axisName'):
2174                checkArrayAttrib(self,'axisNames')
2175                self.axisNames.append(frag.text)
2176    def toXML(self,csmlFrag):
2177        AbstractGeometryType.toXML(self,csmlFrag)
2178        if hasattr(self, 'limits'):
2179            frag=Element(GML('limits'))
2180            subFrag =Element(GML('GridEnvelope'))
2181            GridEnvelope.toXML(self.limits, subFrag)
2182            frag.append(subFrag)
2183            csmlFrag.append(frag)
2184        if hasattr(self, 'axisNames'):
2185            for axis in self.axisNames:
2186                frag=Element(GML('axisName'))
2187                frag.text =axis
2188                csmlFrag.append(frag)
2189        return csmlFrag
2190           
2191class GridOrdinateDescription:
2192    #Class GridOrdinateDescription:
2193        #+gridAxesSpanned
2194        #+sequenceRule
2195        #+definesAxis,attrib -href
2196        #+axisValues
2197
2198    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
2199        if gridAxesSpanned:
2200            self.gridAxesSpanned=gridAxesSpanned
2201        if sequenceRule:
2202            self.sequenceRule=sequenceRule
2203        if definesAxis:
2204            self.definesAxis=definesAxis
2205            if href:
2206                self.href = href
2207        if axisValues:
2208            self.axisValues=axisValues
2209       
2210    def fromXML(self,csmlFrag):
2211        for frag in csmlFrag.getchildren():
2212            if frag.tag ==CSML('gridAxesSpanned'):
2213                self.gridAxesSpanned=frag.text
2214            elif frag.tag ==CSML('sequenceRule'):
2215                self.sequenceRule=frag.text
2216            elif frag.tag ==CSML('definesAxis'):
2217                self.definesAxis=frag.text
2218                if frag.attrib.has_key(XLINK('href')):
2219                        self.href = frag.attrib[XLINK('href')]
2220            elif frag.tag ==CSML('axisValues'):
2221                if frag.getchildren() !=[]:
2222                    subFrag= frag.getchildren()[0]
2223                    if subFrag.tag == CSML ('NetCDFExtract'):
2224                        self.axisValues=NetCDFExtract()
2225                        NetCDFExtract.fromXML(self.axisValues, subFrag)
2226                else:
2227                    self.axisValues=frag.text
2228                   
2229               
2230    def toXML(self, csmlFrag):
2231        if hasattr(self, 'gridAxesSpanned'):
2232            frag=Element(CSML('gridAxesSpanned'))
2233            frag.text = self.gridAxesSpanned
2234            csmlFrag.append(frag)
2235        if hasattr(self, 'sequenceRule'):
2236            frag=Element(CSML('sequenceRule'))
2237            frag.text = self.sequenceRule
2238            csmlFrag.append(frag)
2239        if hasattr(self, 'definesAxis'):
2240            frag=Element(CSML('definesAxis'))
2241            frag.text = self.definesAxis
2242            if hasattr(self, 'href'):
2243                frag.attrib[XLINK('href')] = self.href
2244            csmlFrag.append(frag)
2245        if hasattr(self, 'axisValues'):
2246            frag=Element(CSML('axisValues'))
2247            if isinstance(self.axisValues,NetCDFExtract):
2248                subFrag=Element(CSML('NetCDFExtract'))
2249                NetCDFExtract.toXML(self.axisValues,subFrag)
2250                frag.append(subFrag)
2251            else:
2252                frag.text = self.axisValues
2253            csmlFrag.append(frag)
2254        return csmlFrag
2255
2256
2257class Grid(GmlGrid):
2258#Class GmlGrid representing a gml:Grid
2259# + dimension(attrib) [1]
2260#  +ordinate [1..*]
2261    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
2262        GmlGrid.__init__(self)
2263        if srsName:
2264            self.srsName=srsName
2265        if srsDimension:
2266            self.srsDimension=srsDimension
2267        if dimension:
2268            self.dimension=dimension
2269        if ordinates:
2270            self.ordinates=ordinates
2271    def fromXML(self, csmlFrag):
2272        GmlGrid.fromXML(self,csmlFrag)
2273        if csmlFrag.attrib.has_key('srsName'):
2274            self.srsName = csmlFrag.attrib['srsName']
2275        if csmlFrag.attrib.has_key('srsDimension'):
2276            self.srsDimension = csmlFrag.attrib['srsDimension']
2277        if csmlFrag.attrib.has_key('dimension'):
2278            self.dimension = csmlFrag.attrib['dimension']
2279        for frag in csmlFrag:
2280            if frag.tag==CSML('ordinate'):
2281                checkArrayAttrib(self,'ordinates')
2282                ordinate=GridOrdinateDescription()
2283                GridOrdinateDescription.fromXML(ordinate, frag)
2284                self.ordinates.append(ordinate)
2285    def toXML(self,csmlFrag):
2286        GmlGrid.toXML(self,csmlFrag)
2287        if hasattr(self, 'srsName'):
2288            csmlFrag.attrib['srsName'] = self.srsName
2289        if hasattr(self, 'srsDimension'):
2290            csmlFrag.attrib['srsDimension'] = self.srsDimension
2291        if hasattr(self, 'dimension'):
2292            csmlFrag.attrib['dimension'] = self.dimension
2293       
2294        if hasattr(self, 'ordinates'):
2295            for ordinate in self.ordinates:
2296                frag=Element(CSML('ordinate'))
2297                GridOrdinateDescription.toXML(ordinate, frag)
2298                csmlFrag.append(frag)
2299        return csmlFrag
2300
2301class TimeInstant:
2302    def __init__(self, timePosition=None):
2303        if timePosition:
2304            self.timePosition=timePosition
2305    def fromXML(self,csmlFrag):
2306        for frag in csmlFrag.getchildren():
2307            if frag.tag==GML('timePosition'):
2308                self.timePosition=frag.text
2309    def toXML(self,csmlFrag):
2310         if hasattr(self,'timePosition'):
2311            frag = Element(GML('timePosition'))
2312            frag.text=self.timePosition
2313            csmlFrag.append(frag)
2314         return csmlFrag
2315
2316class TimePositionList(AssociationAttributeGroup):
2317              #class TimePositionList
2318              #+frame[0..1]:anyURI
2319              # + calendarEraName [0..1]:string (not implemented)
2320              # +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType  (not implemented)
2321    def __init__(self, frame=None, timePositions=None,*args, **kwargs):
2322        if frame:
2323            self.frame=frame
2324        if timePositions:
2325            self.timePositions=timePositions
2326        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2327    def fromXML(self,csmlFrag):
2328        self.timePositions=csmlFrag.text
2329        if csmlFrag.attrib.has_key('frame'):
2330            self.frame = csmlFrag.attrib['frame']
2331        AssociationAttributeGroup.fromXML(self,csmlFrag)
2332    def toXML(self,csmlFrag):
2333         if hasattr(self,'timePositions'):
2334            csmlFrag.text=self.timePositions
2335         if hasattr(self,'frame'):
2336             csmlFrag.attrib['frame']=self.frame
2337         AssociationAttributeGroup.toXML(self,csmlFrag)
2338         return csmlFrag
2339             
2340class Measure:
2341    def __init__(self, uom=None, vals=None):
2342        if uom:
2343            self.uom=uom
2344        if vals:
2345            self.vals=vals
2346    def fromXML(self,csmlFrag):
2347        self.vals=csmlFrag.text
2348        if csmlFrag.attrib.has_key('uom'):
2349            self.uom = csmlFrag.attrib['uom']
2350    def toXML(self, csmlFrag):
2351        frag = Element(GML('measure'))
2352        if hasattr(self, 'vals'):
2353            frag.text = self.vals
2354        if hasattr(self,'uom'):
2355            frag.attrib[('uom')] = self.uom
2356        csmlFrag.append(frag)
2357        return csmlFrag
2358
2359class MeasureOrNullList:
2360    #class MeasureOrNullList:
2361    # +uom[1]:anyURI
2362    #Actually based on doubleOrNullList, but not modelled to that level of detail.
2363   
2364    def __init__(self, uom=None, val=None):
2365        if uom:
2366            self.uom=uom
2367        if val:
2368            self.val=val
2369    def fromXML(self,csmlFrag):
2370        self.val=csmlFrag.text
2371        if csmlFrag.attrib.has_key('uom'):
2372            self.uom = csmlFrag.attrib['uom']
2373    def toXML(self, csmlFrag):
2374        if hasattr(self,'val'):
2375            csmlFrag.text = self.val
2376        if hasattr(self,'uom'):
2377           csmlFrag.attrib[('uom')] = self.uom
2378        return csmlFrag
2379   
2380class CompositeValue:
2381    def __init__(self, valueComponents=None):
2382        if valueComponents:
2383            self.valueComponents=valueComponents
2384    def fromXML(self,csmlFrag):
2385        for frag in csmlFrag.getchildren():
2386            if frag.tag == GML('valueComponents'):
2387                self.valueComponents = []
2388                for subFrag in frag.getchildren():                   
2389                    if subFrag.tag == GML('measure'):
2390                        self.valueComponents.append(Measure())
2391                        self.valueComponents[-1].fromXML(subFrag)
2392
2393    def toXML(self, csmlFrag):
2394         if hasattr(self,'valueComponents'):
2395            frag=Element(GML('valueComponents'))
2396            for valueComponent in self.valueComponents:
2397                if isinstance(valueComponent,Measure):
2398                    subFrag=Element(GML('measure'))
2399                    Measure.toXML(valueComponent,subFrag)
2400                    frag.append(subFrag)
2401            csmlFrag.append(frag)
2402         return csmlFrag
2403   
2404
2405   
2406class DataBlock:
2407    #class GML DataBlock
2408   
2409    #DataBlock()
2410    #+gml:rangeParameters
2411    def __init__(self,rangeParameters=None, doubleOrNullTupleList=None):
2412        if rangeParameters:
2413            self.rangeParameters=rangeParameters
2414        if doubleOrNullTupleList:
2415            self.doubleOrNullTupleList=doubleOrNullTupleList
2416    def fromXML(self,csmlFrag):
2417        for frag in csmlFrag.getchildren():
2418            if frag.tag == GML('rangeParameters'):
2419                for subFrag in frag.getchildren():
2420                    if subFrag.tag==GML('CompositeValue'):
2421                        self.rangeParameters=CompositeValue()
2422                        CompositeValue.fromXML(self.rangeParameters,subFrag)
2423            if frag.tag == GML('doubleOrNullTupleList'):
2424                self.doubleOrNullTupleList=frag.text
2425    def toXML(self,csmlFrag):
2426        if hasattr(self, 'rangeParameters'):
2427            frag=Element(GML('rangeParameters'))
2428            subFrag=Element(GML('CompositeValue'))
2429            CompositeValue.toXML(self.rangeParameters, subFrag)
2430            frag.append(subFrag)
2431            csmlFrag.append(frag)
2432        if hasattr(self,'doubleOrNullTupleList'):
2433            frag=Element(GML('doubleOrNullTupleList'))
2434            frag.text=self.doubleOrNullTupleList
2435            csmlFrag.append(frag)
2436        return csmlFrag
2437
2438
2439
2440class TypedCategory:
2441#class om:TypedCategory
2442    # +axis (attrib)
2443    # + codeSpace (attrib)
2444    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
2445        if axis:
2446            self.axis=axis
2447        if codeSpace:
2448            self.codeSpace=codeSpace
2449        if text:
2450            self.text=text
2451    def fromXML(self,csmlFrag):
2452        if csmlFrag.attrib.has_key('axis'):
2453            self.axis=csmlFrag.attrib['axis']
2454        if csmlFrag.attrib.has_key('codeSpace'):
2455            self.codeSpace=csmlFrag.attrib['codeSpace']
2456        self.text=csmlFrag.text
2457    def toXML(self,csmlFrag):
2458        if hasattr(self,'axis'):
2459            csmlFrag.attrib[('axis')] =self.axis
2460        if hasattr(self,'codeSpace'):
2461            csmlFrag.attrib[('codeSpace')] =self.codeSpace
2462        csmlFrag.text=self.text
2463        return csmlFrag
2464
2465class Phenomenon(Definition,AssociationAttributeGroup):
2466    #class Obs& Measures: PhenomenonProperty
2467    #Note, in this does not really inherit from AbstractGML, but for CMSL
2468    #purposes it is used  to pick up the basic description, id, name attributes
2469    def __init__(self,*args,**kwargs):
2470         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
2471        self.MetaDataProperty=None
2472        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
2473        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2474    def fromXML(self,csmlFrag):
2475        Definition.fromXML(self,csmlFrag)
2476        AssociationAttributeGroup.fromXML(self,csmlFrag)
2477       
2478    def toXML(self,csmlFrag):
2479        csmlFrag=Definition.toXML(self,csmlFrag)
2480        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2481        return csmlFrag
2482
2483
2484class OLD_CompositePhenomenon(Phenomenon):
2485    #Class om:CompositePhenomenon
2486    # + om:componentPhenomenon [1...*]
2487    def __init__(self,componentPhenomenon=None,*args,**kwargs):
2488        Phenomenon.__init__(self,*args,**kwargs)
2489        if componentPhenomenon:
2490            self.componentPhenomenon=componentPhenomenon
2491    def fromXML(self,csmlFrag):
2492        Phenomenon.fromXML(self,csmlFrag)
2493        for frag in csmlFrag.getchildren():
2494            if frag.tag == OM('componentPhenomenon'):
2495                checkArrayAttrib(self,'componentPhenomenon')
2496                self.componentPhenomenon.append(frag.attrib)
2497    def toXML(self,csmlFrag):
2498        Phenomenon.toXML(self,csmlFrag)
2499        if hasattr(self, 'componentPhenomenon'):
2500            for cp in self.componentPhenomenon:
2501                frag=Element(OM('componentPhenomenon'))
2502                frag.attrib= cp
2503                csmlFrag.append(frag)
2504        return csmlFrag
2505
2506class CompositePhenomenon(Phenomenon):
2507    #Class om:CompositePhenomenon
2508    # + om:componentPhenomenon [1...*]
2509    def __init__(self,componentPhenomena=None,*args,**kwargs):
2510        Phenomenon.__init__(self,*args,**kwargs)
2511        if componentPhenomena:
2512            self.componentPhenomena=componentPhenomena
2513    def fromXML(self,csmlFrag):
2514        Phenomenon.fromXML(self,csmlFrag)
2515        self.componentPhenomena=[]
2516        for frag in csmlFrag.getchildren():
2517            if frag.tag == OM('componentPhenomenon'):
2518                componentPhenomenon=Phenomenon()
2519                Phenomenon.fromXML(componentPhenomenon,frag)
2520                self.componentPhenomena.append(componentPhenomenon)
2521    def toXML(self,csmlFrag):
2522        Phenomenon.toXML(self,csmlFrag)
2523        if hasattr(self, 'componentPhenomena'):
2524            for phenomenon in self.componentPhenomena:
2525                frag=Element(OM('componentPhenomenon'))
2526                Phenomenon.toXML(phenomenon,frag)
2527                csmlFrag.append(frag)
2528        return csmlFrag
2529           
2530               
2531class ParameterisedPhenomenon(Phenomenon):
2532    #Class ParameterisedPhenomenon:
2533        # + basePhenomenon
2534        # + constraint
2535        # + href (attrib)
2536    def __init__(self,*args,**kwargs):
2537        Phenomenon.__init__(self,*args,**kwargs)
2538    def fromXML(self,csmlFrag):
2539        Phenomenon.fromXML(self,csmlFrag)
2540        for frag in csmlFrag.getchildren():
2541            if frag.tag == OM('basePhenomenon'):
2542                self.basePhenomenon=frag.text
2543                if frag.attrib.has_key(XLINK('href')):
2544                    self.href = frag.attrib[XLINK('href')]
2545            if frag.tag == OM('constraint'):
2546                subFrag=frag.getchildren()[0]
2547                if subFrag.tag== OM('TypedCategory'):
2548                    self.constraint = TypedCategory()
2549                #TO DO: what other types are valid?
2550                elif subFrag.tag== OM('??'):
2551                    self.constraint = 123
2552                self.constraint.fromXML(subFrag)
2553    def toXML(self,csmlFrag):
2554        csmlFrag=Phenomenon.toXML(self,csmlFrag)
2555        if hasattr(self,'basePhenomenon'):
2556            frag=Element(OM('basePhenomenon'))
2557            frag.text=self.basePhenomenon
2558            if hasattr(self, 'href'):
2559                frag.attrib[XLINK('href')] = self.href
2560            csmlFrag.append(frag)
2561        if hasattr(self, 'constraint'):
2562            frag=Element(OM('constraint'))
2563            subFrag=Element(OM('TypedCategory'))
2564            subFrag=self.constraint.toXML(subFrag)
2565            frag.append(subFrag)
2566            csmlFrag.append(frag)
2567        return csmlFrag
2568
2569class RangeSet:
2570#class GML RangeSet 
2571
2572        # RangeSet()
2573        # +gml:ValueArray
2574        # +gml:_ScalarValueList
2575        # +gml:DataBlock
2576        # +gml:File
2577    #class GML RangeSet
2578    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None):
2579        if quantityList:
2580            self.quantityList=quantityList
2581        if dataBlock:
2582            self.dataBlock=dataBlock
2583        if arrayDescriptor:
2584            self.arrayDescriptor=arrayDescriptor
2585        if aggregatedArray:
2586            self.aggregatedArray=aggregatedArray
2587           
2588    def fromXML(self,csmlFrag):
2589        for frag in csmlFrag.getchildren():
2590            if frag.tag==GML('QuantityList'):
2591                self.quantityList=MeasureOrNullList()
2592                MeasureOrNullList.fromXML(self.quantityList,frag)
2593            elif frag.tag==GML('DataBlock'):
2594                self.dataBlock=DataBlock()
2595                DataBlock.fromXML(self.dataBlock, frag)
2596            elif frag.tag == CSML('NetCDFExtract'):
2597                self.arrayDescriptor=NetCDFExtract()
2598                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
2599            elif frag.tag == CSML('NASAmesExtract'):
2600                self.arrayDescriptor=NASAAmesExtract()
2601                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
2602            elif frag.tag == CSML('GRIBExtract'):
2603                self.arrayDescriptor=GRIBExtract()
2604                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
2605            elif frag.tag == CSML('AggregatedArray'):
2606                self.aggregatedArray=AggregatedArray()
2607                AggregatedArray.fromXML(self.aggregatedArray,frag)
2608    def toXML(self, csmlFrag):
2609        if hasattr(self,'quantityList'):
2610            frag = Element(GML('QuantityList'))
2611            MeasureOrNullList.toXML(self.quantityList,frag)
2612            csmlFrag.append(frag)
2613        if hasattr(self,'dataBlock'):
2614            frag=Element(GML('DataBlock'))
2615            DataBlock.toXML(self.dataBlock,frag)
2616            csmlFrag.append(frag)
2617        if hasattr(self,'aggregatedArray'):
2618            frag=Element(CSML('AggregatedArray'))
2619            AggregatedArray.toXML(self.aggregatedArray,frag)
2620            csmlFrag.append(frag)
2621        if hasattr(self,'arrayDescriptor'):
2622            if isinstance(self.arrayDescriptor,NetCDFExtract):
2623                frag=Element(CSML('NetCDFExtract'))
2624                NetCDFExtract.toXML(self.arrayDescriptor,frag)
2625                csmlFrag.append(frag)
2626            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
2627                frag=Element(CSML('NASAAmesExtract'))
2628                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
2629                csmlFrag.append(frag)
2630            elif isinstance(self.arrayDescriptor,GRIBExtract):
2631                frag=Element(CSML('GRIBExtract'))
2632                GRIBAmesExtract.toXML(self.arrayDescriptor,frag)
2633                csmlFrag.append(frag)
2634               
2635        return csmlFrag
2636
2637class PointDomain(AbstractDomain):
2638    def __init__(self,*args,**kwargs):
2639        AbstractDomain.__init__(self,*args,**kwargs)
2640    def fromXML(self,csmlFrag):
2641        AbstractDomain.fromXML(self,csmlFrag)
2642    def toXML(self,csmlFrag):
2643        AbstractDomain.toXML(self,csmlFrag)
2644        return csmlFrag
2645   
2646class ProfileDomain(AbstractDomain):
2647    def __init__(self,*args,**kwargs):
2648        AbstractDomain.__init__(self,*args,**kwargs)
2649    def fromXML(self,csmlFrag):
2650        AbstractDomain.fromXML(self,csmlFrag)
2651    def toXML(self,csmlFrag):
2652        AbstractDomain.toXML(self,csmlFrag)
2653        return csmlFrag
2654
2655class GridDomain(AbstractDomain):
2656    def __init__(self,*args,**kwargs):
2657        AbstractDomain.__init__(self,*args,**kwargs)
2658    def fromXML(self,csmlFrag):
2659        AbstractDomain.fromXML(self,csmlFrag)
2660    def toXML(self,csmlFrag):
2661        AbstractDomain.toXML(self,csmlFrag)
2662        return csmlFrag
2663   
2664class PointSeriesDomain(AbstractDomain):
2665    def __init__(self,*args,**kwargs):
2666        AbstractDomain.__init__(self,*args,**kwargs)
2667    def fromXML(self,csmlFrag):
2668        AbstractDomain.fromXML(self,csmlFrag)
2669    def toXML(self,csmlFrag):
2670        AbstractDomain.toXML(self,csmlFrag)
2671        return csmlFrag
2672   
2673class ProfileSeriesDomain(AbstractDomain):
2674    def __init__(self,*args,**kwargs):
2675        AbstractDomain.__init__(self,*args,**kwargs)
2676    def fromXML(self,csmlFrag):
2677        AbstractDomain.fromXML(self,csmlFrag)
2678    def toXML(self,csmlFrag):
2679        AbstractDomain.toXML(self,csmlFrag)
2680        return csmlFrag
2681   
2682class GridSeriesDomain(AbstractDomain):
2683    def __init__(self,*args,**kwargs):
2684        AbstractDomain.__init__(self,*args,**kwargs)
2685    def fromXML(self,csmlFrag):
2686        AbstractDomain.fromXML(self,csmlFrag)
2687    def toXML(self,csmlFrag):
2688        AbstractDomain.toXML(self,csmlFrag)
2689        return csmlFrag
2690
2691class PointFeature(AbstractStaticCoverageFeature):
2692    #CSML PointFeature class
2693    #       PointFeature(AbstractStaticCoverageFeatureType):
2694    #      +PointDomain
2695    def __init__(self, domain=None,*args,**kwargs):
2696        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2697        if domain:
2698            self.domain=domain
2699    def fromXML(self,csmlFrag):
2700        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2701        for frag in csmlFrag.getchildren():
2702            if frag.tag == CSML('PointDomain'):
2703                self.domain = PointDomain()
2704                self.domain.fromXML(frag)
2705    def toXML(self,csmlFrag):
2706        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2707        if hasattr(self,'domain'):
2708            frag = Element(CSML('PointDomain'))
2709            PointDomain.toXML(self.domain,frag)
2710#             if hasattr(self,'href'):
2711#                 frag.attrib[XLINK('href')] = self.href
2712            csmlFrag.append(frag)
2713        return csmlFrag
2714
2715   
2716class PointSeriesFeature(AbstractSeriesCoverageFeature):
2717    #CSML PointSeriesFeature class
2718    #       PointSeriesFeature(AbstractStaticCoverageFeatureType):
2719    #      +pointSeriesDomain[1]:PointSeriesDomain
2720
2721    def __init__(self,domain=None,*args,**kwargs):
2722        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
2723        if domain:
2724            self.domain=domain
2725    def fromXML(self,csmlFrag):
2726        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
2727        for frag in csmlFrag.getchildren():
2728            if frag.tag == CSML('PointSeriesDomain'):
2729                self.domain = PointSeriesDomain()
2730                self.domain.fromXML(frag)
2731    def toXML(self,csmlFrag):
2732        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
2733        if hasattr(self,'domain'):
2734             frag = Element(CSML('PointSeriesDomain'))
2735             PointSeriesDomain.toXML(self.domain,frag)
2736             csmlFrag.append(frag)
2737        return csmlFrag
2738
2739class ProfileFeature(AbstractStaticCoverageFeature):
2740     #CSML ProfileFeature class
2741    #       ProfileFeature(AbstractStaticCoverageFeature):
2742    #      +profileDomain[1]:ProfileDomain
2743
2744    def __init__(self,domain=None,*args,**kwargs):
2745        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2746        if domain:
2747            self.domain=domain
2748    def fromXML(self,csmlFrag):
2749        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2750        for frag in csmlFrag.getchildren():
2751            if frag.tag == CSML('ProfileDomain'):
2752                self.domain = ProfileDomain()
2753                ProfileDomain.fromXML(self.domain,frag)
2754    def toXML(self,csmlFrag):
2755        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2756        if hasattr(self,'domain'):
2757             frag = Element(CSML('ProfileDomain'))
2758             ProfileDomain.toXML(self.domain,frag)
2759             csmlFrag.append(frag)
2760        return csmlFrag
2761
2762
2763class ProfileSeriesFeature(AbstractStaticCoverageFeature):
2764#CSML ProfileSeriesFeature class
2765    #       ProfileSeriesFeature(AbstractStaticCoverageFeature):
2766    #      +ProfileSeriesDomain
2767
2768    def __init__(self,domain=None,*args,**kwargs):
2769        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2770        if domain:
2771            self.domain=domain
2772    def fromXML(self,csmlFrag):
2773        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2774        for frag in csmlFrag.getchildren():
2775            if frag.tag == CSML('ProfileSeriesDomain'):
2776                self.domain = ProfileSeriesDomain()
2777                ProfileSeriesDomain.fromXML(self.domain,frag)
2778    def toXML(self,csmlFrag):
2779        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2780        if hasattr(self,'domain'):
2781             frag = Element(CSML('ProfileSeriesDomain'))
2782             ProfileSeriesDomain.toXML(self.domain,frag)
2783             csmlFrag.append(frag)
2784        return csmlFrag
2785
2786
2787class GridFeature(AbstractStaticCoverageFeature):
2788#CSML GridFeature class
2789    #       GridFeature(AbstractStaticCoverageFeature):
2790    #      +gridDomain[1]:gridDomain
2791
2792    def __init__(self,domain=None,*args,**kwargs):
2793        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2794        if domain:
2795            self.domain=domain
2796    def fromXML(self,csmlFrag):
2797        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2798        for frag in csmlFrag.getchildren():
2799            if frag.tag == CSML('GridDomain'):
2800                self.domain = GridDomain()
2801                self.domain.fromXML(frag)
2802    def toXML(self,csmlFrag):
2803        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2804        if hasattr(self,'domain'):
2805             frag = Element(CSML('GridDomain'))
2806             GridDomain.toXML(self.domain,frag)
2807             csmlFrag.append(frag)
2808        return csmlFrag
2809
2810
2811class GridSeriesFeature(AbstractStaticCoverageFeature):
2812    def __init__(self,domain=None,*args,**kwargs):
2813        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2814        if domain:
2815            self.domain=domain
2816    def fromXML(self,csmlFrag):
2817        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2818        for frag in csmlFrag.getchildren():
2819            if frag.tag == CSML('GridSeriesDomain'):
2820                self.domain = GridSeriesDomain()
2821                self.domain.fromXML(frag)
2822    def toXML(self,csmlFrag):
2823        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2824        if hasattr(self,'domain'):
2825             frag = Element(CSML('GridSeriesDomain'))
2826             GridSeriesDomain.toXML(self.domain,frag)
2827             csmlFrag.append(frag)
2828        return csmlFrag
2829
2830
2831   
2832class AbstractFeature(AbstractGML):
2833    def __init__(self,boundedBy=None,*args,**kwargs):
2834        AbstractGML.__init__(self,*args,**kwargs)
2835        if boundedBy:
2836            self.boundedBy=boundedBy
2837    def fromXML(self,csmlFrag):
2838        AbstractGML.fromXML(self,csmlFrag)
2839        for frag in csmlFrag.getchildren():
2840            if frag.tag == GML('boundedBy'):
2841                self.boundedBy = EnvelopeWithTimePeriod()
2842                self.boundedBy.fromXML(frag)
2843    def toXML(self,csmlFrag):
2844        AbstractGML.toXML(self,csmlFrag)
2845        if hasattr(self,'boundedBy'):
2846             superfrag = Element(GML('boundedBy'))
2847             frag = Element (GML('EnvelopeWithTimePeriod'))
2848             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
2849             superfrag.append(frag)
2850             csmlFrag.append(superfrag)
2851        return csmlFrag
2852
2853class AbstractGeometryFeature(AbstractFeature):
2854    def __init__(self,*args,**kwargs):
2855        AbstractFeature.__init__(self,*args,**kwargs)
2856    def fromXML(self,csmlFrag):
2857        AbstractFeature.fromXML(self,csmlFrag)
2858    def toXML(self, csmlFrag):
2859        AbstractFeature.toXML(self,csmlFrag)
2860        return csmlFrag
2861
2862
2863class TrajectoryFeature(AbstractGeometryFeature):
2864    def __init__(self,track=None, *args, **kwargs):
2865        AbstractGeometryFeature.__init__(self,*args,**kwargs)
2866        if track:
2867            self.track=track
2868    def fromXML(self,csmlFrag):
2869        AbstractGeometryFeature.fromXML(self,csmlFrag)
2870        for frag in csmlFrag.getchildren():
2871            if frag.tag == CSML('track'):
2872                self.track=Trajectory()
2873                Trajectory.fromXML(self.track,frag)
2874    def toXML(self,csmlFrag):
2875        AbstractGeometryFeature.toXML(self,csmlFrag)
2876        if hasattr(self, 'track'):
2877            frag = Element(CSML('track'))
2878            subFrag=Element(CSML('Trajectory'))
2879            Trajectory.toXML(self.track,subFrag)
2880            frag.append(subFrag)
2881            csmlFrag.append(frag)
2882        return csmlFrag
2883       
2884class AbstractFeatureCollection(AbstractFeature):
2885    """GML AbstractFeatureCollection class
2886
2887    AbstractFeatureCollection(AbstractFeature):
2888     +featureMember[0..*]: AbstractFeature
2889     +featureMembers[0..1]: FeatureArray
2890    """
2891    def __init__(self,members=[]):
2892        if members:
2893            self.members=members
2894    def fromXML(self,csmlFrag):
2895        AbstractFeature.fromXML(self,csmlFrag)
2896        for frag in csmlFrag.getchildren():
2897            if frag.tag == GML('featureMember'):
2898                checkArrayAttrib(self,'members')
2899                featureFrag = frag.getchildren()[0]
2900                if featureFrag.tag == CSML('PointFeature'):
2901                    self.members.append(PointFeature())
2902                    self.members[-1].fromXML(featureFrag)
2903                if featureFrag.tag == CSML('ProfileFeature'):
2904                    self.members.append(ProfileFeature())
2905                    self.members[-1].fromXML(featureFrag)
2906                if featureFrag.tag == CSML('GridFeature'):
2907                    self.members.append(GridFeature())
2908                    self.members[-1].fromXML(featureFrag)
2909                if featureFrag.tag == CSML('PointSeriesFeature'):
2910                    self.members.append(PointSeriesFeature())
2911                    self.members[-1].fromXML(featureFrag)
2912                if featureFrag.tag == CSML('ProfileSeriesFeature'):
2913                    self.members.append(ProfileSeriesFeature())
2914                    self.members[-1].fromXML(featureFrag)
2915                if featureFrag.tag == CSML('GridSeriesFeature'):
2916                    self.members.append(GridSeriesFeature())
2917                    self.members[-1].fromXML(featureFrag)
2918                if featureFrag.tag == CSML('TrajectoryFeature'):
2919                    self.members.append(TrajectoryFeature())
2920                    self.members[-1].fromXML(featureFrag)
2921    def toXML(self,csmlFrag):
2922        AbstractFeature.toXML(self,csmlFrag)
2923        for member in self.members:
2924            if isinstance(member,PointFeature):
2925                superFrag=Element(GML('FeatureMember'))
2926                frag=Element(CSML('PointFeature'))
2927                PointFeature.toXML(member,frag)
2928                superFrag.append(frag)
2929                csmlFrag.append(superFrag)
2930            if isinstance(member,ProfileFeature):
2931                superFrag=Element(GML('FeatureMember'))
2932                frag=Element(CSML('ProfileFeature'))
2933                ProfileFeature.toXML(member,frag)
2934                superFrag.append(frag)
2935                csmlFrag.append(superFrag)
2936            if isinstance(member,GridFeature):
2937                superFrag=Element(GML('FeatureMember'))
2938                frag=Element(CSML('GridFeature'))
2939                GridFeature.toXML(member,frag)
2940                superFrag.append(frag)
2941                csmlFrag.append(superFrag)
2942            if isinstance(member,PointSeriesFeature):
2943                superFrag=Element(GML('FeatureMember'))
2944                frag=Element(CSML('PointSeriesFeature'))
2945                PointSeriesFeature.toXML(member,frag)
2946                superFrag.append(frag)
2947                csmlFrag.append(superFrag)
2948            if isinstance(member,ProfileSeriesFeature):
2949                superFrag=Element(GML('FeatureMember'))
2950                frag=Element(CSML('ProfileSeriesFeature'))
2951                ProfileSeriesFeature.toXML(member,frag)
2952                superFrag.append(frag)
2953                csmlFrag.append(superFrag)
2954            if isinstance(member,GridSeriesFeature):
2955                superFrag=Element(GML('FeatureMember'))
2956                frag=Element(CSML('GridSeriesFeature'))
2957                GridSeriesFeature.toXML(member,frag)
2958                superFrag.append(frag)
2959                csmlFrag.append(superFrag)
2960            if isinstance(member,TrajectoryFeature):
2961                superFrag=Element(GML('FeatureMember'))
2962                frag=Element(CSML('TrajectoryFeature'))
2963                TrajectoryFeature.toXML(member,frag)
2964                superFrag.append(frag)
2965                csmlFrag.append(superFrag)
2966       
2967        return csmlFrag
2968
2969class FeatureCollection(AbstractFeatureCollection):
2970    """GML FeatureCollection class
2971        FeatureCollection()
2972        +FeatureMembers[0..*]
2973    """
2974    def __init__(self,*args,**kwargs):
2975        AbstractFeatureCollection.__init__(self,*args,**kwargs)
2976    def fromXML(self,csmlFrag):
2977        AbstractFeatureCollection.fromXML(self,csmlFrag)
2978    def toXML(self,csmlFrag):
2979        AbstractFeatureCollection.toXML(self,csmlFrag)
2980        return csmlFrag
2981
2982class Dataset(AbstractGML):
2983    """CSML Dataset class
2984
2985    Dataset(AbstractGML):
2986     +unitDefinitions[0..*]: UnitDefinitions
2987     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
2988     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
2989     +arrayDescriptors[0..*]: AbstractArrayDescriptor
2990     +featureCollection[0..1]: FeatureCollection
2991    """
2992    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
2993                 phenomenonDefinitions=None,arrayDescriptors=[],
2994                 featureCollection=None,*args,**kwargs):
2995        AbstractGML.__init__(self,*args,**kwargs)
2996        if unitDefinitions:
2997            self.unitDefinitions = unitDefinitions
2998        if referenceSystemDefinitions:
2999            self.referenceSystemDefinitions = referenceSystemDefinitions
3000        if phenomenonDefinitions:
3001            self.phenomenonDefinitions = phenomenonDefinitions
3002        if arrayDescriptors:
3003            self.arrayDescriptors = arrayDescriptors
3004        if featureCollection:
3005            self.featureCollection = featureCollection
3006    def fromXML(self,csmlFrag):
3007        if csmlFrag.tag != CSML('Dataset'):
3008            print 'This does not appear to be a CSML file. Does not contain a root Dataset element.'
3009            print ' '
3010            sys.exit()
3011        AbstractGML.fromXML(self,csmlFrag)
3012        for frag in csmlFrag.getchildren():
3013            if frag.tag == CSML('UnitDefinitions'):
3014                self.unitDefinitions = UnitDefinitions()
3015                self.unitDefinitions.fromXML(frag)
3016            elif frag.tag == CSML('ReferenceSystemDefinitions'):
3017                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
3018                self.referenceSystemDefinitions.fromXML(frag)
3019            elif frag.tag == CSML('PhenomenonDefinitions'):
3020                self.phenomenonDefinitions = PhenomenonDefinitions()
3021                self.phenomenonDefinitions.fromXML(frag)
3022            elif frag.tag == GML('FeatureCollection'):
3023                self.featureCollection = FeatureCollection()
3024                self.featureCollection.fromXML(frag)
3025            elif frag.tag == CSML('AggregatedArray'):
3026                checkArrayAttrib(self,'arrayDescriptors')
3027                self.arrayDescriptors.append(AggregatedArray())
3028                self.arrayDescriptors[-1].fromXML(frag)
3029            elif frag.tag == CSML('InlineArray'):
3030                checkArrayAttrib(self,'arrayDescriptors')
3031                self.arrayDescriptors.append(InlineArray())
3032                self.arrayDescriptors[-1].fromXML(frag)
3033            elif frag.tag == CSML('ArrayGenerator'):
3034                checkArrayAttrib(self,'arrayDescriptors')
3035                self.arrayDescriptors.append(ArrayGenerator())
3036                self.arrayDescriptors[-1].fromXML(frag)
3037            elif frag.tag == CSML('NASAAmesExtract'):
3038                checkArrayAttrib(self,'arrayDescriptors')
3039                self.arrayDescriptors.append(NASAAmesExtract())
3040                self.arrayDescriptors[-1].fromXML(frag)
3041            elif frag.tag == CSML('NetCDFExtract'):
3042                checkArrayAttrib(self,'arrayDescriptors')
3043                self.arrayDescriptors.append(NetCDFExtract())
3044                self.arrayDescriptors[-1].fromXML(frag)
3045            elif frag.tag == CSML('GRIBExtract'):
3046                checkArrayAttrib(self,'arrayDescriptors')
3047                self.arrayDescriptors.append(GRIBExtract())
3048                self.arrayDescriptors[-1].fromXML(frag)
3049##            else:
3050##                raise Exception('Unexpected element: "'+frag.tag+'"')
3051    def toXML(self,csmlFrag=None):
3052        if csmlFrag is None:
3053            csmlFrag = Element('Dataset')
3054        csmlFrag = AbstractGML.toXML(self,csmlFrag)
3055        if hasattr(self,'unitDefinitions'):
3056            frag = Element(CSML('UnitDefinitions'))
3057            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
3058            csmlFrag.append(frag)
3059        if hasattr(self,'referenceSystemDefinitions'):
3060            frag = Element(CSML('ReferenceSystemDefinitions'))
3061            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
3062            csmlFrag.append(frag)
3063        if hasattr(self,'phenomenonDefinitions'):
3064            frag = Element(CSML('PhenomenonDefinitions'))
3065            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
3066            csmlFrag.append(frag)
3067        if hasattr(self,'arrayDescriptors'):
3068            for arrayDesc in self.arrayDescriptors:
3069                if isinstance(arrayDesc,AggregatedArray):
3070                    frag = Element(CSML('AggregatedArray'))
3071                    frag = AggregatedArray.toXML(arrayDesc,frag)
3072                elif isinstance(arrayDesc,InlineArray):
3073                    frag = Element(CSML('InlineArray'))
3074                    frag = InlineArray.toXML(arrayDesc,frag)
3075                elif isinstance(arrayDesc,ArrayGenerator):
3076                    frag = Element(CSML('ArrayGenerator'))
3077                    frag = ArrayGenerator.toXML(arrayDesc,frag)
3078                elif isinstance(arrayDesc,NASAAmesExtract):
3079                    frag = Element(CSML('NASAAmesExtract'))
3080                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
3081                elif isinstance(arrayDesc,NetCDFExtract):
3082                    frag = Element(CSML('NetCDFExtract'))
3083                    frag = NetCDFExtract.toXML(arrayDesc,frag)
3084                elif isinstance(arrayDesc,GRIBExtract):
3085                    frag = Element(CSML('GRIBExtract'))
3086                    frag = GRIBExtract.toXML(arrayDesc,frag)
3087                csmlFrag.append(frag)
3088        if hasattr(self,'featureCollection'):
3089            frag = Element(GML('FeatureCollection'))
3090            frag = FeatureCollection.toXML(self.featureCollection,frag)
3091            csmlFrag.append(frag)
3092            #csmlFrag=fixNameSpaces(csmlFrag)
3093        return csmlFrag
Note: See TracBrowser for help on using the repository browser.