---

CdbPathName.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbPathName.cc,v 1.7 2005/08/23 18:54:58 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbPathNameItr.hh"

#include <string.h>     // strstr()
#include <assert.h>

#include <iostream>
using std::endl;

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

std::string
CdbPathName::separatorTerminated( const std::string& theName )
{
    assert( !theName.empty( ));
    assert( theName.length( ) != 0 );

  // The following test is done just in case if the current model of
  // of the separator's concept would change and it will be a multi-character
  // string.

    assert( strlen( separator( )) == 1 );

  // If the last character in the input string is not the separator
  // then we're adding the one by the string's end.

    if( theName[theName.length( )-1] == separator( )[0] ) return theName;
    return theName + separator( );
}

CdbPathName::CdbPathName( const char* theStr ) :
    _isValid    (false),
    _isAbsolute (false),
    _isRoot     (false),
    _isComposite(false)
{
    _isValid = translateStringIntoTokens( theStr );

    recalculateDescriptorFlags( );
}

CdbPathName::CdbPathName( const std::string& theStr ) :
    _isValid    (false),
    _isAbsolute (false),
    _isRoot     (false),
    _isComposite(false)
{
    _isValid  = translateStringIntoTokens(( theStr.empty( ) ? 0 : theStr.c_str( )));

    recalculateDescriptorFlags( );
}

CdbPathName::CdbPathName( const std::vector< std::string >& theTokens ) :
    _isValid    (false),
    _isAbsolute (false),
    _isRoot     (false),
    _isComposite(false),
    _tokens     (theTokens) // must be set before to proceed with the rest
{
    _isValid = rebuildFullPath( );

    recalculateDescriptorFlags( );
}

CdbPathName::CdbPathName( const CdbPathName& thePath ) :
    _isValid    (thePath._isValid),
    _isAbsolute (thePath._isAbsolute),
    _isRoot     (thePath._isRoot),
    _isComposite(thePath._isComposite),
    _name       (thePath._name),
    _tokens     (thePath._tokens)
{ }

CdbPathName::~CdbPathName( )
{ }

CdbPathName&
CdbPathName::operator=( const CdbPathName& thePath )
{
    if( this != &thePath ) {
        _isValid     = thePath._isValid;
        _isAbsolute  = thePath._isAbsolute;
        _isRoot      = thePath._isRoot;
        _isComposite = thePath._isComposite;
        _name        = thePath._name;
        _tokens      = thePath._tokens;
    }
    return *this;
}

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

bool
CdbPathName::isRoot( ) const
{
    return _isRoot;
}

bool
CdbPathName::isAbsolute( ) const
{
    return _isAbsolute;
}

bool
CdbPathName::isComposite( ) const
{
    return _isComposite;
}

CdbPathName
CdbPathName::first( ) const
{
    if( _isValid ) return CdbPathName( _tokens[0] );
    return CdbPathName( );
}

CdbPathName
CdbPathName::afterFirst( ) const
{
    if( _isValid && ( _tokens.size( ) > 1 )) {

        CdbPathName result( _tokens[1] );

        for( unsigned int i = 2; i < _tokens.size( ); i++ )
            result = result + _tokens[i];

        return result;
    }
    return CdbPathName( );
}

CdbPathName
CdbPathName::last( ) const
{
    if( _isValid ) return CdbPathName( _tokens[_tokens.size( ) - 1] );
    return CdbPathName( );
}

CdbPathName
CdbPathName::beforeLast( ) const
{
    if( _isValid && ( _tokens.size( ) > 1 )) {

        CdbPathName result( _tokens[0] );

        for( size_t i = 1; i < _tokens.size( ) - 1; i++ )
            result = result + _tokens[i];

        return result;
    }
    return CdbPathName( );
}

std::string
CdbPathName::toString( ) const
{
    return _name;
}

CdbPathName
CdbPathName::operator+( const CdbPathName& thePath ) const
{
  // Make sure the input path is valid

    if( thePath.isValid( )) {

        if( _isValid ) {

          // Concatenate the input path to the current one if the current
          // one is valid.
          //
          // NOTE: We only allow a relative path to be added

            if( ! thePath.isAbsolute( )) {

                std::vector< std::string > tokens( _tokens );
                tokens.insert( tokens.end( ),
                               thePath._tokens.begin( ),
                               thePath._tokens.end( ));

                return CdbPathName( tokens );
            }

        } else {

          // Replace the current (invalid) path with the specified one.
          //
          // This scenariou can be used when a temporary path object gets
          // created during manipulations with the path.
          //
          // NOTE: Unlike the previous scenario (of the valid current path)
          //       the other path can be both absolute and relative one.

            return CdbPathName( thePath );
        }
    }

  // Return a non-valid path otherwise

    return CdbPathName( );
}

