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

                 

---

/BdbUtil/BdbPathName.cc

Go to the documentation of this file.

//---------------------------------------------------------------------------
// File:
//      BdbPathName.cc
//
// Description:
//      BdbPathName functions
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Akbar Mokhtarani             original author
//
// Copyright Information:
//      Copyright (C) 2001      LBNL
//
//---------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbUtil/BdbPathName.hh"


//-------------
// C Headers --
//-------------
extern "C" {
#include <string.h>
}

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "ErrLogger/ErrLog.hh"

const char localSeparator( '/' );

BdbPathName::~BdbPathName()
{
}

char*
BdbPathName::relative(const char* refPath, const char* targetPath )
{
   // If no target is specified return nothing
   if ( 0 == targetPath )
   {
      return( 0 );
   }

   // If target path doesn't have a / at the start it is already relative
   // copy the targetPath and return that (called owns the string)
   if ( localSeparator != targetPath[0] )
   {
      char* toReturn = new char[strlen(targetPath) + 1];
      strcpy( toReturn, targetPath );
      return toReturn;
   }

   // First find any common part
   int common = commonDirsLength( refPath, targetPath );

   // Find if there are any directories further down the reference path
   const char* refEnd = refPath + common;

   int slashes = countSlashes( refEnd );

  // For each slash stick ../ before what is left of the targetPath
   static const char* upStr = "../";
   static const int upStrLen = strlen( upStr );
   const char* targetEnd = targetPath + common;
   char* toReturn = new char[ upStrLen*slashes + strlen(targetEnd) + 1 ];
   char* toReturnPtr = toReturn;
   for ( int i=0; i<slashes; i++ )
   {
      strcpy( toReturnPtr, upStr );
      toReturnPtr += upStrLen;
   }
   strcpy( toReturnPtr, targetEnd );

   return toReturn;
}

char*
BdbPathName::absolute(const char* refPath, const char* targetPath)
{
   if( ( ( 0 != refPath ) &&
         ( localSeparator == *refPath ) ) ||
       ( ( 0 != targetPath ) &&
         ( localSeparator == *targetPath ) ) ) {
      return( merge( refPath,
                     targetPath ) );
   }
   return( 0 );
}

char*
BdbPathName::merge( const char* firstPath, const char* secondPath )
{
   // If no target is specified simply copy the firstPath into
   // new memory
   if ( 0 == secondPath ) {
      if( 0 == firstPath ) {
         return( 0 );
      }
      char* result = new char[ strlen( firstPath ) + 1 ];
      strcpy( result,
              firstPath );
      return result;
   }

   char* result( 0 );
   char* joint( 0 );
   // If target path has a / at the start it is already absolute
   // copy the secondPath and return that (called owns the string)
   if ( localSeparator == *secondPath ) {
      result = new char[ strlen( secondPath ) + 1 ];
      joint = result;
   }

   else {

      // Build the part of the result that is based of the firstPath
      const char* emptyString( "" );
      if( 0 == firstPath ) {
         firstPath = emptyString;
      }
      result = new char[ strlen( firstPath ) + strlen( secondPath ) + 1 ];
      const char* firstResult( append( result,
                                       result,
                                       firstPath ) );
      if( 0 == firstResult ) {
         delete [] result;
         return( 0 );
      }

      joint = leafJoint( result );
      if( 0 == joint ) {
         joint = result;
      }
      else {
         joint++;
      }
   }

   const char* secondResult( append( result,
                                     joint,
                                     secondPath ) );
   if( 0 == secondResult ) {
      delete [] result;
      result = 0 ;
   }
   return( result );
}

