[REACTOS] Fix 64 bit issues
[reactos.git] / sdk / lib / atl / atlpath.h
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 int PathFindExtensionX(LPCSTR pszPath) { return PathFindExtensionA(pszPath); }
27 inline int PathFindExtensionX(LPCWSTR pszPath) { return PathFindExtensionW(pszPath); }
28 inline int PathFindFileNameX(LPCSTR pszPath) { return PathFindFileNameA(pszPath); }
29 inline int 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 int PathSkipRootX(LPCSTR pszPath) { return PathSkipRootA(pszPath); }
53 inline int 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