source: TI02-CSML/trunk/parser/Parser.py @ 1147

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

Added CSML security metadata: example.xml contains sample csml security tags (same as MOLES). Parser now parses security elements. CSML Schema has been revised and will be committed separately.

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