source: TI02-CSML/trunk/csml/parser.py @ 2377

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

fixed Xlinking in SpatialOrTemporalLists? fixed uom attribute

Line 
1import cElementTree as ET
2import elementtree.ElementTree as etree
3import sys, traceback
4import csml
5'''CSML v2 Parser ''' 
6
7#this map needs updating for V2
8etree._namespace_map.update({'http://www.opengis.net/om': 'om', 'http://www.opengis.net/swe': 'swe',  'http://www.opengis.net/gml': 'gml','http://ndg.nerc.ac.uk/csml' : 'csml', 'http://www.w3.org/1999/xlink':'xlink'})
9
10nsCSML = 'http://ndg.nerc.ac.uk/csml'
11nsGML = 'http://www.opengis.net/gml'
12nsOM = 'http://www.opengis.net/om'
13nsXLINK = 'http://www.w3.org/1999/xlink'
14nsXML = 'http://ndg.nerc.ac.uk/csml'
15nsMOLES='http://ndg.nerc.ac.uk/moles'
16nsSWE='http://www.opengis.net/swe'
17
18
19def myQName(uri,tag):
20    return "{"+uri+"}"+tag
21
22def CSML(tag):
23    return myQName(nsCSML,tag)
24
25def GML(tag):
26    return myQName(nsGML,tag)
27
28def SWE(tag):
29    return myQName(nsSWE,tag)
30
31def XLINK(tag):
32    return myQName(nsXLINK,tag)
33
34def addchildren(obj, dict):
35    ''' merges (adds) dictionary to existing self.CHILDREN dictionary '''
36    dict1 = dict
37    if hasattr(obj, 'CHILDREN'):
38      dict2=obj.CHILDREN
39    else:
40      dict2={}
41    dict3={}
42    for item in dict1:
43        dict3[item] =dict1[item]
44    for item in dict2:
45        dict3[item] =dict2[item]
46    obj.CHILDREN=dict3
47   
48
49def addatts(obj, atts):
50  ''' merges self.ATTRIBUTES  of inherited classes'''
51  if hasattr(obj, 'ATTRIBUTES'):
52    for att in atts:
53        obj.ATTRIBUTES.append(att)
54  else:
55    obj.ATTRIBUTES=atts
56
57def addelems(obj, elems):
58  ''' merges self.elems of inherited classes'''
59  if hasattr(obj, 'ELEMORDER'):
60    for elem in elems:
61        obj.ELEMORDER.append(elem)
62  else:
63    obj.ELEMORDER=elems
64
65
66#Some variable definitions: these things are often repeated so store in variables.
67FILEFORMATS=[CSML('NetCDFExtract'),CSML('NASAAmesExtract'), CSML('GRIBExtract'),CSML('CDMLExtract'), CSML('RawFileExtract'), CSML('AggregatedArray')]
68
69
70class csElement(object):
71    ''' main csElement class - all other elements inherit from this baseclass 
72    all the from/to XML conversion is done by this class'''
73   
74    def __init__(self, **kwargs):
75        for kw in kwargs:
76            self.__setattr__(kw, kwargs[kw])
77        if not hasattr(self, 'ATTRIBUTES'):
78            self.__dict__['ATTRIBUTES']=[]
79        if not hasattr(self, 'ELEMORDER'):
80            self.__dict__['ELEMORDER']=[]       
81        if not hasattr(self, 'CHILDREN'):
82            self.__dict__['CHILDREN']={}
83    #The __setattr__ and __getattribute__ special methods have been overridden.
84    #This is so that attributes can be called by their fully qualified name internally
85    #while being referenced by their short name externally.
86    # so 'id' and {'http://www.opengis.net/gml'}id always have the same value
87    #you can set either of them at any time and the other will be kept in sync.
88       
89    def __setattr__(self, name, value):
90        if hasattr(self, CSML(name)):
91            object.__setattr__(self, CSML(name), value)
92            object.__setattr__(self, name, value)
93        elif hasattr(self,GML(name)):
94            object.__setattr__(self, GML(name), value)
95            object.__setattr__(self, name, value)
96        elif hasattr(self,XLINK(name)):
97            object.__setattr__(self, XLINK(name), value)
98            object.__setattr__(self, name, value)
99        else:
100            if hasattr(self, 'ATTRIBUTES'):
101                if CSML(name) in self.__dict__['ATTRIBUTES']:
102                    object.__setattr__(self, CSML(name), value)
103                    object.__setattr__(self, name, value)
104                elif GML(name) in self.__dict__['ATTRIBUTES']:
105                    object.__setattr__(self, GML(name), value)
106                    object.__setattr__(self, name, value)
107                elif XLINK(name) in self.__dict__['ATTRIBUTES']:
108                    object.__setattr__(self, XLINK(name), value)
109                    object.__setattr__(self, name, value)
110                elif name in self.__dict__['ATTRIBUTES']:
111                    object.__setattr__(self, name, value)
112                    try:
113                        name=name.split('}')[1]
114                    except IndexError:
115                        pass
116                    object.__setattr__(self, name, value)
117                else:
118                    object.__setattr__(self, name, value)
119            else:
120                    object.__setattr__(self, name, value)
121   
122    def __getattribute__(self, name):
123            if CSML(name) in object.__dict__:
124                return object.__getattribute__(self,CSML(name))
125            elif GML(name) in object.__dict__:
126                return object.__getattribute__(self,GML(name))
127            elif XLINK(name) in object.__dict__:
128                return object.__getattribute__(self,XLINK(name))
129            else:
130                return object.__getattribute__(self,name) 
131       
132    def __removeURI(self, qname):
133        try:
134            attname = qname.split('}')[1]
135        except IndexError:
136            attname = qname
137        return attname
138       
139    def _getSubstitutionType(self,tag):
140        return tag.split('}')[1]
141       
142   
143    def _getReverseSubsType(self, typename):
144        return typename
145   
146    def addChildElem(self, childname, childobj):
147        #sometimes you want to add a child element but don't know if there is one already. In which case you want to create a list of child objects.
148        if hasattr(self, childname):
149            currentattribute=getattr(self,childname)
150            if type(getattr(self,childname)) is list:
151                currentattribute.append(childobj)
152            else:
153                newlist=[currentattribute]
154                newlist.append(childobj)
155                setattr(self,childname, newlist)
156        else:
157            setattr(self,childname, childobj)
158
159    def toXML(self, csmlfrag, **kwargs):
160        #process self and convert to XML     
161        if hasattr(self, 'CONTENT'):
162            if self.CONTENT is not None: csmlfrag.text=self.CONTENT
163        if hasattr(self, 'ATTRIBUTES'):
164            for item in self.__dict__:
165                if item in self.ATTRIBUTES:                   
166                    csmlfrag.set(item, self.__dict__[item])
167    # self.CHILDREN (recursive - calls the toXML method of children
168        for child in self.ELEMORDER:
169            if not self.__dict__.has_key(child):
170                continue
171            appendLater=False
172            parserobjects=[]
173            if type(self.__dict__[child]) is list:
174                for a in self.__dict__[child]:
175                    parserobjects.append(a)
176            else:
177                parserobjects.append(self.__dict__[child])
178            parentfrag=None
179            if len(self.CHILDREN[child])>=3:
180                    ename2=self.CHILDREN[child][2]
181                    parentfrag=ET.Element(ename2)
182            for po in parserobjects:
183                if type(self.CHILDREN[child][0]) is not list:
184                    ename=self.CHILDREN[child][0]
185                else:
186                    ename = self._getReverseSubsType(type(po).__name__)
187                if len(self.CHILDREN[child])==3:
188                    frag=ET.Element(ename)
189                    po.toXML(frag)
190                    parentfrag.append(frag)
191                    appendLater=True
192                elif len(self.CHILDREN[child])>=4:
193                    if self.CHILDREN[child][3]==1:
194                        frag=ET.Element(ename)
195                        po.toXML(frag)
196                        parentfrag.append(frag)
197                        csmlfrag.append(parentfrag)
198                        parentfrag=ET.Element(parentfrag.tag)
199                        appendLater=False
200                else:
201                    frag=ET.Element(ename)
202                    try:
203                        po.toXML(frag)
204                    except:
205                        print 'PARSING ERROR - could not convert %s to XML'%frag
206                        print dir(ename)
207                        raise
208                    csmlfrag.append(frag)
209                    appendLater=True
210
211                if appendLater==True and parentfrag != None:             
212                    csmlfrag.append(parentfrag)   
213
214        return csmlfrag
215       
216    def fromXML(self,csmlfrag):
217        # deal with attributes, e.g. gml id's
218        if csmlfrag.text is not None:
219                self.CONTENT = csmlfrag.text
220        for item in csmlfrag.items():
221            if item[0] in self.ATTRIBUTES:
222                setattr(self, item[0], item[1])
223        #self.CHILDREN (recursive - calls the fromXML method of children
224        for frag in csmlfrag[:]:
225            #for each child element
226            #iterate through expected CHILDREN to find match
227            for child in self.CHILDREN:
228                if len(self.CHILDREN[child])>=3:
229                    ename = self.CHILDREN[child][2]
230                    ename2 = self.CHILDREN[child][0]
231                else:
232                    ename = self.CHILDREN[child][0] 
233                    ename2=None
234                #if there are options, then find the name that matches the frag
235                if ename2 is not None:
236                    if frag[:] != []:
237                        for subfrag in frag[:]:
238                            etype=None
239                            if type(ename2) is list:
240                                if subfrag.tag in ename2:
241                                    etype=self._getSubstitutionType(subfrag.tag)
242                            if subfrag.tag==ename2:
243                                etype=self.CHILDREN[child][1]
244                            if etype:
245                                childobj=eval(etype)()
246                                if len(self.CHILDREN[child])>=3:
247                                    if frag[:] != []:
248                                        childobj.fromXML(subfrag)
249                                else:
250                                    childobj.fromXML(frag)
251                                #set this object to be an attribute of the 'parent' (self) object
252                                if hasattr(self, child):
253                                    if type(self.__dict__[child]) is not list:
254                                        tmp=self.__dict__[child]
255                                        setattr(self, child, [tmp]) #convert to list
256                                    self.__dict__[child].append(childobj)
257                                else:
258                                    setattr(self, child, childobj)
259                else:
260                    etype=None
261                    if type(ename) is list:
262                        if frag.tag in ename:
263                            etype=self._getSubstitutionType(frag.tag)
264                    elif frag.tag==ename:
265                        etype=self.CHILDREN[child][1]
266                    if etype:
267                        childobj=eval(etype)()
268                        if len(self.CHILDREN[child])>=3:
269                            if frag[:] != []:
270                                childobj.fromXML(frag[0])
271                        else:
272                            childobj.fromXML(frag)
273                           
274                        #set this object to be an attribute of the 'parent' (self) object
275                        if hasattr(self, child):
276                            if type(self.__dict__[child]) is not list:
277                                tmp=self.__dict__[child]
278                                setattr(self, child, [tmp]) #convert to list
279                            self.__dict__[child].append(childobj)
280                        else:
281                            setattr(self, child, childobj)
282
283               
284   
285class AbstractGML(csElement):
286    def __init__(self, **kwargs):
287        a=[GML('id'), GML('name')]
288        addatts(self,a)
289        elems=['metaDataProperty', 'description']
290        addelems(self,elems)
291        children={elems[0]:[GML('metaDataProperty'),'csString'],elems[1]:[GML('description'),'csString']}
292        addchildren(self,children)
293        csElement.__init__(self,**kwargs)
294       
295class AssociationAttributeGroup(csElement):
296    def __init__(self, **kwargs):
297        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')] 
298        addatts(self,a)
299        csElement.__init__(self,**kwargs)
300       
301class csString(AssociationAttributeGroup, csElement):
302    def __init__(self, text=None,**kwargs):
303        #Needed so it can use xlink
304        addelems(self,[])
305        AssociationAttributeGroup.__init__(self,**kwargs)
306        if text != None:
307            if type(text) is not str:
308                text=str(text)
309            self.CONTENT=text
310        children={}
311        addchildren(self,children)
312        csElement.__init__(self,**kwargs)
313       
314class SRSReferenceGroup(csElement):
315    def __init__(self, **kwargs):
316        a =['srsName','srsDimension'] 
317        addatts(self,a)
318        csElement.__init__(self,**kwargs)
319               
320class SRSInformationGroup(csElement):
321    def __init__(self, **kwargs):
322        a =['uomLabels','axisLabels']
323        addatts(self,a)
324        csElement.__init__(self,**kwargs)
325       
326class ArrayDescriptor(csElement):
327    def __init__(self,**kwargs):
328        a=['id']
329        addatts(self,a)
330        elems=['arraySize', 'uom', 'numericType','regExpTransform','numericTransform']
331        addelems(self,elems)
332        children={elems[0]:[CSML('arraySize'), 'csString'], elems[1]:[CSML('uom'),'csString'], elems[2]:[CSML('numericType'),'csString'], elems[3]:[CSML('regExpTransform'),'csString'], elems[4]:[CSML('numericTransform'),'csString']}
333        addchildren(self,children)
334        csElement.__init__(self,**kwargs)
335               
336class GridEnvelope(AbstractGML,SRSReferenceGroup, csElement):
337    def __init__(self, **kwargs):
338        SRSReferenceGroup.__init__(self,**kwargs)
339        AbstractGML.__init__(self,**kwargs)
340        elems=['low', 'high']
341        addelems(self,elems)
342        children={elems[0]:[GML('low'), 'csString'],elems[1]:[GML('high'), 'csString']}
343        addchildren(self,children)
344        csElement.__init__(self,**kwargs)
345       
346class Envelope(AbstractGML,SRSReferenceGroup, csElement):
347    def __init__(self, **kwargs):
348        SRSReferenceGroup.__init__(self,**kwargs)
349        AbstractGML.__init__(self,**kwargs)
350        elems=['lowerCorner','upperCorner']
351        addelems(self,elems)
352        children={elems[0]:[GML('lowerCorner'), 'csString'],elems[1]:[GML('upperCorner'), 'csString']}
353        addchildren(self,children)
354        csElement.__init__(self,**kwargs)
355       
356class EnvelopeWithTimePeriod(Envelope):
357    def __init__(self, **kwargs):
358        Envelope.__init__(self,**kwargs)
359        elems=['beginPosition', 'endPosition']
360        addelems(self,elems)
361        children={elems[0]:[GML('beginPosition'), 'csString'], elems[1]:[GML('endPosition'), 'csString']}
362        addchildren(self,children)
363        csElement.__init__(self,**kwargs)
364
365class AbstractFeature(AbstractGML,csElement):
366    def __init__(self, **kwargs):
367        AbstractGML.__init__(self,**kwargs)
368        elems=['boundedBy']
369        addelems(self,elems)
370        #this pattern works but can only accept EnvelopeWithTimePeriod for the boundedBy,
371        #which is probably ok   
372        children={elems[0]:[GML('EnvelopeWithTimePeriod'), 'EnvelopeWithTimePeriod', GML('boundedBy')]}
373        addchildren(self,children)
374        csElement.__init__(self,**kwargs)
375       
376class AbstractFeatureCollection(AbstractFeature,csElement):
377    def __init__(self, **kwargs):
378        AbstractFeature.__init__(self,**kwargs)
379        csElement.__init__(self,**kwargs)
380       
381class DomainSet(AbstractGML,AssociationAttributeGroup,csElement):
382    def __init__(self, **kwargs):
383        AbstractGML.__init__(self,**kwargs)
384        addchildren(self,{})
385        csElement.__init__(self,**kwargs)
386       
387class AggregatedArray(ArrayDescriptor,csElement):
388    def __init__(self, **kwargs):
389        ArrayDescriptor.__init__(self,**kwargs)
390        elems=['aggType', 'aggIndex', 'components']
391        addelems(self,elems)
392        children={elems[0]:[CSML('aggType'),'csString'], elems[1]:[CSML('aggIndex'),'csString'],elems[2]:[FILEFORMATS, 'ArrayDescriptor',CSML('component')]}
393        addchildren(self,children)
394        csElement.__init__(self,**kwargs)
395#'component':[CSML:('component'), 'ArrayDescriptor', CSML('component')],
396class MeasureOrNullList(AbstractGML,csElement):
397    def __init__(self, **kwargs):
398        AbstractGML.__init__(self,**kwargs)
399        elems=['__insertedExtract']  # should this be here ? check
400        addelems(self,elems)
401        #note __insertedExtract is used in resolving xlinks and shouldn't be written to directly (except by the code which handles the xlink resolutions)
402        children={elems[0]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
403        addchildren(self,children)
404        a =['uom'] 
405        addatts(self,a)
406        csElement.__init__(self,**kwargs)
407       
408       
409class CompositeValue(AbstractGML,csElement):
410    def __init__(self, **kwargs):
411        AbstractGML.__init__(self,**kwargs)
412        elems=['measures']
413        addelems(self,elems)
414        children={elems[0]:[GML('measure'),'csString',GML('valueComponents')]}
415        addchildren(self,children)
416        csElement.__init__(self,**kwargs)
417       
418class DataBlock(AbstractGML,csElement):
419    #THIS IS INCOMPLETE
420    def __init__(self, **kwargs):
421        AbstractGML.__init__(self,**kwargs)
422        elems=['doubleOrNullTupleList','rangeParameters']
423        addelems(self,elems)
424        children={elems[0]:[GML('doubleOrNullTupleList'),'csString'],elems[1]:[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
425        addchildren(self,children)
426        csElement.__init__(self,**kwargs)
427
428class ValueComponent(AbstractGML, AssociationAttributeGroup, csElement):
429    def __init__(self, **kwargs):
430        AbstractGML.__init__(self,**kwargs)
431        AssociationAttributeGroup.__init__(self,**kwargs)
432        elems=['quantityList']
433        addelems(self,elems)
434        children=children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList']}
435        addchildren(self,children)
436        csElement.__init__(self,**kwargs)
437
438class ValueArray(AbstractGML, csElement):
439    def __init__(self, **kwargs):
440        AbstractGML.__init__(self,**kwargs)
441        elems=['valueComponent']
442        addelems(self,elems)
443        #this is a bit of a diversion from the object/property pattern but is necessary to
444        #make valueComponent a class so valueComponent can have xlink attributes
445        children=children={elems[0]:[GML('valueComponent'), 'ValueComponent', ]}
446        addchildren(self,children)
447        csElement.__init__(self,**kwargs)
448       
449
450class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
451    def __init__(self, **kwargs):
452        AbstractGML.__init__(self,**kwargs)
453        AssociationAttributeGroup.__init__(self,**kwargs)
454        elems=['quantityList', 'dataBlock', 'arrayDescriptor', 'valueArray']
455        addelems(self,elems)
456        children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList'],        elems[1]:[GML('DataBlock'),'DataBlock'],'arrayDescriptor':[FILEFORMATS, 'ArrayDescriptor'],  elems[2]:[CSML('AggregatedArray'), 'AggregatedArray'],
457        elems[3]:[GML('ValueArray'),'ValueArray']}
458        addchildren(self,children)
459        csElement.__init__(self,**kwargs)
460       
461class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
462    def __init__(self, **kwargs):
463        AbstractGML.__init__(self,**kwargs)
464        SRSReferenceGroup.__init__(self,**kwargs)
465        elems=['pointMember','pointMembers']
466        addelems(self,elems)
467        children={elems[0]:[GML('pointMember'), 'csString'],elems[0]:[GML('pointMember'), 'csString']}
468        addchildren(self,children)
469        csElement.__init__(self,**kwargs)
470       
471class Point(AbstractGML,SRSReferenceGroup,csElement):
472    def __init__(self, **kwargs):
473        AbstractGML.__init__(self,**kwargs)
474        SRSReferenceGroup.__init__(self,**kwargs)
475        elems=['pos','coordinates']
476        addelems(self,elems)
477        children={elems[0]:[GML('pos'), 'csString'],elems[1]:[GML('coordinates'), 'csString']}
478        addchildren(self,children)
479        csElement.__init__(self,**kwargs)
480       
481class PointDomain(DomainSet, MultiPoint,csElement):
482    def __init__(self, **kwargs):
483        DomainSet.__init__(self,**kwargs)
484        MultiPoint.__init__(self,**kwargs)
485        children={}
486        addchildren(self,children)
487        csElement.__init__(self,**kwargs)
488       
489class ProfileDomain(DomainSet, MultiPoint,csElement):
490    def __init__(self, **kwargs):
491        DomainSet.__init__(self,**kwargs)
492        MultiPoint.__init__(self,**kwargs)
493        children={}
494        addchildren(self,children)
495        csElement.__init__(self,**kwargs)
496
497
498class AbstractCoverage(AbstractFeature, csElement):
499    def __init__(self, **kwargs):
500        AbstractFeature.__init__(self,**kwargs)
501        csElement.__init__(self,**kwargs)
502       
503class AbstractDiscreteCoverage(AbstractCoverage, csElement):
504    def __init__(self, **kwargs):
505        AbstractCoverage.__init__(self,**kwargs)
506        addchildren(self,{})
507        csElement.__init__(self,**kwargs)
508       
509class Definition(AbstractGML):
510    def __init__(self, **kwargs):
511        AbstractGML.__init__(self,**kwargs)
512        addchildren(self,{})
513        csElement.__init__(self,**kwargs)
514       
515class Phenomenon(Definition,AssociationAttributeGroup):
516    def __init__(self, **kwargs):
517        Definition.__init__(self,**kwargs)
518        AssociationAttributeGroup.__init__(self,**kwargs)
519        children = {'':[CSML(''), '']}   
520        addchildren(self,children)
521        csElement.__init__(self,**kwargs)
522               
523class SpatialOrTemporalPositionList(AssociationAttributeGroup, AbstractGML,  csElement):
524    def __init__(self, **kwargs):
525        AbstractGML.__init__(self,**kwargs)
526        AssociationAttributeGroup.__init__(self,**kwargs)
527        elems=['coordinateList', 'timePositionList','__insertedExtract']
528        addelems(self,elems)
529        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
530        addchildren(self,children)
531        csElement.__init__(self,**kwargs)
532   
533    def toXML(self,csmlfrag,**kwargs):
534        csmlfrag=csElement.toXML(self,csmlfrag, **kwargs)
535        #This is mandatory even if empty when using xlink       
536        if not hasattr(self, 'timePositionList'):
537            if not hasattr(self, 'coordinateList'):
538                 if csmlfrag.get(XLINK('arcrole')) is not None:
539                    print csmlfrag.get(XLINK('arcrole')).split('#')[1]
540                    if csmlfrag.get(XLINK('arcrole')).split('#')[1] == 'timePositionList':
541                        ET.SubElement(csmlfrag, CSML('timePositionList'))
542                    elif csmlfrag.get(XLINK('arcrole')).split('#')[1] =='coordinateList':
543                        ET.SubElement(csmlfrag, CSML('coordinateList'))                       
544        return csmlfrag
545
546class GridOrdinateDescription(AbstractGML,csElement):
547    def __init__(self, **kwargs):
548        AbstractGML.__init__(self,**kwargs)
549        elems=['coordAxisLabel', 'coordAxisValues', 'gridAxesSpanned', 'sequenceRule']
550        addelems(self,elems)
551        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], elems[2]:[CSML('gridAxesSpanned'), 'csString'], elems[3]:[CSML('sequenceRule'),'SequenceRule']}
552        addchildren(self,children)
553        csElement.__init__(self,**kwargs)
554    def toXML(self, csmlfrag, **kwargs):
555        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
556        #promote XLinks up from SpatialOrTemporalPositionList       
557        #this all done at the elementtree level
558       
559        for frag in csmlfrag:
560            if frag.tag ==CSML('coordAxisValues'):
561                try:       
562                    frag.set(XLINK('href'),self.coordAxisValues.href)                               
563                    for subfrag in frag:   
564                        del subfrag.attrib[XLINK('href')]                                                             
565                except:
566                    pass
567                try:       
568                    frag.set(XLINK('show'),self.coordAxisValues.show)                               
569                    for subfrag in frag:   
570                        del subfrag.attrib[XLINK('show')]                                                             
571                except:
572                    pass
573                try:       
574                    frag.set(XLINK('role'),self.coordAxisValues.role)                               
575                    for subfrag in frag:   
576                        del subfrag.attrib[XLINK('role')]                                                             
577                except:
578                    pass
579                try:       
580                    frag.set(XLINK('arcrole'),self.coordAxisValues.arcrole)                               
581                    for subfrag in frag:   
582                        del subfrag.attrib[XLINK('arcrole')]                                                             
583                except:
584                    pass
585             
586
587        return csmlfrag
588   
589    def fromXML(self, csmlfrag):
590        #promote xlinks up a level to the coordAxisValues property element
591        for frag in csmlfrag:
592            if frag.tag == CSML('coordAxisValues'):             
593                for att in ['href', 'show', 'role', 'arcrole']:
594                    try: 
595                        for subfrag in frag[:]:
596                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
597                    except:
598                        pass
599               
600        csElement.fromXML(self, csmlfrag)
601
602           
603       
604class SequenceRule(csElement):
605    def __init__(self, **kwargs):
606        a=['axisOrder']
607        addatts(self,a)
608        children={}
609        addchildren(self,children)
610        csElement.__init__(self,**kwargs)
611       
612class GridPointDescription(AbstractGML,csElement):
613    def __init__(self, **kwargs):
614        AbstractGML.__init__(self,**kwargs)
615        elems=['posList', 'sequenceRule']
616        addelems(self,elems)
617        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
618        addchildren(self,children)
619        csElement.__init__(self,**kwargs)
620
621class TimePositionList(AbstractGML,csString,csElement):
622    def __init__(self, **kwargs):
623        AbstractGML.__init__(self,**kwargs)
624        csString.__init__(self, **kwargs)
625        elems=[]
626        addelems(self,elems)
627        a=['frame', 'calendarEraName','indeterminatePosition']
628        addatts(self,a)
629        addchildren(self,{})
630        csElement.__init__(self,**kwargs)
631
632class GridCoordinatesTable(AbstractGML,csElement):
633    def __init__(self,**kwargs):
634        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
635        <gml:ordinate>
636            <gml:GridOrdinateDescription>
637        </gml:ordinate>
638        <gml:ordinate>
639            <gml:GridOrdinateDescription>
640        </gml:ordinate>
641       
642        not as:
643        <gml:ordinate>
644            <gml:GridOrdinateDescription>
645            <gml:GridOrdinateDescription>
646        </gml:ordinate> '''
647        AbstractGML.__init__(self,**kwargs)
648        elems=['gridOrdinates' , 'gridPoints']
649        addelems(self,elems)
650        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
651        addchildren(self,children)
652        csElement.__init__(self,**kwargs)
653       
654class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
655    def __init__(self, **kwargs):
656        AbstractGML.__init__(self,**kwargs)
657        AssociationAttributeGroup.__init__(self,**kwargs)
658        SRSReferenceGroup.__init__(self,**kwargs)
659        SRSInformationGroup.__init__(self,**kwargs)
660        a=['dimension']
661        addatts(self,a)
662        elems=['limits', 'aLabels','axisName']
663        addelems(self, elems)
664        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
665        addchildren(self,children)
666        csElement.__init__(self,**kwargs)
667           
668class ReferenceableGrid(Grid, csElement):
669    def __init__(self, **kwargs):
670        Grid.__init__(self,**kwargs)
671        elems=['coordTransformTable']
672        addelems(self,elems)
673        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
674        addchildren(self,children)
675        csElement.__init__(self,**kwargs)
676
677class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
678    def __init__(self, **kwargs):
679        AbstractDiscreteCoverage.__init__(self,**kwargs)
680        elems=[referenceableGridDomain]
681        addelems(self,elems)
682        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
683        addchildren(self,children)
684        csElement.__init__(self,**kwargs)
685       
686class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
687    def __init__(self, **kwargs):
688        AbstractDiscreteCoverage.__init__(self,**kwargs)
689        elems=['alternatePointDomain','rangeSet','coverageFunction']
690        addelems(self,elems)
691        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
692        addchildren(self,children)
693        csElement.__init__(self,**kwargs)
694
695class ProfileCoverage(AbstractDiscreteCoverage, csElement):
696    def __init__(self, **kwargs):
697        AbstractDiscreteCoverage.__init__(self,**kwargs)
698        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
699        addelems(self,elems)
700        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
701        addchildren(self,children)
702        csElement.__init__(self,**kwargs)
703       
704class PointCoverage(AbstractDiscreteCoverage, csElement):
705    def __init__(self, **kwargs):
706        AbstractDiscreteCoverage.__init__(self,**kwargs)
707        elems=['pointDomain','rangeSet', 'coverageFunction']
708        addelems(self,elems)
709        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
710        addchildren(self,children)
711        csElement.__init__(self,**kwargs)
712       
713class TimeSeries(AbstractGML, csElement):
714    def __init__(self, **kwargs):
715        AbstractGML.__init__(self,**kwargs)
716        elems=['timePositionList']
717        addelems(self,elems)
718        children={elems[0]:[CSML('timePositionList'), 'csString']}
719        addchildren(self,children)
720        csElement.__init__(self,**kwargs)
721
722class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
723    def __init__(self, **kwargs):
724        AbstractDiscreteCoverage.__init__(self,**kwargs)
725        elems=['pointSeriesDomain','rangeSet','coverageFunction']
726        addelems(self,elems)
727        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
728        addchildren(self,children)
729        csElement.__init__(self,**kwargs)
730       
731class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
732    def __init__(self, **kwargs):
733        DomainSet.__init__(self,**kwargs)
734        ReferenceableGrid.__init__(self,**kwargs)
735        children={}
736        addchildren(self,children)
737        csElement.__init__(self,**kwargs)
738       
739class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
740    def __init__(self, **kwargs):
741        AbstractDiscreteCoverage.__init__(self,**kwargs)
742        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
743        addelems(self,elems)
744        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
745        addchildren(self,children)
746        csElement.__init__(self,**kwargs)
747       
748class SectionDomain(ReferenceableGrid, DomainSet, csElement):
749    def __init__(self, **kwargs):
750        DomainSet.__init__(self,**kwargs)
751        ReferenceableGrid.__init__(self,**kwargs)
752        children={}
753        addchildren(self,children)
754        csElement.__init__(self,**kwargs)
755       
756class SectionCoverage(AbstractDiscreteCoverage,csElement):
757    def __init__(self, **kwargs):
758        AbstractDiscreteCoverage.__init__(self,**kwargs)
759        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
760        addelems(self,elems)
761        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
762        addchildren(self,children)
763        csElement.__init__(self,**kwargs)
764       
765class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
766    def __init__(self, **kwargs):
767        DomainSet.__init__(self,**kwargs)
768        ReferenceableGrid.__init__(self,**kwargs)
769        children={}
770        addchildren(self,children)
771        csElement.__init__(self,**kwargs)
772       
773class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
774    def __init__(self, **kwargs):
775        AbstractDiscreteCoverage.__init__(self,**kwargs)
776        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
777        addelems(self,elems)
778        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
779        addchildren(self,children)
780        csElement.__init__(self,**kwargs)
781
782class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
783    def __init__(self, **kwargs):
784        DomainSet.__init__(self,**kwargs)
785        ReferenceableGrid.__init__(self,**kwargs)
786        children={}
787        addchildren(self,children)
788        csElement.__init__(self,**kwargs)
789       
790class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
791    def __init__(self, **kwargs):
792        AbstractDiscreteCoverage.__init__(self,**kwargs)
793        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
794        addelems(self,elems)
795        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
796        addchildren(self,children)
797        csElement.__init__(self,**kwargs)
798
799
800class GridSeriesDomain(ReferenceableGrid, csElement):
801    def __init__(self, **kwargs):
802        #DomainSet.__init__(self,**kwargs)
803        ReferenceableGrid.__init__(self,**kwargs)
804        children={}
805        addchildren(self,children)
806        csElement.__init__(self,**kwargs)
807
808class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
809    def __init__(self, **kwargs):
810        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
811        addelems(self,elems)
812        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
813        addchildren(self,children)
814        AbstractDiscreteCoverage.__init__(self,**kwargs)
815        csElement.__init__(self,**kwargs)
816
817class AlternatePointFeature(AbstractFeature, csElement):
818    def __init__(self, **kwargs):
819        AbstractFeature.__init__(self,**kwargs)
820        elems=['location', 'time', 'value','parameter']
821        addelems(self,elems)
822        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
823        addchildren(self,children)
824        csElement.__init__(self,**kwargs)
825
826class DirectPositionList(SRSReferenceGroup, csElement):
827    def __init__(self, **kwargs):
828        SRSReferenceGroup.__init__(self,**kwargs)
829        children=[]
830        addchildren(self,children)
831        csElement.__init__(self,**kwargs)
832       
833class PointFeature(AbstractFeature, csElement):
834    def __init__(self, **kwargs):
835        AbstractFeature.__init__(self,**kwargs)
836        elems=['location', 'time', 'value','parameter']
837        addelems(self,elems)
838        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
839        addchildren(self,children)
840        csElement.__init__(self,**kwargs)
841
842class PointCollectionFeature(AbstractFeature, csElement):
843    def __init__(self, **kwargs):
844        AbstractFeature.__init__(self,**kwargs)
845        elems=['time', 'value', 'parameter']
846        addelems(self,elems)
847        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
848        addchildren(self,children)
849        csElement.__init__(self,**kwargs)
850
851
852class PointSeriesFeature(AbstractFeature, csElement):
853    def __init__(self, **kwargs):
854        AbstractFeature.__init__(self,**kwargs)
855        elems=['location','value','parameter']
856        addelems(self,elems)
857        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
858        addchildren(self,children)
859        csElement.__init__(self,**kwargs)
860
861
862class GridFeature(AbstractFeature, csElement):
863    def __init__(self, **kwargs):
864        AbstractFeature.__init__(self,**kwargs)
865        elems=['time', 'value', 'parameter']
866        addelems(self,elems)
867        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
868        addchildren(self,children)
869        csElement.__init__(self,**kwargs)
870
871class GridSeriesFeature(AbstractFeature, csElement):
872    def __init__(self, **kwargs):
873        AbstractFeature.__init__(self,**kwargs)
874        elems=['value','parameter']
875        addelems(self,elems)
876        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
877        addchildren(self,children)
878        csElement.__init__(self,**kwargs)
879
880class ProfileFeature(AbstractFeature, csElement):
881    def __init__(self, **kwargs):
882        AbstractFeature.__init__(self,**kwargs)
883        elems=['time', 'location', 'value', 'parameter']
884        addelems(self,elems)
885        children={elems[0]:[CSML('time'), 'csString'],elems[1]:[CSML('location'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
886        addchildren(self,children)
887        csElement.__init__(self,**kwargs)
888
889class ProfileSeriesFeature(AbstractFeature, csElement):
890    def __init__(self, **kwargs):
891        AbstractFeature.__init__(self,**kwargs)
892        elems=['location', 'value', 'parameter']
893        addelems(self,elems)
894        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
895        addchildren(self,children)
896        csElement.__init__(self,**kwargs)
897
898class RaggedProfileSeriesFeature(AbstractFeature, csElement):
899    def __init__(self, **kwargs):
900        AbstractFeature.__init__(self,**kwargs)
901        elems=['location', 'profileLength', 'value', 'parameter']
902        addelems(self,elems)
903        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
904        addchildren(self,children)
905        csElement.__init__(self,**kwargs)
906
907class RaggedSectionFeature(AbstractFeature, csElement):
908    def __init__(self, **kwargs):
909        AbstractFeature.__init__(self,**kwargs)
910        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
911        addelems(self,elems)
912        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'csString'],elems[2]:[CSML('profileLength'),'csString'],elems[3]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[4]:[CSML('parameter'), 'Phenomenon']}
913        addchildren(self,children)
914        csElement.__init__(self,**kwargs)
915
916class SectionFeature(AbstractFeature, csElement):
917    def __init__(self, **kwargs):
918        AbstractFeature.__init__(self,**kwargs)
919        elems=['stationLocations', 'stationTimes','value', 'parameter']
920        addelems(self,elems)
921        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
922        addchildren(self,children)
923        csElement.__init__(self,**kwargs)
924
925class ScanningRadarFeature(AbstractFeature, csElement):
926    def __init__(self, **kwargs):
927        AbstractFeature.__init__(self,**kwargs)
928        elems=['elevation','value', 'parameter']
929        addelems(self,elems)
930        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
931        addchildren(self,children)
932        csElement.__init__(self,**kwargs)
933
934       
935class SwathFeature(AbstractFeature, csElement):
936    def __init__(self, **kwargs):
937        AbstractFeature.__init__(self,**kwargs)
938        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
939        addelems(self,elems)
940        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
941        addchildren(self,children)
942        csElement.__init__(self,**kwargs)
943       
944class TrajectoryFeature(AbstractFeature, csElement):
945    def __init__(self, **kwargs):
946        AbstractFeature.__init__(self,**kwargs)
947        elems=['value', 'parameter']
948        addelems(self,elems)
949        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
950        addchildren(self,children)
951        csElement.__init__(self,**kwargs)
952       
953class FileList(AssociationAttributeGroup,AbstractGML,csElement):
954    def __init__(self,**kwargs):
955        elems=['fileNames']
956        addelems(self,elems)
957        AssociationAttributeGroup.__init__(self,**kwargs)
958        AbstractGML.__init__(self,**kwargs)
959        addatts(self,[])
960        children= {elems[0]:[CSML('fileNames'), 'csString']}
961        addchildren(self,children)
962        csElement.__init__(self,**kwargs)
963       
964class FileExtract(ArrayDescriptor, csElement):
965    def __init__(self,**kwargs):
966        ArrayDescriptor.__init__(self,**kwargs)
967        elems=['fileName', 'fileList', 'fileListXLINK']
968        addelems(self,elems)
969        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
970        addchildren(self,children)
971        csElement.__init__(self,**kwargs)
972
973class NetCDFExtract(FileExtract, csElement):
974    def __init__(self,**kwargs):
975        FileExtract.__init__(self, **kwargs)
976        elems=['variableName']
977        addelems(self,elems)
978        children={elems[0]:[CSML('variableName'), 'csString']}
979        addchildren(self,children)
980        csElement.__init__(self,**kwargs)
981
982class NASAAmesExtract(FileExtract, csElement):
983    def __init__(self,**kwargs):
984        FileExtract.__init__(self, **kwargs)
985        elems=['variableName', 'index']
986        addelems(self,elems)
987        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
988        addchildren(self,children)
989        csElement.__init__(self,**kwargs)
990
991class CSMLStorageDescriptor(csElement):
992    def __init__(self,**kwargs):
993        addatts(self,[])
994        elems=['descriptors']
995        addelems(self,elems)
996        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
997        addchildren(self,children)
998        csElement.__init__(self,**kwargs)
999
1000class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
1001    def __init__(self,**kwargs):
1002        AbstractFeatureCollection.__init__(self,**kwargs)
1003        elems=['featureMembers']
1004        addelems(self,elems)
1005        children={elems[0]:[[CSML('GridFeature'), CSML('GridSeriesFeature'),CSML('PointFeature'),CSML('TrajectoryFeature'),CSML('ProfileFeature'),CSML('ProfileSeriesFeature'),CSML('RaggedProfileSeriesFeature'),CSML('RaggedSectionFeature'),CSML('SectionFeature'),CSML('ScanningRadarFeature'),CSML('PointSeriesFeature'),CSML('AlternatePointFeature')], 'AbstractFeature', CSML('featureMember'),1]}
1006        addchildren(self,children)
1007        csElement.__init__(self,**kwargs)
1008    def _getSubstitutionType(self,tag):
1009        if tag==CSML('GridFeature'):
1010            return 'GridFeature'
1011        elif tag==CSML('GridSeriesFeature'):
1012            return 'GridSeriesFeature'
1013        elif tag==CSML('PointFeature'):
1014            return 'PointFeature'
1015        elif tag==CSML('TrajectoryFeature'):
1016            return 'TrajectoryFeature'
1017        elif tag==CSML('PointSeriesFeature'):
1018            return 'PointSeriesFeature'
1019        elif tag==CSML('ProfileFeature'):
1020            return 'ProfileFeature'
1021        elif tag==CSML('ProfileSeriesFeature'):
1022            return 'ProfileSeriesFeature'
1023        elif tag==CSML('RaggedProfileSeriesFeature'):
1024            return 'RaggedProfileSeriesFeature'
1025        elif tag==CSML('RaggedSectionFeature'):
1026            return 'RaggedSectionFeature'
1027        elif tag==CSML('SectionFeature'):
1028            return 'SectionFeature'
1029        elif tag==CSML('ScanningRadarFeature'):
1030            return 'ScanningRadarFeature'
1031        elif tag==CSML('AlternatePointFeature'):
1032            return 'AlternatePointFeature'
1033        else: return 'AbstractFeature'
1034    def _getReverseSubsType(self, typename):
1035        if typename== 'GridFeature':
1036            return CSML('GridFeature')
1037        elif typename == 'GridSeriesFeature':
1038            return CSML('GridSeriesFeature')
1039        elif typename == 'PointSeriesFeature':
1040            return CSML('PointSeriesFeature')
1041        elif typename == 'ProfileFeature':
1042            return CSML('ProfileFeature')
1043        elif typename == 'ProfileSeriesFeature':
1044            return CSML('ProfileSeriesFeature')
1045        elif typename == 'SectionFeature':
1046            return CSML('SectionFeature')
1047        elif typename == 'ScanningRadarFeature':
1048            return CSML('ScanningRadarFeature')
1049        elif typename == 'RaggedSectionFeature':
1050            return CSML('RaggedSectionFeature')
1051        elif typename == 'RaggedProfileSeriesFeature':
1052            return CSML('RaggedProfileSeriesFeature')
1053        elif typename == 'PointFeature':
1054            return CSML('PointFeature')
1055        elif typename == 'TrajectoryFeature':
1056            return CSML('TrajectoryFeature')
1057        elif typename == 'AlternatePointFeature':
1058            return CSML('AlternatePointFeature')
1059        else: return CSML('AbstractFeature')
1060
1061       
1062class Dataset(csElement):   
1063    ''' Dataset class, needed as root of tree'''
1064    def __init__(self, **kwargs):
1065        a=[CSML('id')]
1066        addatts(self,a)
1067        elems=['featureCollection','storageDescriptor']
1068        addelems(self,elems)
1069        children = {elems[0]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[1]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1070        addchildren(self,children)
1071        csElement.__init__(self,**kwargs)
1072   
1073    def toXML(self):
1074        csmlfrag=ET.Element(CSML('Dataset'))
1075        csElement.toXML(self, csmlfrag)
1076        return csmlfrag
1077    #def _getSubstitutionType(self,tag): 
1078        #if tag==CSML('NetCDFExtract'):
1079            #return 'NetCDFExtract'
1080        #elif tag==CSML('NASAAmesExtract'):
1081            #return 'NASAAmesExtract'
1082        #else: return 'ArrayDescriptor'
1083    #def _getReverseSubsType(self, typename):
1084        #if typename== 'NetCDFExtract':
1085            #return CSML('NetCDFExtract')
1086        #elif typename == 'NASAAmesExtract':
1087            #return CSML('NASAAmesExtract')
1088        #else: return CSML('ArrayDescriptor')
1089       
1090        return typename
1091
1092   
1093def main():
1094    '''round trip for testing purposes:'''
1095    import parser_extra
1096   
1097    print '\n'
1098    tree=ET.ElementTree(file='testfiles/gridseries/testout.xml')
1099    ds=Dataset()
1100    ds.fromXML(tree.getroot())
1101    csmltree=ds.toXML()
1102   
1103    csmlout=parser_extra.PrettyPrint(csmltree)
1104    csmlout=parser_extra.removeInlineNS(csmlout)
1105    print '\n %s'% csmlout
1106    #for member in ds.featureCollection.members:
1107      #print dir(member.value)
1108       
1109
1110if __name__=='__main__':
1111    main()
Note: See TracBrowser for help on using the repository browser.