/[escript]/trunk/escript/src/DataTagged.h
ViewVC logotype

Diff of /trunk/escript/src/DataTagged.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/escript/src/Data/DataTagged.h revision 100 by jgs, Wed Dec 15 03:48:48 2004 UTC trunk/escript/src/DataTagged.h revision 2548 by jfenwick, Mon Jul 20 06:20:06 2009 UTC
# Line 1  Line 1 
1  // $Id$  
2  /*  /*******************************************************
3   ******************************************************************************  *
4   *                                                                            *  * Copyright (c) 2003-2009 by University of Queensland
5   *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *  * Earth Systems Science Computational Center (ESSCC)
6   *                                                                            *  * http://www.uq.edu.au/esscc
7   * This software is the property of ACcESS. No part of this code              *  *
8   * may be copied in any form or by any means without the expressed written    *  * Primary Business: Queensland, Australia
9   * consent of ACcESS.  Copying, use or modification of this software          *  * Licensed under the Open Software License version 3.0
10   * by any unauthorised person is illegal unless that person has a software    *  * http://www.opensource.org/licenses/osl-3.0.php
11   * license agreement with ACcESS.                                             *  *
12   *                                                                            *  *******************************************************/
13   ******************************************************************************  
14  */  
                                                                             
15  #if !defined escript_DataTagged_20040615_H  #if !defined escript_DataTagged_20040615_H
16  #define escript_DataTagged_20040615_H  #define escript_DataTagged_20040615_H
17    #include "system_dep.h"
18    
19  #include "escript/Data/DataAbstract.h"  #include "DataReady.h"
20  #include "escript/Data/DataArray.h"  #include "DataTypes.h"
 #include "escript/Data/DataArrayView.h"  
