/[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

revision 580 by gross, Wed Mar 8 05:45:51 2006 UTC revision 2881 by jfenwick, Thu Jan 28 02:03:15 2010 UTC
# Line 1  Line 1 
 // $Id$  
1    
2  /*  /*******************************************************
3   ******************************************************************************  *
4   *                                                                            *  * Copyright (c) 2003-2010 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 "DataAbstract.h"  #include "DataReady.h"
20  #include "DataArrayView.h"  #include "DataTypes.h"
21    
22  #include <vector>  #include <vector>
23  #include <map>  #include <map>
# Line 38  class DataConstant; Line 37  class DataConstant;
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    //    //
45    // Types for the lists of tags and values.    // Types for the lists of tags and values.
46    typedef std::vector<int>           TagListType;    typedef std::vector<int>           TagListType;
47    typedef std::vector<DataArrayView> ValueListType;  //  typedef std::vector<DataArrayView> ValueListType;
48    typedef DataArrayView::ValueType   ValueType;    typedef DataTypes::ValueType   ValueType;
49      typedef std::vector<ValueType::ElementType> ValueBatchType;
50    
51    //    //
52    // Map from a tag to an offset into the data array.    // Map from a tag to an offset into the data array.
# Line 62  class DataTagged : public DataAbstract { Line 62  class DataTagged : public DataAbstract {
62       tag values are stored.       tag values are stored.
63      T      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 tags.       \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 scalar data-point of value       \param tags - Input - An array of tags, one for each sample number (starts at tag[1]).
77                       0. If it contains one value all tag values will be assigned       \param data - The data values for each tag.
78               this value. Otherwise consecutive tags will be assigned      NB: no unit testing yet
                      consecutive values.  If there is a mismatch between  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.  
     T  
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       Alternative Constructor for DataTagged.       Alternative Constructor for DataTagged.
89    
# Line 95  class DataTagged : public DataAbstract { Line 91  class DataTagged : public DataAbstract {
91       Alternative Constructor for DataTagged.       Alternative Constructor for DataTagged.
92       \param what - Input - A description of what this data object represents.       \param what - Input - A description of what this data object represents.
93       \param shape - Input - The shape of each data-point.       \param shape - Input - The shape of each data-point.
94       \param tags - Input - An array of tags, one for each sample number.       \param tags - Input - An vector of tags, one for each sample number.
95       \param data - The data values for each tag.       \param data - The data values for each tag.
96      NB: no unit testing yet  TODO Make sure to document the relationship between tags and data, ie: data also contains the default value
97    */   */
98      ESCRIPT_DLL_API
99    DataTagged(const FunctionSpace& what,    DataTagged(const FunctionSpace& what,
100               const DataArrayView::ShapeType &shape,               const DataTypes::ShapeType &shape,
101               const int tags[],               const TagListType& tags,
102               const ValueType& data);               const ValueType& data);
103    
104    /**    /**
# Line 110  class DataTagged : public DataAbstract { Line 107  class DataTagged : public DataAbstract {
107       Performs a deep copy from the given DataTagged object.       Performs a deep copy from the given DataTagged object.
108      T      T
109    */    */
110      ESCRIPT_DLL_API
111    DataTagged(const DataTagged& other);    DataTagged(const DataTagged& other);
112    
113    /**    /**
# Line 119  class DataTagged : public DataAbstract { Line 117  class DataTagged : public DataAbstract {
117       The default value will be the value of the DataConstant object.       The default value will be the value of the DataConstant object.
118      T      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      \brief Return true if any one of the datapoints contains a NaN.
156      */
157      ESCRIPT_DLL_API
158      bool
159      hasNaN() const;
160    
161      /**
162         \brief Return a deep copy of the current object.
163      */
164      ESCRIPT_DLL_API
165      virtual
166      DataAbstract*
167      deepCopy();
168    
169    
170      /**
171         \brief
172       getSampleDataByTag       getSampleDataByTag
173    
174       Description:       Description:
# Line 133  class DataTagged : public DataAbstract { Line 179  class DataTagged : public DataAbstract {
179       ** NB: need to do array bounds checking when accessing returned value!       ** NB: need to do array bounds checking when accessing returned value!
180      T      T
181    */    */
182      ESCRIPT_DLL_API
183    virtual    virtual
184    double*    double*
185    getSampleDataByTag(int tag);    getSampleDataByTag(int tag);
# Line 144  class DataTagged : public DataAbstract { Line 191  class DataTagged : public DataAbstract {
191       associated with each tag.       associated with each tag.
192      T      T
193    */    */
194      ESCRIPT_DLL_API
195    virtual    virtual
196    std::string    std::string
197    toString() const;    toString() const;
198     /**
199         \brief
200         dumps the object into a netCDF file
201      */
202      ESCRIPT_DLL_API
203      virtual
204      void
205      dump(const std::string fileName) const;
206    
207      /**
208        \brief invert square matricies
209        \param out - Where to store the results
210        \return errorcode (0 indicates success)
211      */
212      ESCRIPT_DLL_API
213      virtual int
214      matrixInverse(DataAbstract* out) const;
215    
216     /**
217         \brief
218        sets all values to zero
219      */
220      ESCRIPT_DLL_API
221      virtual
222      void
223      setToZero();
224    
225    /**    /**
226       \brief       \brief
# Line 154  class DataTagged : public DataAbstract { Line 228  class DataTagged : public DataAbstract {
228       according to the associated function space.       according to the associated function space.
229      T      T
230    */    */
231      ESCRIPT_DLL_API
232    virtual    virtual
233    int    int
234    getTagNumber(int dpno);    getTagNumber(int dpno);
# Line 170  class DataTagged : public DataAbstract { Line 245  class DataTagged : public DataAbstract {
245       \param dataPointNo - Input - data-point number.       \param dataPointNo - Input - data-point number.
246      T      T
247    */    */
248      ESCRIPT_DLL_API
249    virtual    virtual
250    ValueType::size_type    ValueType::size_type
251    getPointOffset(int sampleNo,    getPointOffset(int sampleNo,
252                   int dataPointNo) const;                   int dataPointNo) const;
253    
254    /**    ESCRIPT_DLL_API
255      virtual
256      ValueType::size_type
257      getPointOffset(int sampleNo,
258                     int dataPointNo);
259    
260     /**
261       \brief       \brief
262       addTaggedValues       addTaggedValues
263    
264       Description:       Description:
265       Add the given tags and values to this DataTagged object.       Add the given tags and values to this DataTagged object.
266       \param tagKeys - Input - A vector of integer tags.       \param tagKeys - Input - A vector of integer tags.
267       \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
268                       all tag values will be assigned a scalar data-point of value                       this DataTagged will be used for all tags.
269                       0. If it contains one value all tag values will be assigned                       If it contains one value all tag values will be assigned
270               this value. Otherwise consecutive tags will be assigned               this value. Otherwise consecutive tags will be assigned
271                       consecutive values.  If there is a mismatch between  the                       consecutive values.  If there is a mismatch between  the
272               number of keys and the number of values an exception               number of keys and the number of values an exception
273               will be generated.               will be generated.
274         \param vShape - shape of the datapoints in "values"
275      T      T
276     */
277      ESCRIPT_DLL_API
278      void
279      addTaggedValues(const TagListType& tagKeys,
280                                const ValueBatchType& values,
281                                const ShapeType& vShape);
282    
283    
284      /**
285       Description:
286       Add the given tags and values to this DataTagged object.
287       \param tagKeys - Input - A vector of integer tags.
288       \param values - Input - A DataVector containing the datapoints.
289                 If this is empty, the default value for
290                         this DataTagged will be used for all tags.
291                         If it contains one value all tag values will be assigned
292                 this value. Otherwise consecutive tags will be assigned
293                         consecutive values.  If there is a mismatch between  the
294                 number of keys and the number of values an exception
295                 will be generated.
296        \param vShape - shape of the datapoints in "values"
297    
298       TODO Makesure this is properly unit tested
299    */    */
300      ESCRIPT_DLL_API
301    void    void
302    addTaggedValues(const TagListType& tagKeys,    addTaggedValues(const TagListType& tagKeys,
303                    const ValueListType& values);                                const ValueType& values,
304                                const ShapeType& vShape);
305    
306    
307    
308    
309    /**    /**
310       \brief       \brief
# Line 203  class DataTagged : public DataAbstract { Line 314  class DataTagged : public DataAbstract {
314       Add a single tag and value to this DataTagged object. If this tag already has       Add a single tag and value to this DataTagged object. If this tag already has
315       a value associated with it, setTaggedValue will be used to update this value.       a value associated with it, setTaggedValue will be used to update this value.
316       \param tagKey - Input - Integer tag.       \param tagKey - Input - Integer tag.
317       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param pointshape - Shape of the value parameter
318      T       \param value - Input - Single DataArrayView value to be assigned to the tag.
319         \param dataOffset - Input - Offset of the beginning of the point in the value parameter
320    */    */
321      ESCRIPT_DLL_API
322    void    void
323    addTaggedValue(int tagKey,    addTaggedValue(int tagKey,
324                   const DataArrayView& value);           const DataTypes::ShapeType& pointshape,
325                     const ValueType& value,
326             int dataOffset=0);
327    
328    /**    /**
329       \brief       \brief
330       setTaggedValues       addTag - does not modify the default value for this object. ** Not unit tested **
331    
332       Description:       Description:
333       Set the given tags to the given values in this DataTagged object.       Add a single tag. The default value for this DataTagged will be associated with the tag.
334       \param tagKeys - Input - A vector of integer tag.       If this tag already has a value associated with it, then no change will be made.
335       \param values - Input - A vector of DataArrayViews. If this is empty       \param tagKey - Input - Integer tag.
336                       all tag values will be assigned a scalar data-point of value      TODO: Make sure this is unit tested
                      0. If it contains one value all tag values will be assigned  
              this value. Otherwise consecutive tags will be assigned  
                      consecutive values.  If there is a mismatch between  the  
              number of keys and the number of values an exception  
              will be generated.  
     T  
337    */    */
338      ESCRIPT_DLL_API
339    void    void
340    setTaggedValues(const TagListType& tagKeys,    addTag(int tagKey);
                   const ValueListType& values);  
341    
342    /**    /**
343       \brief       \brief
# Line 237  class DataTagged : public DataAbstract { Line 346  class DataTagged : public DataAbstract {
346       Description:       Description:
347       Assign the given value to the given tag.       Assign the given value to the given tag.
348       \param tagKey - Input - Integer tag.       \param tagKey - Input - Integer tag.
349       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param pointshape - the shape of the value parameter
350         \param value - Input - Vector storing the datapoint to be assigned to the tag.
351         \param dataOffset - beginning of the datapoint within "value".
352      T      T
353    */    */
354    virtual    ESCRIPT_DLL_API
355    void    void
356    setTaggedValue(int tagKey,    setTaggedValue(int tagKey,
357                   const DataArrayView& value);           const DataTypes::ShapeType& pointshape,
358                     const ValueType& value,
359             int dataOffset=0);
360    
361    /**    /**
362       \brief       \brief
363       getDataPointByTag       getDataByTag
364    
365       Description:       Return a pointer to the beginning of the datapoint with the specified tag.
366       Return data-point associated with the given tag as a DataArrayView.       TODO Eventually these should be inlined.
367       \param tag - Input - Integer key.       \param tag - Input - Integer key.
368      T       \param i - position in the underlying datastructure
369      */
370    
371      ESCRIPT_DLL_API
372      DataTypes::ValueType::reference
373      getDataByTagRW(int tag, DataTypes::ValueType::size_type i);
374    
375      ESCRIPT_DLL_API
376      DataTypes::ValueType::const_reference
377      getDataByTagRO(int tag, DataTypes::ValueType::size_type i) const;
378    
379    
380    
381      /**
382          \brief
383          getOffsetForTag
384    
385          \param tag
386          \return the offset of the beginning of the datapoint corresponding to tag.
387    
388          Note: If the tag is not valid, the offset of the default value is returned instead.
389    */    */
390    DataArrayView    ESCRIPT_DLL_API
391    getDataPointByTag(int tag) const;    DataTypes::ValueType::size_type
392      getOffsetForTag(int tag) const;
393    
394    
395    /**    /**
396       \brief       \brief
397       getDataPoint       Return a reference to the underlying DataVector.
   
      Description:  
      Return the data-point specified by the given sample and data-point  
      numbers as a DataArrayView.  
      \param sampleNo - Input.  
      \param dataPointNo - Input.  
     T  
398    */    */
399    virtual  
400    DataArrayView    ESCRIPT_DLL_API
401    getDataPoint(int sampleNo,    DataTypes::ValueType&
402                 int dataPointNo);    getVectorRW();
403    
404      ESCRIPT_DLL_API
405      const DataTypes::ValueType&
406      getVectorRO() const;
407    
408    
409    
410    /**    /**
411       \brief       \brief
# Line 281  class DataTagged : public DataAbstract { Line 415  class DataTagged : public DataAbstract {
415       Return a reference to the tag offset lookup table.       Return a reference to the tag offset lookup table.
416      T      T
417    */    */
418      ESCRIPT_DLL_API
419    const DataMapType&    const DataMapType&
420    getTagLookup() const;    getTagLookup() const;
421    
# Line 295  class DataTagged : public DataAbstract { Line 430  class DataTagged : public DataAbstract {
430       keys in the associated function space.       keys in the associated function space.
431      T      T
432    */    */
433      ESCRIPT_DLL_API
434    bool    bool
435    isCurrentTag(int tag) const;    isCurrentTag(int tag) const;
436    
# Line 305  class DataTagged : public DataAbstract { Line 441  class DataTagged : public DataAbstract {
441       Description:       Description:
442       Return the default value. This value is associated with any tag which       Return the default value. This value is associated with any tag which
443       is not explicitly recorded in this DataTagged object's tag map.       is not explicitly recorded in this DataTagged object's tag map.
444      T       \param i - position in the underlying datastructure
445    */    */
446    DataArrayView&    ESCRIPT_DLL_API
447    getDefaultValue();    DataTypes::ValueType::reference
448      getDefaultValueRW(DataTypes::ValueType::size_type i);
449    
450      ESCRIPT_DLL_API
451      DataTypes::ValueType::const_reference
452      getDefaultValueRO(DataTypes::ValueType::size_type i) const;
453    
454    
455    
456    
   const DataArrayView&  
   getDefaultValue() const;  
457    
458    /**    /**
459       \brief       \brief
# Line 321  class DataTagged : public DataAbstract { Line 463  class DataTagged : public DataAbstract {
463       Return the total number of doubles stored for this DataTagged object.       Return the total number of doubles stored for this DataTagged object.
464      T      T
465    */    */
466      ESCRIPT_DLL_API
467    virtual    virtual
468    ValueType::size_type    ValueType::size_type
469    getLength() const;    getLength() const;
# Line 335  class DataTagged : public DataAbstract { Line 478  class DataTagged : public DataAbstract {
478       The caller is reponsible for managing the returned object.       The caller is reponsible for managing the returned object.
479      T      T
480    */    */
481      ESCRIPT_DLL_API
482    virtual    virtual
483    DataAbstract*    DataAbstract*
484    getSlice(const DataArrayView::RegionType& region) const;    getSlice(const DataTypes::RegionType& region) const;
485    
486    /**    /**
487       \brief       \brief
# Line 350  class DataTagged : public DataAbstract { Line 494  class DataTagged : public DataAbstract {
494       \param region - Input - Region to slice.       \param region - Input - Region to slice.
495      T      T
496    */    */
497      ESCRIPT_DLL_API
498    DataTagged(const DataTagged& other,    DataTagged(const DataTagged& other,
499           const DataArrayView::RegionType& region);           const DataTypes::RegionType& region);
500    
501    /**    /**
502       \brief       \brief
# Line 363  class DataTagged : public DataAbstract { Line 508  class DataTagged : public DataAbstract {
508       \param region - Input - Region to copy into (NB: must have same shape as other!).       \param region - Input - Region to copy into (NB: must have same shape as other!).
509      T      T
510    */    */
511      ESCRIPT_DLL_API
512    virtual    virtual
513    void    void
514    setSlice(const DataAbstract* other,    setSlice(const DataAbstract* other,
515             const DataArrayView::RegionType& region);             const DataTypes::RegionType& region);
516    
517    
518    /**    /**
519       \brief       \brief
520       reshapeDataPoint       Computes a symmetric matrix (A + AT) / 2
521    
522         \param ev - Output - symmetric matrix
523    
      Description:  
      Reshape each data-point in this object to the given shape, only  
      if current data-points are scalars. An exception is thrown if  
      the current data-points have rank other than 0.  
      The original values of the data-points are used for all values  
      of the new data-points.  
     T  
524    */    */
525    void    ESCRIPT_DLL_API
526    reshapeDataPoint(const DataArrayView::ShapeType& shape);    virtual void
527      symmetric(DataAbstract* ev);
528    
529    /**    /**
530       \brief       \brief
531       Archive the underlying data values to the file referenced       Computes a nonsymmetric matrix (A - AT) / 2
532       by ofstream. A count of the number of values expected to be written  
533       is provided as a cross-check.       \param ev - Output - nonsymmetric matrix
534    
      The return value indicates success (0) or otherwise (1).  
535    */    */
536    int    ESCRIPT_DLL_API
537    archiveData(std::ofstream& archiveFile,    virtual void
538                const DataArrayView::ValueType::size_type noValues) const;    nonsymmetric(DataAbstract* ev);
539    
540    /**    /**
541       \brief       \brief
542       Extract the number of values specified by noValues from the file       Computes the trace of a matrix
      referenced by ifstream to the underlying data structure.  
543    
544       The return value indicates success (0) or otherwise (1).       \param ev - Output - the trace of a matrix
545         \param axis_offset
546    */    */
547    int    ESCRIPT_DLL_API
548    extractData(std::ifstream& archiveFile,    virtual void
549                const DataArrayView::ValueType::size_type noValues);    trace(DataAbstract* ev, int axis_offset);
550    
551      /**
552         \brief
553         swaps components axis0 and axis1
554    
555         \param ev - Output - swapped components
556         \param axis0
557         \param axis1
558      */
559      ESCRIPT_DLL_API
560      virtual void
561      swapaxes(DataAbstract* ev, int axis0, int axis1);
562    
563      /**
564         \brief
565         Transpose each data point of this Data object around the given axis.
566    
567         \param ev - Output - the transpose of a matrix
568         \param axis_offset
569      */
570      ESCRIPT_DLL_API
571      virtual void
572      transpose(DataAbstract* ev, int axis_offset);
573    
574    /**    /**
575       \brief       \brief
# Line 413  class DataTagged : public DataAbstract { Line 578  class DataTagged : public DataAbstract {
578       \param ev - Output - eigenvalues in increasing order at each data point       \param ev - Output - eigenvalues in increasing order at each data point
579    
580    */    */
581      ESCRIPT_DLL_API
582    virtual void    virtual void
583    eigenvalues(DataAbstract* ev);    eigenvalues(DataAbstract* ev);
584    
# Line 427  class DataTagged : public DataAbstract { Line 593  class DataTagged : public DataAbstract {
593    
594    */    */
595    
596      ESCRIPT_DLL_API
597    virtual void    virtual void
598    eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);    eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
599    
600    
601      /**
602         \brief  Returns the offset in the structure which stores the default value
603      */
604      ESCRIPT_DLL_API
605      DataTypes::ValueType::size_type
606      getDefaultOffset() const;
607    
608   protected:   protected:
609    
610   private:   private:
# Line 457  DataTagged::isCurrentTag(int tag) const Line 631  DataTagged::isCurrentTag(int tag) const
631    return (pos!=m_offsetLookup.end());    return (pos!=m_offsetLookup.end());
632  }  }
633    
634  inline  inline
635  DataArrayView&  DataTypes::ValueType::size_type
636  DataTagged::getDefaultValue()  DataTagged::getDefaultOffset() const
637  {  {
638    // The default value is always the first value.    return m_defaultValueOffset;  
639    return getPointDataView();  }
640    
641    inline
642    DataTypes::ValueType::reference
643    DataTagged::getDefaultValueRW(DataTypes::ValueType::size_type i)
644    {  
645        return getVectorRW()[i];        // getVectorRW has exclusive write checks
646  }  }
647    
648  inline  inline
649  const DataArrayView&  DataTypes::ValueType::const_reference
650  DataTagged::getDefaultValue() const  DataTagged::getDefaultValueRO(DataTypes::ValueType::size_type i) const
651  {  {
652    // The default value is always the first value.      return getVectorRO()[i];
   return getPointDataView();  
653  }  }
654    
655  inline  inline
# Line 481  DataTagged::getTagLookup() const Line 660  DataTagged::getTagLookup() const
660  }  }
661    
662  inline  inline
663  DataArrayView::ValueType::size_type  DataTypes::ValueType::size_type
664  DataTagged::getLength() const  DataTagged::getLength() const
665  {  {
666    return m_data.size();    return m_data.size();

Legend:
Removed from v.580  
changed lines
  Added in v.2881

  ViewVC Help
Powered by ViewVC 1.1.26