Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/CdbBase/CdbCompositeName.cc

Go to the documentation of this file.

/// The implementation of the CdbCompositeName class.
/**
  * @see CdbCompositeName
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbCompositeName.hh"

#include <string.h>

const char*
CdbCompositeName::separator( )
{
    return "::";
}

CdbCompositeName::CdbCompositeName( const char* theStr ) :
    _isValid(false),
    _first(""),
    _last("")
{
    _isValid = translate( theStr );
}

CdbCompositeName::CdbCompositeName( const char* theFirst,
                                    const char* theLast ) :
    _isValid(false),
    _first(""),
    _last("")
{
    _isValid = load( theFirst,
                     theLast );
}

CdbCompositeName::CdbCompositeName( const CdbCompositeName& theName ) :
    _isValid(theName._isValid),
    _first(theName._first),
    _last(theName._last)
{ }

CdbCompositeName::~CdbCompositeName( )
{ }

CdbCompositeName&
CdbCompositeName::operator=( const CdbCompositeName& theName )
{
    if( this != &theName ) {
        _isValid = theName._isValid;
        _first   = theName._first;
        _last    = theName._last;
    }
    return *this;
}

bool
CdbCompositeName::isValid( ) const
{
    return _isValid;
}

std::string
CdbCompositeName::first( ) const
{
    return _first;
}

std::string
CdbCompositeName::last( ) const
{
    return _last;
}

std::string
CdbCompositeName::getName( ) const
{
    return _first + std::string( separator( )) + _last;
}

bool
CdbCompositeName::operator==( const CdbCompositeName& theName ) const
{
    return _isValid && theName._isValid &&
           ( theName._first == _first ) &&
           ( theName._last  == _last );
}

bool
CdbCompositeName::translate( const char* theStr )
{
  // This method is expecting for the following
  // format of names:
  //
  //    <first><separator><last>
  //
  // Where both <first> and <last> must be non-empty strings, and
  // there is just one separator in the whole input string.

    bool result = false;

    if( 0 != theStr ) {

        const char* begin   = theStr;
        const char* end     = theStr + strlen( theStr );
        char*       current = const_cast<char*>( theStr );

      // <first>

        current = strstr( current, separator( ));
        if(( 0 != current ) &&      // <separator> was found
           ( begin != current )) {  // <first> is not empty

            _first = std::string( begin, current - begin );

          // <last>

            current += strlen( separator( ));
            if(( end != current ) &&                        // the <last> is not empty
               ( 0 == strstr( current, separator( )))) {    // the <last> does not contain <separator>

                _last = std::string( current, end - current );
                result = true;
            }
        }
    }
    return result;
}

bool
CdbCompositeName::load( const char* theFirst,
                        const char* theLast )
{
  // This method is expecting two names:
  //
  //    <first>
  //    <separator>
  //
  // Where both <first> and <last> must be non-empty strings
  // not containing the separator

    bool result = false;

    if(( 0 != theFirst ) && ( 0 != theLast )) {

        if(( 0 == strstr( const_cast<char*>( theFirst ), separator( ))) &&
           ( 0 == strstr( const_cast<char*>( theLast  ), separator( )))) {

            _first = theFirst;
            _last  = theLast;

            result = true;
        }
    }
    return result;
}

void
CdbCompositeName::dump( ostream& o ) const
{
    if( _isValid ) {
        o << _first.c_str( ) << separator( ) << _last.c_str( );
    } else {
        o << "<invalid_composite_name>";
    }
}

/////////////////
// End Of File //
/////////////////

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002