---

UnitSystem.C

#include <citrus/config.h>

#include <citrus/UnitSystem.H>
#include <citrus/DimensionGroup.H>

UnitSystem* UnitSystem::theUnitSystems = 0 ;

UnitSystem::UnitSystem()
{
  m_name = 0 ;
  m_abbr = 0 ;
  m_desc = 0 ;
  m_next = 0 ;

  if ( theUnitSystems ) {
    UnitSystem* us = theUnitSystems ;
    while ( us->m_next )
      us = us->m_next ;
    us->m_next = this ;
  } else {
    theUnitSystems = this ;
  }
}

UnitSystem::~UnitSystem()
{
  if ( m_name )
    delete [] m_name ;
  if ( m_abbr )
    delete [] m_abbr ;
  if ( m_desc )
    delete [] m_desc ;

  if ( theUnitSystems == this ) {
    theUnitSystems = m_next ;
  } else {
    UnitSystem* us = theUnitSystems ;
    while ( us->m_next != this )
      us = us->m_next ;
    us->m_next = m_next ;
  }
}

void UnitSystem::name( const char* name )
{
  if ( !name )
    return ;

  if ( m_name )
    delete [] m_name ;
  m_name = new char[ strlen( name ) + 1 ] ;
  strcpy( m_name, name ) ;
}

const char* UnitSystem::name() const
{
  return m_name ;
}

void UnitSystem::abbr( const char* abbr )
{
  if ( !abbr )
    return ;

  if ( m_abbr )
    delete [] m_abbr ;
  m_abbr = new char[ strlen( abbr ) + 1 ] ;
  strcpy( m_abbr, abbr ) ;
}


const char* UnitSystem::abbr() const
{
  return m_abbr ;
}


void UnitSystem::description( const char* desc )
{
  if ( !desc )
    return ;

  if ( m_desc )
    delete [] m_desc ;
  m_desc = new char[ strlen( desc ) + 1 ] ;
  strcpy( m_desc, desc ) ;
}

const char* UnitSystem::description() const
{
  return m_desc ;
}

bool UnitSystem::addSpec( const DimensionGroup* dg, const char* spec )
{
  if ( ! dg )
    return false ;

  Quantity qty( spec ) ;
  if ( qty.group() == dg )
    m_specs[ dg ] = qty ;
  else
    return false ;

  return true ;
}

bool UnitSystem::getSpec( Quantity& result, const DimensionGroup* dg )
{
  /* FIXME! This should eventually try harder: when a DimensionGroup* is 
   * not in m_specs, we should look at the DimensionPowers of dg and
   * see if each is represented in the UnitSystem (a well-defined system
   * will have a unit for each base dimension, so this should always be
   * satisfied). Then, we can compose a Quantity from those dimensions.
   */
  result = m_specs[ dg ] ;
  if ( result.group() != dg )
    return false ;

  return true ;
}

bool UnitSystem::convert( Quantity& result, const Quantity& source )
{
  if ( ! getSpec( result, source.group() ) )
    return false ;

  ::convert( &result, &source ) ;
  return true ;
}

C++ Reference Manual

20010520