Git/TGitPath.h

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