src/Git/TGitPath.h

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