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

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

corrected namespace of AggregatedArray?

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