TDataElement.cc

TDataElementクラスの解説 TDataElement.hh
// ============================================================================
//  $Id$
//  $Name$
// ============================================================================
#include "TDataElement.hh"
#include "TModule.hh"

TDataElement::TDataElement( Telement_t type, Tint id )
  : TStreamableObject( tDataElement, id ), 
    theData( 0 ), theElementType( type ), theNumberOfPrimitives( 1 )
{;}

TDataElement::TDataElement( Tvoid* data, Telement_t type, Tint id )
  : TStreamableObject( tDataElement, id ), 
    theElementType( type ), theNumberOfPrimitives( 1 )
{
  allocateDataSpace( data );
}

TDataElement::~TDataElement()
{
  freeDataSpace();
}

Tvoid TDataElement::Print( Tostream& tos )
{
  Tstring head = Twspace + Twspace + Twspace + "* Data Element, ";
  tos << head << "ID: " << theID;
  tos << Twspace << "Primitives: " << theNumberOfPrimitives;
  tos << Twspace << "Type: " << theElementType;

  switch ( theElementType ) {
    case tTypeString:
      tos << "(Tstring)" << Twspace << "Data: ";
      tos << *( (Tstring*)theData ) << Tendl;
      break;
    case tTypeDouble:
      tos << "(Tdouble)" << Twspace << "Data: ";
      tos << *( (Tdouble*)theData ) << Tendl;
      break;
    case tTypeInt:
      tos << "(Tint)" << Twspace << "Data: ";
      tos << *( (Tint*)theData ) << Tendl;
      break;
    case tTypeUnknown:
    case tTypeObject:
    case tTypeFloat:
    default:
      tos << "(Unknown)" << Twspace << "Data: ";
      tos << "unknown(or undefined) data ..." << Tendl;
      break;
  }

  return;
}

Tvoid TDataElement::freeDataSpace()
{
  if ( theData != 0 ) {
    switch ( theElementType ) {
      case tTypeString:
	delete (Tstring*)( theData );
	break;
      case tTypeDouble:
	delete (Tdouble*)( theData );
	break;
      case tTypeInt:
	delete (Tint*)( theData );
      case tTypeUnknown:
      case tTypeObject:
      case tTypeFloat:
      default:
	break;
    }
  }
  theNumberOfPrimitives = 1;
  return;
}

Tvoid TDataElement::allocateDataSpace( Tvoid* data )
{
  switch ( theElementType ) {
    case tTypeString:
      theData = new Tstring( *( (Tstring*)(data) ) );
      theNumberOfPrimitives += ( ( (Tstring*)theData ) -> size() );
      break;
    case tTypeDouble:
      theData = new Tdouble( *( (Tdouble*)(data) ) );
      break;
    case tTypeInt:
      theData = new Tint( *( (Tint*)(data) ) );
      break;
    case tTypeUnknown:
    case tTypeObject:
    case tTypeFloat:
    default:
      break;
  }
  return;
}

Tint TDataElement::WriteData( TOutputObjectStream* output )
{
  Tsize_t size = 0;
  Tstream_t streamtype = output -> GetStreamType();

  if ( streamtype == tFileStream ) {
    TOutputObjectFile* ofile = (TOutputObjectFile*)output;
    static const Tsize_t nmemb = 1;
    size += fwrite( this, Tsizeof( *this ), nmemb, ofile -> GetFileStream() );

    switch ( theElementType ) {
      case tTypeString:
	Tchar c;
	for ( Tint i = 0; i < theNumberOfPrimitives; i ++ ) {
	  if ( i == theNumberOfPrimitives - 1 )
	    c = '\0';
	  else
	    c = ( (Tstring*)theData ) -> at( i );
	  size += fwrite( &c, Tsizeof( Tchar ), nmemb, 
			  ofile -> GetFileStream() );
	}
	break;
      case tTypeDouble:
	Tdouble d;
	d = *( (Tdouble*)theData );
	size += fwrite( &d, Tsizeof( Tdouble ), nmemb, 
			ofile -> GetFileStream() );
	break;
      case tTypeInt:
	Tint i;
 	i = *( (Tint*)theData );
 	size += fwrite( &i, Tsizeof( Tint ), nmemb, 
 			ofile -> GetFileStream() );
	break;
      case tTypeUnknown:
      case tTypeObject:
      case tTypeFloat:
      default:
	break;
    }
  } else if ( streamtype == tSocketStream ) {
    //now implement ....
    //TOutputObjectSocket* osocket = (TOutputObjectSocket*)output;
    ;
  } else {
    //
    //
    ;
  }

  return( (Tint)size );
}

Tint TDataElement::GetDataSize()
{
  Tsize_t size = Tsizeof( *this );

  switch ( theElementType ) {
    case tTypeString:
      size += ( Tsizeof( Tchar ) ) * theNumberOfPrimitives;
      break;
    case tTypeDouble:
      size += Tsizeof( Tdouble );
      break;
    case tTypeInt:
      size += Tsizeof( Tint );
      break;
    case tTypeUnknown:
    case tTypeObject:
    case tTypeFloat:
    default:
      break;
  }

  return( (Tint)size );
}
$Id$
$Name$