OpenSG: osg::MField< FieldTypeT, fieldNameSpace

00066                                                :
00067      Inherited   ( ),
00068     _values      ( ),
00069     _uiSharedWith(0)
00070 {
00071 }

00074                                                             :
00075      Inherited   (obj        ),
00076     _values      (obj._values),
00077     _uiSharedWith(          0)
00078 {
00079 }

00082                                                             :
00083      Inherited   ( ),
00084     _values      ( ),
00085     _uiSharedWith(0)
00086 {
00087     _values.resize(size);
00088 }

00057 {
00058     return _fieldType;
00059 }

00484 {
00485     return operator[](index);
00486 }

00491 {
00492     return operator[](index);
00493 }

00511 {
00512     return size();
00513 }

00107 {
00108     return _values;
00109 }

00117 {
00118     return _values;
00119 }

00124 {
00125     return _fieldType;
00126 }

00131 {
00132     return empty();
00133 }

00162 {
00163     _values = value;
00164 }

00169 {
00170     // Hack probably move it to MFieldVector (GV)
00171 
00172     *(static_cast<StorageTypeParent *>(&_values)) = value;
00173 }

00177 {
00178     _values = obj._values;
00179 }

00153 {
00154     if(getType() == obj.getType())
00155     {
00156         setValues(*((const MField<FieldTypeT, fieldNameSpace> *) &obj));
00157     }
00158 }

00498 {
00499     operator[](index) = value;
00500 }

00504 {
00505     push_back(value);
00506 }

00188 {
00189     return _values.begin();
00190 }

00196 {
00197     return _values.end();
00198 }

00205 {
00206     return _values.rbegin();
00207 }

00214 {
00215     return _values.rend();
00216 }

00223 {
00224     return _values.begin();
00225 }

00232 {
00233     return _values.end();
00234 }

00241 {
00242     return _values.rbegin();
00243 }

00250 {
00251     return _values.rend();
00252 }

00258 {
00259     return _values.front();
00260 }

00267 {
00268     return _values.front();
00269 }

00275 {
00276     return _values.back();
00277 }

00284 {
00285     return _values.back();
00286 }

00290 {
00291     _values.clear();
00292 }

00299 {
00300     return _values.insert(pos, value);
00301 }

00308 {
00309     return _values.erase(pos);
00310 }

00317 {
00318     return STD::find(_values.begin(), _values.end(), value);
00319 }

00326 {
00327     return STD::find(_values.begin(), _values.end(), value);
00328 }

00332 {
00333     _values.push_back(value);
00334 }

00338 {
00339     _values.resize(newsize, t);
00340 }

00344 {
00345     _values.reserve(newsize);
00346 }

00350 {
00351     return _values.size();
00352 }

00356 {
00357     return _values.capacity();
00358 }

00362 {
00363     return _values.empty();
00364 }

00469 {
00470     return _values[index];
00471 }

00476 {
00477     return _values[index];
00478 }

00137 {
00138     if(this == &source)
00139        return;
00140 
00141     _values = source._values;
00142 }

00371 {
00372     FieldTypeT  tmpVal;
00373 
00374     typedef typename osgIF< (MFieldTraits::StringConvertable &
00375                              FieldTraits ::FromStringConvertable), 
00376                             MFieldTraits, 
00377                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00378     
00379     Converter::getFromString(tmpVal, str);
00380     
00381     push_back(tmpVal);
00382 }

00387 {
00388     std::string tmpString;
00389 
00390     typedef typename osgIF< (MFieldTraits::StringConvertable &
00391                              FieldTraits ::ToStringConvertable),
00392                             MFieldTraits,
00393                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00394 
00395     for(UInt32 i = 0; i < size(); ++i)
00396     {
00397         Converter::putToString(_values[i], tmpString);
00398 
00399         str.append(tmpString);
00400 
00401         if(i < (size()-1))
00402         {
00403             str.append(", ");
00404         }
00405     }
00406 
00407     return str;
00408 }

