KDevelop API Documentation

urlutil.cpp

Go to the documentation of this file.
00001 /* This file is part of the KDE project
00002    Copyright (C) 2003 Julian Rockey <linux@jrockey.com>
00003    Copyright (C) 2003 Alexander Dymo <cloudtemple@mksat.net>
00004    Copyright (C) 2003 Mario Scalas <mario.scalas@libero.it>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License as published by the Free Software Foundation; either
00009    version 2 of the License, or (at your option) any later version.
00010 
00011    This library is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014    Library General Public License for more details.
00015 
00016    You should have received a copy of the GNU Library General Public License
00017    along with this library; see the file COPYING.LIB.  If not, write to
00018    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00019    Boston, MA 02111-1307, USA.
00020 */
00021 #include <qstringlist.h>
00022 
00023 #include <qdir.h>
00024 #include <qfileinfo.h>
00025 #include <kdebug.h>
00026 #include <qdir.h>
00027 
00028 #include <unistd.h>
00029 #include <limits.h>
00030 #include <stdlib.h>
00031 
00032 #include "urlutil.h"
00033 
00034 #include <kdeversion.h>
00035 #if (KDE_VERSION_MINOR==0) && (KDE_VERSION_MAJOR==3)
00036 #include <kdevkurl.h>
00037 #endif
00038 
00040 // Namespace URLUtil
00042 
00043 QString URLUtil::filename(const QString & name) {
00044   int slashPos = name.findRev("/");
00045   return slashPos<0 ? name : name.mid(slashPos+1);
00046 }
00047 
00049 
00050 QString URLUtil::directory(const QString & name) {
00051   int slashPos = name.findRev("/");
00052   return slashPos<0 ? QString("") : name.left(slashPos);
00053 }
00054 
00056 
00057 QString URLUtil::relativePath(const KURL & parent, const KURL & child, uint slashPolicy) {
00058   bool slashPrefix = slashPolicy & SLASH_PREFIX;
00059   bool slashSuffix = slashPolicy & SLASH_SUFFIX;
00060   if (parent.cmp(child,true))
00061     return slashPrefix ? QString("/") : QString("");
00062 
00063   if (!parent.isParentOf(child)) return QString();
00064   int a=slashPrefix ? -1 : 1;
00065   int b=slashSuffix ? 1 : -1;
00066   return child.path(b).mid(parent.path(a).length());
00067 }
00068 
00070 
00071 QString URLUtil::relativePath(const QString & parent, const QString & child, uint slashPolicy) {
00072   return relativePath(KURL(parent), KURL(child), slashPolicy);
00073 }
00074 
00076 
00077 QString URLUtil::upDir(const QString & path, bool slashSuffix) {
00078   int slashPos = path.findRev("/");
00079   if (slashPos<1) return QString::null;
00080   return path.mid(0,slashPos+ (slashSuffix ? 1 : 0) );
00081 }
00082 
00084 
00085 KURL URLUtil::mergeURL(const KURL & source, const KURL & dest, const KURL & child) {
00086 
00087   // if already a child of source, then fine
00088   if (source.isParentOf(child) || source.cmp(child,true)) return child;
00089 
00090   // if not a child of dest, return blank URL (error)
00091   if (!dest.isParentOf(child) && !dest.cmp(child,true)) return KURL();
00092 
00093   // if child is same as dest, return source
00094   if (dest.cmp(child,true)) return source;
00095 
00096   // calculate
00097   QString childUrlStr = child.url(-1);
00098   QString destStemStr = dest.url(1);
00099   QString sourceStemStr = source.url(1);
00100   return KURL(sourceStemStr.append( childUrlStr.mid( destStemStr.length() ) ) );
00101 
00102 }
00103 
00105 
00106 QString URLUtil::getExtension(const QString & path) {
00107   int dotPos = path.findRev('.');
00108   if (dotPos<0) return QString("");
00109   return path.mid(dotPos+1);
00110 }
00111 
00113 
00114 QString URLUtil::extractPathNameRelative(const KURL &baseDirUrl, const KURL &url )
00115 {
00116   QString absBase = extractPathNameAbsolute( baseDirUrl ),
00117     absRef = extractPathNameAbsolute( url );
00118   int i = absRef.find( absBase, 0, true );
00119 
00120   if (i == -1)
00121     return QString();
00122 
00123   if (absRef == absBase)
00124     return QString( "." );
00125   else
00126     return absRef.replace( 0, absBase.length(), QString() );
00127 }
00128 
00130 
00131 QString URLUtil::extractPathNameRelative(const QString &basePath, const KURL &url )
00132 {
00133 #if (KDE_VERSION_MINOR!=0) || (KDE_VERSION_MAJOR!=3)
00134   KURL baseDirUrl = KURL::fromPathOrURL( basePath );
00135 #else
00136   KURL baseDirUrl = KdevKURL::fromPathOrURL( basePath );
00137 #endif
00138   return extractPathNameRelative( baseDirUrl, url );
00139 }
00140 
00142 
00143 QString URLUtil::extractPathNameRelative(const QString &basePath, const QString &absFilePath )
00144 {
00145 #if (KDE_VERSION_MINOR!=0) || (KDE_VERSION_MAJOR!=3)
00146   KURL baseDirUrl = KURL::fromPathOrURL( basePath ),
00147        fileUrl = KURL::fromPathOrURL( absFilePath );
00148 #else
00149   KURL baseDirUrl = KdevKURL::fromPathOrURL( basePath ),
00150        fileUrl = KdevKURL::fromPathOrURL( absFilePath );
00151 #endif
00152   return extractPathNameRelative( baseDirUrl, fileUrl );
00153 }
00154 
00156 
00157 QString URLUtil::extractPathNameAbsolute( const KURL &url )
00158 {
00159   if (isDirectory( url ))
00160     return url.path( +1 ); // with trailing "/" if none is present
00161   else
00162   {
00163     // Ok, this is an over-tight pre-condition on "url" since I hope nobody will never
00164     // stress this function with absurd cases ... but who knows?
00165   /*
00166     QString path = url.path();
00167     QFileInfo fi( path );  // Argh: QFileInfo is back ;))
00168     return ( fi.exists()? path : QString() );
00169   */
00170     return url.path();
00171   }
00172 }
00173 
00175 
00176 bool URLUtil::isDirectory( const KURL &url )
00177 {
00178   return isDirectory( url.path() );
00179 }
00180 
00182 
00183 bool URLUtil::isDirectory( const QString &absFilePath )
00184 {
00185   return QDir( absFilePath ).exists();
00186 }
00187 
00189 
00190 void URLUtil::dump( const KURL::List &urls, const QString &aMessage )
00191 {
00192   if (!aMessage.isNull())
00193   {
00194     kdDebug(9000) << aMessage << endl;
00195   }
00196   kdDebug(9000) << " List has " << urls.count() << " elements." << endl;
00197 
00198   for (size_t i = 0; i<urls.count(); ++i)
00199   {
00200     KURL url = urls[ i ];
00201 //    kdDebug(9000) << " * Element = "  << url.path() << endl;
00202   }
00203 }
00204 
00206 
00207 QStringList URLUtil::toRelativePaths( const QString &baseDir, const KURL::List &urls)
00208 {
00209   QStringList paths;
00210 
00211   for (size_t i=0; i<urls.count(); ++i)
00212   {
00213     paths << extractPathNameRelative( baseDir, urls[i] );
00214   }
00215 
00216   return paths;
00217 }
00218 
00220 
00221 QString URLUtil::relativePathToFile( const QString & dirUrl, const QString & fileUrl )
00222 {
00223   if (dirUrl.isEmpty() || (dirUrl == "/"))
00224     return fileUrl;
00225 
00226   QStringList dir = QStringList::split("/", dirUrl, false);
00227   QStringList file = QStringList::split("/", fileUrl, false);
00228 
00229   QString resFileName = file.last();
00230   file.remove(file.last());
00231 
00232   uint i = 0;
00233   while ( (i < dir.count()) && (i < (file.count())) && (dir[i] == file[i]) )
00234     i++;
00235 
00236   QString result_up;
00237   QString result_down;
00238   QString currDir;
00239   QString currFile;
00240   do
00241   {
00242     i >= dir.count() ? currDir = "" : currDir = dir[i];
00243     i >= file.count() ? currFile = "" : currFile = file[i];
00244     qWarning("i = %d, currDir = %s, currFile = %s", i, currDir.latin1(), currFile.latin1());
00245     if (currDir.isEmpty() && currFile.isEmpty())
00246       break;
00247     else if (currDir.isEmpty())
00248       result_down += file[i] + "/";
00249     else if (currFile.isEmpty())
00250       result_up += "../";
00251     else
00252     {
00253       result_down += file[i] + "/";
00254       result_up += "../";
00255     }
00256     i++;
00257   }
00258   while ( (!currDir.isEmpty()) || (!currFile.isEmpty()) );
00259 
00260   return result_up + result_down + resFileName;
00261 }
00262 
00264 
00265 // code from qt-3.1.2 version of QDir::canonicalPath()
00266 QString URLUtil::canonicalPath( const QString & path )
00267 {
00268     QString r;
00269     char cur[PATH_MAX+1];
00270     if ( ::getcwd( cur, PATH_MAX ) )
00271     {
00272         char tmp[PATH_MAX+1];
00273         if( ::realpath( QFile::encodeName( path ), tmp ) )
00274         {
00275             r = QFile::decodeName( tmp );
00276         }
00277         //always make sure we go back to the current dir
00278         ::chdir( cur );
00279     }
00280     return r;
00281 }
00282 
00284 
00285 //written by "Dawit A." <adawit@kde.org>
00286 //borrowed from his patch to KShell
00287 QString URLUtil::envExpand ( const QString& str )
00288 {
00289     uint len = str.length();
00290 
00291     if (len > 1 && str[0] == '$')
00292     {
00293       int pos = str.find ('/');
00294 
00295       if (pos < 0)
00296         pos = len;
00297 
00298       char* ret = getenv( QConstString(str.unicode()+1, pos-1).string().local8Bit().data() );
00299 
00300       if (ret)
00301       {
00302         QString expandedStr ( QFile::decodeName( ret ) );
00303         if (pos < (int)len)
00304           expandedStr += str.mid(pos);
00305         return expandedStr;
00306       }
00307     }
00308 
00309     return str;
00310 }
00311 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:52 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003