Helper.cpp

gehe zur Dokumentation dieser Datei

// Copyright (C) 2004 Bernhard Assmann <bernie@tuxomania.net>
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//  
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//  
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//  

#include <iomanip>
#include <sstream>
#include <cstdio>
#include <qdir.h>
#include <qstringlist.h>
#include <qfileinfo.h>

extern "C" {
#include <xcrypt.h>
}

#include "psfa/Helper.hpp"



bool
psfahelper::onlyWhiteSpace( const std::string theString ) 
{
  using std::string;
   
  string whiteSpaces = " \n\t";
  string::size_type wSPos = theString.find_first_not_of( whiteSpaces );
  if( wSPos == string::npos ) {
    return true;
  }
  return false;
}



unsigned int
psfahelper::getXMLChLength ( const XMLCh* const field ) 
{
  if( field ) {
    std::string::size_type i = 0;
    while( field[i] != 0 ) {
      ++i;
    }
    return i;
  }
  return 0;
}



const std::string
psfahelper::stripWhiteSpace( std::string theString ) 
{
  using std::string;
  using psfahelper::onlyWhiteSpace;
  
  if( onlyWhiteSpace( theString ) ) {
    return "";
  }
    
  string::size_type whiteSpacePos;
  
  whiteSpacePos = theString.find( "  " );
  while( whiteSpacePos < string::npos ) {
    theString.replace( whiteSpacePos, 2, "" );
    whiteSpacePos = theString.find( "  ", whiteSpacePos );
  }

  whiteSpacePos = theString.find( "\n" );
  while( whiteSpacePos < string::npos ) {
    theString.replace( whiteSpacePos, 1, " " );
    whiteSpacePos = theString.find( "\n", whiteSpacePos + 1 );
  }
  
  whiteSpacePos = theString.find( "\t" );
  while( whiteSpacePos < string::npos ) {
    theString.replace( whiteSpacePos, 1, "" );
    whiteSpacePos = theString.find( "\t", whiteSpacePos + 1 );
  }
  
  return theString;
}



const std::string
psfahelper::getMd5Sum( const std::string path, const std::string fileName ) 
{
  std::string filePath = path + "/" + fileName;

  std::FILE* file = std::fopen( filePath.c_str(), "r" );
  unsigned char buff[16];
  md5_stream( file, buff );

  std::ostringstream sum;
  for (int cnt = 0; cnt < 16; ++cnt) {
    sum << std::setfill('0')
   << std::setw(2)
   << std::hex
   << static_cast<int>(buff[cnt]);
  }
  std::fclose( file );

  return sum.str();
}

  

void
psfahelper::splitString( const std::string theString,
          std::vector< std::string >& theVector,
          const std::string delim ) 
{
  using std::string;
  
  if( theString.empty() ) {
    return;
  }
  string::size_type startToken = 0;
  string::size_type nextToken  = theString.find( delim );
  while( nextToken < string::npos ) {
    string token( theString, startToken, nextToken - startToken );
    if( token != "" ) {
      theVector.push_back( token );
    }
    ++nextToken;
    startToken = nextToken;
    nextToken = theString.find( delim, startToken );
  }
  string token( theString, startToken );
  if( token != "" ) {
    theVector.push_back( token );
  }
  return;
}



void
psfahelper::getFilePaths( const std::string path, 
           const std::string pattern, 
           std::vector< std::string >& fileList ) 
{
  QDir dir( path.c_str() );
  dir.setFilter( QDir::Files | QDir::NoSymLinks | QDir::Readable );
  bool success = dir.exists();
  if( !success ) {
    return;
  }
  dir.setNameFilter( pattern.c_str() );
  QStringList dirList = dir.entryList();
  for( QStringList::Iterator i = dirList.begin(); i != dirList.end(); ++i ) {
    fileList.push_back( (*i).ascii() );
  }
  return;
}



bool
psfahelper::pathIsDir( const std::string path ) 
{
  QDir dir( path.c_str() );
  return dir.exists();
}



bool
psfahelper::pathIsReadable( const std::string path ) 
{
  QFileInfo file( path.c_str() );
  return file.isReadable();
}



int
psfahelper::getFileSize( const std::string path ) 
{
  QFileInfo file( path.c_str() );
  return file.size();
}

---