00415 {
00416     std::string valStr;
00417 
00418     typedef typename osgIF< (MFieldTraits::StringConvertable &
00419                              FieldTraits ::ToStringConvertable),
00420                             MFieldTraits,
00421                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00422 
00423     state.beginField(this, outStr);
00424 
00425     for(UInt32 i = 0; i < size(); ++i)
00426     {
00427         valStr.erase();
00428         Converter::putToString(_values[i], valStr);
00429 
00430         state.addValueStr(valStr, outStr);
00431     }
00432 
00433     state.endField(this, outStr);
00434     
00435     return outStr;
00436 }

00443 {
00444     if(index >= size())
00445     {
00446         return str;
00447     }
00448 
00449     std::string tmpString;
00450 
00451     typedef typename osgIF< (MFieldTraits::StringConvertable &
00452                              FieldTraits::ToStringConvertable),
00453                             MFieldTraits,
00454                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00455 
00456     Converter::putToString(_values[index], tmpString);
00457 
00458     str.append(tmpString);
00459 
00460     return str;
00461 }

00521 {
00522     setValues(source);
00523 }

00688 {
00689     return sizeof(UInt32) + // num elements
00690            MFieldTraits::getBinSize(&(_values[0]), _values.size());
00691 }

00696 {
00697     UInt32 n = _values.size();
00698 
00699     pMem.putValue(n);
00700     MFieldTraits::copyToBin(   pMem, 
00701                             &(_values[0]),
00702                               _values.size());
00703 }

00707 {
00708     UInt32 n;
00709 
00710      pMem  .getValue(n);
00711     _values.clear ( );
00712 
00713 #ifdef __hpux
00714     FieldTypeT tmpVal;
00715 
00716     _values.resize(n, tmpVal);
00717 #else
00718     _values.resize(n);
00719 #endif
00720 
00721     MFieldTraits::copyFromBin(pMem, 
00722                               &(_values[0]),
00723                               n);
00724 }

00731 {
00732     std::cout << "STMFST : " << std::endl;
00733 
00734     for(UInt32 i = 0; i < _values.size(); i++)
00735     {
00736 //        cout << _values[i] << " , ";
00737     }
00738 
00739     std::cout << std::endl;
00740 }

00747 {
00748     return new MField<FieldTypeT, fieldNameSpace>(); 
00749 }

00079 {
00080     return sizeof(UInt32) + // num elements
00081            sizeof(UInt8) * _values.size();
00082 }

00086 {
00087     UInt32 n = _values.size();
00088 
00089     pMem.putValue(n);
00090 
00091     for(UInt32 i = 0; i < n; ++i)
00092     {
00093         UInt8 bval = _values[i];
00094 
00095         pMem.putValue(bval);
00096     }
00097 }

00101 {
00102     UInt32 n;
00103     
00104      pMem  .getValue(n);
00105     _values.clear ( );
00106 
00107 #ifdef __hpux
00108     bool tmpVal;
00109 
00110     _values.resize(n, tmpVal);
00111 #else
00112     _values.resize(n);
00113 #endif
00114 
00115     UInt8 tmpBVal;
00116 
00117     for(UInt32 i = 0; i < n; ++i)
00118     {
00119         pMem.getValue(tmpBVal);
00120 
00121         _values[i] = (tmpBVal != 0);
00122     }
00123 }

00063 {
00064     return getType().getContentType();
00065 }

00068 {
00069     return getType().getCardinality();
00070 }


