---

DimensionGroup.C

#include <citrus/config.h>

#include <stdio.h>
#include <algorithm>
#include <iterator>

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

DimensionGroup* DimensionGroup::theDimensionGroups = 0 ;

DimensionGroup::DimensionGroup( const char* name )
{
  if ( name ) {
    m_name = new char[ strlen(name) + 1 ] ;
    strcpy( m_name, name ) ;
  } else {
    m_name = 0 ;
  }

  // Add each dimension to the global list of all dimensions
  if ( theDimensionGroups ) {
    m_next = theDimensionGroups ;
  } else {
    m_next = 0 ;
  }
  
  m_dims.clear() ;

  theDimensionGroups = this ;
}

DimensionGroup::DimensionGroup( const char* name, 
                                const vector<DimensionPower> dims )
{
  if ( name ) {
    m_name = new char[ strlen(name) + 1 ] ;
    strcpy( m_name, name ) ;
  } else {
    m_name = 0 ;
  }

  // Add each dimension to the global list of all dimensions
  if ( theDimensionGroups ) {
    m_next = theDimensionGroups ;
  } else {
    m_next = 0 ;
  }
  
  m_dims = dims ;

  theDimensionGroups = this ;
}

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

  destroy( m_children.begin(), m_children.end() ) ;

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

void    DimensionGroup::setDimensions( vector<DimensionPower> dims ) 
{
  m_dims = dims ;
}

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

  if ( m_name )
    delete m_name ;

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

void    DimensionGroup::p_add( Unit* unit )
{
  m_children.push_back( unit ) ;
}

void    DimensionGroup::p_remove( Unit* unit )
{
  list<Unit*>::iterator posn = ::find( m_children.begin(), m_children.end(),
                                       unit ) ;
  if ( posn != m_children.end() )
    m_children.erase( posn ) ;
  // was m_children.remove( unit ) ;
}

bool    DimensionGroup::operator == (const vector<DimensionPower>& pwr)
{
  return pwr == m_dims ;
}

DimensionGroup* DimensionGroup::find( const char* dgrp_name )
{
  DimensionGroup*       tmp = theDimensionGroups ;
  while ( tmp ) {
    if (!strcmp(tmp->name(), dgrp_name) ) {
      return tmp ;
    }
    tmp=tmp->next() ;
  }
  return 0 ;
}

void DimensionPower::print( const vector<DimensionPower>& dpwr, FILE* f=stderr)
{
  vector<DimensionPower>::const_iterator iter = dpwr.begin() ;
  while ( iter != dpwr.end() ) {
    fprintf( f, "%c(%d) ", iter->m_dim->symbol(), iter->m_pwr ) ;
    ++iter ;
  }
}

DimensionGroup* DimensionGroup::find( const vector<DimensionPower>& dpwr )
{
  DimensionGroup*       norbert = theDimensionGroups ;
  while (norbert) {
    if ( (*norbert) == dpwr )
      return norbert ;
   norbert = norbert->next() ;
  }
  return 0 ;
}

vector<DimensionPower>::iterator find_dimn( Dimension* dimn,
                                            vector<DimensionPower>& dpwr)
{
  DimensionPower        phil ;

  vector<DimensionPower>::iterator iter = dpwr.begin() ;
  while ( iter != dpwr.end() ) {
    /* fprintf( stderr, "%x != %x\n", &(*iter), &(*dpwr.end()) ) ;*/
    phil = *iter ;
    if (phil.m_dim == dimn)
      return iter ;
    iter++ ;
  }
  return dpwr.end() ; /* dpwr.end() should be past_end, right? */
}

vector<DimensionPower>::const_iterator find_dimn( Dimension* dimn,
                                            const vector<DimensionPower>& dpwr)
{
  DimensionPower        phil ;

  vector<DimensionPower>::const_iterator iter = dpwr.begin() ;
  while ( iter != dpwr.end() ) {
    /* fprintf( stderr, "%x != %x\n", &(*iter), &(*dpwr.end()) ) ;*/
    phil = *iter ;
    if (phil.m_dim == dimn)
      return iter ;
    iter++ ;
  }
  return dpwr.end() ; /* dpwr.end() should be past_end, right? */
}

bool areDimensionsMatched( const vector<DimensionPower>& d1, 
                           const vector<DimensionPower>& d2 )
{
  if ( d1.size() != d2.size() )
    return false ;

  vector<DimensionPower>::const_iterator found ;
  vector<DimensionPower>::const_iterator iter = d1.begin() ;
  while ( iter != d1.end() ) {
    found = find_dimn( iter->m_dim, d2 ) ;
    if ( found != d2.end() ) {
      if ( found->m_pwr != iter->m_pwr )
        return false ;
    } else {
      return false ;
    }
    ++iter ;
  }

  return true ;
}

C++ Reference Manual

20010520