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