src/Git/TGitPath.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2011 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #pragma once
  21 #include "gittype.h"
  22
  23 #define PARENT_MASK   0xFFFFFF
  24 #define MERGE_MASK      (0x1000000)
  25
  26 class CTGitPath
  27 {
  28 public:
  29         CTGitPath(void);
  30         ~CTGitPath(void);
  31         CTGitPath(const CString& sUnknownPath);
  32         int m_Stage;
  33         int m_ParentNo;
  34 public:
  35         enum
  36         {
  37                 LOGACTIONS_ADDED        = 0x00000001,
  38                 LOGACTIONS_MODIFIED     = 0x00000002,
  39                 LOGACTIONS_REPLACED     = 0x00000004,
  40                 LOGACTIONS_DELETED      = 0x00000008,
  41                 LOGACTIONS_UNMERGED = 0x00000010,
  42                 LOGACTIONS_CACHE        = 0x00000020,
  43                 LOGACTIONS_COPY         = 0x00000040,
  44                 LOGACTIONS_MERGED   = 0x00000080,
  45                 LOGACTIONS_FORWORD  = 0x00000100,
  46                 LOGACTIONS_UNVER        = 0x80000000,
  47                 LOGACTIONS_IGNORE       = 0x40000000,
  48                 //LOGACTIONS_CONFLICT = 0x20000000,
  49
  50                 // For log filter only
  51                 LOGACTIONS_HIDE         = 0x20000000,
  52                 LOGACTIONS_GRAY         = 0x10000000,
  53
  54                 // For Rebase only
  55                 LOGACTIONS_REBASE_CURRENT = 0x08000000,
  56                 LOGACTIONS_REBASE_PICK    = 0x04000000,
  57                 LOGACTIONS_REBASE_SQUASH  = 0x02000000,
  58                 LOGACTIONS_REBASE_EDIT    = 0x01000000,
  59                 LOGACTIONS_REBASE_DONE    = 0x00800000,
  60                 LOGACTIONS_REBASE_SKIP    = 0x00400000,
  61                 LOGACTIONS_REBASE_MASK    = 0x0FC00000,
  62                 LOGACTIONS_REBASE_MODE_MASK=0x07C00000,
  63
  64         };
  65
  66         CString m_StatAdd;
  67         CString m_StatDel;
  68         int             m_Action;
  69         bool    m_Checked;
  70         int     ParserAction(BYTE action);
  71         CString GetActionName();
  72         static CString GetActionName(int action);
  73         /**
  74          * Set the path as an UTF8 string with forward slashes
  75          */
  76         void SetFromGit(const char* pPath);
  77         void SetFromGit(const char* pPath, bool bIsDirectory);
  78         void SetFromGit(const TCHAR* pPath, bool bIsDirectory);
  79         void SetFromGit(const CString& sPath,CString *OldPath=NULL);
  80
  81         /**
  82          * Set the path as UNICODE with backslashes
  83          */
  84         void SetFromWin(LPCTSTR pPath);
  85         void SetFromWin(const CString& sPath);
  86         void SetFromWin(const CString& sPath, bool bIsDirectory);
  87         /**
  88          * Set the path from an unknown source.
  89          */
  90         void SetFromUnknown(const CString& sPath);
  91         /**
  92          * Returns the path in Windows format, i.e. with backslashes
  93          */
  94         LPCTSTR GetWinPath() const;
  95         /**
  96          * Returns the path in Windows format, i.e. with backslashes
  97          */
  98         const CString& GetWinPathString() const;
  99         /**
 100          * Returns the path with forward slashes.
 101          */
 102         const CString& GetGitPathString() const;
 103
 104         const CString& GetGitOldPathString() const;
 105         /**
 106          * Returns the path completely prepared to be fed the the Git APIs
 107          * It will be in UTF8, with URLs escaped, if necessary
 108          */
 109 //      const char* GetGitApiPath(apr_pool_t *pool) const;
 110         /**
 111          * Returns the path for showing in an UI.
 112          *
 113          * URL's are returned with forward slashes, unescaped if necessary
 114          * Paths are returned with backward slashes
 115          */
 116         const CString& GetUIPathString() const;
 117         /**
 118          * Checks if the path is an URL.
 119          */
 120         bool IsUrl() const;
 121         /**
 122          * Returns true if the path points to a directory
 123          */
 124         bool IsDirectory() const;
 125
 126         CTGitPath GetSubPath(const CTGitPath &root);
 127
 128         /**
 129          * Returns the directory. If the path points to a directory, then the path
 130          * is returned unchanged. If the path points to a file, the path to the
 131          * parent directory is returned.
 132          */
 133         CTGitPath GetDirectory() const;
 134         /**
 135         * Returns the the directory which contains the item the path refers to.
 136         * If the path is a directory, then this returns the directory above it.
 137         * If the path is to a file, then this returns the directory which contains the path
 138         * parent directory is returned.
 139         */
 140         CTGitPath GetContainingDirectory() const;
 141         /**
 142          * Get the 'root path' (e.g. "c:\") - Used to pass to GetDriveType
 143          */
 144         CString GetRootPathString() const;
 145         /**
 146          * Returns the filename part of the full path.
 147          * \remark don't call this for directories.
 148          */
 149         CString GetFilename() const;
 150         CString GetBaseFilename() const;
 151         /**
 152          * Returns the item's name without the full path.
 153          */
 154         CString GetFileOrDirectoryName() const;
 155         /**
 156          * Returns the item's name without the full path, unescaped if necessary.
 157          */
 158         CString GetUIFileOrDirectoryName() const;
 159         /**
 160          * Returns the file extension, including the dot.
 161          * \remark Returns an empty string for directories
 162          */
 163         CString GetFileExtension() const;
 164
 165         bool IsEmpty() const;
 166         void Reset();
 167         /**
 168          * Checks if two paths are equal. The slashes are taken care of.
 169          */
 170         bool IsEquivalentTo(const CTGitPath& rhs) const;
 171         bool IsEquivalentToWithoutCase(const CTGitPath& rhs) const;
 172         bool operator==(const CTGitPath& x) const {return IsEquivalentTo(x);}
 173
 174         /**
 175          * Checks if \c possibleDescendant is a child of this path.
 176          */
 177         bool IsAncestorOf(const CTGitPath& possibleDescendant) const;
 178         /**
 179          * Get a string representing the file path, optionally with a base
 180          * section stripped off the front
 181          * Returns a string with fwdslash paths
 182          */
 183         CString GetDisplayString(const CTGitPath* pOptionalBasePath = NULL) const;
 184         /**
 185          * Compares two paths. Slash format is irrelevant.
 186          */
 187         static int Compare(const CTGitPath& left, const CTGitPath& right);
 188
 189         /** As PredLeftLessThanRight, but for checking if paths are equivalent
 190          */
 191         static bool PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right);
 192
 193         /** Checks if the left path is pointing to the same working copy path as the right.
 194          * The same wc path means the paths are equivalent once all the admin dir path parts
 195          * are removed. This is used in the TGitCache crawler to filter out all the 'duplicate'
 196          * paths to crawl.
 197          */
 198         static bool PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right);
 199
 200         static bool CheckChild(const CTGitPath &parent, const CTGitPath& child);
 201
 202         /**
 203          * appends a string to this path.
 204          *\remark - missing slashes are not added - this is just a string concatenation, but with
 205          * preservation of the proper caching behavior.
 206          * If you want to join a file- or directory-name onto the path, you should use AppendPathString
 207          */
 208         void AppendRawString(const CString& sAppend);
 209
 210         /**
 211         * appends a part of a path to this path.
 212         *\remark - missing slashes are dealt with properly. Don't use this to append a file extension, for example
 213         *
 214         */
 215         void AppendPathString(const CString& sAppend);
 216
 217         /**
 218          * Get the file modification time - returns zero for files which don't exist
 219          * Returns a FILETIME structure cast to an __int64, for easy comparisons
 220          */
 221         __int64 GetLastWriteTime() const;
 222
 223         bool IsReadOnly() const;
 224
 225         /**
 226          * Checks if the path really exists.
 227          */
 228         bool Exists() const;
 229
 230         /**
 231          * Deletes the file/folder
 232          * \param bTrash if true, uses the Windows trash bin when deleting.
 233          */
 234         bool Delete(bool bTrash) const;
 235
 236         /**
 237          * Checks if a Subversion admin directory is present. For files, the check
 238          * is done in the same directory. For folders, it checks if the folder itself
 239          * contains an admin directory.
 240          */
 241         bool HasAdminDir() const;
 242         bool HasAdminDir(CString *ProjectTopDir) const;
 243         bool HasSubmodules() const;
 244         bool HasGitSVNDir() const;
 245         bool HasStashDir() const;
 246         bool HasRebaseApply() const;
 247
 248         int  GetAdminDirMask() const;
 249
 250         /**
 251          * Checks if the path point to or below a Subversion admin directory (.Git).
 252          */
 253         bool IsAdminDir() const;
 254
 255         void SetCustomData(LPARAM lp) {m_customData = lp;}
 256         LPARAM GetCustomData() {return m_customData;}
 257
 258         /**
 259          * Checks if the path or URL is valid on Windows.
 260          * A path is valid if conforms to the specs in the windows API.
 261          * An URL is valid if the path checked out from it is valid
 262          * on windows. That means an URL which is valid according to the WWW specs
 263          * isn't necessarily valid as a windows path (e.g. http://myserver.com/repos/file:name
 264          * is a valid URL, but the path is illegal on windows ("file:name" is illegal), so
 265          * this function would return \c false for that URL).
 266          */
 267         bool IsValidOnWindows() const;
 268
 269         /**
 270          * Checks to see if the path or URL represents one of the special directories
 271          * (branches, tags, or trunk).
 272          */
 273         bool IsSpecialDirectory() const;
 274 private:
 275         // All these functions are const, and all the data
 276         // is mutable, in order that the hidden caching operations
 277         // can be carried out on a const CTGitPath object, which is what's
 278         // likely to be passed between functions
 279         // The public 'SetFromxxx' functions are not const, and so the proper
 280         // const-correctness semantics are preserved
 281         void SetFwdslashPath(const CString& sPath) const;
 282         void SetBackslashPath(const CString& sPath) const;
 283         void SetUTF8FwdslashPath(const CString& sPath) const;
 284         void EnsureBackslashPathSet() const;
 285         void EnsureFwdslashPathSet() const;
 286         /**
 287          * Checks if two path strings are equal. No conversion of slashes is done!
 288          * \remark for slash-independent comparison, use IsEquivalentTo()
 289          */
 290         static bool ArePathStringsEqual(const CString& sP1, const CString& sP2);
 291         static bool ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2);
 292
 293         /**
 294          * Adds the required trailing slash to local root paths such as 'C:'
 295          */
 296         void SanitizeRootPath(CString& sPath, bool bIsForwardPath) const;
 297
 298         void UpdateAttributes() const;
 299
 300
 301
 302 private:
 303         mutable CString m_sBackslashPath;
 304         mutable CString m_sFwdslashPath;
 305         mutable CString m_sUIPath;
 306         mutable CStringA m_sUTF8FwdslashPath;
 307         mutable CStringA m_sUTF8FwdslashPathEscaped;
 308         mutable CString m_sProjectRoot;
 309
 310         //used for rename case
 311         mutable CString m_sOldBackslashPath;
 312         mutable CString m_sOldFwdslashPath;
 313
 314         // Have we yet determined if this is a directory or not?
 315         mutable bool m_bDirectoryKnown;
 316         mutable bool m_bIsDirectory;
 317         mutable bool m_bLastWriteTimeKnown;
 318         mutable bool m_bURLKnown;
 319         mutable bool m_bIsURL;
 320         mutable __int64 m_lastWriteTime;
 321         mutable bool m_bIsReadOnly;
 322         mutable bool m_bHasAdminDirKnown;
 323         mutable bool m_bHasAdminDir;
 324         mutable bool m_bIsValidOnWindowsKnown;
 325         mutable bool m_bIsValidOnWindows;
 326         mutable bool m_bIsAdminDirKnown;
 327         mutable bool m_bIsAdminDir;
 328         mutable bool m_bExists;
 329         mutable bool m_bExistsKnown;
 330         mutable LPARAM m_customData;
 331         mutable bool m_bIsSpecialDirectoryKnown;
 332         mutable bool m_bIsSpecialDirectory;
 333
 334         friend bool operator<(const CTGitPath& left, const CTGitPath& right);
 335 };
 336 /**
 337  * Compares two paths and return true if left is earlier in sort order than right
 338  * (Uses CTGitPath::Compare logic, but is suitable for std::sort and similar)
 339  */
 340  bool operator<(const CTGitPath& left, const CTGitPath& right);
 341
 342
 343 //////////////////////////////////////////////////////////////////////////
 344
 345 /**
 346  * \ingroup Utils
 347  * This class represents a list of paths
 348  */
 349 class CTGitPathList
 350 {
 351 public:
 352         CTGitPathList();
 353         // A constructor which allows a path list to be easily built with one initial entry in
 354         explicit CTGitPathList(const CTGitPath& firstEntry);
 355         int m_Action;
 356
 357 public:
 358         void AddPath(const CTGitPath& newPath);
 359         bool LoadFromFile(const CTGitPath& filename);
 360         bool WriteToFile(const CString& sFilename, bool bANSI = false) const;
 361         CTGitPath * LookForGitPath(CString path);
 362         int     ParserFromLog(BYTE_VECTOR &log, bool parseDeletes = false);
 363         int ParserFromLsFile(BYTE_VECTOR &out,bool staged=true);
 364         int FillUnRev(int Action,CTGitPathList *list=NULL);
 365         int GetAction();
 366         /**
 367          * Load from the path argument string, when the 'path' parameter is used
 368          * This is a list of paths, with '*' between them
 369          */
 370         void LoadFromAsteriskSeparatedString(const CString& sPathString);
 371         CString CreateAsteriskSeparatedString() const;
 372
 373         int GetCount() const;
 374         void Clear();
 375         const CTGitPath& operator[](INT_PTR index) const;
 376         bool AreAllPathsFiles() const;
 377         bool AreAllPathsFilesInOneDirectory() const;
 378         CTGitPath GetCommonDirectory() const;
 379         CTGitPath GetCommonRoot() const;
 380         void SortByPathname(bool bReverse = false);
 381         /**
 382          * Delete all the files in the list, then clear the list.
 383          * \param bTrash if true, the items are deleted using the Windows trash bin
 384          */
 385         void DeleteAllFiles(bool bTrash);
 386         /** Remove duplicate entries from the list (sorts the list as a side-effect */
 387         void RemoveDuplicates();
 388         /** Removes all paths which are on or in a Subversion admin directory */
 389         void RemoveAdminPaths();
 390         void RemovePath(const CTGitPath& path);
 391         void RemoveItem(CTGitPath &path);
 392         /**
 393          * Removes all child items and leaves only the top folders. Useful if you
 394          * create the list to remove them (i.e. if you remove a parent folder, the
 395          * child files and folders don't have to be deleted anymore)
 396          */
 397         void RemoveChildren();
 398
 399         /** Checks if two CTGitPathLists are the same */
 400         bool IsEqual(const CTGitPathList& list);
 401
 402         /** Convert into the Git API parameter format */
 403 //      apr_array_header_t * MakePathArray (apr_pool_t *pool) const;
 404
 405         typedef std::vector<CTGitPath> PathVector;
 406         PathVector m_paths;
 407         // If the list contains just files in one directory, then
 408         // this contains the directory name
 409         mutable CTGitPath m_commonBaseDirectory;
 410 };