CdbPathName
CdbPathName::operator+( const char* theStr ) const
{
    return operator+( CdbPathName( theStr ));
}

CdbPathName
CdbPathName::operator+( const std::string& theStr ) const
{
    return operator+( CdbPathName( theStr ));
}

CdbIItr<CdbPathName>*
CdbPathName::iterator( ) const
{
    return new CdbPathNameItr( *this );
}

void
CdbPathName::dump( std::ostream&      theStream,
                   const std::string& thePrefix ) const
{
    theStream << thePrefix << "_isValid     = " << ( _isValid     ? "Yes" : "No" ) << endl
              << thePrefix << "_isAbsolute  = " << ( _isAbsolute  ? "Yes" : "No" ) << endl
              << thePrefix << "_isRoot      = " << ( _isRoot      ? "Yes" : "No" ) << endl
              << thePrefix << "_isComposite = " << ( _isComposite ? "Yes" : "No" ) << endl
              << thePrefix << "_name        = \"" << ( _name.empty() ? "" : _name ) << "\"" << endl
              << thePrefix << "_tokens      = ";

    for( std::vector< std::string >::const_iterator itr = _tokens.begin( );
                                                    itr < _tokens.end( );
                                                  ++itr ) {
        if( itr == _tokens.begin( )) {
            theStream << "\"" << (*itr) << "\"" << endl;
        } else {
            theStream << thePrefix << "               \"" << (*itr) << "\"" << endl;
        }
    }
    if( _tokens.empty( )) theStream << endl;
}

bool
CdbPathName::translateStringIntoTokens( const char* theStr )
{
    if( 0 == theStr ) return false;

  // Break the specified string down to tokens and populate the object's
  // list of tokens.

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

    std::vector< std::string > vectorOfTokens;

    while( current < end ) {

        char* next = strstr( current, separator( ));
        if( 0 == next ) {

          // Treat the rest of the input string as the last element

            vectorOfTokens.push_back( std::string( current, end - current ));
            current = const_cast<char*>( end );

        } else {

          // A separator is found. Now we are going to see how to interpret it.
          // This depends on a position of the found separator in the string.

            if( current == next ) {

              // Separator at the current position

                if( begin == next ) {

                  // The ROOT DIR found - remember it.

                    vectorOfTokens.push_back( std::string( separator( ), strlen( separator( ))));

                } else {

                  // A regular separator found - ignore it
                  //
                  // NOTE: We treat repeating separators as a single one.
                  //       The trailing separator is also ignored unless
                  //       it's the ROOT DIR.

                    ;
                }

            } else {

              // Another element is found - store it

                vectorOfTokens.push_back( std::string( current, next - current ));
                current = next;
            }

          // Skip the separator

            current += strlen( separator( ));
        }
    }
    _tokens = vectorOfTokens;

  // A final step - try rebuild the full path name.

    return rebuildFullPath( );
}

bool
CdbPathName::rebuildFullPath( )
{
  // The operation will make a sense if a valid list of tokens is already loaded.

    unsigned int nTokens = _tokens.size( );

    if( 0 == nTokens ) return false;

  // Rebuild the path

    std::string result = "";

    for( unsigned int i = 0; i < nTokens; ++i ) {

      // Prepend a separator before any token except:
      //
      //   (1) the very first token for any path value to avoid mis-interpreting
      //       the current path as the ROOT one.
      //
      //   (2) the second token if the current path is an absolute one. In this case
      //       the path already begins with the separator, which is also the ROOT path.

        if( 0 == i ) {

            ;   // (1)

        } else if(( 1 == i ) && ( _tokens[0] == separator( ))) {

            ;   // (2)

        } else {

            result += separator( );
        }
        result += _tokens[i];
    }

  // Update the internal state

    _name = result;

    return true;
}

void
CdbPathName::recalculateDescriptorFlags( )
{
  // The object must be loaded and be in a valid state

    if( !_isValid ) return;
    if( 0 == _tokens.size( )) return;

  // Proceed

    _isAbsolute  = _isValid && ( _tokens[0] == separator( ));
    _isRoot      = _isValid && _isAbsolute && ( 1 == _tokens.size( ));
    _isComposite = _isValid && ( _tokens.size( ) > 1 );
}

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

---