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

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

fixed featureMember misspelling

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