const char*
BdbPathName::append( const char* beginning,
                     char* cursor,
                     const char* addition )
{
   if( ( beginning != cursor ) &&
       ( localSeparator != *( cursor - 1 ) ) ) {
      return( 0 );
   }

   while( '\0' != *addition ) {

      // If end of target is ',' drop it and remove last separator
      if( ( '.' == *addition ) &&
          ( '\0' == *( addition + 1 ) ) ) {
         addition++ ;
         if( beginning == cursor ) {
            delete [] beginning;
            beginning = 0;
         }
         else {
            cursor--;
         }
      }

      // If target contains './' simply drop it
      else if( ( '.' == *addition ) &&
               ( localSeparator == *( addition + 1 ) ) ) {
         addition += 2;
      }

      // If end of target is '..' or '../' remove last directory
      else if( ( '.' == *addition ) &&
               ( '.' == *( addition + 1 ) ) &&
               ( ( '\0' == *( addition + 2 ) ) ||
                 ( localSeparator == *( addition + 2 ) ) ) ) {
         addition += 2;
         if( beginning == cursor ) {
            addition = addition + strlen( addition );
            delete [] beginning;
            beginning = 0;
         }
         else {
            cursor--;
            *cursor = '\0';
            const char* newCursor( strrchr( beginning,
                                            localSeparator ) );
            if( 0 == newCursor ) {
               addition = addition + strlen( addition );
               delete [] beginning;
               beginning = 0;
            }
            else {
               cursor = const_cast< char* >( newCursor );
               *cursor = *addition;
               if( localSeparator == *addition ) {
                  addition++;
                  cursor++;
               }
            }
         }
      }

      // Otherwise copy next leaf into result
      else {
         const char* newAddition( strchr( addition,
                                          localSeparator ) );
         if( newAddition == addition ) {
            if( beginning == cursor ) {
               *cursor = localSeparator;
               cursor++;
            }
            addition++;
         }
         else {
            size_t length( 0 );
            if( 0 == newAddition ) {
               length = strlen( addition );
            }
            else {
               length = newAddition - addition + 1;
            }
            strncpy( cursor,
                     addition,
                     length );
            addition += length;
            cursor += length;
         }
      }
   }

   *cursor = '\0';
   return( beginning );
}

char*
BdbPathName::stem( const char* path,
                   bool trailingSeparator )
{
   const char* joint( leafJoint( path ) );
   if( ( 0 == joint ) ||
       ( '\0' == *joint ) ||
       ( ( path == joint ) &&
         ( ! trailingSeparator ) ) ) {
      return( 0 );
   }
   size_t length( joint - path );
   if( trailingSeparator ) {
      length++;
   }
   char* result( new char[ length + 1 ] );
   strncpy( result,
            path,
            length );
   result[ length ] = '\0';
   return( result );
}

char*
BdbPathName::leaf( const char* path )
{
   if( 0 == path ) {
      return( 0 );
   }
   const char* joint( leafJoint( path ) );
   if( ( 0 != joint ) &&
       ( '\0' == *joint ) ) {
      return( 0 );
   }
   if( 0 == joint ) {
      joint = path;
   }
   if( localSeparator == *joint ) {
      if( '\0' == *(joint + 1 ) ) {
         return( 0 ) ;
      }
      joint++;
   }
   char* result( new char[ strlen( joint ) + 1 ] );
   strcpy( result,
           joint ) ;
   return( result );
}

char*
BdbPathName::leaf( const char* path,
                   unsigned int index )
{
   if( ( 0 == path ) ||
       ( '\0' == *path ) ) {
      return( 0 );
   }

   // Ignore first separator
   const char* start( path );
   if( localSeparator == *path ) {
      start++;
      if( '\0' == start ) {
         return( 0 );
      }
   }

   // Move to the beginning of nth leaf
   while( ( 0 != start ) &&
          ( 0 != index ) ) {
      start = strchr( start,
                      localSeparator );
      if( 0 != start ) {
         start++ ;
      }
      index--;
   }
   if( ( 0 == start ) ||
       ( '\0' == start ) ) {
      return( 0 );
   }

   // Create leaf as result
   const char* finish( strchr( start,
                               localSeparator ) );
   unsigned int length( 0 );
   if( 0 == finish ) {
      length = strlen( start );
   }
   else {
      length = finish - start;
   }
   char* result( new char[ length + 1 ] );
   strncpy( result,
            start,
            length) ;
   result[ length ] = '\0';
   return( result );
}

char
BdbPathName::separator()
{
   return( localSeparator );
}

int
BdbPathName::commonDirsLength( const char* one, const char* two )
{
   int lenOne = strlen( one ), lenTwo = strlen( two );
   int minLen = ( (lenOne>lenTwo)? lenTwo:lenOne );

   bool done( false );
   int i( 0 );
   int result( 0 ) ;
   while( !done &&
          ( i != minLen ) ) {
      if ( one[i] != two[i] ) {
         done = !false ;
      }
      else {
         if ( localSeparator == one[i] ) {
            result = i + 1;
         }
         i++;
      }
   }

   return result;
}

int
BdbPathName::countSlashes( const char* aString )
{
   int length = strlen( aString ), slashes=0;

   for ( int i=0; i<length; i++ ) if ( localSeparator ==aString[i] ) slashes++;

   return slashes;
}

char*
BdbPathName::leafJoint( char* path )
{
   if( 0 == path ) {
      return( 0 );
   }
   char* result( strrchr( path,
                          localSeparator ) );
   return( result );
}

const char*
BdbPathName::leafJoint( const char* path )
{
   return( leafJoint( const_cast< char* >( path ) ) ) ;
}

 

---

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

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