xref: /reactos/sdk/lib/atl/atlpath.h (revision 53221834) 
1 // PROJECT:        ReactOS ATL CPathT
2 // LICENSE:        Public Domain
3 // PURPOSE:        Provides compatibility to Microsoft ATL
4 // PROGRAMMERS:    Benedikt Freisen
5 
6 #ifndef __ATLPATH_H__
7 #define __ATLPATH_H__
8 
9 // WARNING: Untested code
10 
11 #pragma once
12 
13 #include <atlcore.h>
14 #include <atlstr.h>
15 #include <shlwapi.h>
16 
17 namespace ATL
18 {
19 
20 template<typename StringType>
21 class CPathT
22 {
23     // const
24     inline BOOL PathFileExistsX(LPCSTR pszPath) { return PathFileExistsA(pszPath); }
25     inline BOOL PathFileExistsX(LPCWSTR pszPath) { return PathFileExistsW(pszPath); }
26     inline LPCSTR PathFindExtensionX(LPCSTR pszPath) { return PathFindExtensionA(pszPath); }
27     inline LPCWSTR PathFindExtensionX(LPCWSTR pszPath) { return PathFindExtensionW(pszPath); }
28     inline LPCSTR PathFindFileNameX(LPCSTR pszPath) { return PathFindFileNameA(pszPath); }
29     inline LPCWSTR PathFindFileNameX(LPCWSTR pszPath) { return PathFindFileNameW(pszPath); }
30     inline int PathGetDriveNumberX(LPCSTR pszPath) { return PathGetDriveNumberA(pszPath); }
31     inline int PathGetDriveNumberX(LPCWSTR pszPath) { return PathGetDriveNumberW(pszPath); }
32     inline BOOL PathIsDirectoryX(LPCSTR pszPath) { return PathIsDirectoryA(pszPath); }
33     inline BOOL PathIsDirectoryX(LPCWSTR pszPath) { return PathIsDirectoryW(pszPath); }
34     inline BOOL PathIsFileSpecX(LPCSTR pszPath) { return PathIsFileSpecA(pszPath); }
35     inline BOOL PathIsFileSpecX(LPCWSTR pszPath) { return PathIsFileSpecW(pszPath); }
36     inline BOOL PathIsPrefixX(LPCSTR pszPath, LPCSTR pszPrefix) { return PathIsPrefixA(pszPath, pszPrefix); }
37     inline BOOL PathIsPrefixX(LPCWSTR pszPath, LPCWSTR pszPrefix) { return PathIsPrefixW(pszPath, pszPrefix); }
38     inline BOOL PathIsRelativeX(LPCSTR pszPath) { return PathIsRelativeA(pszPath); }
39     inline BOOL PathIsRelativeX(LPCWSTR pszPath) { return PathIsRelativeW(pszPath); }
40     inline BOOL PathIsRootX(LPCSTR pszPath) { return PathIsRootA(pszPath); }
41     inline BOOL PathIsRootX(LPCWSTR pszPath) { return PathIsRootW(pszPath); }
42     inline BOOL PathIsSameRootX(LPCSTR pszPath, LPCSTR pszOther) { return PathIsSameRootA(pszPath, pszOther); }
43     inline BOOL PathIsSameRootX(LPCWSTR pszPath, LPCWSTR pszOther) { return PathIsSameRootW(pszPath, pszOther); }
44     inline BOOL PathIsUNCX(LPCSTR pszPath) { return PathIsUNCA(pszPath); }
45     inline BOOL PathIsUNCX(LPCWSTR pszPath) { return PathIsUNCW(pszPath); }
46     inline BOOL PathIsUNCServerX(LPCSTR pszPath) { return PathIsUNCServerA(pszPath); }
47     inline BOOL PathIsUNCServerX(LPCWSTR pszPath) { return PathIsUNCServerW(pszPath); }
48     inline BOOL PathIsUNCServerShareX(LPCSTR pszPath) { return PathIsUNCServerShareA(pszPath); }
49     inline BOOL PathIsUNCServerShareX(LPCWSTR pszPath) { return PathIsUNCServerShareW(pszPath); }
50     inline BOOL PathMatchSpecX(LPCSTR pszPath, LPCSTR pszSpec) { return PathMatchSpecA(pszPath, pszSpec); }
51     inline BOOL PathMatchSpecX(LPCWSTR pszPath, LPCWSTR pszSpec) { return PathMatchSpecW(pszPath, pszSpec); }
52     inline LPCSTR PathSkipRootX(LPCSTR pszPath) { return PathSkipRootA(pszPath); }
53     inline LPCWSTR PathSkipRootX(LPCWSTR pszPath) { return PathSkipRootW(pszPath); }
54 
55     // non-const
56     inline void PathAddBackslashX(LPSTR pszPath) { PathAddBackslashA(pszPath); }
57     inline void PathAddBackslashX(LPWSTR pszPath) { PathAddBackslashW(pszPath); }
58     inline BOOL PathAddExtensionX(LPSTR pszPath, LPCSTR pszExt) { return PathAddExtensionA(pszPath, pszExt); }
59     inline BOOL PathAddExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return PathAddExtensionW(pszPath, pszExt); }
60     inline BOOL PathAppendX(LPSTR pszPath, LPCSTR pszMore) { return PathAppendA(pszPath, pszMore); }
61     inline BOOL PathAppendX(LPWSTR pszPath, LPCWSTR pszMore) { return PathAppendW(pszPath, pszMore); }
62     inline void PathBuildRootX(LPSTR pszRoot, int iDrive) { PathBuildRootA(pszRoot, iDrive); }
63     inline void PathBuildRootX(LPWSTR pszRoot, int iDrive) { PathBuildRootW(pszRoot, iDrive); }
64     inline void PathCanonicalizeX(LPSTR pszDst, LPCSTR pszSrc) { PathCanonicalizeA(pszDst, pszSrc); }
65     inline void PathCanonicalizeX(LPWSTR pszDst, LPCWSTR pszSrc) { PathCanonicalizeW(pszDst, pszSrc); }
66     inline void PathCombineX(LPSTR pszPathOut, LPCSTR pszPathIn, LPCSTR pszMore) { PathCombineA(pszPathOut, pszPathIn, pszMore); }
67     inline void PathCombineX(LPWSTR pszPathOut, LPCWSTR pszPathIn, LPCWSTR pszMore) { PathCombineW(pszPathOut, pszPathIn, pszMore); }
68     inline CPathT<StringType> PathCommonPrefixX(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR pszPath) { return PathCommonPrefixA(pszFile1, pszFile2, pszPath); }
69     inline CPathT<StringType> PathCommonPrefixX(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR pszPath) { return PathCommonPrefixW(pszFile1, pszFile2, pszPath); }
70     inline BOOL PathCompactPathX(HDC hDC, LPSTR pszPath, UINT dx) { return PathCompactPathA(hDC, pszPath, dx); }
71     inline BOOL PathCompactPathX(HDC hDC, LPWSTR pszPath, UINT dx) { return PathCompactPathW(hDC, pszPath, dx); }
72     inline BOOL PathCompactPathExX(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD dwFlags) { return PathCompactPathExA(pszOut, pszSrc, cchMax, dwFlags); }
73     inline BOOL PathCompactPathExX(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD dwFlags) { return PathCompactPathExW(pszOut, pszSrc, cchMax, dwFlags); }
74     inline BOOL PathMakePrettyX(LPSTR pszPath) { return PathMakePrettyA(pszPath); }
75     inline BOOL PathMakePrettyX(LPWSTR pszPath) { return PathMakePrettyW(pszPath); }
76     inline void PathQuoteSpacesX(LPSTR pszPath) { PathQuoteSpacesA(pszPath); }
77     inline void PathQuoteSpacesX(LPWSTR pszPath) { PathQuoteSpacesW(pszPath); }
78     inline BOOL PathRelativePathToX(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToA(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo); }
79     inline BOOL PathRelativePathToX(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToW(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo); }
80     inline void PathRemoveArgsX(LPSTR pszPath) { PathRemoveArgsA(pszPath); }
81     inline void PathRemoveArgsX(LPWSTR pszPath) { PathRemoveArgsW(pszPath); }
82     inline void PathRemoveBackslashX(LPSTR pszPath) { PathRemoveBackslashA(pszPath); }
83     inline void PathRemoveBackslashX(LPWSTR pszPath) { PathRemoveBackslashW(pszPath); }
84     inline void PathRemoveBlanksX(LPSTR pszPath) { PathRemoveBlanksA(pszPath); }
85     inline void PathRemoveBlanksX(LPWSTR pszPath) { PathRemoveBlanksW(pszPath); }
86     inline void PathRemoveExtensionX(LPSTR pszPath) { PathRemoveExtensionA(pszPath); }
87     inline void PathRemoveExtensionX(LPWSTR pszPath) { PathRemoveExtensionW(pszPath); }
88     inline BOOL PathRemoveFileSpecX(LPSTR pszPath) { return PathRemoveFileSpecA(pszPath); }
89     inline BOOL PathRemoveFileSpecX(LPWSTR pszPath) { return PathRemoveFileSpecW(pszPath); }
90     inline BOOL PathRenameExtensionX(LPSTR pszPath, LPCSTR pszExt) { return PathRenameExtensionA(pszPath, pszExt); }
91     inline BOOL PathRenameExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return PathRenameExtensionW(pszPath, pszExt); }
92     inline void PathStripPathX(LPSTR pszPath) { PathStripPathA(pszPath); }
93     inline void PathStripPathX(LPWSTR pszPath) { PathStripPathW(pszPath); }
94     inline BOOL PathStripToRootX(LPSTR pszPath) { return PathStripToRootA(pszPath); }
95     inline BOOL PathStripToRootX(LPWSTR pszPath) { return PathStripToRootW(pszPath); }
96     inline void PathUnquoteSpacesX(LPSTR pszPath) { PathUnquoteSpacesA(pszPath); }
97     inline void PathUnquoteSpacesX(LPWSTR pszPath) { PathUnquoteSpacesW(pszPath); }
98 
99 public:
100     typedef typename StringType::PCXSTR PCXSTR;
101     typedef typename StringType::PXSTR PXSTR;
102     typedef typename StringType::XCHAR XCHAR;
103 
104     StringType m_strPath;
105 
106     CPathT(PCXSTR pszPath)
107     {
108         m_strPath = StringType(pszPath);
109     }
110 
111     CPathT(const CPathT<StringType>& path)
112     {
113         m_strPath = path.m_strPath;
114     }
115 
116     CPathT() throw()
117     {
118         // do nothing, m_strPath initializes itself
119     }
120 
121     void AddBackslash()
122     {
123         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
124         PathAddBackslashX(str);
125         m_strPath.ReleaseBuffer();
126     }
127 
128     BOOL AddExtension(PCXSTR pszExtension)
129     {
130         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
131         BOOL result = PathAddExtensionX(str, pszExtension);
132         m_strPath.ReleaseBuffer();
133         return result;
134     }
135 
136     BOOL Append(PCXSTR pszMore)
137     {
138         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
139         BOOL result = PathAppendX(str, pszMore);
140         m_strPath.ReleaseBuffer();
141         return result;
142     }
143 
144     void BuildRoot(int iDrive)
145     {
146         PXSTR str = m_strPath.GetBuffer(4);
147         PathBuildRootX(str, iDrive);
148         m_strPath.ReleaseBuffer();
149     }
150 
151     void Canonicalize()
152     {
153         StringType strTemp;
154         PXSTR str = strTemp.GetBuffer(MAX_PATH);
155         PathCanonicalizeX(str, m_strPath);
156         strTemp.ReleaseBuffer();
157         m_strPath = strTemp;
158     }
159 
160     void Combine(PCXSTR pszDir, PCXSTR pszFile)
161     {
162         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
163         PathCombineX(str, pszDir, pszFile);
164         m_strPath.ReleaseBuffer();
165     }
166 
167     CPathT<StringType> CommonPrefix(PCXSTR pszOther)
168     {
169         StringType result;
170         result.SetString(m_strPath, PathCommonPrefixX(m_strPath, pszOther, NULL));
171         return result;
172     }
173 
174     BOOL CompactPath(HDC hDC, UINT nWidth)
175     {
176         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
177         BOOL result = PathCompactPathX(hDC, str, nWidth);
178         m_strPath.ReleaseBuffer();
179         return result;
180     }
181 
182     BOOL CompactPathEx(UINT nMaxChars, DWORD dwFlags = 0)
183     {
184         StringType strTemp;
185         PXSTR str = strTemp.GetBuffer(nMaxChars);
186         BOOL result = PathCompactPathExX(str, m_strPath, nMaxChars, dwFlags);
187         strTemp.ReleaseBuffer();
188         m_strPath = strTemp;
189         return result;
190     }
191 
192     BOOL FileExists() const
193     {
194         return PathFileExistsX(m_strPath);
195     }
196 
197     int FindExtension() const
198     {
199         return PathFindExtensionX(m_strPath);
200     }
201 
202     int FindFileName() const
203     {
204         return PathFindFileNameX(m_strPath);
205     }
206 
207     int GetDriveNumber() const
208     {
209         return PathGetDriveNumberX(m_strPath);
210     }
211 
212     StringType GetExtension() const
213     {
214         return StringType(PathFindExtensionX(m_strPath));
215     }
216 
217     BOOL IsDirectory() const
218     {
219         return PathIsDirectoryX(m_strPath);
220     }
221 
222     BOOL IsFileSpec() const
223     {
224         return PathIsFileSpecX(m_strPath);
225     }
226 
227     BOOL IsPrefix(PCXSTR pszPrefix) const
228     {
229         return PathIsPrefixX(m_strPath);
230     }
231 
232     BOOL IsRelative() const
233     {
234         return PathIsRelativeX(m_strPath);
235     }
236 
237     BOOL IsRoot() const
238     {
239         return PathIsRootX(m_strPath);
240     }
241 
242     BOOL IsSameRoot(PCXSTR pszOther) const
243     {
244         return PathIsSameRootX(m_strPath, pszOther);
245     }
246 
247     BOOL IsUNC() const
248     {
249         return PathIsUNCX(m_strPath);
250     }
251 
252     BOOL IsUNCServer() const
253     {
254         return PathIsUNCServerX(m_strPath);
255     }
256 
257     BOOL IsUNCServerShare() const
258     {
259         return PathIsUNCServerShareX(m_strPath);
260     }
261 
262     BOOL MakePretty()
263     {
264         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
265         BOOL result = PathMakePrettyX(str);
266         m_strPath.ReleaseBuffer();
267         return result;
268     }
269 
270     BOOL MatchSpec(PCXSTR pszSpec) const
271     {
272         return PathMatchSpecX(m_strPath, pszSpec);
273     }
274 
275     void QuoteSpaces()
276     {
277         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
278         PathQuoteSpacesX(str);
279         m_strPath.ReleaseBuffer();
280     }
281 
282     BOOL RelativePathTo(PCXSTR pszFrom, DWORD dwAttrFrom, PCXSTR pszTo, DWORD dwAttrTo)
283     {
284         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
285         BOOL result = PathRelativePathToX(str, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
286         m_strPath.ReleaseBuffer();
287         return result;
288     }
289 
290     void RemoveArgs()
291     {
292         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
293         PathRemoveArgsX(str);
294         m_strPath.ReleaseBuffer();
295     }
296 
297     void RemoveBackslash()
298     {
299         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
300         PathRemoveBackslashX(str);
301         m_strPath.ReleaseBuffer();
302     }
303 
304     void RemoveBlanks()
305     {
306         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
307         PathRemoveBlanksX(str);
308         m_strPath.ReleaseBuffer();
309     }
310 
311     void RemoveExtension()
312     {
313         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
314         PathRemoveExtensionX(str);
315         m_strPath.ReleaseBuffer();
316     }
317 
318     BOOL RemoveFileSpec()
319     {
320         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
321         BOOL result = PathRemoveFileSpecX(str);
322         m_strPath.ReleaseBuffer();
323         return result;
324     }
325 
326     BOOL RenameExtension(PCXSTR pszExtension)
327     {
328         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
329         BOOL result = PathRenameExtensionX(str, pszExtension);
330         m_strPath.ReleaseBuffer();
331         return result;
332     }
333 
334     int SkipRoot() const
335     {
336         return PathSkipRootX(m_strPath);
337     }
338 
339     void StripPath()
340     {
341         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
342         PathStripPathX(str);
343         m_strPath.ReleaseBuffer();
344     }
345 
346     BOOL StripToRoot()
347     {
348         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
349         BOOL result = PathStripToRootX(str);
350         m_strPath.ReleaseBuffer();
351         return result;
352     }
353 
354     void UnquoteSpaces()
355     {
356         PXSTR str = m_strPath.GetBuffer(MAX_PATH);
357         PathUnquoteSpacesX(str);
358         m_strPath.ReleaseBuffer();
359     }
360 
361     operator const StringType&() const throw()
362     {
363         return m_strPath;
364     }
365 
366     operator PCXSTR() const throw()
367     {
368         return m_strPath;
369     }
370 
371     operator StringType&() throw()
372     {
373         return m_strPath;
374     }
375 
376     CPathT<StringType>& operator+=(PCXSTR pszMore)
377     {
378         m_strPath += pszMore;
379     }
380 
381 };
382 
383 typedef CPathT<CString> CPath;
384 typedef CPathT<CStringA> CPathA;
385 typedef CPathT<CStringW> CPathW;
386 
387 }  // namespace ATL
388 
389 #endif
390