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

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

resolving conflicted state of parser.py

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