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

Legend:
Removed from v.102  
changed lines
  Added in v.1388

  ViewVC Help
Powered by ViewVC 1.1.26