---

Unit.C

#include <citrus/config.h>

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

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

int UnitReadConfig( const char* filename ) ;

Unit* Unit::s_allUnits = 0 ;

Unit* Unit::s_dimensionless = 0 ;

Unit::Unit( const char* name, const char* abbr,
            double scale, DimensionGroup* dgrp )
{
  m_name = new char[strlen(name)+1] ;
  strcpy( m_name, name ) ;

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

  m_dgrp = dgrp ;
  if (m_dgrp)
    m_dgrp->p_add( this ) ;

  m_scale = scale ;
  // now for the default settings
  m_offsetVal   = 0.0 ;
  m_offsetPolicy= false ;
  m_avoid       = false ;
  m_prefix      = true ;
  m_pluralPolicy= CITRUS_PLURAL_NORMAL ;
  m_pluralName  = 0 ;

  if ( s_allUnits)
    m_next = s_allUnits ;
  else
    m_next = 0 ;

  s_allUnits = this ;
}

Unit::~Unit()
{
  if (m_name)
    delete [] m_name ;

  if (m_abbr)
    delete [] m_abbr ;

  if ( m_pluralPolicy= CITRUS_PLURAL_SPECIAL && m_pluralName )
    delete [] m_pluralName ;

  if (m_dgrp)
    m_dgrp->p_remove( this ) ;

  if ( s_allUnits == this ) {
    s_allUnits = m_next ;
  } else {
    Unit*       tmp = s_allUnits ;
    while ( tmp && tmp->m_next != this )
      tmp = tmp->m_next ;
    tmp->m_next = m_next ;
  }
}

void Unit::plural( const char* name )
{
  if (m_pluralPolicy == CITRUS_PLURAL_SPECIAL && m_pluralName)
    delete [] m_pluralName ;

  m_pluralPolicy = CITRUS_PLURAL_SPECIAL ;
  m_pluralName = new char[strlen(name)+1] ;
  strcpy( m_pluralName, name ) ; 
}

void Unit::plural( int type )
{
  if (m_pluralPolicy == CITRUS_PLURAL_SPECIAL && m_pluralName)
    delete [] m_pluralName ;

  m_pluralPolicy = type ;
}

Unit*   Unit::dimensionless()
{
  return s_dimensionless ;
}

Unit*   Unit::find( const char* unit_abbr )
{
  Unit*       tmp = s_allUnits ;
  while ( tmp && strcmp(tmp->abbr(), unit_abbr ) )
    tmp = tmp->next() ;
  return tmp ;
}

Unit*   Unit::findByFullName( const char* unit_name )
{
  Unit*       tmp = s_allUnits ;
  while ( tmp ) {
    if ( ! strcmp(tmp->name(), unit_name ) )
      return tmp ;
    else {
      if (tmp->pluralPolicy() == CITRUS_PLURAL_SPECIAL) {
        if ( ! strcmp(tmp->pluralForm(), unit_name ) )
          return tmp ;
      } else if ( tmp->pluralPolicy() == CITRUS_PLURAL_NORMAL) {
        int sl = strlen( tmp->name() ) ;
        if ( ( strstr(unit_name, tmp->name() ) == unit_name ) &&
             (unit_name[sl] == 's') && (unit_name[sl+1] == '\0') ) {
          return tmp ;
        }
      }
    }
    tmp = tmp->next() ;
  }
  return 0 ;
}

extern int updebug ;
bool Unit::initialize( const char* config )
{
  struct stat s ;
  int i = 0 ;
  int ok = 0 ;
  char* initList[] =
        {
                CITRUS_CONFIG "/units.xml",
                "~/.citrus/units.xml",
                0
        } ;

  if ( s_dimensionless != 0 ) // Don't initialize if we already have!
    return false ;

  if ( !config )
    config = initList[i++] ;

  do {
    if (! stat( config, &s ) ) {
      if ( ! UnitReadConfig( config ) )
        ok = 1 ;
    } 
    config = initList[i++] ;
  } while ( (!ok) && config ) ;

  if ( !ok )
    return false ;

  s_dimensionless = Unit::find("none") ;

  /*updebug = 1 ;*/
  return true ;
}

Unit*   Unit::first()
{
  return s_allUnits ;
}

C++ Reference Manual

20010520