/[escript]/branches/arrayview_from_1695_trunk/escript/src/DataTagged.h
ViewVC logotype

Diff of /branches/arrayview_from_1695_trunk/escript/src/DataTagged.h

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

trunk/esys2/escript/src/Data/DataTagged.h revision 97 by jgs, Tue Dec 14 05:39:33 2004 UTC trunk/escript/src/DataTagged.h revision 1118 by gross, Tue Apr 24 08:55:04 2007 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2  /*  
3   ******************************************************************************  /*
4   *                                                                            *   ************************************************************
5   *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *   *          Copyright 2006 by ACcESS MNRF                   *
6   *                                                                            *   *                                                          *
7   * This software is the property of ACcESS. No part of this code              *   *              http://www.access.edu.au                    *
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 "DataAbstract.h"
20  #include "escript/Data/DataArray.h"  #include "DataArrayView.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  */  */
# Line 44  class DataTagged : public DataAbstract { Line 41  class DataTagged : public DataAbstract {
41    
42   public:   public:
43    
44    typedef std::vector<int> TagListType;    //
45      // Types for the lists of tags and values.
46      typedef std::vector<int>           TagListType;
47    typedef std::vector<DataArrayView> ValueListType;    typedef std::vector<DataArrayView> ValueListType;
48      typedef DataArrayView::ValueType   ValueType;
49    
50    //    //
51    // Map type, maps the key to an array offset.    // Map from a tag to an offset into the data array.
52    typedef std::map<int, int> DataMapType;    typedef std::map<int, int> DataMapType;
53    
54    /**    /**
# Line 57  class DataTagged : public DataAbstract { Line 57  class DataTagged : public DataAbstract {
57    
58       Description:       Description:
59       Default constructor for DataTagged. Creates a DataTagged object for which       Default constructor for DataTagged. Creates a DataTagged object for which
60       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
61       will map to this data-point.       tag values are stored.
62        T
63    */    */
64      ESCRIPT_DLL_API
65    DataTagged();    DataTagged();
66    
67    /**    /**
# Line 68  class DataTagged : public DataAbstract { Line 70  class DataTagged : public DataAbstract {
70    
71       Description:       Description:
72       Constructor for DataTagged.       Constructor for DataTagged.
73       \param tagKeys - Input - A vector of integer keys.       \param tagKeys - Input - A vector of integer tags.
74       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
75                     all tag values will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
76                     it contains one value all tag values will be assigned the                       0. If it contains one value all tag values will be assigned
77             same value. Otherwise if there is a mismatch between               this value. Otherwise consecutive tags will be assigned
78             the number of keys and the number of values an exception                       consecutive values.  If there is a mismatch between  the
79             will be generated.               number of keys and the number of values an exception
80                 will be generated.
81       \param defaultValue - Input - Value returned if a requested tag doesn't exist.       \param defaultValue - Input - Value returned if a requested tag doesn't exist.
82       \param what - Input - A description of what this data represents.       \param what - Input - A description of what this data represents.
83        T
84    */    */
85      ESCRIPT_DLL_API
86    DataTagged(const TagListType& tagKeys,    DataTagged(const TagListType& tagKeys,
87               const ValueListType& values,               const ValueListType& values,
88           const DataArrayView& defaultValue,           const DataArrayView& defaultValue,
# Line 85  class DataTagged : public DataAbstract { Line 90  class DataTagged : public DataAbstract {
90    
91    /**    /**
92       \brief       \brief
93       Slice constructor for DataTagged.       Alternative Constructor for DataTagged.
94    
95       Description:       Description:
96       Slice constructor for DataTagged.       Alternative Constructor for DataTagged.
97       Copies a slice from another DataTagged object.       \param what - Input - A description of what this data object represents.
98       \param other - Input - DataTagged object to copy from.       \param shape - Input - The shape of each data-point.
99       \param region - Input - region to copy.       \param tags - Input - An array of tags, one for each sample number.
100         \param data - The data values for each tag.
101        NB: no unit testing yet
102    */    */
103    DataTagged(const DataTagged& other,    ESCRIPT_DLL_API
104           const DataArrayView::RegionType& region);    DataTagged(const FunctionSpace& what,
105                 const DataArrayView::ShapeType &shape,
106                 const int tags[],
107                 const ValueType& data);
108    
109    /**    /**
110       \brief       \brief
111       Copy constructorfor DataTagged.       Alternative Constructor for DataTagged.
112    
113         Description:
114         Alternative Constructor for DataTagged.
115         \param what - Input - A description of what this data object represents.
116         \param shape - Input - The shape of each data-point.
117         \param tags - Input - An vector of tags, one for each sample number.
118         \param data - The data values for each tag.
119        NB: no unit testing yet
120      */
121      ESCRIPT_DLL_API
122      DataTagged(const FunctionSpace& what,
123                 const DataArrayView::ShapeType &shape,
124                 const TagListType& tags,
125                 const ValueType& data);
126    
127      /**
128         \brief
129         Copy Constructor for DataTagged.
130       Performs a deep copy from the given DataTagged object.       Performs a deep copy from the given DataTagged object.
131        T
132    */    */
133      ESCRIPT_DLL_API
134    DataTagged(const DataTagged& other);    DataTagged(const DataTagged& other);
135    
136    /**    /**
137       \brief       \brief
138       Construct a tagged data from a DataConstant object.       Copy Constructor for DataTagged.
139       The default data-point will be that held by the DataConstant object.       Construct a DataTagged object from a DataConstant object.
140         The default value will be the value of the DataConstant object.
141        T
142    */    */
143      ESCRIPT_DLL_API
144    DataTagged(const DataConstant& other);    DataTagged(const DataConstant& other);
145    
146    /**    /**
# Line 115  class DataTagged : public DataAbstract { Line 148  class DataTagged : public DataAbstract {
148       getSampleDataByTag       getSampleDataByTag
149    
150       Description:       Description:
151       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
152       sample should be visable via the returned pointer. This provides an       sample will be visible via the returned pointer.
153       interface into the data suitable for legacy C code.  
154         ** This provides an interface into the data suitable for legacy C code.
155         ** NB: need to do array bounds checking when accessing returned value!
156        T
157    */    */
158      ESCRIPT_DLL_API
159    virtual    virtual
160    double*    double*
161    getSampleDataByTag(int tag);    getSampleDataByTag(int tag);
# Line 128  class DataTagged : public DataAbstract { Line 165  class DataTagged : public DataAbstract {
165       Write the data as a string.       Write the data as a string.
166       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
167       associated with each tag.       associated with each tag.
168        T
169    */    */
170      ESCRIPT_DLL_API
171    virtual    virtual
172    std::string    std::string
173    toString() const;    toString() const;
174     /**
175         \brief
176         dumps the object into a netCDF file
177      */
178      ESCRIPT_DLL_API
179      virtual
180      void
181      dump(const std::string fileName) const;
182    
183     /**
184         \brief
185        sets all values to zero
186      */
187      ESCRIPT_DLL_API
188      virtual
189      void
190      setToZero();
191    
192      /**
193         \brief
194         Return the tag number associated with the given data-point number
195         according to the associated function space.
196        T
197      */
198      ESCRIPT_DLL_API
199      virtual
200      int
201      getTagNumber(int dpno);
202    
203    /**    /**
204       \brief       \brief
205       getPointOffset       getPointOffset
206    
207       Description:       Description:
208       Return the offset to the given data-point. This is somewhat artificial,       Return the offset to the given data-point value in the underlying
209       but returns the offset for the given point in the DataTagged object.       data vector.
      Only really necessary to avoid many DataArrayView objects.  
210    
211       \param sampleNo - Input - sample number.       \param sampleNo - Input - sample number.
212       \param dataPointNo - Input - data-point number.       \param dataPointNo - Input - data-point number.
213     */      T
214      */
215      ESCRIPT_DLL_API
216    virtual    virtual
217    DataArrayView::ValueType::size_type    ValueType::size_type
218    getPointOffset(int sampleNo,    getPointOffset(int sampleNo,
219                   int dataPointNo) const;                   int dataPointNo) const;
220    
# Line 155  class DataTagged : public DataAbstract { Line 223  class DataTagged : public DataAbstract {
223       addTaggedValues       addTaggedValues
224    
225       Description:       Description:
226       Add the given tags and values to this DataTagged object.       Add the given tags and values to this DataTagged object.
227       \param tagKeys - Input - A vector of integer keys.       \param tagKeys - Input - A vector of integer tags.
228       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
229                     then all given tags will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
230                     it contains one value all tags will be assigned the same value.                       0. If it contains one value all tag values will be assigned
231                     Otherwise if there is a mismatch between the number of tags and               this value. Otherwise consecutive tags will be assigned
232                     the number of values an exception will be generated.                       consecutive values.  If there is a mismatch between  the
233       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
234       value will have no effect. setTaggedValues is more versatile and should be               will be generated.
235       used in most cases in preference to addTaggedValues.      T
236    */    */
237      ESCRIPT_DLL_API
238    void    void
239    addTaggedValues(const TagListType& tagKeys,    addTaggedValues(const TagListType& tagKeys,
240                    const ValueListType& values);                      const ValueListType& values);  
# Line 175  class DataTagged : public DataAbstract { Line 244  class DataTagged : public DataAbstract {
244       addTaggedValue       addTaggedValue
245    
246       Description:       Description:
247       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
248       \param tagKey - Input - Integer key.       a value associated with it, setTaggedValue will be used to update this value.
249       \param value - Input - DataArrayView.       \param tagKey - Input - Integer tag.
250       NB: If this tag already exists in this object, this attempt to add the given       \param value - Input - Single DataArrayView value to be assigned to the tag.
251       value will have no effect. setTaggedValue is more versatile and should be      T
      used in most cases in preference to addTaggedValue.  
252    */    */
253      ESCRIPT_DLL_API
254    void    void
255    addTaggedValue(int tagKey,    addTaggedValue(int tagKey,
256                   const DataArrayView& value);                   const DataArrayView& value);
# Line 191  class DataTagged : public DataAbstract { Line 260  class DataTagged : public DataAbstract {
260       setTaggedValues       setTaggedValues
261    
262       Description:       Description:
263       Assign the given values to the tags listed.       Set the given tags to the given values in this DataTagged object.
264       \param tagKeys - Input - A vector of integer keys.       \param tagKeys - Input - A vector of integer tag.
265       \param values - Input - A vector of DataArrayViews. If this is empty       \param values - Input - A vector of DataArrayViews. If this is empty
266                        then all given tags will be assigned a value of zero. If                       all tag values will be assigned a scalar data-point of value
267                        it contains one value all tag values will be assigned the same value.                       0. If it contains one value all tag values will be assigned
268                        Otherwise if there is a mismatch between the number of keys and               this value. Otherwise consecutive tags will be assigned
269                        the number of values an exception will be generated.                       consecutive values.  If there is a mismatch between  the
270       NB: If a given tag does not yet exist in this DataTagged object, it will be added.               number of keys and the number of values an exception
271                 will be generated.
272        T
273    */    */
274      ESCRIPT_DLL_API
275    void    void
276    setTaggedValues(const TagListType& tagKeys,    setTaggedValues(const TagListType& tagKeys,
277                    const ValueListType& values);                    const ValueListType& values);
# Line 210  class DataTagged : public DataAbstract { Line 282  class DataTagged : public DataAbstract {
282    
283       Description:       Description:
284       Assign the given value to the given tag.       Assign the given value to the given tag.
285       \param tagKey - Input - Integer key.       \param tagKey - Input - Integer tag.
286       \param value - Input - Single DataArrayView value to be assigned to the tag.       \param value - Input - Single DataArrayView value to be assigned to the tag.
287       NB: If the given tag does not yet exist in this DataTagged object, it will be added.      T
288    */    */
289      ESCRIPT_DLL_API
290    virtual    virtual
291    void    void
292    setTaggedValue(int tagKey,    setTaggedValue(int tagKey,
# Line 224  class DataTagged : public DataAbstract { Line 297  class DataTagged : public DataAbstract {
297       getDataPointByTag       getDataPointByTag
298    
299       Description:       Description:
300       Return a view into the data-point associated with the given tag.       Return data-point associated with the given tag as a DataArrayView.
301       \param tag - Input - Integer key.       \param tag - Input - Integer key.
302        T
303    */    */
304      ESCRIPT_DLL_API
305    DataArrayView    DataArrayView
306    getDataPointByTag(int tag) const;    getDataPointByTag(int tag) const;
307    
# Line 235  class DataTagged : public DataAbstract { Line 310  class DataTagged : public DataAbstract {
310       getDataPoint       getDataPoint
311    
312       Description:       Description:
313       Return a view into the data-point specified by the given sample       Return the data-point specified by the given sample and data-point
314       and data-point numbers.       numbers as a DataArrayView.
      NOTE: Construction of the DataArrayView is a relatively expensive  
      operation.  
315       \param sampleNo - Input.       \param sampleNo - Input.
316       \param dataPointNo - Input.       \param dataPointNo - Input.
317        T
318    */    */
319      ESCRIPT_DLL_API
320    virtual    virtual
321    DataArrayView    DataArrayView
322    getDataPoint(int sampleNo,    getDataPoint(int sampleNo,
323                 int dataPointNo);                 int dataPointNo);
324    
325    /**    /**
326         \brief
327         getData
328    
329         Description:
330         Return pointer to the data
331        T
332      */
333      ESCRIPT_DLL_API
334      const DataArrayView::ValueType::ElementType*
335      getData() const;
336    
337      /**
338       \brief       \brief
339       getTagLookup       getTagLookup
340    
341       Description:       Description:
342       Return a reference to the tag offset lookup table.       Return a reference to the tag offset lookup table.
343        T
344    */    */
345      ESCRIPT_DLL_API
346    const DataMapType&    const DataMapType&
347    getTagLookup() const;    getTagLookup() const;
348    
# Line 262  class DataTagged : public DataAbstract { Line 351  class DataTagged : public DataAbstract {
351       isCurrentTag       isCurrentTag
352    
353       Description:       Description:
354       Return true if the given tag exists within the DataTagged tag keys.       Return true if the given tag exists within the DataTagged tag map.
355       NOTE: The DataTagged keys do not necessarily coincide with the tag  
356       keys for the function space.       *** NB: The DataTagged tag map does not necessarily coincide with the tag
357     */       keys in the associated function space.
358        T
359      */
360      ESCRIPT_DLL_API
361    bool    bool
362    isCurrentTag(int tag) const;    isCurrentTag(int tag) const;
363    
# Line 275  class DataTagged : public DataAbstract { Line 367  class DataTagged : public DataAbstract {
367    
368       Description:       Description:
369       Return the default value. This value is associated with any tag which       Return the default value. This value is associated with any tag which
370       is not explicitly recorded in this DataTagged object.       is not explicitly recorded in this DataTagged object's tag map.
371        T
372    */    */
373      ESCRIPT_DLL_API
374    DataArrayView&    DataArrayView&
375    getDefaultValue();    getDefaultValue();
376    
377    /**    ESCRIPT_DLL_API
      \brief  
      getDefaultValue  
   
      Description:  
      Return the default value, const version.  
   */  
378    const DataArrayView&    const DataArrayView&
379    getDefaultValue() const;    getDefaultValue() const;
380    
# Line 295  class DataTagged : public DataAbstract { Line 383  class DataTagged : public DataAbstract {
383       getLength       getLength
384    
385       Description:       Description:
386       Return the number of doubles stored for the Data.       Return the total number of doubles stored for this DataTagged object.
387        T
388    */    */
389      ESCRIPT_DLL_API
390    virtual    virtual
391    ValueType::size_type    ValueType::size_type
392    getLength() const;    getLength() const;
# Line 306  class DataTagged : public DataAbstract { Line 396  class DataTagged : public DataAbstract {
396       getSlice       getSlice
397    
398       Description:       Description:
399       Factory method that returns a newly created DataTagged object.       Factory method that returns a newly created DataTagged object generated
400       The caller is reponsible for managing the object created.       by taking the specified slice from this DataTagged object.
401         The caller is reponsible for managing the returned object.
402        T
403    */    */
404      ESCRIPT_DLL_API
405    virtual    virtual
406    DataAbstract*    DataAbstract*
407    getSlice(const DataArrayView::RegionType& region) const;    getSlice(const DataArrayView::RegionType& region) const;
408    
409    /**    /**
410       \brief       \brief
411         Slice Constructor for DataTagged.
412    
413         Description:
414         Creates a DataTagged object which is the specified slice
415         from the given DataTagged object.
416         \param other - Input - DataTagged object to slice from.
417         \param region - Input - Region to slice.
418        T
419      */
420      ESCRIPT_DLL_API
421      DataTagged(const DataTagged& other,
422             const DataArrayView::RegionType& region);
423    
424      /**
425         \brief
426       setSlice       setSlice
427    
428       Description:       Description:
429       Copy the specified region from the given value into this object.       Copy the given Data object into the specified region in this object.
430       \param value - Input - Data to copy from.       \param other - Input - Data object to copy from.
431       \param region - Input - Region to copy.       \param region - Input - Region to copy into (NB: must have same shape as other!).
432        T
433    */    */
434      ESCRIPT_DLL_API
435    virtual    virtual
436    void    void
437    setSlice(const DataAbstract* value,    setSlice(const DataAbstract* other,
438             const DataArrayView::RegionType& region);             const DataArrayView::RegionType& region);
439    
440    /**    /**
441       \brief       \brief
442       reshapeDataPoint       Archive the underlying data values to the file referenced
443         by ofstream. A count of the number of values expected to be written
444         is provided as a cross-check.
445    
446       Description:       The return value indicates success (0) or otherwise (1).
      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.  
447    */    */
448    void    ESCRIPT_DLL_API
449    reshapeDataPoint(const DataArrayView::ShapeType& shape);    int
450      archiveData(std::ofstream& archiveFile,
451                  const DataArrayView::ValueType::size_type noValues) const;
452    
453      /**
454         \brief
455         Extract the number of values specified by noValues from the file
456         referenced by ifstream to the underlying data structure.
457    
458         The return value indicates success (0) or otherwise (1).
459      */
460      ESCRIPT_DLL_API
461      int
462      extractData(std::ifstream& archiveFile,
463                  const DataArrayView::ValueType::size_type noValues);
464    
465      /**
466         \brief
467         Computes a symmetric matrix (A + AT) / 2
468    
469         \param ev - Output - symmetric matrix
470    
471      */
472      ESCRIPT_DLL_API
473      virtual void
474      symmetric(DataAbstract* ev);
475    
476      /**
477         \brief
478         Computes a nonsymmetric matrix (A - AT) / 2
479    
480         \param ev - Output - nonsymmetric matrix
481    
482      */
483      ESCRIPT_DLL_API
484      virtual void
485      nonsymmetric(DataAbstract* ev);
486    
487      /**
488         \brief
489         Computes the trace of a matrix
490    
491         \param ev - Output - the trace of a matrix
492    
493      */
494      ESCRIPT_DLL_API
495      virtual void
496      trace(DataAbstract* ev, int axis_offset);
497    
498      /**
499         \brief
500         swaps components axis0 and axis1
501    
502         \param ev - Output - swapped components
503    
504      */
505      ESCRIPT_DLL_API
506      virtual void
507      swapaxes(DataAbstract* ev, int axis0, int axis1);
508    
509      /**
510         \brief
511         Transpose each data point of this Data object around the given axis.
512    
513         \param ev - Output - the transpose of a matrix
514    
515      */
516      ESCRIPT_DLL_API
517      virtual void
518      transpose(DataAbstract* ev, int axis_offset);
519    
520      /**
521         \brief
522         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
523    
524         \param ev - Output - eigenvalues in increasing order at each data point
525    
526      */
527      ESCRIPT_DLL_API
528      virtual void
529      eigenvalues(DataAbstract* ev);
530    
531      /**
532         \brief
533         solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
534    
535         \param ev - Output - eigenvalues in increasing order at each data point
536         \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
537                             and the first nonzero component is positive.
538         \param tol - Input - eigenvalue with relative distance tol are treated as equal.
539    
540      */
541    
542      ESCRIPT_DLL_API
543      virtual void
544      eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
545    
546    
547   protected:   protected:
548    
# Line 349  class DataTagged : public DataAbstract { Line 553  class DataTagged : public DataAbstract {
553    DataMapType m_offsetLookup;    DataMapType m_offsetLookup;
554    
555    //    //
556    // The actual data    // the offset to the default value
557    DataArrayView::ValueType m_data;    static const int m_defaultValueOffset = 0;
558    
559    //    //
560    // the default value offset    // The actual data
561    static const int m_defaultValueOffset = 0;    ValueType m_data;
562    
563  };  };
564    
# Line 370  inline Line 574  inline
574  DataArrayView&  DataArrayView&
575  DataTagged::getDefaultValue()  DataTagged::getDefaultValue()
576  {  {
   //  
577    // The default value is always the first value.    // The default value is always the first value.
578    return getPointDataView();    return getPointDataView();
579  }  }
# Line 379  inline Line 582  inline
582  const DataArrayView&  const DataArrayView&
583  DataTagged::getDefaultValue() const  DataTagged::getDefaultValue() const
584  {  {
   //  
585    // The default value is always the first value.    // The default value is always the first value.
586    return getPointDataView();    return getPointDataView();
587  }  }
588    
589    inline
590    const DataArrayView::ValueType::ElementType*
591    DataTagged::getData() const
592    {
593       return &(m_data[0]);
594    }
595    
596    inline
597    const DataTagged::DataMapType&
598    DataTagged::getTagLookup() const
599    {
600      return m_offsetLookup;
601    }
602    
603    inline
604    DataArrayView::ValueType::size_type
605    DataTagged::getLength() const
606    {
607      return m_data.size();
608    }
609    
610  } // end of namespace  } // end of namespace
611    
612  #endif  #endif

Legend:
Removed from v.97  
changed lines
  Added in v.1118

  ViewVC Help
Powered by ViewVC 1.1.26