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

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

removed unused code (minor edit)

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            elif frag.tag == CSML('uom'):
1471                if frag.getchildren() !=[]:
1472                    subFrag= frag.getchildren()[0]
1473                    if subFrag.tag == GML ('UnitDefinition'):
1474                        self.uom=UnitDefinition()
1475                        UnitDefinition.fromXML(self.uom, subFrag)
1476                else:
1477                    self.uom=frag.text
1478            elif frag.tag == CSML('numericType'):
1479                self.numericType = frag.text
1480            elif frag.tag == CSML('regExpTransform'):
1481                self.regExpTransform = frag.text
1482            elif frag.tag == CSML('numericTransform'):
1483                self.numericTransform = frag.text
1484        checkMandatory(self,'arraySize')
1485    def toXML(self,csmlFrag):
1486        csmlFrag = AbstractGML.toXML(self,csmlFrag)
1487        if hasattr(self,'arraySize'):
1488            frag = Element(CSML('arraySize'))
1489            frag.text = ' '.join(map(str,self.arraySize))
1490            csmlFrag.append(frag)
1491        if hasattr(self,'uom'):
1492            frag = Element(CSML('uom'))
1493            if isinstance(self.uom,UnitDefinition):
1494                subFrag=Element(GML('UnitDefinition'))
1495                UnitDefinition.toXML(self.uom,subFrag)
1496                frag.append(subFrag)
1497            else:
1498                frag.text = self.uom
1499            csmlFrag.append(frag)
1500        if hasattr(self,'numericType'):
1501            frag = Element(CSML('numericType'))
1502            frag.text  = self.numericType
1503            csmlFrag.append(frag)
1504        if hasattr(self,'regExpTransform'):
1505            frag = Element(CSML('regExpTransform'))
1506            frag.text = self.regExpTransform
1507            csmlFrag.append(frag)
1508        if hasattr(self,'numericTransform'):
1509            frag = Element(CSML('numericTransform'))
1510            frag.text = self.numericTransform
1511            csmlFrag.append(frag)
1512        return csmlFrag
1513
1514class AggregatedArray(AbstractArrayDescriptor):
1515    """CSML class for aggregated array
1516
1517    AggregatedArray(AbstractArrayDescriptor):
1518     +aggType: string
1519     +aggIndex: int
1520     +component[1..*]: AbstractArrayDescriptor
1521    """
1522    def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs):
1523        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1524        if aggType:
1525            self.aggType = aggType
1526        if aggIndex:
1527            self.aggIndex = aggIndex
1528        if component:
1529            self.component = component
1530    def fromXML(self,csmlFrag):
1531        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1532        for frag in csmlFrag.getchildren():
1533            if frag.tag == CSML('aggType'):
1534                self.aggType = frag.text
1535            elif frag.tag == CSML('aggIndex'):
1536                self.aggIndex = int(frag.text)
1537            elif frag.tag == CSML('component'):
1538                checkArrayAttrib(self,'component')
1539                componentFrag = frag[0]
1540                if componentFrag.tag == CSML('AggregatedArray'):
1541                    self.component.append(AggregatedArray())
1542                elif componentFrag.tag == CSML('InlineArray'):
1543                    self.component.append(InlineArray())
1544                elif componentFrag.tag == CSML('ArrayGenerator'):
1545                    self.component.append(ArrayGenerator())
1546                elif componentFrag.tag == CSML('NASAAmesExtract'):
1547                    self.component.append(NASAAmesExtract())
1548                elif componentFrag.tag == CSML('NetCDFExtract'):
1549                    self.component.append(NetCDFExtract())
1550                elif componentFrag.tag == CSML('GRIBExtract'):
1551                    self.component.append(GRIBExtract())
1552                elif componentFrag.tag == CSML('PPExtract'):
1553                    self.component.append(PPExtract())
1554##                else:
1555##                    raise Exception('Unexpected element: "'+componentFrag.tag+'"')
1556                self.component[-1].fromXML(componentFrag)
1557    def toXML(self,csmlFrag):
1558        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1559        if hasattr(self,'aggType'):
1560            frag = Element(CSML('aggType'))
1561            frag.text = self.aggType
1562            csmlFrag.append(frag)
1563        if hasattr(self,'aggIndex'):
1564            frag = Element(CSML('aggIndex'))
1565            frag.text = str(self.aggIndex)
1566            csmlFrag.append(frag)
1567        if hasattr(self,'component'):
1568            compFrag = Element(CSML('component'))
1569            for comp in self.component:
1570                if isinstance(comp,AggregatedArray):
1571                    frag = Element(CSML('AggregatedArray'))
1572                    frag = AggregatedArray.toXML(comp,frag)
1573                elif isinstance(comp,InlineArray):
1574                    frag = Element(CSML('InlineArray'))
1575                    frag = InlineArray.toXML(comp,frag)
1576                elif isinstance(comp,ArrayGenerator):
1577                    frag = Element(CSML('ArrayGenerator'))
1578                    frag = ArrayGenerator.toXML(comp,frag)
1579                elif isinstance(comp,NASAAmesExtract):
1580                    frag = Element(CSML('NASAAmesExtract'))
1581                    frag = NASAAmesExtract.toXML(comp,frag)
1582                elif isinstance(comp,NetCDFExtract):
1583                    frag = Element(CSML('NetCDFExtract'))
1584                    frag = NetCDFExtract.toXML(comp,frag)
1585                elif isinstance(comp,PPExtract):
1586                    frag = Element(CSML('PPExtract'))
1587                    frag = PPExtract.toXML(comp,frag)
1588                elif isinstance(comp,GRIBExtract):
1589                    frag = Element(CSML('GRIBExtract'))
1590                    frag = GRIBExtract.toXML(comp,frag)
1591                compFrag.append(frag)
1592            csmlFrag.append(compFrag)
1593        return csmlFrag
1594
1595class InlineArray(AbstractArrayDescriptor):
1596    pass
1597
1598class ArrayGenerator(AbstractArrayDescriptor):
1599    pass
1600
1601class AbstractFileExtract(AbstractArrayDescriptor):
1602    """Base abstract clas for CSML file array extract
1603
1604    AbstractFileExtract(AbstractArrayDescriptor):
1605     +fileName: string
1606    """
1607    def __init__(self,fileName=None,*args,**kwargs):
1608        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
1609        if fileName:
1610            self.fileName = fileName
1611    def fromXML(self,csmlFrag):
1612        AbstractArrayDescriptor.fromXML(self,csmlFrag)
1613        for frag in csmlFrag.getchildren():
1614            if frag.tag == CSML('fileName'):
1615                self.fileName = frag.text
1616##        else:
1617##            raise Exception('Unexpected element: "'+frag.tag+'"')
1618    def toXML(self,csmlFrag):
1619        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
1620        if hasattr(self,'fileName'):
1621            frag = Element(CSML('fileName'))
1622            frag.text = self.fileName
1623            csmlFrag.append(frag)
1624        return csmlFrag
1625
1626class NASAAmesExtract(AbstractFileExtract):
1627    """CSML class for NASA Ames file extract
1628
1629    NASAAmesExtract(AbstractFileExtract):
1630     +variableName: string
1631     +index[0..1]: int
1632    """
1633    def __init__(self,variableName=None,index=None,*args,**kwargs):
1634        AbstractFileExtract.__init__(self,*args,**kwargs)
1635        if variableName:
1636            self.variableName = variableName
1637        if index:
1638            self.index = index
1639    def fromXML(self,csmlFrag):
1640        AbstractFileExtract.fromXML(self,csmlFrag)
1641        for frag in csmlFrag.getchildren():
1642            if frag.tag == CSML('variableName'):
1643                self.variableName = frag.text
1644            elif frag.tag == CSML('index'):
1645                self.index = int(frag.text)
1646##            else:
1647##                raise Exception('Unexpected element: "'+frag.tag+'"')
1648    def toXML(self,csmlFrag):
1649        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1650        frag = Element(CSML('variableName'))
1651        frag.text = self.variableName
1652        csmlFrag.append(frag)
1653        if hasattr(self,'index'):
1654            frag = Element(CSML('index'))
1655            frag.text = str(self.index)
1656            csmlFrag.append(frag)
1657        return csmlFrag
1658
1659class NetCDFExtract(AbstractFileExtract):
1660    """CSML class for netCDF file extract
1661
1662    NetCDFExtract(AbstractFileExtract):
1663     +variableName: string
1664    """
1665    def __init__(self,variableName=None,*args,**kwargs):
1666        AbstractFileExtract.__init__(self,*args,**kwargs)
1667        if variableName:
1668            self.variableName = variableName
1669    def fromXML(self,csmlFrag):
1670        AbstractFileExtract.fromXML(self,csmlFrag)
1671        for frag in csmlFrag.getchildren():
1672            if frag.tag == CSML('variableName'):
1673                self.variableName = frag.text
1674##        else:
1675##            raise Exception('Unexpected element: "'+frag.tag+'"')
1676        checkMandatory(self, 'variableName')
1677    def toXML(self,csmlFrag):
1678        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1679        if hasattr(self, 'variableName'):
1680            frag = Element(CSML('variableName'))
1681            frag.text = self.variableName
1682            csmlFrag.append(frag)
1683        return csmlFrag
1684
1685class PPExtract(AbstractFileExtract):
1686    """CSML class for PPExtract file extract
1687    same as NetCDFExtract
1688    PPExtract(AbstractFileExtract):
1689     +variableName: string
1690    """
1691    def __init__(self,variableName=None,*args,**kwargs):
1692        AbstractFileExtract.__init__(self,*args,**kwargs)
1693        if variableName:
1694            self.variableName = variableName
1695    def fromXML(self,csmlFrag):
1696        AbstractFileExtract.fromXML(self,csmlFrag)
1697        for frag in csmlFrag.getchildren():
1698            if frag.tag == CSML('variableName'):
1699                self.variableName = frag.text
1700##        else:
1701##            raise Exception('Unexpected element: "'+frag.tag+'"')
1702        checkMandatory(self, 'variableName')
1703    def toXML(self,csmlFrag):
1704        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1705        if hasattr(self, 'variableName'):
1706            frag = Element(CSML('variableName'))
1707            frag.text = self.variableName
1708            csmlFrag.append(frag)
1709        return csmlFrag
1710       
1711class GRIBExtract(AbstractFileExtract):
1712    """CSML class for GRIB file extract
1713
1714    GRIBExtract(AbstractFileExtract):
1715     +parameterCode: int
1716     +recordNumber[0..1]: int
1717     +fileOffset[0..1]: int
1718     
1719     temporary addition of 'variableName' attribute
1720    """
1721    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, variableName=None, *args,**kwargs):
1722        AbstractFileExtract.__init__(self,*args,**kwargs)
1723        if parameterCode:
1724            self.parameterCode = parameterCode
1725        if recordNumber:
1726            self.recordNumber = recordNumber
1727        if fileOffset:
1728            self.fileOffset = fileOffset
1729        if variableName:
1730            self.variableName=variableName
1731    def fromXML(self,csmlFrag):
1732        AbstractFileExtract.fromXML(self,csmlFrag)
1733        for frag in csmlFrag.getchildren():
1734            if frag.tag == CSML('parameterCode'):
1735                self.parameterCode = int(frag.text)
1736            elif frag.tag == CSML('recordNumber'):
1737                self.recordNumber = int(frag.text)
1738            elif frag.tag == CSML('fileOffset'):
1739                self.fileOffset = int(frag.text)
1740            elif frag.tag == CSML('variableName'):
1741                self.variableName = frag.text
1742##            else:
1743##                raise Exception('Unexpected element: "'+frag.tag+'"')
1744    def toXML(self,csmlFrag):
1745        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
1746        if hasattr(self,'parameterCode'):
1747            frag = Element(CSML('parameterCode'))
1748            frag.text = str(self.parameterCode)
1749            csmlFrag.append(frag)
1750        if hasattr(self,'recordNumber'):
1751            frag = Element(CSML('recordNumber'))
1752            frag.text = str(self.recordNumber)
1753            csmlFrag.append(frag)
1754        if hasattr(self,'fileOffset'):
1755            frag = Element(CSML('fileOffset'))
1756            frag.text = str(self.fileOffset)
1757            csmlFrag.append(frag)
1758        if hasattr(self,'variableName'):
1759            frag = Element(CSML('variableName'))
1760            frag.text = self.variableName
1761            csmlFrag.append(frag)
1762        return csmlFrag
1763
1764class DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup,SRSInformationGroup):
1765    #class representing a DirectPositionList
1766    def __init__(self, order=None, vals=None,*args,**kwargs):
1767        if order:
1768            self.order=order
1769        if vals:
1770            self.vals=vals
1771        AssociationAttributeGroup.__init__(self,*args,**kwargs)
1772        SRSReferenceGroup.__init__(self,*args,**kwargs)
1773        SRSInformationGroup.__init__(self,*args,**kwargs)
1774    def fromXML(self,csmlFrag):
1775        AssociationAttributeGroup.fromXML(self,csmlFrag)
1776        SRSReferenceGroup.fromXML(self,csmlFrag)
1777        SRSInformationGroup.fromXML(self,csmlFrag)       
1778        self.vals=csmlFrag.text
1779        if csmlFrag.attrib.has_key('order'):
1780            self.order=csmlFrag.attrib['order']
1781    def toXML(self,csmlFrag): 
1782        AssociationAttributeGroup.toXML(self,csmlFrag)
1783        SRSReferenceGroup.toXML(self,csmlFrag)
1784        SRSInformationGroup.toXML(self,csmlFrag)
1785        csmlFrag.text=self.vals
1786        if hasattr(self,'order'):
1787            csmlFrag.attrib['order']=self.order
1788        return csmlFrag
1789       
1790class MappingRule(MutableString):
1791    """Class representing a GML MappingRule element(string):
1792    """
1793    def __init__(self,val=''):
1794        MutableString.__init__(self,val)
1795    def fromXML(self,csmlFrag):
1796        self.data = csmlFrag.text
1797        if csmlFrag.attrib.has_key('scanOrder'):
1798            self.scanOrder=csmlFrag.attrib['scanOrder']
1799    def toXML(self,csmlFrag):
1800        csmlFrag.text = self.data
1801        if hasattr(self,'scanOrder'):
1802            csmlFrag.attrib['scanOrder']=self.scanOrder
1803        return csmlFrag
1804
1805   
1806   
1807   
1808   
1809class AbstractDiscreteCoverage(AbstractGML):
1810     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
1811    #GML AbstractDiscreteCoverage Class
1812    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs):
1813        AbstractGML.__init__(self,*args,**kwargs)
1814        if rangeSet:
1815            self.rangeSet=rangeSet
1816        if coverageFunction:
1817            self.coverageFunction=coverageFunction
1818
1819    def fromXML(self,csmlFrag):
1820        AbstractGML.fromXML(self,csmlFrag)
1821        for frag in csmlFrag.getchildren():
1822            if frag.tag == GML('rangeSet'):
1823                self.rangeSet=RangeSet()
1824                self.rangeSet.fromXML(frag)
1825            if frag.tag == GML('coverageFunction'):
1826                self.coverageFunction=MappingRule()
1827                for subFrag in frag.getchildren():
1828                    if subFrag.tag==CSML('MappingRule'):
1829                        self.coverageFunction.fromXML(subFrag)
1830
1831
1832    def toXML(self,csmlFrag):
1833        AbstractGML.toXML(self,csmlFrag)
1834        if hasattr(self,'rangeSet'):
1835            frag = Element(GML('rangeSet'))
1836            RangeSet.toXML(self.rangeSet,frag)
1837            csmlFrag.append(frag)
1838        if hasattr(self,'coverageFunction'):
1839            frag = Element(GML('coverageFunction'))
1840            subFrag=Element(CSML('MappingRule'))
1841            MappingRule.toXML(self.coverageFunction,subFrag)
1842            frag.append(subFrag)
1843            csmlFrag.append(frag)
1844        return csmlFrag
1845       
1846class AbstractCoverageFeature(AbstractDiscreteCoverage):
1847    #CSML Abstract Coverage FT class
1848    #     AbstractCoverageFeature(AbstractDiscreteCoverage)
1849    #       + om:parameter:PhenomenonPropertyType
1850   
1851    def __init__(self, parameter=None, *args,**kwargs):
1852        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
1853        if parameter:
1854            self.parameter=parameter
1855    def fromXML(self,csmlFrag):
1856        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
1857        for frag in csmlFrag.getchildren():
1858            if frag.tag == CSML('parameter'):
1859                self.parameter=None
1860                if frag.getchildren() == []:
1861                    self.parameter=Phenomenon()
1862                    self.parameter.fromXML(frag)
1863                else:
1864                    subFrag=frag.getchildren()[0]
1865                    if subFrag.tag == OM('Phenomenon'):
1866                        self.parameter = Phenomenon()
1867                    elif subFrag.tag == OM('CompositePhenomenon'):
1868                        self.parameter = CompositePhenomenon()
1869                    elif subFrag.tag == OM('ParameterisedPhenomenon'):
1870                        self.parameter = ParameterisedPhenomenon()
1871                    self.parameter.fromXML(subFrag)
1872                       
1873    def toXML(self,csmlFrag):
1874        AbstractDiscreteCoverage.toXML(self,csmlFrag)
1875        if hasattr(self,'parameter'):
1876            frag = Element(CSML('parameter'))
1877            if isinstance(self.parameter,ParameterisedPhenomenon):
1878                subFrag=Element(OM('ParameterisedPhenomenon'))
1879                ParameterisedPhenomenon.toXML(self.parameter,subFrag)
1880                frag.append(subFrag)
1881                csmlFrag.append(frag)
1882            elif isinstance(self.parameter,CompositePhenomenon):
1883                subFrag=Element(OM('CompositePhenomenon'))
1884                CompositePhenomenon.toXML(self.parameter,subFrag)
1885                frag.append(subFrag)
1886                csmlFrag.append(frag)
1887            elif isinstance(self.parameter,Phenomenon):
1888                Phenomenon.toXML(self.parameter,frag)
1889                subFrag=Element(OM('Phenomenon'))
1890                Phenomenon.toXML(self.parameter,subFrag)
1891                if subFrag.attrib != frag.attrib:
1892                    frag.append(subFrag)
1893                csmlFrag.append(frag)
1894               
1895               
1896                #frag.attrib[XLINK('href')] = self.href
1897
1898        return csmlFrag
1899
1900   
1901class AbstractStaticCoverageFeature(AbstractCoverageFeature):
1902    #CSML Abstract Static Coverage FT class
1903    def __init__(self,*args,**kwargs):
1904        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1905    def fromXML(self,csmlFrag):
1906        AbstractCoverageFeature.fromXML(self,csmlFrag)
1907    def toXML(self,csmlFrag):
1908        AbstractCoverageFeature.toXML(self,csmlFrag)
1909        return csmlFrag
1910   
1911class AbstractSeriesCoverageFeature(AbstractCoverageFeature):
1912    #CSML Abstract Series Coverage FT class
1913    def __init__(self,*args,**kwargs):
1914        AbstractCoverageFeature.__init__(self,*args,**kwargs)
1915    def fromXML(self,csmlFrag):
1916        AbstractCoverageFeature.fromXML(self,csmlFrag)
1917    def toXML(self,csmlFrag):
1918        AbstractCoverageFeature.toXML(self,csmlFrag)
1919        return csmlFrag
1920   
1921class AbstractDomain:
1922    #CSML AbstractDomain class
1923    #   AbstractDomain()
1924    #   +csml:domainReference
1925    #   +csml:domainComplement [0...1]
1926       
1927    def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs):
1928        if domainReference:
1929            self.domainReference=domainReference
1930        if domainComplement:
1931            self.domainComplement=domainComplement
1932    def fromXML(self,csmlFrag):
1933        for frag in csmlFrag.getchildren():
1934            if frag.tag == CSML('domainReference'):
1935                subfrag=frag.getchildren()[0]
1936                if subfrag.tag==CSML('Position'):
1937                    self.domainReference=Position()
1938                elif subfrag.tag == CSML('Trajectory'):
1939                    self.domainReference=Trajectory()
1940                elif subfrag.tag==CSML('OrientedPosition'):
1941                    self.domainReference=OrientedPosition()
1942                elif subfrag.tag == CSML('OrientedTrajectory'):
1943                    self.domainReference=OrientedTrajectory()
1944                elif subfrag.tag == GML('TimeInstant'):
1945                    self.domainReference=TimeInstant()
1946                elif subfrag.tag == GML('TimePositionList'):
1947                    self.domainReference=TimePositionList()
1948                self.domainReference.fromXML(subfrag)
1949               
1950            if frag.tag == CSML('domainComplement'):
1951                subfrag=frag.getchildren()[0]
1952                if subfrag.tag==CSML('DirectPositionList'):
1953                    self.domainComplement=DirectPositionList()
1954                    self.domainComplement.fromXML(subfrag)
1955                elif subfrag.tag==CSML('Grid'):
1956                    self.domainComplement=Grid()
1957                    self.domainComplement.fromXML(subfrag)
1958    def toXML(self,csmlFrag):
1959        if hasattr(self,'domainReference'):
1960            frag = Element(CSML('domainReference'))
1961            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object
1962            #self.domainReference.toXML(frag)
1963            if isinstance(self.domainReference,OrientedPosition):
1964                subFrag=Element(CSML('OrientedPosition'))
1965                self.domainReference.toXML(subFrag)
1966                frag.append(subFrag)
1967                csmlFrag.append(frag)
1968            elif isinstance(self.domainReference,OrientedTrajectory):
1969                subFrag=Element(CSML('OrientedTrajectory'))
1970                self.domainReference.toXML(subFrag)
1971                frag.append(subFrag)
1972                csmlFrag.append(frag)       
1973            elif isinstance(self.domainReference,Position):
1974                subFrag=Element(CSML('Position'))
1975                self.domainReference.toXML(subFrag)
1976                frag.append(subFrag)
1977                csmlFrag.append(frag)
1978            elif isinstance(self.domainReference,Trajectory):
1979                subFrag=Element(CSML('Trajectory'))
1980                self.domainReference.toXML(subFrag)
1981                frag.append(subFrag)
1982                csmlFrag.append(frag)
1983            elif isinstance(self.domainReference,TimeInstant):
1984                subFrag=Element(GML('TimeInstant'))
1985                self.domainReference.toXML(subFrag)
1986                frag.append(subFrag)
1987                csmlFrag.append(frag)
1988            elif isinstance(self.domainReference,TimePositionList):
1989                subFrag=Element(GML('TimePositionList'))
1990                self.domainReference.toXML(subFrag)
1991                frag.append(subFrag)
1992                csmlFrag.append(frag)   
1993        if hasattr(self,'domainComplement'):
1994            frag = Element(CSML('domainComplement'))
1995            if isinstance(self.domainComplement,DirectPositionList):
1996                    subFrag=Element(CSML('DirectPositionList'))
1997                    self.domainComplement.toXML(subFrag)
1998                    frag.append(subFrag)
1999                    csmlFrag.append(frag)
2000            elif isinstance(self.domainComplement,Grid):
2001                    subFrag=Element(CSML('Grid'))
2002                    self.domainComplement.toXML(subFrag)
2003                    frag.append(subFrag)
2004                    csmlFrag.append(frag)
2005        return csmlFrag
2006
2007
2008class EnvelopeWithTimePeriod:
2009    # CSML EnvelopeWithTimePeriod class
2010    # EnvelopeWithTimePeriod():
2011        # +gml:lowerCorner:DirectPosition
2012        # +gml:upperCorner:DirectPosition
2013        # +gml:timePosition [2] ?
2014       
2015    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
2016        if srsName:
2017            self.srsName=srsName
2018        if lowerCorner:
2019            self.lowerCorner=lowerCorner
2020        if upperCorner:
2021            self.upperCorner=upperCorner
2022        if timePosition:
2023            self.timePosition=timePosition
2024        if timePosition2:
2025            self.timePosition2=timePosition2
2026    def fromXML(self,csmlFrag):
2027        EnvTPfrag=csmlFrag.getchildren()[0]
2028        for frag in EnvTPfrag.getchildren():
2029            if frag.attrib.has_key('srsName'):
2030                self.srsName=frag.attrib['srsName']
2031            if frag.tag == GML('lowerCorner'):
2032                #self.lowerCorner=frag.text
2033                self.lowerCorner=DirectPosition()
2034                DirectPosition.fromXML(self.lowerCorner, frag)
2035            if frag.tag == GML('upperCorner'):
2036                #self.upperCorner=frag.text
2037                self.upperCorner=DirectPosition()
2038                DirectPosition.fromXML(self.upperCorner, frag)
2039            if frag.tag == GML('timePosition'):
2040                if hasattr(self, 'timePosition'):
2041                    self.timePosition2=frag.text
2042                else:
2043                    self.timePosition=frag.text
2044    def toXML(self,csmlFrag):
2045        if hasattr(self,'srsName'):
2046            csmlFrag.attrib['srsName'] = self.srsName
2047        if hasattr(self,'lowerCorner'):
2048            frag=Element(GML('lowerCorner'))
2049           # frag.text=self.lowerCorner
2050            DirectPosition.toXML(self.lowerCorner,frag)
2051            csmlFrag.append(frag)
2052        if hasattr(self,'upperCorner'):
2053            frag=Element(GML('upperCorner'))
2054            #frag.text=self.upperCorner
2055            DirectPosition.toXML(self.upperCorner,frag)
2056            csmlFrag.append(frag)
2057        if hasattr(self,'timePosition'):
2058            frag=Element(GML('timePosition'))
2059            frag.text=self.timePosition
2060            csmlFrag.append(frag)
2061        if hasattr(self,'timePosition2'):
2062            frag=Element(GML('timePosition'))
2063            frag.text=self.timePosition2
2064            csmlFrag.append(frag)
2065        return csmlFrag
2066
2067
2068       
2069class AngleList:
2070    #Should really inherit from MeasureList, but not implemented.
2071    #class AngleList
2072    #+uom[1]:anyURI
2073    #+double[0...1]
2074    def __init__(self,uom=None, vals=None):
2075        if uom:
2076            self.uom=uom
2077        if vals:
2078            self.vals=vals
2079    def fromXML(self,csmlFrag):
2080        self.vals=csmlFrag.text
2081        if csmlFrag.attrib.has_key('uom'):
2082            self.uom = csmlFrag.attrib['uom']
2083        checkMandatory(self,'uom')
2084    def toXML(self, csmlFrag):
2085        if hasattr(self,'vals'):
2086            csmlFrag.text = self.vals
2087        if hasattr(self,'uom'):
2088            csmlFrag.attrib[('uom')] = self.uom
2089        return csmlFrag
2090       
2091class DirectionVectorList:
2092    def __init__(self, horizontalAngle=None, verticalAngle=None):
2093        if horizontalAngle:
2094            self.horizontalAngle=horizontalAngle
2095        if verticalAngle:
2096            self.verticalAngle=verticalAngle
2097    def fromXML(self, csmlFrag):
2098        for frag in csmlFrag.getchildren():
2099            if frag.tag==GML('horizontalAngle'):
2100                self.horizontalAngle=AngleList()
2101                AngleList.fromXML(self.horizontalAngle,frag)
2102            elif frag.tag==GML('verticalAngle'):
2103                self.verticalAngle=AngleList()
2104                AngleList.fromXML(self.verticalAngle,frag)
2105    def toXML(self,csmlFrag):
2106         if hasattr(self,'horizontalAngle'):
2107            frag = Element(GML('horizontalAngle'))
2108            AngleList.toXML(self.horizontalAngle,frag)
2109            csmlFrag.append(frag)
2110         if hasattr(self,'verticalAngle'):
2111            frag = Element(GML('verticalAngle'))
2112            AngleList.toXML(self.verticalAngle,frag)
2113            csmlFrag.append(frag)
2114         return csmlFrag
2115
2116       
2117class Position:
2118    def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs):
2119        if srsName:
2120            self.srsName=srsName
2121        if axisLabels:
2122            self.axisLabels=axisLabels
2123        if uomLabels:
2124            self.uomLabels=uomLabels
2125        if location:
2126            self.location=location
2127        if time:
2128            self.time = time
2129    def fromXML(self,csmlFrag):
2130        if csmlFrag.attrib.has_key('srsName'):           
2131            self.srsName = csmlFrag.attrib['srsName']
2132        if csmlFrag.attrib.has_key('axisLabels'):
2133            self.axisLabels = csmlFrag.attrib['axisLabels']
2134            if csmlFrag.attrib.has_key('uomLabels'):
2135                self.uomLabels = csmlFrag.attrib['uomLabels']
2136        for frag in csmlFrag.getchildren():
2137            if frag.tag==CSML('location'):
2138                self.location=frag.text
2139            if frag.tag==CSML('time'):
2140                self.time=frag.text
2141    def toXML(self,csmlFrag):
2142        #subFrag = Element(CSML('Position'))
2143        if hasattr(self,'uomLabels'):
2144            csmlFrag.attrib['uomLabels'] = self.uomLabels
2145        if hasattr(self,'axisLabels'):
2146            csmlFrag.attrib['axisLabels'] = self.axisLabels
2147        if hasattr(self,'srsName'):
2148            csmlFrag.attrib['srsName'] = self.srsName
2149        if hasattr(self,'location'):
2150            frag = Element(CSML('location'))
2151            frag.text=self.location
2152            csmlFrag.append(frag)
2153        if hasattr(self,'time'):
2154            frag = Element(CSML('time'))
2155            frag.text=self.time
2156            csmlFrag.append(frag)
2157        return csmlFrag
2158
2159class OrientedPosition(Position):
2160    def __init__(self, direction=None, *args,**kwargs):
2161        Position.__init__(self, *args,**kwargs)
2162        if direction:
2163            self.direction=direction
2164    def fromXML(self,csmlFrag):
2165        Position.fromXML(self, csmlFrag)
2166        for frag in csmlFrag.getchildren():
2167            if frag.tag==CSML('direction'):
2168                self.direction=DirectionVectorList()
2169                DirectionVectorList.fromXML(self.direction,frag)
2170    def toXML(self, csmlFrag):
2171        Position.toXML(self,csmlFrag)
2172        if hasattr(self,'direction'):
2173            frag = Element(CSML('direction'))
2174            DirectionVectorList.toXML(self.direction,frag)
2175            csmlFrag.append(frag)
2176        return csmlFrag
2177       
2178
2179
2180class Trajectory(SRSReferenceGroup):
2181    def __init__(self,locations=None,times=None,*args,**kwargs):
2182
2183        if locations:
2184            self.locations=locations
2185        if times:
2186            self.times = times
2187        SRSReferenceGroup.__init__(self,*args,**kwargs)
2188    def fromXML(self,csmlFrag):
2189        SRSReferenceGroup.fromXML(self,csmlFrag)
2190        for frag in csmlFrag.getchildren():
2191            if frag.tag==CSML('locations'):
2192                self.locations=DirectPositionList()
2193                DirectPositionList.fromXML(self.locations,frag)
2194            if frag.tag==CSML('times'):
2195                self.times=TimePositionList()
2196                TimePositionList.fromXML(self.times,frag)
2197    def toXML(self,csmlFrag):
2198        SRSReferenceGroup.toXML(self,csmlFrag)
2199        if hasattr(self,'srsName'):
2200            csmlFrag.attrib['srsName'] = self.srsName
2201        if hasattr(self,'locations'):
2202            frag = Element(CSML('locations'))
2203            frag=DirectPositionList.toXML(self.locations,frag)
2204            csmlFrag.append(frag)
2205        if hasattr(self,'times'):
2206            frag = Element(CSML('times'))
2207            TimePositionList.toXML(self.times, frag)
2208            csmlFrag.append(frag)
2209        return csmlFrag
2210
2211class OrientedTrajectory(Trajectory):
2212    def __init__(self, direction=None, *args,**kwargs):
2213        Trajectory.__init__(self, *args,**kwargs)
2214        if direction:
2215             self.direction=direction
2216    def fromXML(self,csmlFrag):
2217        Trajectory.fromXML(self, csmlFrag)
2218        for frag in csmlFrag.getchildren():
2219            if frag.tag==CSML('direction'):
2220                self.direction=DirectionVectorList()
2221                DirectionVectorList.fromXML(self.direction,frag)
2222    def toXML(self, csmlFrag):
2223        Trajectory.toXML(self,csmlFrag)
2224        if hasattr(self,'direction'):
2225            frag = Element(CSML('direction'))
2226            DirectionVectorList.toXML(self.direction,frag)
2227            csmlFrag.append(frag)
2228        return csmlFrag
2229
2230class AbstractGeometryType(AbstractGML):
2231    def __init__(self, low=None, high=None):
2232        AbstractGML.__init__(self)
2233        if low:
2234            self.low=low
2235        if high:
2236            self.high=high
2237    def fromXML(self, csmlFrag):
2238        AbstractGML.fromXML(self,csmlFrag)
2239    def toXML(self,csmlFrag):
2240        AbstractGML.toXML(self,csmlFrag)
2241        return csmlFrag
2242
2243class GridEnvelope:
2244    def __init__(self, low=None, high = None):
2245        if low:
2246            self.low = low
2247        if high:
2248            self.high = high
2249    def fromXML(self, csmlFrag):
2250        frag = csmlFrag.getchildren()[0]
2251        for subFrag in frag.getchildren():
2252            if subFrag.tag == GML('low'):
2253                self.low=subFrag.text
2254            elif subFrag.tag == GML('high'):
2255                self.high=subFrag.text
2256    def toXML(self,csmlFrag):
2257        if hasattr(self, 'low'):
2258            frag=Element(GML('low'))
2259            frag.text=self.low
2260            csmlFrag.append(frag)
2261        if hasattr(self, 'high'):
2262            frag=Element(GML('high'))
2263            frag.text=self.high
2264            csmlFrag.append(frag)
2265        return csmlFrag
2266
2267class GmlGrid(AbstractGeometryType):
2268    #Class GmlGrid, representing a gml:Grid element.
2269    #  +dimension positiveInteger [1]
2270    # +gml:limits  (gml:GridLimitsType) </gml:limits> [1]
2271    #+gml:axisNames  (string) [1..*]
2272    def __init__(self,dimension=None,limits=None,axisNames=None):
2273        AbstractGeometryType.__init__(self)
2274        if dimension:
2275            self.dimension=dimension
2276        if limits:
2277            self.limits=limits
2278        if axisNames:
2279            self.axisNames=axisNames
2280    def fromXML(self, csmlFrag):
2281        AbstractGeometryType.fromXML(self,csmlFrag)
2282        for frag in csmlFrag.getchildren():
2283            if frag.tag == GML('limits'):
2284                self.limits=GridEnvelope()
2285                GridEnvelope.fromXML(self.limits,frag)
2286            elif frag.tag == GML('axisName'):
2287                checkArrayAttrib(self,'axisNames')
2288                self.axisNames.append(frag.text)
2289    def toXML(self,csmlFrag):
2290        AbstractGeometryType.toXML(self,csmlFrag)
2291        if hasattr(self, 'limits'):
2292            frag=Element(GML('limits'))
2293            subFrag =Element(GML('GridEnvelope'))
2294            GridEnvelope.toXML(self.limits, subFrag)
2295            frag.append(subFrag)
2296            csmlFrag.append(frag)
2297        if hasattr(self, 'axisNames'):
2298            for axis in self.axisNames:
2299                frag=Element(GML('axisName'))
2300                frag.text =axis
2301                csmlFrag.append(frag)
2302        return csmlFrag
2303           
2304class GridOrdinateDescription:
2305    #Class GridOrdinateDescription:
2306        #+gridAxesSpanned
2307        #+sequenceRule
2308        #+definesAxis,attrib -href
2309        #+axisValues
2310
2311    def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None):
2312        if gridAxesSpanned:
2313            self.gridAxesSpanned=gridAxesSpanned
2314        if sequenceRule:
2315            self.sequenceRule=sequenceRule
2316        if definesAxis:
2317            self.definesAxis=definesAxis
2318            if href:
2319                self.href = href
2320        if axisValues:
2321            self.axisValues=axisValues
2322       
2323    def fromXML(self,csmlFrag):
2324        for frag in csmlFrag.getchildren():
2325            if frag.tag ==CSML('gridAxesSpanned'):
2326                self.gridAxesSpanned=frag.text
2327            elif frag.tag ==CSML('sequenceRule'):
2328                self.sequenceRule=frag.text
2329            elif frag.tag ==CSML('definesAxis'):
2330                self.definesAxis=frag.text
2331                if frag.attrib.has_key(XLINK('href')):
2332                        self.href = frag.attrib[XLINK('href')]
2333            elif frag.tag ==CSML('axisValues'):
2334                if frag.getchildren() !=[]:
2335                    subFrag= frag.getchildren()[0]
2336                    if subFrag.tag == CSML ('NetCDFExtract'):
2337                        self.axisValues=NetCDFExtract()
2338                        NetCDFExtract.fromXML(self.axisValues, subFrag)
2339                    elif subFrag.tag == CSML ('NASAAmesExtract'):
2340                        self.axisValues=NASAAmesExtract()
2341                        NASAAmesExtract.fromXML(self.axisValues, subFrag)
2342                    elif subFrag.tag == CSML ('GRIBExtract'):
2343                        self.axisValues=GRIBExtract()
2344                        GRIBExtract.fromXML(self.axisValues, subFrag)
2345                    elif subFrag.tag == CSML ('PPExtract'):
2346                        self.axisValues=PPExtract()
2347                        PPExtract.fromXML(self.axisValues, subFrag)
2348                else:
2349                    self.axisValues=frag.text
2350                   
2351               
2352    def toXML(self, csmlFrag):
2353        if hasattr(self, 'gridAxesSpanned'):
2354            frag=Element(CSML('gridAxesSpanned'))
2355            frag.text = self.gridAxesSpanned
2356            csmlFrag.append(frag)
2357        if hasattr(self, 'sequenceRule'):
2358            frag=Element(CSML('sequenceRule'))
2359            frag.text = self.sequenceRule
2360            csmlFrag.append(frag)
2361        if hasattr(self, 'definesAxis'):
2362            frag=Element(CSML('definesAxis'))
2363            frag.text = self.definesAxis
2364            if hasattr(self, 'href'):
2365                frag.attrib[XLINK('href')] = self.href
2366            csmlFrag.append(frag)
2367        if hasattr(self, 'axisValues'):
2368            frag=Element(CSML('axisValues'))
2369            if isinstance(self.axisValues,NetCDFExtract):
2370                subFrag=Element(CSML('NetCDFExtract'))
2371                NetCDFExtract.toXML(self.axisValues,subFrag)
2372                frag.append(subFrag)
2373            elif isinstance(self.axisValues,NASAAmesExtract):
2374                subFrag=Element(CSML('NASAAmesExtract'))
2375                NASAAmesExtract.toXML(self.axisValues,subFrag)
2376                frag.append(subFrag)
2377            elif isinstance(self.axisValues,GRIBExtract):
2378                subFrag=Element(CSML('GRIBExtract'))
2379                GRIBExtract.toXML(self.axisValues,subFrag)
2380                frag.append(subFrag)
2381            elif isinstance(self.axisValues,PPExtract):
2382                subFrag=Element(CSML('PPExtract'))
2383                PPExtract.toXML(self.axisValues,subFrag)
2384                frag.append(subFrag)
2385            else:
2386                frag.text = self.axisValues
2387            csmlFrag.append(frag)
2388        return csmlFrag
2389
2390
2391class Grid(GmlGrid):
2392#Class GmlGrid representing a gml:Grid
2393# + dimension(attrib) [1]
2394#  +ordinate [1..*]
2395    def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None):
2396        GmlGrid.__init__(self)
2397        if srsName:
2398            self.srsName=srsName
2399        if srsDimension:
2400            self.srsDimension=srsDimension
2401        if dimension:
2402            self.dimension=dimension
2403        if ordinates:
2404            self.ordinates=ordinates
2405    def fromXML(self, csmlFrag):
2406        GmlGrid.fromXML(self,csmlFrag)
2407        if csmlFrag.attrib.has_key('srsName'):
2408            self.srsName = csmlFrag.attrib['srsName']
2409        if csmlFrag.attrib.has_key('srsDimension'):
2410            self.srsDimension = csmlFrag.attrib['srsDimension']
2411        if csmlFrag.attrib.has_key('dimension'):
2412            self.dimension = csmlFrag.attrib['dimension']
2413        for frag in csmlFrag:
2414            if frag.tag==CSML('ordinate'):
2415                checkArrayAttrib(self,'ordinates')
2416                ordinate=GridOrdinateDescription()
2417                GridOrdinateDescription.fromXML(ordinate, frag)
2418                self.ordinates.append(ordinate)
2419    def toXML(self,csmlFrag):
2420        GmlGrid.toXML(self,csmlFrag)
2421        if hasattr(self, 'srsName'):
2422            csmlFrag.attrib['srsName'] = self.srsName
2423        if hasattr(self, 'srsDimension'):
2424            csmlFrag.attrib['srsDimension'] = self.srsDimension
2425        if hasattr(self, 'dimension'):
2426            csmlFrag.attrib['dimension'] = self.dimension
2427       
2428        if hasattr(self, 'ordinates'):
2429            for ordinate in self.ordinates:
2430                frag=Element(CSML('ordinate'))
2431                GridOrdinateDescription.toXML(ordinate, frag)
2432                csmlFrag.append(frag)
2433        return csmlFrag
2434
2435class TimeInstant:
2436    def __init__(self, timePosition=None):
2437        if timePosition:
2438            self.timePosition=timePosition
2439    def fromXML(self,csmlFrag):
2440        for frag in csmlFrag.getchildren():
2441            if frag.tag==GML('timePosition'):
2442                self.timePosition=frag.text
2443    def toXML(self,csmlFrag):
2444         if hasattr(self,'timePosition'):
2445            frag = Element(GML('timePosition'))
2446            frag.text=self.timePosition
2447            csmlFrag.append(frag)
2448         return csmlFrag
2449
2450class TimePositionList(AssociationAttributeGroup):
2451              #class TimePositionList
2452              #+frame[0..1]:anyURI
2453              # + calendarEraName [0..1]:string (not implemented)
2454              # +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType  (not implemented)
2455    def __init__(self, frame=None, timePositions=None,*args, **kwargs):
2456        if frame:
2457            self.frame=frame
2458        if timePositions:
2459            self.timePositions=timePositions
2460        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2461    def fromXML(self,csmlFrag):
2462        self.timePositions=csmlFrag.text
2463        if csmlFrag.attrib.has_key('frame'):
2464            self.frame = csmlFrag.attrib['frame']
2465        AssociationAttributeGroup.fromXML(self,csmlFrag)
2466    def toXML(self,csmlFrag):
2467         if hasattr(self,'timePositions'):
2468            if  isinstance(self.timePositions, NASAAmesExtract):
2469                subFrag=Element(CSML('NASAAmesExtract'))
2470                NASAAmesExtract.toXML(self.timePositions,subFrag)
2471                csmlFrag.append(subFrag)
2472            elif  isinstance(self.timePositions, NetCDFExtract):
2473                subFrag=Element(CSML('NetCDFExtract'))
2474                NetCDFExtract.toXML(self.timePositions,subFrag)
2475                csmlFrag.append(subFrag)
2476            elif  isinstance(self.timePositions, GRIBExtract):
2477                subFrag=Element(CSML('GRIBExtract'))
2478                GRIBExtract.toXML(self.timePositions,subFrag)
2479                csmlFrag.append(subFrag)
2480            elif  isinstance(self.timePositions, PPExtract):
2481                subFrag=Element(CSML('PPExtract'))
2482                PPExtract.toXML(self.timePositions,subFrag)
2483                csmlFrag.append(subFrag)
2484            else:
2485                csmlFrag.text=self.timePositions
2486         if hasattr(self,'frame'):
2487             csmlFrag.attrib['frame']=self.frame
2488         AssociationAttributeGroup.toXML(self,csmlFrag)
2489         return csmlFrag
2490             
2491class Measure:
2492    def __init__(self, uom=None, vals=None):
2493        if uom:
2494            self.uom=uom
2495        if vals:
2496            self.vals=vals
2497    def fromXML(self,csmlFrag):
2498        self.vals=csmlFrag.text
2499        if csmlFrag.attrib.has_key('uom'):
2500            self.uom = csmlFrag.attrib['uom']
2501    def toXML(self, csmlFrag):
2502        frag = Element(GML('measure'))
2503        if hasattr(self, 'vals'):
2504            frag.text = self.vals
2505        if hasattr(self,'uom'):
2506            frag.attrib[('uom')] = self.uom
2507        csmlFrag.append(frag)
2508        return csmlFrag
2509
2510class MeasureOrNullList:
2511    #class MeasureOrNullList:
2512    # +uom[1]:anyURI
2513    #Actually based on doubleOrNullList, but not modelled to that level of detail.
2514   
2515    def __init__(self, uom=None, val=None):
2516        if uom:
2517            self.uom=uom
2518        if val:
2519            self.val=val
2520    def fromXML(self,csmlFrag):
2521        self.val=csmlFrag.text
2522        if csmlFrag.attrib.has_key('uom'):
2523            self.uom = csmlFrag.attrib['uom']
2524    def toXML(self, csmlFrag):
2525        if hasattr(self,'val'):
2526            if  isinstance(self.val, NASAAmesExtract):
2527                subFrag=Element(CSML('NASAAmesExtract'))
2528                NASAAmesExtract.toXML(self.val,subFrag)
2529                csmlFrag.append(subFrag)
2530            elif  isinstance(self.val, NetCDFExtract):
2531                subFrag=Element(CSML('NetCDFExtract'))
2532                NetCDFExtract.toXML(self.val,subFrag)
2533                csmlFrag.append(subFrag)
2534            elif  isinstance(self.val, GRIBExtract):
2535                subFrag=Element(CSML('GRIBExtract'))
2536                GRIBExtract.toXML(self.val,subFrag)
2537                csmlFrag.append(subFrag)
2538            elif  isinstance(self.val, PPExtract):
2539                subFrag=Element(CSML('PPExtract'))
2540                PPExtract.toXML(self.val,subFrag)
2541                csmlFrag.append(subFrag)
2542            else:
2543                csmlFrag.text = self.val
2544        if hasattr(self,'uom'):
2545           csmlFrag.attrib[('uom')] = self.uom
2546        return csmlFrag
2547   
2548class CompositeValue:
2549    def __init__(self, valueComponents=None):
2550        if valueComponents:
2551            self.valueComponents=valueComponents
2552    def fromXML(self,csmlFrag):
2553        for frag in csmlFrag.getchildren():
2554            if frag.tag == GML('valueComponents'):
2555                self.valueComponents = []
2556                for subFrag in frag.getchildren():                   
2557                    if subFrag.tag == GML('measure'):
2558                        self.valueComponents.append(Measure())
2559                        self.valueComponents[-1].fromXML(subFrag)
2560
2561    def toXML(self, csmlFrag):
2562         if hasattr(self,'valueComponents'):
2563            frag=Element(GML('valueComponents'))
2564            for valueComponent in self.valueComponents:
2565                if isinstance(valueComponent,Measure):
2566                    subFrag=Element(GML('measure'))
2567                    Measure.toXML(valueComponent,subFrag)
2568                    frag.append(subFrag)
2569            csmlFrag.append(frag)
2570         return csmlFrag
2571   
2572
2573   
2574class DataBlock:
2575    #class GML DataBlock
2576   
2577    #DataBlock()
2578    #+gml:rangeParameters
2579    def __init__(self,rangeParameters=None, doubleOrNullTupleList=None):
2580        if rangeParameters:
2581            self.rangeParameters=rangeParameters
2582        if doubleOrNullTupleList:
2583            self.doubleOrNullTupleList=doubleOrNullTupleList
2584    def fromXML(self,csmlFrag):
2585        for frag in csmlFrag.getchildren():
2586            if frag.tag == GML('rangeParameters'):
2587                for subFrag in frag.getchildren():
2588                    if subFrag.tag==GML('CompositeValue'):
2589                        self.rangeParameters=CompositeValue()
2590                        CompositeValue.fromXML(self.rangeParameters,subFrag)
2591            if frag.tag == GML('doubleOrNullTupleList'):
2592                self.doubleOrNullTupleList=frag.text
2593    def toXML(self,csmlFrag):
2594        if hasattr(self, 'rangeParameters'):
2595            frag=Element(GML('rangeParameters'))
2596            subFrag=Element(GML('CompositeValue'))
2597            CompositeValue.toXML(self.rangeParameters, subFrag)
2598            frag.append(subFrag)
2599            csmlFrag.append(frag)
2600        if hasattr(self,'doubleOrNullTupleList'):
2601            frag=Element(GML('doubleOrNullTupleList'))
2602            frag.text=self.doubleOrNullTupleList
2603            csmlFrag.append(frag)
2604        return csmlFrag
2605
2606
2607
2608class TypedCategory:
2609#class om:TypedCategory
2610    # +axis (attrib)
2611    # + codeSpace (attrib)
2612    def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs):
2613        if axis:
2614            self.axis=axis
2615        if codeSpace:
2616            self.codeSpace=codeSpace
2617        if text:
2618            self.text=text
2619    def fromXML(self,csmlFrag):
2620        if csmlFrag.attrib.has_key('axis'):
2621            self.axis=csmlFrag.attrib['axis']
2622        if csmlFrag.attrib.has_key('codeSpace'):
2623            self.codeSpace=csmlFrag.attrib['codeSpace']
2624        self.text=csmlFrag.text
2625    def toXML(self,csmlFrag):
2626        if hasattr(self,'axis'):
2627            csmlFrag.attrib[('axis')] =self.axis
2628        if hasattr(self,'codeSpace'):
2629            csmlFrag.attrib[('codeSpace')] =self.codeSpace
2630        csmlFrag.text=self.text
2631        return csmlFrag
2632
2633class Phenomenon(Definition,AssociationAttributeGroup):
2634    #class Obs& Measures: PhenomenonProperty
2635    #Note, in this does not really inherit from AbstractGML, but for CMSL
2636    #purposes it is used  to pick up the basic description, id, name attributes
2637    def __init__(self,*args,**kwargs):
2638         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None.
2639        self.MetaDataProperty=None
2640        Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs)
2641        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2642    def fromXML(self,csmlFrag):
2643        Definition.fromXML(self,csmlFrag)
2644        AssociationAttributeGroup.fromXML(self,csmlFrag)
2645       
2646    def toXML(self,csmlFrag):
2647        csmlFrag=Definition.toXML(self,csmlFrag)
2648        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2649        return csmlFrag
2650
2651
2652class OLD_CompositePhenomenon(Phenomenon):
2653    #Class om:CompositePhenomenon
2654    # + om:componentPhenomenon [1...*]
2655    def __init__(self,componentPhenomenon=None,*args,**kwargs):
2656        Phenomenon.__init__(self,*args,**kwargs)
2657        if componentPhenomenon:
2658            self.componentPhenomenon=componentPhenomenon
2659    def fromXML(self,csmlFrag):
2660        Phenomenon.fromXML(self,csmlFrag)
2661        for frag in csmlFrag.getchildren():
2662            if frag.tag == OM('componentPhenomenon'):
2663                checkArrayAttrib(self,'componentPhenomenon')
2664                self.componentPhenomenon.append(frag.attrib)
2665    def toXML(self,csmlFrag):
2666        Phenomenon.toXML(self,csmlFrag)
2667        if hasattr(self, 'componentPhenomenon'):
2668            for cp in self.componentPhenomenon:
2669                frag=Element(OM('componentPhenomenon'))
2670                frag.attrib= cp
2671                csmlFrag.append(frag)
2672        return csmlFrag
2673
2674class CompositePhenomenon(Phenomenon):
2675    #Class om:CompositePhenomenon
2676    # + om:componentPhenomenon [1...*]
2677    def __init__(self,componentPhenomena=None,*args,**kwargs):
2678        Phenomenon.__init__(self,*args,**kwargs)
2679        if componentPhenomena:
2680            self.componentPhenomena=componentPhenomena
2681    def fromXML(self,csmlFrag):
2682        Phenomenon.fromXML(self,csmlFrag)
2683        self.componentPhenomena=[]
2684        for frag in csmlFrag.getchildren():
2685            if frag.tag == OM('componentPhenomenon'):
2686                componentPhenomenon=Phenomenon()
2687                Phenomenon.fromXML(componentPhenomenon,frag)
2688                self.componentPhenomena.append(componentPhenomenon)
2689    def toXML(self,csmlFrag):
2690        Phenomenon.toXML(self,csmlFrag)
2691        if hasattr(self, 'componentPhenomena'):
2692            for phenomenon in self.componentPhenomena:
2693                frag=Element(OM('componentPhenomenon'))
2694                Phenomenon.toXML(phenomenon,frag)
2695                csmlFrag.append(frag)
2696        return csmlFrag
2697           
2698               
2699class ParameterisedPhenomenon(Phenomenon):
2700    #Class ParameterisedPhenomenon:
2701        # + basePhenomenon
2702        # + constraint
2703        # + href (attrib)
2704    def __init__(self,*args,**kwargs):
2705        Phenomenon.__init__(self,*args,**kwargs)
2706    def fromXML(self,csmlFrag):
2707        Phenomenon.fromXML(self,csmlFrag)
2708        for frag in csmlFrag.getchildren():
2709            if frag.tag == OM('basePhenomenon'):
2710                self.basePhenomenon=frag.text
2711                if frag.attrib.has_key(XLINK('href')):
2712                    self.href = frag.attrib[XLINK('href')]
2713            if frag.tag == OM('constraint'):
2714                subFrag=frag.getchildren()[0]
2715                if subFrag.tag== OM('TypedCategory'):
2716                    self.constraint = TypedCategory()
2717                #TO DO: what other types are valid?
2718                elif subFrag.tag== OM('??'):
2719                    self.constraint = 123
2720                self.constraint.fromXML(subFrag)
2721    def toXML(self,csmlFrag):
2722        csmlFrag=Phenomenon.toXML(self,csmlFrag)
2723        if hasattr(self,'basePhenomenon'):
2724            frag=Element(OM('basePhenomenon'))
2725            frag.text=self.basePhenomenon
2726            if hasattr(self, 'href'):
2727                frag.attrib[XLINK('href')] = self.href
2728            csmlFrag.append(frag)
2729        if hasattr(self, 'constraint'):
2730            frag=Element(OM('constraint'))
2731            subFrag=Element(OM('TypedCategory'))
2732            subFrag=self.constraint.toXML(subFrag)
2733            frag.append(subFrag)
2734            csmlFrag.append(frag)
2735        return csmlFrag
2736
2737class RangeSet(AssociationAttributeGroup):
2738#class GML RangeSet 
2739
2740        # RangeSet()
2741        # +gml:ValueArray
2742        # +gml:_ScalarValueList
2743        # +gml:DataBlock
2744        # +gml:File
2745    #class GML RangeSet
2746    def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None,*args,**kwargs):
2747        if quantityList:
2748            self.quantityList=quantityList
2749        if dataBlock:
2750            self.dataBlock=dataBlock
2751        if arrayDescriptor:
2752            self.arrayDescriptor=arrayDescriptor
2753        if aggregatedArray:
2754            self.aggregatedArray=aggregatedArray
2755        AssociationAttributeGroup.__init__(self,*args,**kwargs)
2756           
2757    def fromXML(self,csmlFrag):
2758        for frag in csmlFrag.getchildren():
2759            if frag.tag==GML('QuantityList'):
2760                self.quantityList=MeasureOrNullList()
2761                MeasureOrNullList.fromXML(self.quantityList,frag)
2762            elif frag.tag==GML('DataBlock'):
2763                self.dataBlock=DataBlock()
2764                DataBlock.fromXML(self.dataBlock, frag)
2765            elif frag.tag == CSML('NetCDFExtract'):
2766                self.arrayDescriptor=NetCDFExtract()
2767                NetCDFExtract.fromXML(self.arrayDescriptor,frag)
2768            elif frag.tag == CSML('NASAmesExtract'):
2769                self.arrayDescriptor=NASAAmesExtract()
2770                NASAAmesExtract.fromXML(self.arrayDescriptor,frag)
2771            elif frag.tag == CSML('GRIBExtract'):
2772                self.arrayDescriptor=GRIBExtract()
2773                GRIBExtract.fromXML(self.ArrayDescriptor,frag)
2774            elif frag.tag == CSML('PPExtract'):
2775                self.arrayDescriptor=PPExtract()
2776                PPExtract.fromXML(self.ArrayDescriptor,frag)
2777            elif frag.tag == CSML('AggregatedArray'):
2778                self.aggregatedArray=AggregatedArray()
2779                AggregatedArray.fromXML(self.aggregatedArray,frag)
2780        AssociationAttributeGroup.fromXML(self,csmlFrag)
2781
2782    def toXML(self, csmlFrag):
2783        if hasattr(self,'quantityList'):
2784            frag = Element(GML('QuantityList'))
2785            MeasureOrNullList.toXML(self.quantityList,frag)
2786            csmlFrag.append(frag)
2787        if hasattr(self,'dataBlock'):
2788            frag=Element(GML('DataBlock'))
2789            DataBlock.toXML(self.dataBlock,frag)
2790            csmlFrag.append(frag)
2791        if hasattr(self,'aggregatedArray'):
2792            frag=Element(CSML('AggregatedArray'))
2793            AggregatedArray.toXML(self.aggregatedArray,frag)
2794            csmlFrag.append(frag)
2795        if hasattr(self,'arrayDescriptor'):
2796            if isinstance(self.arrayDescriptor,NetCDFExtract):
2797                frag=Element(CSML('NetCDFExtract'))
2798                NetCDFExtract.toXML(self.arrayDescriptor,frag)
2799                csmlFrag.append(frag)
2800            elif isinstance(self.arrayDescriptor,NASAAmesExtract):
2801                frag=Element(CSML('NASAAmesExtract'))
2802                NASAAmesExtract.toXML(self.arrayDescriptor,frag)
2803                csmlFrag.append(frag)
2804            elif isinstance(self.arrayDescriptor,GRIBExtract):
2805                frag=Element(CSML('GRIBExtract'))
2806                GRIBExtract.toXML(self.arrayDescriptor,frag)
2807                csmlFrag.append(frag)
2808            elif isinstance(self.arrayDescriptor,PPExtract):
2809                frag=Element(CSML('PPExtract'))
2810                PPAmesExtract.toXML(self.arrayDescriptor,frag)
2811                csmlFrag.append(frag)
2812        csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag)
2813        return csmlFrag
2814
2815class PointDomain(AbstractDomain):
2816    def __init__(self,*args,**kwargs):
2817        AbstractDomain.__init__(self,*args,**kwargs)
2818    def fromXML(self,csmlFrag):
2819        AbstractDomain.fromXML(self,csmlFrag)
2820    def toXML(self,csmlFrag):
2821        AbstractDomain.toXML(self,csmlFrag)
2822        return csmlFrag
2823   
2824class ProfileDomain(AbstractDomain):
2825    def __init__(self,*args,**kwargs):
2826        AbstractDomain.__init__(self,*args,**kwargs)
2827    def fromXML(self,csmlFrag):
2828        AbstractDomain.fromXML(self,csmlFrag)
2829    def toXML(self,csmlFrag):
2830        AbstractDomain.toXML(self,csmlFrag)
2831        return csmlFrag
2832
2833class GridDomain(AbstractDomain):
2834    def __init__(self,*args,**kwargs):
2835        AbstractDomain.__init__(self,*args,**kwargs)
2836    def fromXML(self,csmlFrag):
2837        AbstractDomain.fromXML(self,csmlFrag)
2838    def toXML(self,csmlFrag):
2839        AbstractDomain.toXML(self,csmlFrag)
2840        return csmlFrag
2841   
2842class PointSeriesDomain(AbstractDomain):
2843    def __init__(self,*args,**kwargs):
2844        AbstractDomain.__init__(self,*args,**kwargs)
2845    def fromXML(self,csmlFrag):
2846        AbstractDomain.fromXML(self,csmlFrag)
2847    def toXML(self,csmlFrag):
2848        AbstractDomain.toXML(self,csmlFrag)
2849        return csmlFrag
2850   
2851class ProfileSeriesDomain(AbstractDomain):
2852    def __init__(self,*args,**kwargs):
2853        AbstractDomain.__init__(self,*args,**kwargs)
2854    def fromXML(self,csmlFrag):
2855        AbstractDomain.fromXML(self,csmlFrag)
2856    def toXML(self,csmlFrag):
2857        AbstractDomain.toXML(self,csmlFrag)
2858        return csmlFrag
2859   
2860class GridSeriesDomain(AbstractDomain):
2861    def __init__(self,*args,**kwargs):
2862        AbstractDomain.__init__(self,*args,**kwargs)
2863    def fromXML(self,csmlFrag):
2864        AbstractDomain.fromXML(self,csmlFrag)
2865    def toXML(self,csmlFrag):
2866        AbstractDomain.toXML(self,csmlFrag)
2867        return csmlFrag
2868
2869class PointFeature(AbstractStaticCoverageFeature):
2870    #CSML PointFeature class
2871    #       PointFeature(AbstractStaticCoverageFeatureType):
2872    #      +PointDomain
2873    def __init__(self, domain=None,*args,**kwargs):
2874        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2875        if domain:
2876            self.domain=domain
2877    def __str__(self):
2878        return 'PointFeature'
2879    def fromXML(self,csmlFrag):
2880        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2881        for frag in csmlFrag.getchildren():
2882            if frag.tag == CSML('PointDomain'):
2883                self.domain = PointDomain()
2884                self.domain.fromXML(frag)
2885    def toXML(self,csmlFrag):
2886        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2887        if hasattr(self,'domain'):
2888            frag = Element(CSML('PointDomain'))
2889            PointDomain.toXML(self.domain,frag)
2890#             if hasattr(self,'href'):
2891#                 frag.attrib[XLINK('href')] = self.href
2892            csmlFrag.append(frag)
2893        return csmlFrag
2894
2895   
2896class PointSeriesFeature(AbstractSeriesCoverageFeature):
2897    #CSML PointSeriesFeature class
2898    #       PointSeriesFeature(AbstractStaticCoverageFeatureType):
2899    #      +pointSeriesDomain[1]:PointSeriesDomain
2900
2901    def __init__(self,domain=None,*args,**kwargs):
2902        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs)
2903        if domain:
2904            self.domain=domain
2905    def __str__(self):
2906        return 'PointSeriesFeature'
2907    def fromXML(self,csmlFrag):
2908        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag)
2909        for frag in csmlFrag.getchildren():
2910            if frag.tag == CSML('PointSeriesDomain'):
2911                self.domain = PointSeriesDomain()
2912                self.domain.fromXML(frag)
2913    def toXML(self,csmlFrag):
2914        AbstractSeriesCoverageFeature.toXML(self,csmlFrag)
2915        if hasattr(self,'domain'):
2916             frag = Element(CSML('PointSeriesDomain'))
2917             PointSeriesDomain.toXML(self.domain,frag)
2918             csmlFrag.append(frag)
2919        return csmlFrag
2920
2921class ProfileFeature(AbstractStaticCoverageFeature):
2922     #CSML ProfileFeature class
2923    #       ProfileFeature(AbstractStaticCoverageFeature):
2924    #      +profileDomain[1]:ProfileDomain
2925
2926    def __init__(self,domain=None,*args,**kwargs):
2927        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2928        if domain:
2929            self.domain=domain
2930    def __str__(self):
2931        return 'ProfileFeature'
2932    def fromXML(self,csmlFrag):
2933        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2934        for frag in csmlFrag.getchildren():
2935            if frag.tag == CSML('ProfileDomain'):
2936                self.domain = ProfileDomain()
2937                ProfileDomain.fromXML(self.domain,frag)
2938    def toXML(self,csmlFrag):
2939        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2940        if hasattr(self,'domain'):
2941             frag = Element(CSML('ProfileDomain'))
2942             ProfileDomain.toXML(self.domain,frag)
2943             csmlFrag.append(frag)
2944        return csmlFrag
2945
2946
2947class ProfileSeriesFeature(AbstractStaticCoverageFeature):
2948#CSML ProfileSeriesFeature class
2949    #       ProfileSeriesFeature(AbstractStaticCoverageFeature):
2950    #      +ProfileSeriesDomain
2951
2952    def __init__(self,domain=None,*args,**kwargs):
2953        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2954        if domain:
2955            self.domain=domain
2956    def __str__(self):
2957        return 'ProfileSeriesFeature'
2958    def fromXML(self,csmlFrag):
2959        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2960        for frag in csmlFrag.getchildren():
2961            if frag.tag == CSML('ProfileSeriesDomain'):
2962                self.domain = ProfileSeriesDomain()
2963                ProfileSeriesDomain.fromXML(self.domain,frag)
2964    def toXML(self,csmlFrag):
2965        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2966        if hasattr(self,'domain'):
2967             frag = Element(CSML('ProfileSeriesDomain'))
2968             ProfileSeriesDomain.toXML(self.domain,frag)
2969             csmlFrag.append(frag)
2970        return csmlFrag
2971
2972
2973class GridFeature(AbstractStaticCoverageFeature):
2974#CSML GridFeature class
2975    #       GridFeature(AbstractStaticCoverageFeature):
2976    #      +gridDomain[1]:gridDomain
2977
2978    def __init__(self,domain=None,*args,**kwargs):
2979        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
2980        if domain:
2981            self.domain=domain
2982    def __str__(self):
2983        return 'GridFeature'
2984    def fromXML(self,csmlFrag):
2985        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
2986        for frag in csmlFrag.getchildren():
2987            if frag.tag == CSML('GridDomain'):
2988                self.domain = GridDomain()
2989                self.domain.fromXML(frag)
2990    def toXML(self,csmlFrag):
2991        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
2992        if hasattr(self,'domain'):
2993             frag = Element(CSML('GridDomain'))
2994             GridDomain.toXML(self.domain,frag)
2995             csmlFrag.append(frag)
2996        return csmlFrag
2997
2998
2999class GridSeriesFeature(AbstractStaticCoverageFeature):
3000    def __init__(self,domain=None,*args,**kwargs):
3001        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
3002        if domain:
3003            self.domain=domain
3004    def __str__(self):
3005        return 'GridSeriesFeature'
3006    def fromXML(self,csmlFrag):
3007        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
3008        for frag in csmlFrag.getchildren():
3009            if frag.tag == CSML('GridSeriesDomain'):
3010                self.domain = GridSeriesDomain()
3011                self.domain.fromXML(frag)
3012    def toXML(self,csmlFrag):
3013        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
3014        if hasattr(self,'domain'):
3015             frag = Element(CSML('GridSeriesDomain'))
3016             GridSeriesDomain.toXML(self.domain,frag)
3017             csmlFrag.append(frag)
3018        return csmlFrag
3019
3020
3021   
3022class AbstractFeature(AbstractGML):
3023    def __init__(self,boundedBy=None,*args,**kwargs):
3024        AbstractGML.__init__(self,*args,**kwargs)
3025        if boundedBy:
3026            self.boundedBy=boundedBy
3027    def fromXML(self,csmlFrag):
3028        AbstractGML.fromXML(self,csmlFrag)
3029        for frag in csmlFrag.getchildren():
3030            if frag.tag == GML('boundedBy'):
3031                self.boundedBy = EnvelopeWithTimePeriod()
3032                self.boundedBy.fromXML(frag)
3033    def toXML(self,csmlFrag):
3034        AbstractGML.toXML(self,csmlFrag)
3035        if hasattr(self,'boundedBy'):
3036             superfrag = Element(GML('boundedBy'))
3037             frag = Element (GML('EnvelopeWithTimePeriod'))
3038             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag)
3039             superfrag.append(frag)
3040             csmlFrag.append(superfrag)
3041        return csmlFrag
3042
3043class AbstractGeometryFeature(AbstractFeature):
3044    def __init__(self,*args,**kwargs):
3045        AbstractFeature.__init__(self,*args,**kwargs)
3046    def fromXML(self,csmlFrag):
3047        AbstractFeature.fromXML(self,csmlFrag)
3048    def toXML(self, csmlFrag):
3049        AbstractFeature.toXML(self,csmlFrag)
3050        return csmlFrag
3051
3052
3053class TrajectoryFeature(AbstractGeometryFeature):
3054    def __init__(self,track=None, *args, **kwargs):
3055        AbstractGeometryFeature.__init__(self,*args,**kwargs)
3056        if track:
3057            self.track=track
3058    def __str__(self):
3059        return 'TrajectoryFeature'
3060    def fromXML(self,csmlFrag):
3061        AbstractGeometryFeature.fromXML(self,csmlFrag)
3062        for frag in csmlFrag.getchildren():
3063            if frag.tag == CSML('track'):
3064                self.track=Trajectory()
3065                Trajectory.fromXML(self.track,frag)
3066    def toXML(self,csmlFrag):
3067        AbstractGeometryFeature.toXML(self,csmlFrag)
3068        if hasattr(self, 'track'):
3069            frag = Element(CSML('track'))
3070            subFrag=Element(CSML('Trajectory'))
3071            Trajectory.toXML(self.track,subFrag)
3072            frag.append(subFrag)
3073            csmlFrag.append(frag)
3074        return csmlFrag
3075       
3076class AbstractFeatureCollection(AbstractFeature):
3077    """GML AbstractFeatureCollection class
3078
3079    AbstractFeatureCollection(AbstractFeature):
3080     +featureMember[0..*]: AbstractFeature
3081     +featureMembers[0..1]: FeatureArray
3082    """
3083    def __init__(self,members=[]):
3084        if members:
3085            self.members=members
3086    def fromXML(self,csmlFrag):
3087        AbstractFeature.fromXML(self,csmlFrag)
3088        for frag in csmlFrag.getchildren():
3089            if frag.tag == GML('featureMember'):
3090                checkArrayAttrib(self,'members')
3091                featureFrag = frag.getchildren()[0]
3092                if featureFrag.tag == CSML('PointFeature'):
3093                    self.members.append(PointFeature())
3094                    self.members[-1].fromXML(featureFrag)
3095                if featureFrag.tag == CSML('ProfileFeature'):
3096                    self.members.append(ProfileFeature())
3097                    self.members[-1].fromXML(featureFrag)
3098                if featureFrag.tag == CSML('GridFeature'):
3099                    self.members.append(GridFeature())
3100                    self.members[-1].fromXML(featureFrag)
3101                if featureFrag.tag == CSML('PointSeriesFeature'):
3102                    self.members.append(PointSeriesFeature())
3103                    self.members[-1].fromXML(featureFrag)
3104                if featureFrag.tag == CSML('ProfileSeriesFeature'):
3105                    self.members.append(ProfileSeriesFeature())
3106                    self.members[-1].fromXML(featureFrag)
3107                if featureFrag.tag == CSML('GridSeriesFeature'):
3108                    self.members.append(GridSeriesFeature())
3109                    self.members[-1].fromXML(featureFrag)
3110                if featureFrag.tag == CSML('TrajectoryFeature'):
3111                    self.members.append(TrajectoryFeature())
3112                    self.members[-1].fromXML(featureFrag)
3113    def toXML(self,csmlFrag):
3114        AbstractFeature.toXML(self,csmlFrag)
3115        for member in self.members:
3116            if isinstance(member,PointFeature):
3117                superFrag=Element(GML('featureMember'))
3118                frag=Element(CSML('PointFeature'))
3119                PointFeature.toXML(member,frag)
3120                superFrag.append(frag)
3121                csmlFrag.append(superFrag)
3122            if isinstance(member,ProfileFeature):
3123                superFrag=Element(GML('featureMember'))
3124                frag=Element(CSML('ProfileFeature'))
3125                ProfileFeature.toXML(member,frag)
3126                superFrag.append(frag)
3127                csmlFrag.append(superFrag)
3128            if isinstance(member,GridFeature):
3129                superFrag=Element(GML('featureMember'))
3130                frag=Element(CSML('GridFeature'))
3131                GridFeature.toXML(member,frag)
3132                superFrag.append(frag)
3133                csmlFrag.append(superFrag)
3134            if isinstance(member,PointSeriesFeature):
3135                superFrag=Element(GML('featureMember'))
3136                frag=Element(CSML('PointSeriesFeature'))
3137                PointSeriesFeature.toXML(member,frag)
3138                superFrag.append(frag)
3139                csmlFrag.append(superFrag)
3140            if isinstance(member,ProfileSeriesFeature):
3141                superFrag=Element(GML('featureMember'))
3142                frag=Element(CSML('ProfileSeriesFeature'))
3143                ProfileSeriesFeature.toXML(member,frag)
3144                superFrag.append(frag)
3145                csmlFrag.append(superFrag)
3146            if isinstance(member,GridSeriesFeature):
3147                superFrag=Element(GML('featureMember'))
3148                frag=Element(CSML('GridSeriesFeature'))
3149                GridSeriesFeature.toXML(member,frag)
3150                superFrag.append(frag)
3151                csmlFrag.append(superFrag)
3152            if isinstance(member,TrajectoryFeature):
3153                superFrag=Element(GML('featureMember'))
3154                frag=Element(CSML('TrajectoryFeature'))
3155                TrajectoryFeature.toXML(member,frag)
3156                superFrag.append(frag)
3157                csmlFrag.append(superFrag)
3158       
3159        return csmlFrag
3160
3161class FeatureCollection(AbstractFeatureCollection):
3162    """GML FeatureCollection class
3163        FeatureCollection()
3164        +featureMembers[0..*]
3165    """
3166    def __init__(self,*args,**kwargs):
3167        AbstractFeatureCollection.__init__(self,*args,**kwargs)
3168    def fromXML(self,csmlFrag):
3169        AbstractFeatureCollection.fromXML(self,csmlFrag)
3170    def toXML(self,csmlFrag):
3171        AbstractFeatureCollection.toXML(self,csmlFrag)
3172        return csmlFrag
3173
3174
3175class SimpleCondition:
3176        def __init__(self,dgAttributeAuthority=None,attrauthRole=None,*args,**kwargs):
3177            if dgAttributeAuthority:
3178                self.dgAttributeAuthority=dgAttributeAuthority
3179            if attrauthRole:
3180                self.attrauthRole=attrauthRole
3181        def fromXML(self,csmlFrag):
3182            for frag in csmlFrag.getchildren():
3183                if frag.tag == MOLES('dgAttributeAuthority'):
3184                    self.dgAttributeAuthority=frag.text
3185                if frag.tag == MOLES('attrauthRole'):
3186                    self.attrauthRole=frag.text
3187        def toXML(self,csmlFrag):
3188            if hasattr(self,'dgAttributeAuthority'):
3189                frag=Element(MOLES('dgAttributeAuthority'))
3190                frag.text=self.dgAttributeAuthority
3191                csmlFrag.append(frag)
3192            if hasattr(self,'attrauthRole'):
3193                frag=Element(MOLES('attrauthRole'))
3194                frag.text=self.attrauthRole
3195                csmlFrag.append(frag)
3196            return csmlFrag
3197   
3198class DGSecurityCondition:
3199        def __init__(self,effect=None,simpleCondition=None, complexCondition=None, conditionExplanationText=None,*args,**kwargs):
3200            if effect:
3201                self.effect=effect
3202            if simpleCondition:
3203                self.simpleCondition=simpleCondition
3204            if complexCondition:
3205                self.complexCondition=complexCondition
3206            if conditionExplanationText:
3207                self.conditionExplanationText=conditionExplanationText
3208        def fromXML(self,csmlFrag):
3209            for frag in csmlFrag.getchildren():
3210                if frag.tag == MOLES('effect'):
3211                    self.effect=frag.text
3212                elif frag.tag == MOLES('conditionExplanationText'):
3213                    self.conditionExplanationText=frag.text
3214                elif frag.tag == MOLES('simpleCondition'):
3215                    simpleCondition=SimpleCondition()
3216                    simpleCondition.fromXML(frag)
3217                    self.simpleCondition=simpleCondition
3218        def toXML(self,csmlFrag):
3219            if hasattr(self,'effect'):
3220                frag=Element(MOLES('effect'))
3221                frag.text=self.effect
3222                csmlFrag.append(frag)
3223            if hasattr(self,'simpleCondition'):
3224                frag=Element(MOLES('simpleCondition'))
3225                frag = SimpleCondition.toXML(self.simpleCondition,frag)
3226                csmlFrag.append(frag)
3227            return csmlFrag
3228       
3229class AccessControlPolicy:
3230        """ AccessControlPolicy class"""
3231        def __init__(self,dgSecurityConditions=None,accessControlPolicyText=None,accessControlPolicyURL=None,*args,**kwargs):
3232            if dgSecurityConditions:
3233                self.dgSecurityConditions=dgSecurityConditions
3234            if accessControlPolicyText:
3235                self.accessControlPolicyText= accessControlPolicyText
3236            if accessControlPolicyURL:
3237                self.accessControlPolicyURL= accessControlPolicyURL
3238        def fromXML(self,csmlFrag):
3239           
3240#             for frag in csmlFrag.getchildren():
3241#                 print frag.tag
3242#                 print MOLES('dgSecurityCondition')
3243#             #sys.exit()
3244            for frag in csmlFrag.getchildren():
3245                if frag.tag == MOLES('dgSecurityCondition'):
3246                    checkArrayAttrib(self, 'dgSecurityConditions')
3247                    dgSecurityCondition=DGSecurityCondition()
3248                    dgSecurityCondition.fromXML(frag)
3249                    self.dgSecurityConditions.append(dgSecurityCondition)
3250                elif frag.tag == MOLES('accessControlPolicyText'):
3251                    checkArrayAttrib(self,'accessControlPolicyText')
3252                    self.accessControlPolicyText.append(frag.text)
3253                elif frag.tag == MOLES('accessControlPolicyURL'):
3254                    checkArrayAttrib(self,'accessControlPolicyURL')
3255                    self.accessControlPolicyURL.append(frag.text)
3256        def toXML(self,csmlFrag):
3257            if hasattr(self,'dgSecurityConditions'):
3258                for condition in self.dgSecurityConditions:
3259                    frag = Element(MOLES('dgSecurityCondition'))
3260                    frag = DGSecurityCondition.toXML(condition,frag)
3261                    csmlFrag.append(frag)
3262            if hasattr(self,'accessControlPolicyText'):     
3263                for txt in self.accessControlPolicyText:
3264                    frag=Element(MOLES('accessControlPolicyText'))
3265                    frag.text=txt
3266                    csmlFrag.append(frag)
3267            if hasattr(self,'accessControlPolicyURL'):     
3268                for policyURL in self.accessControlPolicyURL:
3269                    frag=Element(MOLES('accessControlPolicyURL'))
3270                    frag.text=policyURL
3271                    csmlFrag.append(frag)
3272            return csmlFrag
3273       
3274class Dataset(AbstractGML):
3275    """CSML Dataset class
3276
3277    Dataset(AbstractGML):
3278     + accessControlPolicy[0...1]:AccessControlPolicy
3279     +unitDefinitions[0..*]: UnitDefinitions
3280     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
3281     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
3282     +arrayDescriptors[0..*]: AbstractArrayDescriptor
3283     +featureCollection[0..1]: FeatureCollection
3284    """
3285    def __init__(self,accessControlPolicy=None, unitDefinitions=None,referenceSystemDefinitions=None,
3286                 phenomenonDefinitions=None,arrayDescriptors=[],
3287                 featureCollection=None,*args,**kwargs):
3288        AbstractGML.__init__(self,*args,**kwargs)
3289        if accessControlPolicy:
3290            self.accessControlPolicy=accessControlPolicy
3291        if unitDefinitions:
3292            self.unitDefinitions = unitDefinitions
3293        if referenceSystemDefinitions:
3294            self.referenceSystemDefinitions = referenceSystemDefinitions
3295        if phenomenonDefinitions:
3296            self.phenomenonDefinitions = phenomenonDefinitions
3297        if arrayDescriptors:
3298            self.arrayDescriptors = arrayDescriptors
3299        if featureCollection:
3300            self.featureCollection = featureCollection
3301    def fromXML(self,csmlFrag):
3302        if csmlFrag.tag != CSML('Dataset'):
3303            print 'This does not appear to be a CSML file. Does not contain a root Dataset element.'
3304            print ' '
3305            sys.exit()
3306        AbstractGML.fromXML(self,csmlFrag)
3307        for frag in csmlFrag.getchildren():
3308            if frag.tag == CSML('AccessControlPolicy'):
3309                self.accessControlPolicy = AccessControlPolicy()
3310                self.accessControlPolicy.fromXML(frag)
3311            elif frag.tag == CSML('UnitDefinitions'):
3312                self.unitDefinitions = UnitDefinitions()
3313                self.unitDefinitions.fromXML(frag)
3314            elif frag.tag == CSML('ReferenceSystemDefinitions'):
3315                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
3316                self.referenceSystemDefinitions.fromXML(frag)
3317            elif frag.tag == CSML('PhenomenonDefinitions'):
3318                self.phenomenonDefinitions = PhenomenonDefinitions()
3319                self.phenomenonDefinitions.fromXML(frag)
3320            elif frag.tag == GML('FeatureCollection'):
3321                self.featureCollection = FeatureCollection()
3322                self.featureCollection.fromXML(frag)
3323            elif frag.tag == CSML('AggregatedArray'):
3324                checkArrayAttrib(self,'arrayDescriptors')
3325                self.arrayDescriptors.append(AggregatedArray())
3326                self.arrayDescriptors[-1].fromXML(frag)
3327            elif frag.tag == CSML('InlineArray'):
3328                checkArrayAttrib(self,'arrayDescriptors')
3329                self.arrayDescriptors.append(InlineArray())
3330                self.arrayDescriptors[-1].fromXML(frag)
3331            elif frag.tag == CSML('ArrayGenerator'):
3332                checkArrayAttrib(self,'arrayDescriptors')
3333                self.arrayDescriptors.append(ArrayGenerator())
3334                self.arrayDescriptors[-1].fromXML(frag)
3335            elif frag.tag == CSML('NASAAmesExtract'):
3336                checkArrayAttrib(self,'arrayDescriptors')
3337                self.arrayDescriptors.append(NASAAmesExtract())
3338                self.arrayDescriptors[-1].fromXML(frag)
3339            elif frag.tag == CSML('NetCDFExtract'):
3340                checkArrayAttrib(self,'arrayDescriptors')
3341                self.arrayDescriptors.append(NetCDFExtract())
3342                self.arrayDescriptors[-1].fromXML(frag)
3343            elif frag.tag == CSML('GRIBExtract'):
3344                checkArrayAttrib(self,'arrayDescriptors')
3345                self.arrayDescriptors.append(GRIBExtract())
3346                self.arrayDescriptors[-1].fromXML(frag)
3347            elif frag.tag == CSML('PPExtract'):
3348                checkArrayAttrib(self,'arrayDescriptors')
3349                self.arrayDescriptors.append(PPExtract())
3350                self.arrayDescriptors[-1].fromXML(frag)
3351##            else:
3352##                raise Exception('Unexpected element: "'+frag.tag+'"')
3353    def toXML(self,csmlFrag=None):
3354        if csmlFrag is None:
3355            csmlFrag = Element('Dataset')
3356        csmlFrag = AbstractGML.toXML(self,csmlFrag)
3357        if hasattr(self,'accessControlPolicy'):
3358            frag = Element(CSML('AccessControlPolicy'))
3359            frag = AccessControlPolicy.toXML(self.accessControlPolicy,frag)
3360            csmlFrag.append(frag)
3361        if hasattr(self,'unitDefinitions'):
3362            frag = Element(CSML('UnitDefinitions'))
3363            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
3364            csmlFrag.append(frag)
3365        if hasattr(self,'referenceSystemDefinitions'):
3366            frag = Element(CSML('ReferenceSystemDefinitions'))
3367            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
3368            csmlFrag.append(frag)
3369        if hasattr(self,'phenomenonDefinitions'):
3370            frag = Element(CSML('PhenomenonDefinitions'))
3371            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
3372            csmlFrag.append(frag)
3373        if hasattr(self,'arrayDescriptors'):
3374            for arrayDesc in self.arrayDescriptors:
3375                if isinstance(arrayDesc,AggregatedArray):
3376                    frag = Element(CSML('AggregatedArray'))
3377                    frag = AggregatedArray.toXML(arrayDesc,frag)
3378                elif isinstance(arrayDesc,InlineArray):
3379                    frag = Element(CSML('InlineArray'))
3380                    frag = InlineArray.toXML(arrayDesc,frag)
3381                elif isinstance(arrayDesc,ArrayGenerator):
3382                    frag = Element(CSML('ArrayGenerator'))
3383                    frag = ArrayGenerator.toXML(arrayDesc,frag)
3384                elif isinstance(arrayDesc,NASAAmesExtract):
3385                    frag = Element(CSML('NASAAmesExtract'))
3386                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
3387                elif isinstance(arrayDesc,NetCDFExtract):
3388                    frag = Element(CSML('NetCDFExtract'))
3389                    frag = NetCDFExtract.toXML(arrayDesc,frag)
3390                elif isinstance(arrayDesc,GRIBExtract):
3391                    frag = Element(CSML('GRIBExtract'))
3392                    frag = GRIBExtract.toXML(arrayDesc,frag)
3393                elif isinstance(arrayDesc,PPExtract):
3394                    frag = Element(CSML('PPExtract'))
3395                    frag = PPExtract.toXML(arrayDesc,frag)
3396                csmlFrag.append(frag)
3397        if hasattr(self,'featureCollection'):
3398            frag = Element(GML('FeatureCollection'))
3399            frag = FeatureCollection.toXML(self.featureCollection,frag)
3400            csmlFrag.append(frag)
3401            #csmlFrag=fixNameSpaces(csmlFrag)
3402        return csmlFrag
Note: See TracBrowser for help on using the repository browser.