21    
22  #include <vector>  #include <vector>
23  #include <map>  #include <map>
# Line 29  class DataConstant; Line 28  class DataConstant;
28    
29  /**  /**
30     \brief     \brief
31     Creates the illusion of a full dataset accessible via sampleNo and dataPointNo.     Simulates a full dataset accessible via sampleNo and dataPointNo.
32    
33     Description:     Description:
34     Creates the illusion of a full dataset accessible via sampleNo and     Each data-point has an associated tag number, and a given tag can represent a
35     dataPointNo. In reality a much smaller number of data-points is stored.     range of dataPointNo and sampleNo. Each tag indexes only a single data-point.
    Each data-point has an associated key, thus a given key represents a specific  
    range of dataPointNo and sampleNo. Each key indexes a single data-point.  
36     Thus only a single data-point needs to be stored for a range of sampleNo and     Thus only a single data-point needs to be stored for a range of sampleNo and
37     dataPointNo values.     dataPointNo values.
38  */  */
39    
40  class DataTagged : public DataAbstract {  class DataTagged : public DataReady {
41    typedef DataReady parent;
42   public:   public:
43    
44    typedef std::vector<int> TagListType;    //
45    typedef std::vector<DataArrayView> ValueListType;    // Types for the lists of tags and values.
46      typedef std::vector<int>           TagListType;
47    //  typedef std::vector<DataArrayView> ValueListType;
48      typedef DataTypes::ValueType   ValueType;
49      typedef std::vector<ValueType::ElementType> ValueBatchType;
50    
51    //    //
52    // Map type, maps the key to an array offset.    // Map from a tag to an offset into the data array.
53    typedef std::map<int, int> DataMapType;    typedef std::map<int, int> DataMapType;
54    
55    /**    /**
# Line 57  class DataTagged : public DataAbstract { Line 58  class DataTagged : public DataAbstract {
58    
59       Description:       Description:
60       Default constructor for DataTagged. Creates a DataTagged object for which       Default constructor for DataTagged. Creates a DataTagged object for which
61       the default data-point is a scalar data-point with value 0.0. Any given tag       the default data-point is a scalar data-point with value 0.0, and no other
62       will map to this data-point.       tag values are stored.
63        T
64    */    */
65      ESCRIPT_DLL_API
66    DataTagged();    DataTagged();
67    
68    /**    /**
69       \brief       \brief
70       Constructor for DataTagged.       Alternative Constructor for DataTagged.
71    
72       Description:       Description:
73       Constructor for DataTagged.       Alternative Constructor for DataTagged.
74       \param tagKeys - Input - A vector of integer keys.       \param what - Input - A description of what this data object represents.
75       \param values - Input - A vector of DataArrayViews. If this is empty       \param shape - Input - The shape of each data-point.
76                     all tag values will be assigned a value of zero. If       \param tags - Input - An array of tags, one for each sample number (starts at tag[1]).
77                     it contains one value all tag values will be assigned the       \param data - The data values for each tag.
78             same value. Otherwise if there is a mismatch between      NB: no unit testing yet
            the number of keys and the number of values an exception  
            will be generated.  
      \param defaultValue - Input - Value returned if a requested tag doesn't exist.  
      \param what - Input - A description of what this data represents.  
79    */    */
80    DataTagged(const TagListType& tagKeys,    ESCRIPT_DLL_API
81               const ValueListType& values,    DataTagged(const FunctionSpace& what,
82           const DataArrayView& defaultValue,               const DataTypes::ShapeType &shape,
83           const FunctionSpace& what);               const int tags[],
84                 const ValueType& data);
85    
86    /**   /**
87       \brief       \brief
88       Slice constructor for DataTagged.       Alternative Constructor for DataTagged.
89    
90       Description:       Description:
91       Slice constructor for DataTagged.       Alternative Constructor for DataTagged.
92       Copies a slice from another DataTagged object.       \param what - Input - A description of what this data object represents.
93       \param other - Input - DataTagged object to copy from.       \param shape - Input - The shape of each data-point.
94       \param region - Input - region to copy.       \param tags - Input - An vector of tags, one for each sample number.
95    */       \param data - The data values for each tag.
96    DataTagged(const DataTagged& other,  TODO Make sure to document the relationship between tags and data, ie: data also contains the default value
97           const DataArrayView::RegionType& region);   */
98      ESCRIPT_DLL_API
99      DataTagged(const FunctionSpace& what,
100                 const DataTypes::ShapeType &shape,
101                 const TagListType& tags,
102                 const ValueType& data);
103    
104    /**    /**
105       \brief       \brief
106       Copy constructorfor DataTagged.       Copy Constructor for DataTagged.
107       Performs a deep copy from the given DataTagged object.       Performs a deep copy from the given DataTagged object.
108        T
109    */    */
110      ESCRIPT_DLL_API
111    DataTagged(const DataTagged& other);    DataTagged(const DataTagged& other);
112    
113    /**    /**
114       \brief       \brief
115       Construct a tagged data from a DataConstant object.       Copy Constructor for DataTagged.
116       The default data-point will be that held by the DataConstant object.       Construct a DataTagged object from a DataConstant object.
117         The default value will be the value of the DataConstant object.
118        T
119    */    */
120      ESCRIPT_DLL_API
121    DataTagged(const DataConstant& other);    DataTagged(const DataConstant& other);
122    
123    /**    /**
124       \brief       \brief
125         Copies the tags from a DataTagged into a new Data Tagged and assigns them the default value. ** Not unit tested **
126    
127         This is different from a deep copy because we are not copying shape or other information, just tags.
128         \param what - Input - FunctionSpace for the new DataTagged
129         \param shape - Input - Shape for points in the new DataTagged
130         \param defaultvalue - Input - Default value for new DataTagged
131         \param tagsource - Input - A DataTagged object which supplies the tags.
132      */
133      ESCRIPT_DLL_API
134      DataTagged(const FunctionSpace& what,
135                 const DataTypes::ShapeType& shape,
136             const DataTypes::ValueType& defaultvalue,
137                 const DataTagged* tagsource=0);
138    
139      /**
140         \brief
141         Destructor
142      */
143      ESCRIPT_DLL_API
144      inline virtual
145      ~DataTagged() {};
146    
147      ESCRIPT_DLL_API
148      bool
149      isTagged() const
150      {
151        return true;
152      };
153    
154    
155      /**
156         \brief Return a deep copy of the current object.
157      */
158      ESCRIPT_DLL_API
159      virtual
160      DataAbstract*
161      deepCopy();
162    
163    
164      /**
165         \brief
166       getSampleDataByTag       getSampleDataByTag
167    
168       Description:       Description:
169       Return the data-point for the given tag. All of the data for the entire       Return the data-point for the given tag. All of the data for the
170       sample should be visable via the returned pointer. This provides an       sample will be visible via the returned pointer.
171       interface into the data suitable for legacy C code.  
172         ** This provides an interface into the data suitable for legacy C code.
173         ** NB: need to do array bounds checking when accessing returned value!
174        T
175    */    */
176      ESCRIPT_DLL_API
177    virtual    virtual
178    double*    double*
179    getSampleDataByTag(int tag);    getSampleDataByTag(int tag);
# Line 128  class DataTagged : public DataAbstract { Line 183  class DataTagged : public DataAbstract {
183       Write the data as a string.       Write the data as a string.
184       Writes out each tag, including the default, and the data-point which is       Writes out each tag, including the default, and the data-point which is
185       associated with each tag.       associated with each tag.
186        T
187    */    */
188      ESCRIPT_DLL_API
189    virtual    virtual
190    std::string    std::string
191    toString() const;    toString() const;
192     /**
193         \brief
194         dumps the object into a netCDF file
195      */
196      ESCRIPT_DLL_API
197      virtual
198      void
199      dump(const std::string fileName) const;
200    
201     /**
202         \brief
203        sets all values to zero
204      */
205      ESCRIPT_DLL_API
206      virtual
207      void
208      setToZero();
209    
210      /**
211         \brief
212         Return the tag number associated with the given data-point number
213         according to the associated function space.
214        T
215      */
216      ESCRIPT_DLL_API
217      virtual
218      int
219      getTagNumber(int dpno);
220    
221    /**    /**
222       \brief       \brief
223       getPointOffset       getPointOffset
224    
225       Description:       Description:
226       Return the offset to the given data-point. This is somewhat artificial,       Return the offset to the given data-point value in the underlying
227       but returns the offset for the given point in the DataTagged object.       data vector.
      Only really necessary to avoid many DataArrayView objects.  
228    
229       \param sampleNo - Input - sample number.       \param sampleNo - Input - sample number.
230       \param dataPointNo - Input - data-point number.       \param dataPointNo - Input - data-point number.
231     */      T
232      */
233      ESCRIPT_DLL_API
234    virtual    virtual
235    DataArrayView::ValueType::size_type    ValueType::size_type
236    getPointOffset(int sampleNo,    getPointOffset(int sampleNo,
237                   int dataPointNo) const;                   int dataPointNo) const;
238    
239    /**    ESCRIPT_DLL_API
240      virtual
241      ValueType::size_type
242      getPointOffset(int sampleNo,
243                     int dataPointNo);
244    
245     /**
246       \brief       \brief
247       addTaggedValues       addTaggedValues
248    
249       Description:       Description:
250       Add the given tags and values to this DataTagged object.       Add the given tags and values to this DataTagged object.
251       \param tagKeys - Input - A vector of integer keys.       \param tagKeys - Input - A vector of integer tags.
252       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of doubles. If this is empty, the default value for
253                     then all given tags will be assigned a value of zero. If                       this DataTagged will be used for all tags.
254                     it contains one value all tags will be assigned the same value.                       If it contains one value all tag values will be assigned
255                     Otherwise if there is a mismatch between the number of tags and               this value. Otherwise consecutive tags will be assigned
256                     the number of values an exception will be generated.                       consecutive values.  If there is a mismatch between  the
257       NB: If a tag given here already exists in this object, this attempt to add the given               number of keys and the number of values an exception
258       value will have no effect. setTaggedValues is more versatile and should be               will be generated.
259       used in most cases in preference to addTaggedValues.       \param vShape - shape of the datapoints in "values"
260        T
261     */
262      ESCRIPT_DLL_API
263      void
264      addTaggedValues(const TagListType& tagKeys,
265                                const ValueBatchType& values,
266                                const ShapeType& vShape);
267    
268    
269      /**
270       Description:
271       Add the given tags and values to this DataTagged object.
272       \param tagKeys - Input - A vector of integer tags.
273       \param values - Input - A DataVector containing the datapoints.
274                 If this is empty, the default value for
275                         this DataTagged will be used for all tags.
276                         If it contains one value all tag values will be assigned
277                 this value. Otherwise consecutive tags will be assigned
278                         consecutive values.  If there is a mismatch between  the
279                 number of keys and the number of values an exception
280                 will be generated.
281        \param vShape - shape of the datapoints in "values"
282    
283       TODO Makesure this is properly unit tested
284    */    */
285      ESCRIPT_DLL_API
286    void    void
287    addTaggedValues(const TagListType& tagKeys,    addTaggedValues(const TagListType& tagKeys,
288                    const ValueListType& values);                                const ValueType& values,
289                                const ShapeType& vShape);
290    
291    
292    
293    
294    /**    /**
295       \brief       \brief
296       addTaggedValue       addTaggedValue
297    
298       Description:       Description:
299       Add a single tag and value to this DataTagged object.       Add a single tag and value to this DataTagged object. If this tag already has
300       \param tagKey - Input - Integer key.       a value associated with it, setTaggedValue will be used to update this value.
301       \param value - Input - DataArrayView.       \param tagKey - Input - Integer tag.
302       NB: If this tag already exists in this object, this attempt to add the given       \param pointshape - Shape of the value parameter
303       value will have no effect. setTaggedValue is more versatile and should be       \param value - Input - Single DataArrayView value to be assigned to the tag.
304       used in most cases in preference to addTaggedValue.       \param dataOffset - Input - Offset of the beginning of the point in the value parameter
305    */    */
306      ESCRIPT_DLL_API
307    void    void
308    addTaggedValue(int tagKey,    addTaggedValue(int tagKey,
309                   const DataArrayView& value);           const DataTypes::ShapeType& pointshape,
310                     const ValueType& value,
311             int dataOffset=0);
312    
313    /**    /**
314       \brief       \brief
315       setTaggedValues       addTag - does not modify the default value for this object. ** Not unit tested **
316    
317       Description:       Description:
318       Assign the given values to the tags listed.       Add a single tag. The default value for this DataTagged will be associated with the tag.
319       \param tagKeys - Input - A vector of integer keys.       If this tag already has a value associated with it, then no change will be made.
320       \param values - Input - A vector of DataArrayViews. If this is empty       \param tagKey - Input - Integer tag.
321                        then all given tags will be assigned a value of zero. If      TODO: Make sure this is unit tested
                       it contains one value all tag values will be assigned the same value.  
                       Otherwise if there is a mismatch between the number of keys and  
                       the number of values an exception will be generated.  
      NB: If a given tag does not yet exist in this DataTagged object, it will be added.  
322    */    */
323      ESCRIPT_DLL_API
324    void    void
325    setTaggedValues(const TagListType& tagKeys,    addTag(int tagKey);
                   const ValueListType& values);  
326    
327    /**    /**
328       \brief       \brief
# Line 210  class DataTagged : public DataAbstract { Line 330  class DataTagged : public DataAbstract {
330    
331       Description:       Description:
332       Assign the given value to the given tag.       Assign the given value to the given tag.
333       \param tagKey - Input - Integer key.       \param tagKey - Input - Integer tag.
334       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param pointshape - the shape of the value parameter
335       NB: If the given tag does not yet exist in this DataTagged object, it will be added.       \param value - Input - Vector storing the datapoint to be assigned to the tag.
336         \param dataOffset - beginning of the datapoint within "value".
337        T
338    */    */
339    virtual    ESCRIPT_DLL_API
340    void    void
341    setTaggedValue(int tagKey,    setTaggedValue(int tagKey,
342                   const DataArrayView& value);           const DataTypes::ShapeType& pointshape,
343                     const ValueType& value,
344             int dataOffset=0);
345    
346    /**    /**
347       \brief       \brief
348       getDataPointByTag       getDataByTag
349    
350       Description:       Return a pointer to the beginning of the datapoint with the specified tag.
351       Return a view into the data-point associated with the given tag.       TODO Eventually these should be inlined.
352       \param tag - Input - Integer key.       \param tag - Input - Integer key.
353         \param i - position in the underlying datastructure
354    */    */
355    DataArrayView  
356    getDataPointByTag(int tag) const;    ESCRIPT_DLL_API
357      DataTypes::ValueType::reference
358      getDataByTagRW(int tag, DataTypes::ValueType::size_type i);
359    
360      ESCRIPT_DLL_API
361      DataTypes::ValueType::const_reference
362      getDataByTagRO(int tag, DataTypes::ValueType::size_type i) const;
363    
364    
365    
366    /**    /**
367       \brief        \brief
368       getDataPoint        getOffsetForTag
369    
370       Description:        \param tag
371       Return a view into the data-point specified by the given sample        \return the offset of the beginning of the datapoint corresponding to tag.
372       and data-point numbers.  
373       NOTE: Construction of the DataArrayView is a relatively expensive        Note: If the tag is not valid, the offset of the default value is returned instead.
      operation.  
      \param sampleNo - Input.  
      \param dataPointNo - Input.  
374    */    */
375    virtual    ESCRIPT_DLL_API
376    DataArrayView    DataTypes::ValueType::size_type
377    getDataPoint(int sampleNo,    getOffsetForTag(int tag) const;
378                 int dataPointNo);  
379    
380      /**
381         \brief
382         Return a reference to the underlying DataVector.
383      */
384    
385      ESCRIPT_DLL_API
386      DataTypes::ValueType&
387      getVectorRW();
388    
389      ESCRIPT_DLL_API
390      const DataTypes::ValueType&
391      getVectorRO() const;
392    
393    
394    
395    /**    /**
396       \brief       \brief
# Line 253  class DataTagged : public DataAbstract { Line 398  class DataTagged : public DataAbstract {
398    
399       Description:       Description:
400       Return a reference to the tag offset lookup table.       Return a reference to the tag offset lookup table.
401        T
402    */    */
403      ESCRIPT_DLL_API
404    const DataMapType&    const DataMapType&
405    getTagLookup() const;    getTagLookup() const;
406    
# Line 262  class DataTagged : public DataAbstract { Line 409  class DataTagged : public DataAbstract {
409       isCurrentTag       isCurrentTag
410    
411       Description:       Description:
412       Return true if the given tag exists within the DataTagged tag keys.       Return true if the given tag exists within the DataTagged tag map.
413       NOTE: The DataTagged keys do not necessarily coincide with the tag  
414       keys for the function space.       *** NB: The DataTagged tag map does not necessarily coincide with the tag
415     */       keys in the associated function space.
416        T
417      */
418      ESCRIPT_DLL_API
419    bool    bool
420    isCurrentTag(int tag) const;    isCurrentTag(int tag) const;
421    
# Line 275  class DataTagged : public DataAbstract { Line 425  class DataTagged : public DataAbstract {
425    
426       Description:       Description:
427       Return the default value. This value is associated with any tag which       Return the default value. This value is associated with any tag which
428       is not explicitly recorded in this DataTagged object.       is not explicitly recorded in this DataTagged object's tag map.
429         \param i - position in the underlying datastructure
430    */    */
431    DataArrayView&    ESCRIPT_DLL_API
432    getDefaultValue();    DataTypes::ValueType::reference
433      getDefaultValueRW(DataTypes::ValueType::size_type i);
434    
435      ESCRIPT_DLL_API
436      DataTypes::ValueType::const_reference
437      getDefaultValueRO(DataTypes::ValueType::size_type i) const;
438    
439    
440    
   /**  
      \brief  
      getDefaultValue  
441    
      Description:  
      Return the default value, const version.  
   */  
   const DataArrayView&  
   getDefaultValue() const;  
442    
443    /**    /**
444       \brief       \brief
445       getLength       getLength
446    
447       Description:       Description:
448       Return the number of doubles stored for the Data.       Return the total number of doubles stored for this DataTagged object.
449        T
450    */    */
451      ESCRIPT_DLL_API
452    virtual    virtual
453    ValueType::size_type    ValueType::size_type
454    getLength() const;    getLength() const;
# Line 306  class DataTagged : public DataAbstract { Line 458  class DataTagged : public DataAbstract {
458       getSlice       getSlice
459    
460       Description:       Description:
461       Factory method that returns a newly created DataTagged.       Factory method that returns a newly created DataTagged object generated
462       The caller is reponsible for managing the object created.       by taking the specified slice from this DataTagged object.
463         The caller is reponsible for managing the returned object.
464        T
465    */    */
466      ESCRIPT_DLL_API
467    virtual    virtual
468    DataAbstract*    DataAbstract*
469    getSlice(const DataArrayView::RegionType& region) const;    getSlice(const DataTypes::RegionType& region) const;
470    
471      /**
472         \brief
473         Slice Constructor for DataTagged.
474    
475         Description:
476         Creates a DataTagged object which is the specified slice
477         from the given DataTagged object.
478         \param other - Input - DataTagged object to slice from.
479         \param region - Input - Region to slice.
480        T
481      */
482      ESCRIPT_DLL_API
483      DataTagged(const DataTagged& other,
484             const DataTypes::RegionType& region);
485    
486    /**    /**
487       \brief       \brief
488       setSlice       setSlice
489    
490       Description:       Description:
491       Copy the specified region from the given value.       Copy the given Data object into the specified region in this object.
492       \param value - Input - Data to copy from.       \param other - Input - Data object to copy from.
493       \param region - Input - Region to copy.       \param region - Input - Region to copy into (NB: must have same shape as other!).
494        T
495    */    */
496      ESCRIPT_DLL_API
497    virtual    virtual
498    void    void
499    setSlice(const DataAbstract* value,    setSlice(const DataAbstract* other,
500             const DataArrayView::RegionType& region);             const DataTypes::RegionType& region);
501    
502    
503    /**    /**
504       \brief       \brief
505       reshapeDataPoint       Computes a symmetric matrix (A + AT) / 2
506    
507         \param ev - Output - symmetric matrix
508    
      Description:  
      Reshape the data point only if the data-point is currently rank 0.  
      An exception is thrown if the data-point has rank other than 0.  
      The original data point value is used for all values of the new  
      data point.  
509    */    */
510    void    ESCRIPT_DLL_API
511    reshapeDataPoint(const DataArrayView::ShapeType& shape);    virtual void
512      symmetric(DataAbstract* ev);
513    
514      /**
515         \brief
516         Computes a nonsymmetric matrix (A - AT) / 2
517    
518         \param ev - Output - nonsymmetric matrix
519    
520      */
521      ESCRIPT_DLL_API
522      virtual void
523      nonsymmetric(DataAbstract* ev);
524    
525      /**
526         \brief
527         Computes the trace of a matrix
528    
529         \param ev - Output - the trace of a matrix
530         \param axis_offset
531      */
532      ESCRIPT_DLL_API
533      virtual void
534      trace(DataAbstract* ev, int axis_offset);
535    
536      /**
537         \brief
538         swaps components axis0 and axis1
539    
540         \param ev - Output - swapped components
541         \param axis0
542         \param axis1
543      */
544      ESCRIPT_DLL_API
545      virtual void
546      swapaxes(DataAbstract* ev, int axis0, int axis1);
547    
548      /**
549         \brief
550         Transpose each data point of this Data object around the given axis.
551    
552         \param ev - Output - the transpose of a matrix
553         \param axis_offset
554      */
555      ESCRIPT_DLL_API
556      virtual void
557      transpose(DataAbstract* ev, int axis_offset);
558    
559      /**
560         \brief
561         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
562    
563         \param ev - Output - eigenvalues in increasing order at each data point
564    
565      */
566      ESCRIPT_DLL_API
567      virtual void
568      eigenvalues(DataAbstract* ev);
569    
570      /**
571         \brief
572         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
573    
574         \param ev - Output - eigenvalues in increasing order at each data point
575         \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
576                             and the first nonzero component is positive.
577         \param tol - Input - eigenvalue with relative distance tol are treated as equal.
578    
579      */
580    
581      ESCRIPT_DLL_API
582      virtual void
583      eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
584    
585    
586      /**
587         \brief  Returns the offset in the structure which stores the default value
588      */
589      ESCRIPT_DLL_API
590      DataTypes::ValueType::size_type
591      getDefaultOffset() const;
592    
593   protected:   protected:
594    
# Line 349  class DataTagged : public DataAbstract { Line 599  class DataTagged : public DataAbstract {
599    DataMapType m_offsetLookup;    DataMapType m_offsetLookup;
600    
601    //    //
602    // The actual data    // the offset to the default value
603    DataArrayView::ValueType m_data;    static const int m_defaultValueOffset = 0;
604    
605    //    //
606    // the default value offset    // The actual data
607    static const int m_defaultValueOffset = 0;    ValueType m_data;
608    
609  };  };
610    
# Line 366  DataTagged::isCurrentTag(int tag) const Line 616  DataTagged::isCurrentTag(int tag) const
616    return (pos!=m_offsetLookup.end());    return (pos!=m_offsetLookup.end());
617  }  }
618    
619    inline
620    DataTypes::ValueType::size_type
621    DataTagged::getDefaultOffset() const
622    {
623      return m_defaultValueOffset;  
624    }
625    
626  inline  inline
627  DataArrayView&  DataTypes::ValueType::reference
628  DataTagged::getDefaultValue()  DataTagged::getDefaultValueRW(DataTypes::ValueType::size_type i)
629    {  
630        return getVectorRW()[i];        // getVectorRW has exclusive write checks
631    }
632    
633    inline
634    DataTypes::ValueType::const_reference
635    DataTagged::getDefaultValueRO(DataTypes::ValueType::size_type i) const
636  {  {
637    //      return getVectorRO()[i];
   // The default value is always the first value.  
   return getPointDataView();  
638  }  }
639    
640  inline  inline
641  const DataArrayView&  const DataTagged::DataMapType&
642  DataTagged::getDefaultValue() const  DataTagged::getTagLookup() const
643  {  {
644    //    return m_offsetLookup;
645    // The default value is always the first value.  }
646    return getPointDataView();  
647    inline
648    DataTypes::ValueType::size_type
649    DataTagged::getLength() const
650    {
651      return m_data.size();
652  }  }
653    
654  } // end of namespace  } // end of namespace

Legend:
Removed from v.100  
changed lines
  Added in v.2548

  ViewVC Help
Powered by ViewVC 1.1.26