9 CTGitPath(const CString& sUnknownPath);
\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
25 // For log filter only
\r
26 LOGACTIONS_HIDE = 0x20000000,
\r
27 LOGACTIONS_GRAY = 0x10000000,
\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
45 int ParserAction(BYTE action);
\r
46 CString GetActionName();
\r
48 * Set the path as an UTF8 string with forward slashes
\r
50 void SetFromGit(const char* pPath);
\r
51 void SetFromGit(const char* pPath, bool bIsDirectory);
\r
52 void SetFromGit(const CString& sPath,CString *OldPath=NULL);
\r
55 * Set the path as UNICODE with backslashes
\r
57 void SetFromWin(LPCTSTR pPath);
\r
58 void SetFromWin(const CString& sPath);
\r
59 void SetFromWin(const CString& sPath, bool bIsDirectory);
\r
61 * Set the path from an unknown source.
\r
63 void SetFromUnknown(const CString& sPath);
\r
65 * Returns the path in Windows format, i.e. with backslashes
\r
67 LPCTSTR GetWinPath() const;
\r
69 * Returns the path in Windows format, i.e. with backslashes
\r
71 const CString& GetWinPathString() const;
\r
73 * Returns the path with forward slashes.
\r
75 const CString& GetGitPathString() const;
\r
77 const CString& GetGitOldPathString() const;
\r
79 * Returns the path completely prepared to be fed the the Git APIs
\r
80 * It will be in UTF8, with URLs escaped, if necessary
\r
82 // const char* GetGitApiPath(apr_pool_t *pool) const;
\r
84 * Returns the path for showing in an UI.
\r
86 * URL's are returned with forward slashes, unescaped if necessary
\r
87 * Paths are returned with backward slashes
\r
89 const CString& GetUIPathString() const;
\r
91 * Checks if the path is an URL.
\r
95 * Returns true if the path points to a directory
\r
97 bool IsDirectory() const;
\r
99 * Returns the directory. If the path points to a directory, then the path
\r
100 * is returned unchanged. If the path points to a file, the path to the
\r
101 * parent directory is returned.
\r
103 CTGitPath GetDirectory() const;
\r
105 * Returns the the directory which contains the item the path refers to.
\r
106 * If the path is a directory, then this returns the directory above it.
\r
107 * If the path is to a file, then this returns the directory which contains the path
\r
108 * parent directory is returned.
\r
110 CTGitPath GetContainingDirectory() const;
\r
112 * Get the 'root path' (e.g. "c:\") - Used to pass to GetDriveType
\r
114 CString GetRootPathString() const;
\r
116 * Returns the filename part of the full path.
\r
117 * \remark don't call this for directories.
\r
119 CString GetFilename() const;
\r
120 CString GetBaseFilename() const;
\r
122 * Returns the item's name without the full path.
\r
124 CString GetFileOrDirectoryName() const;
\r
126 * Returns the item's name without the full path, unescaped if necessary.
\r
128 CString GetUIFileOrDirectoryName() const;
\r
130 * Returns the file extension, including the dot.
\r
131 * \remark Returns an empty string for directories
\r
133 CString GetFileExtension() const;
\r
135 bool IsEmpty() const;
\r
138 * Checks if two paths are equal. The slashes are taken care of.
\r
140 bool IsEquivalentTo(const CTGitPath& rhs) const;
\r
141 bool IsEquivalentToWithoutCase(const CTGitPath& rhs) const;
\r
142 bool operator==(const CTGitPath& x) const {return IsEquivalentTo(x);}
\r
145 * Checks if \c possibleDescendant is a child of this path.
\r
147 bool IsAncestorOf(const CTGitPath& possibleDescendant) const;
\r
149 * Get a string representing the file path, optionally with a base
\r
150 * section stripped off the front
\r
151 * Returns a string with fwdslash paths
\r
153 CString GetDisplayString(const CTGitPath* pOptionalBasePath = NULL) const;
\r
155 * Compares two paths. Slash format is irrelevant.
\r
157 static int Compare(const CTGitPath& left, const CTGitPath& right);
\r
159 /** As PredLeftLessThanRight, but for checking if paths are equivalent
\r
161 static bool PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right);
\r
163 /** Checks if the left path is pointing to the same working copy path as the right.
\r
164 * The same wc path means the paths are equivalent once all the admin dir path parts
\r
165 * are removed. This is used in the TGitCache crawler to filter out all the 'duplicate'
\r
168 static bool PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right);
\r
170 static bool CheckChild(const CTGitPath &parent, const CTGitPath& child);
\r
173 * appends a string to this path.
\r
174 *\remark - missing slashes are not added - this is just a string concatenation, but with
\r
175 * preservation of the proper caching behavior.
\r
176 * If you want to join a file- or directory-name onto the path, you should use AppendPathString
\r
178 void AppendRawString(const CString& sAppend);
\r
181 * appends a part of a path to this path.
\r
182 *\remark - missing slashes are dealt with properly. Don't use this to append a file extension, for example
\r
185 void AppendPathString(const CString& sAppend);
\r
188 * Get the file modification time - returns zero for files which don't exist
\r
189 * Returns a FILETIME structure cast to an __int64, for easy comparisons
\r
191 __int64 GetLastWriteTime() const;
\r
193 bool IsReadOnly() const;
\r
196 * Checks if the path really exists.
\r
198 bool Exists() const;
\r
201 * Deletes the file/folder
\r
202 * \param bTrash if true, uses the Windows trash bin when deleting.
\r
204 bool Delete(bool bTrash) const;
\r
207 * Checks if a Subversion admin directory is present. For files, the check
\r
208 * is done in the same directory. For folders, it checks if the folder itself
\r
209 * contains an admin directory.
\r
211 bool HasAdminDir() const;
\r
212 bool HasAdminDir(CString *ProjectTopDir) const;
\r
215 * Checks if the path point to or below a Subversion admin directory (.Git).
\r
217 bool IsAdminDir() const;
\r
219 void SetCustomData(LPARAM lp) {m_customData = lp;}
\r
220 LPARAM GetCustomData() {return m_customData;}
\r
223 * Checks if the path or URL is valid on Windows.
\r
224 * A path is valid if conforms to the specs in the windows API.
\r
225 * An URL is valid if the path checked out from it is valid
\r
226 * on windows. That means an URL which is valid according to the WWW specs
\r
227 * isn't necessarily valid as a windows path (e.g. http://myserver.com/repos/file:name
\r
228 * is a valid URL, but the path is illegal on windows ("file:name" is illegal), so
\r
229 * this function would return \c false for that URL).
\r
231 bool IsValidOnWindows() const;
\r
234 * Checks to see if the path or URL represents one of the special directories
\r
235 * (branches, tags, or trunk).
\r
237 bool IsSpecialDirectory() const;
\r
239 // All these functions are const, and all the data
\r
240 // is mutable, in order that the hidden caching operations
\r
241 // can be carried out on a const CTGitPath object, which is what's
\r
242 // likely to be passed between functions
\r
243 // The public 'SetFromxxx' functions are not const, and so the proper
\r
244 // const-correctness semantics are preserved
\r
245 void SetFwdslashPath(const CString& sPath) const;
\r
246 void SetBackslashPath(const CString& sPath) const;
\r
247 void SetUTF8FwdslashPath(const CString& sPath) const;
\r
248 void EnsureBackslashPathSet() const;
\r
249 void EnsureFwdslashPathSet() const;
\r
251 * Checks if two path strings are equal. No conversion of slashes is done!
\r
252 * \remark for slash-independent comparison, use IsEquivalentTo()
\r
254 static bool ArePathStringsEqual(const CString& sP1, const CString& sP2);
\r
255 static bool ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2);
\r
258 * Adds the required trailing slash to local root paths such as 'C:'
\r
260 void SanitizeRootPath(CString& sPath, bool bIsForwardPath) const;
\r
262 void UpdateAttributes() const;
\r
267 mutable CString m_sBackslashPath;
\r
268 mutable CString m_sFwdslashPath;
\r
269 mutable CString m_sUIPath;
\r
270 mutable CStringA m_sUTF8FwdslashPath;
\r
271 mutable CStringA m_sUTF8FwdslashPathEscaped;
\r
272 mutable CString m_sProjectRoot;
\r
274 //used for rename case
\r
275 mutable CString m_sOldBackslashPath;
\r
276 mutable CString m_sOldFwdslashPath;
\r
278 // Have we yet determined if this is a directory or not?
\r
279 mutable bool m_bDirectoryKnown;
\r
280 mutable bool m_bIsDirectory;
\r
281 mutable bool m_bLastWriteTimeKnown;
\r
282 mutable bool m_bURLKnown;
\r
283 mutable bool m_bIsURL;
\r
284 mutable __int64 m_lastWriteTime;
\r
285 mutable bool m_bIsReadOnly;
\r
286 mutable bool m_bHasAdminDirKnown;
\r
287 mutable bool m_bHasAdminDir;
\r
288 mutable bool m_bIsValidOnWindowsKnown;
\r
289 mutable bool m_bIsValidOnWindows;
\r
290 mutable bool m_bIsAdminDirKnown;
\r
291 mutable bool m_bIsAdminDir;
\r
292 mutable bool m_bExists;
\r
293 mutable bool m_bExistsKnown;
\r
294 mutable LPARAM m_customData;
\r
295 mutable bool m_bIsSpecialDirectoryKnown;
\r
296 mutable bool m_bIsSpecialDirectory;
\r
298 friend bool operator<(const CTGitPath& left, const CTGitPath& right);
\r
301 * Compares two paths and return true if left is earlier in sort order than right
\r
302 * (Uses CTGitPath::Compare logic, but is suitable for std::sort and similar)
\r
304 bool operator<(const CTGitPath& left, const CTGitPath& right);
\r
307 //////////////////////////////////////////////////////////////////////////
\r
311 * This class represents a list of paths
\r
313 class CTGitPathList
\r
317 // A constructor which allows a path list to be easily built with one initial entry in
\r
318 explicit CTGitPathList(const CTGitPath& firstEntry);
\r
322 void AddPath(const CTGitPath& newPath);
\r
323 bool LoadFromFile(const CTGitPath& filename);
\r
324 bool WriteToFile(const CString& sFilename, bool bANSI = false) const;
\r
325 CTGitPath * LookForGitPath(CString path);
\r
326 int ParserFromLog(BYTE_VECTOR &log);
\r
327 int ParserFromLsFile(BYTE_VECTOR &out,bool staged=true);
\r
328 int FillUnRev(int Action,CTGitPathList *list=NULL);
\r
331 * Load from the path argument string, when the 'path' parameter is used
\r
332 * This is a list of paths, with '*' between them
\r
334 void LoadFromAsteriskSeparatedString(const CString& sPathString);
\r
335 CString CreateAsteriskSeparatedString() const;
\r
337 int GetCount() const;
\r
339 const CTGitPath& operator[](INT_PTR index) const;
\r
340 bool AreAllPathsFiles() const;
\r
341 bool AreAllPathsFilesInOneDirectory() const;
\r
342 CTGitPath GetCommonDirectory() const;
\r
343 CTGitPath GetCommonRoot() const;
\r
344 void SortByPathname(bool bReverse = false);
\r
346 * Delete all the files in the list, then clear the list.
\r
347 * \param bTrash if true, the items are deleted using the Windows trash bin
\r
349 void DeleteAllFiles(bool bTrash);
\r
350 /** Remove duplicate entries from the list (sorts the list as a side-effect */
\r
351 void RemoveDuplicates();
\r
352 /** Removes all paths which are on or in a Subversion admin directory */
\r
353 void RemoveAdminPaths();
\r
354 void RemovePath(const CTGitPath& path);
\r
355 void RemoveItem(CTGitPath &path);
\r
357 * Removes all child items and leaves only the top folders. Useful if you
\r
358 * create the list to remove them (i.e. if you remove a parent folder, the
\r
359 * child files and folders don't have to be deleted anymore)
\r
361 void RemoveChildren();
\r
363 /** Checks if two CTGitPathLists are the same */
\r
364 bool IsEqual(const CTGitPathList& list);
\r
366 /** Convert into the Git API parameter format */
\r
367 // apr_array_header_t * MakePathArray (apr_pool_t *pool) const;
\r
370 typedef std::vector<CTGitPath> PathVector;
\r
371 PathVector m_paths;
\r
372 // If the list contains just files in one directory, then
\r
373 // this contains the directory name
\r
374 mutable CTGitPath m_commonBaseDirectory;
\r