Public Types
typedef MFieldVector< FieldTypeT >	StorageType
typedef StorageType::Inherited	StorageTypeParent
typedef StorageType::iterator	iterator
typedef StorageType::const_iterator	const_iterator
typedef StorageType::reverse_iterator	reverse_iterator
typedef StorageType::const_reverse_iterator	const_reverse_iterator
typedef StorageType::reference	reference
typedef StorageType::const_reference	const_reference
typedef osgIF< fieldNameSpace==0, FieldDataTraits< FieldTypeT >, InvalidTrait >::_IRet	MF0Trait
typedef osgIF< fieldNameSpace==1, FieldDataTraits1< FieldTypeT >, MF0Trait >::_IRet	MF1Trait
typedef osgIF< fieldNameSpace==2, FieldDataTraits2< FieldTypeT >, MF1Trait >::_IRet	MFieldTraits
typedef MField< FieldTypeT, fieldNameSpace >	Self
typedef FieldTypeT	StoredType
typedef MFieldTraits::ArgumentType	ArgumentType
Public Member Functions
template<>
UInt32	getBinSize (void) const
template<>
void	copyToBin (BinaryDataHandler &pMem) const
template<>
void	copyFromBin (BinaryDataHandler &pMem)
Constructors
*	MField (void)
	MField (const MField &obj)
	MField (const UInt32 size)
Destructor
*virtual	~MField (void)
Get
*reference	getValue (const UInt32 index)
const_reference	getValue (const UInt32 index) const
virtual UInt32	getSize (void) const
StorageType &	getValues (void)
const StorageType &	getValues (void) const
virtual const FieldType &	getType (void) const
virtual bool	isEmpty (void) const
Set
*void	setValues (const StorageType &value)
void	setValues (const StorageTypeParent &value)
void	setValues (const Self &obj)
virtual void	setAbstrValue (const Field &obj)
	Copies the values from a given field iff the two fieldtypes are equal.
void	setValue (ArgumentType value, const UInt32 index)
void	addValue (ArgumentType value)
STL Interface
*iterator	begin (void)
iterator	end (void)
reverse_iterator	rbegin (void)
reverse_iterator	rend (void)
const_iterator	begin (void) const
const_iterator	end (void) const
const_reverse_iterator	rbegin (void) const
const_reverse_iterator	rend (void) const
reference	front (void)
const_reference	front (void) const
reference	back (void)
const_reference	back (void) const
void	clear (void)
iterator	insert (iterator pos, ArgumentType value)
iterator	erase (iterator pos)
iterator	find (ArgumentType value)
const_iterator	find (ArgumentType value) const
void	push_back (ArgumentType value)
void	resize (size_t newsize, FieldTypeT t=FieldTypeT())
void	reserve (size_t newsize)
UInt32	size (void) const
UInt32	capacity (void) const
bool	empty (void) const
Index Operator
*reference	operator[] (UInt32 index)
const_reference	operator[] (UInt32 index) const
Assignment
*void	operator= (const MField &source)
String IO
*virtual void	pushValueByStr (const Char8 *str)
virtual std::string &	getValueByStr (std::string &str) const
virtual std::string &	getValueByStr (std::string &str, StringConversionStateBase &state) const
virtual std::string &	getValueByStr (std::string &str, UInt32 index) const
MT Sync
*void	syncWith (Self &source)
Binary Interface
*UInt32	getBinSize (void) const
void	copyToBin (BinaryDataHandler &pMem) const
void	copyFromBin (BinaryDataHandler &pMem)
Dump
*virtual void	dump (void) const
Static Public Member Functions
Class Get
*static const FieldType &	getClassType (void)
Protected Types
typedef Field	Inherited
Static Protected Member Functions
static Field *	create (void)
Protected Attributes
StorageType	_values
UInt32	_uiSharedWith
Static Protected Attributes
static const FieldType	_fieldType
Friends
class	FieldContainer

osg::MField< FieldTypeT, fieldNameSpace > Class Template Reference
[Fields, Multi-Element Fields]

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

template<class FieldTypeT, Int32 fieldNameSpace = 0>
class osg::MField< FieldTypeT, fieldNameSpace >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

osg::MField< FieldTypeT, fieldNameSpace > Class Template Reference [Fields, Multi-Element Fields]

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

template<class FieldTypeT, Int32 fieldNameSpace = 0> class osg::MField< FieldTypeT, fieldNameSpace >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

osg::MField< FieldTypeT, fieldNameSpace > Class Template Reference
[Fields, Multi-Element Fields]

template<class FieldTypeT, Int32 fieldNameSpace = 0>
class osg::MField< FieldTypeT, fieldNameSpace >