---

UnitPower.C

#include <citrus/config.h>
#include <stdlib.h>

#include <glib.h>

#include <vector>

#include <citrus/Unit.H>
#include <citrus/Prefix.H>
#include <citrus/UnitPower.H>

UnitPower::UnitPower()
    : m_unit(0), m_prfx(0), m_pwr(0)
{

}

UnitPower::UnitPower( Unit* unit, Prefix* prfx, int pwr )
    : m_unit(unit), m_prfx( prfx ), m_pwr(pwr)
{

}

bool UnitPower::operator ==( const UnitPower& other ) const
{
  // Don't compare prefixes.
  return ( (m_unit == other.m_unit) && (m_pwr == other.m_pwr) ) ;
}

UnitPower& UnitPower::operator =( const UnitPower& other )
{
  if ( &other == this )
    return *this ;

  m_unit = other.m_unit ;
  m_prfx = other.m_prfx ;
  m_pwr = other.m_pwr ;
  return *this ;
}

bool UnitPower::isNull() const
{
  return m_unit == 0 ;
}

void UnitPower::print( const vector<UnitPower>& upwr, FILE* f )
{
  vector<UnitPower>::const_iterator iter = upwr.begin() ;
  while ( iter != upwr.end() ) {
    if ( iter->m_prfx == 0 )
      if ( iter->m_pwr == 1 )
        fprintf( f, "(%s)", iter->m_unit->abbr() ) ;
      else
        fprintf( f, "(%s^%d)", iter->m_unit->abbr(), iter->m_pwr ) ;
    else
      if ( iter->m_pwr == 1 )
        fprintf( f, "(%s%s)", iter->m_prfx->abbr(), iter->m_unit->abbr() ) ;
      else
        fprintf( f, "(%s%s^%d)", iter->m_prfx->abbr(), iter->m_unit->abbr(),
                 iter->m_pwr ) ;
    ++iter ;
  }

}

vector<UnitPower>::iterator find_unit( Unit* unit,
                                       vector<UnitPower>& upwr )
{
  vector<UnitPower>::iterator iter = upwr.begin() ;
  while ( iter != upwr.end() ) {
    if ( iter->m_unit == unit )
      return iter ;
    ++iter ;
  }
  return upwr.end() ;
}

xmlNodePtr UnitPower::mathML() const
{
  if ( ! m_pwr )
    return NULL ;

  xmlNodePtr upn ;
  CHAR* content ;

  if ( abs(m_pwr) == 1 ) {
    upn = xmlNewNode( NULL, (const CHAR*)"mi" ) ;
    content = (CHAR*) g_strdup_printf( "%s%s", m_prfx ? m_prfx->abbr() : "",
                                m_unit->abbr() ) ;
    xmlNodeSetContent( upn, content ) ;
    g_free( content ) ;
  } else {
    xmlNodePtr nd ;
    upn = xmlNewNode( NULL, (const CHAR*)"msup" ) ;

    content = (CHAR*) g_strdup_printf( "%s%s", m_prfx ? m_prfx->abbr() : "",
                                m_unit->abbr() ) ;
    nd = xmlNewChild( upn, NULL, (const CHAR*)"mi", content ) ;
    g_free( content ) ;

    content = (CHAR*) g_strdup_printf( "%d", abs(m_pwr) ) ;
    nd = xmlNewChild( upn, NULL, (const CHAR*)"mn", content ) ;
    g_free( content ) ;
  }

  return upn ;
}

xmlNodePtr UnitPower::mathML( const vector<UnitPower>& upwr )
{
  assert( upwr.size() != 0 ) ;
  int nnum = 0, nden = 0 ;
  xmlNodePtr item ;
  xmlNodePtr top = xmlNewNode( NULL, (const CHAR*)"mrow" ) ;
  xmlNodePtr frac = xmlNewChild( top, NULL, (const CHAR*)"mfrac", NULL ) ;
  xmlNodePtr numer = xmlNewChild( frac, NULL, (const CHAR*)"mrow", NULL ) ;
  xmlNodePtr denom = xmlNewChild( frac, NULL, (const CHAR*)"mrow", NULL ) ;

  vector<UnitPower>::const_iterator iter = upwr.begin() ;
  while ( iter != upwr.end() ) {
    item = iter->mathML() ;
    if ( ! item ) 
      continue ;

    // Only add the centerdot if this isn't the first item in the
    // numerator or denominator.
    if ( iter->m_pwr < 0 ) {
      if ( nden )
        xmlNewChild( denom, NULL,
                     (const CHAR*)"mo", (const CHAR*)"&centerdot;" ) ;
      xmlAddChild( denom, item ) ;
      nden++ ;
    } else {
      if ( nnum )
        xmlNewChild( numer, NULL,
                     (const CHAR*)"mo", (const CHAR*)"&centerdot;" ) ;
      xmlAddChild( numer, item ) ;
      nnum++ ;
    }
    iter++ ;
  }
  if ( !nnum ) {
    xmlNewChild( numer, NULL, (const CHAR*)"mi", (const CHAR*)"1" ) ;
  } else if ( !nden ) {
    xmlUnlinkNode( numer ) ;
    xmlUnlinkNode( frac ) ;
    xmlFreeNode( frac ) ; // also frees denom
    xmlAddChild( top, numer ) ;
  }
  return top ;
}

C++ Reference Manual

20010520