src/Git/TGitPath.h

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