OSDN Git Service

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