---

citrus.C

#include <citrus/config.H>

#include <stdexcept>
#include <list>

/* #include <citrus/citrus.h> */
#include <glib.h>

#include <citrus/UnitInfo.H>
#include <citrus/Quantity.H>
#include <citrus/UnitExpr.H>
#include <citrus/Unit.H>
#include <citrus/DimensionGroup.H>
#include <citrus/Prefix.H>

extern "C" {

  int citrus_initialize( const char* configFile )
  {
    return (int) Unit::initialize( configFile ) ;
  }

  void* citrus_quantity_from_string( const char* src )
  {
    Quantity* q ;
    try {
      q = new Quantity( src ) ;
    } catch ( runtime_error* ) {
      return 0 ; // Parse error
    }
    return (void*) q ;
  }

  int citrus_convert_quantities( void* from, void* to, double* result )
  {
    assert( from != 0 ) ;
    assert( to != 0 ) ;

    Quantity* qFrom = (Quantity*)from ;
    Quantity* qTo = (Quantity*)to ;
    int code = convert( qTo, qFrom ) ;
    if ( (code == 0) && result )
      *result = qTo->val() ;
    return code ;
  }

  int citrus_convert_string( const char* from, const char* to, double* result )
  {
    try {
      Quantity qFrom( from ) ;
      Quantity qTo( to ) ;
      int code = convert( &qTo, &qFrom ) ;
      if ( code == 0 )
        *result = qTo.val() ;

      return code ;
    } catch ( runtime_error* ) {
      return 2 ; // Parse error = 2
    }
  }

  int citrus_convert( double value, const char* from, const char* to, 
                     double* result )
  {
    try {
      Quantity qFrom( from ) ;
      Quantity qTo( to ) ;
      qFrom.val( value ) ;
      int code = convert( &qTo, &qFrom ) ;
      if ( code == 0 )
        *result = qTo.val() ;

      return code ;
    } catch ( runtime_error* ) {
      return 2 ; // Parse error = 2
    }
  }

  int citrus_convert_array( double* value, int len,
                            const char* from, const char* to, 
                            double* result )
  {
    try {
      Quantity qFrom( from ) ;
      Quantity qTo( to ) ;
      int code,err=0 ;
      for (int i=0; i<len; i++) {
        qFrom.val( value[i] ) ;
        code = convert( &qTo, &qFrom ) ;
        if ( code == 0 )
          result[i] = qTo.val() ;
        else
          err = 1 ;
      }
      return err ;
    } catch ( runtime_error* ) {
      return 2 ; // Parse error = 2
    }
  }

  const void* citrus_dimension_group_get_next( const void* pDgrp )
  {
    if ( pDgrp == 0 )
      return DimensionGroup::first() ;

    DimensionGroup* dgrp = (DimensionGroup*) pDgrp ;
    return dgrp->next() ;
  }

  const gchar* citrus_dimension_group_get_name( const void* pDgrp )
  {
    if ( pDgrp == 0 )
      return 0 ;

    DimensionGroup* dgrp = (DimensionGroup*) pDgrp ;
    return (const gchar*) dgrp->name() ;
  }

  list<Unit*>::const_iterator unit_iter = 0 ;

  list<Unit*>::const_iterator* citrus_dimension_group_get_next_unit( const void* pDgrp, list<Unit*>::const_iterator* pUnit )
  {
    if ( pDgrp == 0 )
      return 0 ;

    // FIXME! Can't depend on iterators being equivalent to const void* !
    // I think the newer versions of glibc (RH7) break this.
    DimensionGroup* dgrp = (DimensionGroup*) pDgrp ;
    if ( pUnit == 0 ) {
      unit_iter = dgrp->unitBegin() ;
      if ( unit_iter == dgrp->unitEnd() )
        return 0 ;
      return &unit_iter ;
    }

    unit_iter++ ;
    if ( unit_iter == dgrp->unitEnd() )
       return 0 ;
    return &unit_iter ;
  }

  double citrus_unit_get_scale( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return (*(*pUnit))->scale() ;
  }

  gboolean citrus_unit_has_offset( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return gboolean( (*(*pUnit))->offsetPolicy() == true ) ;
  }

  double citrus_unit_get_offset( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return (*(*pUnit))->offsetValue() ;
  }

  const gchar* citrus_unit_get_name( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return (const gchar*) (*(*pUnit))->name() ;
  }

  const gchar* citrus_unit_get_abbr( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return (const gchar*) (*(*pUnit))->abbr() ;
  }

  xmlNodePtr citrus_quantity_export_mathml( const void* quantity )
  {
    const Quantity* qty = (const Quantity*) quantity ;

    return qty->mathML() ;
  }

  gint citrus_unit_get_plural_policy( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    return (*(*pUnit))->pluralPolicy() ;
  }

  gchar* citrus_unit_get_plural_form( list<Unit*>::const_iterator* pUnit )
  {
    if ( pUnit == 0 )
      return 0 ;

    gchar* plural = (*(*pUnit))->pluralForm() ;
    if ( plural )
      return g_strdup( plural ) ;

    int policy = (*(*pUnit))->pluralPolicy() ;
    plural = g_strdup_printf( "%s%s", (*(*pUnit))->name(), 
                policy == CITRUS_PLURAL_NONE ? "" : "s" ) ;
    return plural ;
  }

}

C++ Reference Manual

20010520