Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #define CSV_USE_CSV_ASSERTIONS
21 : #include <cosv/csv_env.hxx>
22 :
23 : #include <cosv/comfunc.hxx>
24 : #include <cosv/string.hxx>
25 : #include <cosv/streamstr.hxx>
26 : #include <cosv/std_outp.hxx>
27 : #include <cosv/tpl/dyn.hxx>
28 : #include <cosv/ploc.hxx>
29 :
30 : // NOT FULLY DECLARED SERVICES
31 : #include <ctype.h>
32 : #include <cosv/bstream.hxx>
33 : #include <cosv/csv_ostream.hxx>
34 :
35 :
36 : namespace csv
37 : {
38 : namespace ploc
39 : {
40 :
41 :
42 0 : class UnixRootDir : public Root
43 : {
44 : public:
45 : UnixRootDir();
46 :
47 : virtual void Get(
48 : ostream & o_rPath ) const;
49 : virtual void Get(
50 : bostream & o_rPath ) const;
51 : virtual DYN Root * CreateCopy() const;
52 : virtual const char *
53 : OwnDelimiter() const;
54 : };
55 :
56 40100 : class WorkingDir : public Root
57 : {
58 : public:
59 : WorkingDir(
60 : const char * i_sDelimiter = Delimiter() );
61 :
62 : virtual void Get(
63 : ostream & o_rPath ) const;
64 : virtual void Get(
65 : bostream & o_rPath ) const;
66 : virtual DYN Root * CreateCopy() const;
67 : virtual const char *
68 : OwnDelimiter() const;
69 : private:
70 : String sOwnDelimiter;
71 : };
72 :
73 0 : class WinRootDir : public Root
74 : {
75 : public:
76 : WinRootDir();
77 :
78 : virtual void Get(
79 : ostream & o_rPath ) const;
80 : virtual void Get(
81 : bostream & o_rPath ) const;
82 : virtual DYN Root * CreateCopy() const;
83 : virtual const char *
84 : OwnDelimiter() const;
85 : };
86 :
87 0 : class WinDrive : public Root
88 : {
89 : public:
90 : WinDrive(
91 : char i_cDrive );
92 : virtual void Get(
93 : ostream & o_rPath ) const;
94 : virtual void Get(
95 : bostream & o_rPath ) const;
96 : virtual DYN Root * CreateCopy() const;
97 : virtual const char *
98 : OwnDelimiter() const;
99 : private:
100 : char cDrive;
101 : };
102 :
103 0 : class WinDriveRootDir : public Root
104 : {
105 : public:
106 : WinDriveRootDir(
107 : const char * i_sPath );
108 : WinDriveRootDir(
109 : char i_cDrive );
110 :
111 : virtual void Get(
112 : ostream & o_rPath ) const;
113 : virtual void Get(
114 : bostream & o_rPath ) const;
115 : virtual DYN Root * CreateCopy() const;
116 : virtual const char *
117 : OwnDelimiter() const;
118 : private:
119 : char cDrive;
120 : };
121 :
122 0 : class UNCRoot : public Root
123 : {
124 : public:
125 : UNCRoot(
126 : const char * i_sPath );
127 : UNCRoot(
128 : const String & i_sComputer,
129 : const String & i_sEntryPt );
130 :
131 : virtual void Get(
132 : ostream & o_rPath ) const;
133 : virtual void Get(
134 : bostream & o_rPath ) const;
135 : virtual DYN Root * CreateCopy() const;
136 : virtual const char *
137 : OwnDelimiter() const;
138 : private:
139 : String sComputer;
140 : String sEntryPt;
141 : };
142 :
143 0 : class InvalidRoot : public Root
144 : {
145 : public:
146 : virtual void Get(
147 : ostream & o_rPath ) const;
148 : virtual void Get(
149 : bostream & o_rPath ) const;
150 : virtual DYN Root * CreateCopy() const;
151 : virtual const char *
152 : OwnDelimiter() const;
153 : };
154 :
155 :
156 : DYN Root *
157 0 : Create_WindowsRoot( const char * & o_sPathAfterRoot,
158 : const char * i_sPath )
159 : {
160 0 : if (i_sPath[0] == '\\')
161 : {
162 0 : if (i_sPath[1] == '\\')
163 : { // UNC path name
164 0 : o_sPathAfterRoot = strchr(i_sPath+2,'\\');
165 0 : if (o_sPathAfterRoot != 0)
166 : {
167 0 : o_sPathAfterRoot = strchr(o_sPathAfterRoot+1,'\\');
168 0 : if (o_sPathAfterRoot != 0)
169 0 : ++o_sPathAfterRoot;
170 0 : return new UNCRoot(i_sPath);
171 : }
172 0 : return new InvalidRoot; // Incomplete UNC root.
173 : }
174 : else
175 : {
176 0 : o_sPathAfterRoot = i_sPath+1;
177 0 : return new WinRootDir;
178 : }
179 : }
180 0 : else if (i_sPath[1] == ':')
181 : {
182 0 : if ( i_sPath[2] == '\\')
183 : {
184 0 : o_sPathAfterRoot = i_sPath + 3;
185 0 : return new WinDriveRootDir(i_sPath);
186 : }
187 : else
188 : {
189 0 : o_sPathAfterRoot = i_sPath + 2;
190 0 : return new WinDrive(*i_sPath);
191 : }
192 : }
193 : else
194 : {
195 0 : o_sPathAfterRoot = i_sPath;
196 0 : return new WorkingDir("\\");
197 : }
198 : }
199 :
200 : DYN Root *
201 1 : Create_UnixRoot( const char * & o_sPathAfterRoot,
202 : const char * i_sPath )
203 : {
204 1 : if (*i_sPath == '/')
205 : {
206 0 : o_sPathAfterRoot = i_sPath + 1;
207 0 : return new UnixRootDir;
208 : }
209 : else //
210 : {
211 1 : o_sPathAfterRoot = i_sPath;
212 1 : return new WorkingDir("/");
213 : } // endif
214 : }
215 :
216 :
217 : //********************** Root ****************************//
218 :
219 20050 : Root::~Root()
220 : {
221 :
222 20050 : }
223 :
224 : DYN Root *
225 19925 : Root::Create_( const char * & o_sPathAfterRoot,
226 : const char * i_sPath,
227 : const char * i_sDelimiter )
228 : {
229 19925 : if (i_sPath[0] == '.')
230 : {
231 19924 : switch ( i_sPath[1] )
232 : {
233 3 : case '\0': o_sPathAfterRoot = i_sPath + 1;
234 3 : break;
235 0 : case '\\': o_sPathAfterRoot = i_sPath + 2;
236 0 : break;
237 19800 : case '/': o_sPathAfterRoot = i_sPath + 2;
238 19800 : break;
239 121 : case '.': o_sPathAfterRoot = i_sPath;
240 121 : break;
241 : default:
242 0 : o_sPathAfterRoot = 0;
243 0 : return new InvalidRoot;
244 : } // end switch (i_sPath[1])
245 :
246 19924 : return new WorkingDir;
247 : } // end if (i_sPath[0] == '.')
248 :
249 1 : switch (*i_sDelimiter)
250 : {
251 0 : case '\\': return Create_WindowsRoot(o_sPathAfterRoot, i_sPath);
252 1 : case '/': return Create_UnixRoot(o_sPathAfterRoot, i_sPath);
253 : }
254 :
255 0 : o_sPathAfterRoot = 0;
256 0 : return new InvalidRoot;
257 : }
258 :
259 :
260 :
261 : //********************** UnixRootDir ****************************//
262 :
263 :
264 0 : UnixRootDir::UnixRootDir()
265 : {
266 0 : }
267 :
268 : void
269 0 : UnixRootDir::Get( ostream & o_rPath ) const
270 : {
271 0 : o_rPath << '/';
272 0 : }
273 :
274 : void
275 0 : UnixRootDir::Get( bostream & o_rPath ) const
276 : {
277 0 : o_rPath.write( "/", 1 );
278 0 : }
279 :
280 : DYN Root *
281 0 : UnixRootDir::CreateCopy() const
282 : {
283 0 : return new UnixRootDir;
284 : }
285 :
286 : const char *
287 0 : UnixRootDir::OwnDelimiter() const
288 : {
289 0 : return "/";
290 : }
291 :
292 :
293 : //********************** WorkingDir ****************************//
294 :
295 20050 : WorkingDir::WorkingDir( const char * i_sDelimiter )
296 20050 : : sOwnDelimiter(i_sDelimiter)
297 : {
298 20050 : }
299 :
300 : void
301 0 : WorkingDir::Get( ostream & o_rPath ) const
302 : {
303 0 : o_rPath << '.' << sOwnDelimiter;
304 0 : }
305 :
306 : void
307 28113 : WorkingDir::Get( bostream & o_rPath ) const
308 : {
309 28113 : o_rPath.write( ".", 1 );
310 28113 : o_rPath.write( sOwnDelimiter );
311 28113 : }
312 :
313 : DYN Root *
314 125 : WorkingDir::CreateCopy() const
315 : {
316 125 : return new WorkingDir(sOwnDelimiter);
317 : }
318 :
319 : const char *
320 56226 : WorkingDir::OwnDelimiter() const
321 : {
322 56226 : return sOwnDelimiter;
323 : }
324 :
325 :
326 : //********************** WinRootDir ****************************//
327 :
328 0 : WinRootDir::WinRootDir()
329 : {
330 0 : }
331 :
332 : void
333 0 : WinRootDir::Get( ostream & o_rPath ) const
334 : {
335 0 : o_rPath << '\\';
336 0 : }
337 :
338 : void
339 0 : WinRootDir::Get( bostream & o_rPath ) const
340 : {
341 0 : o_rPath.write( "\\", 1 );
342 0 : }
343 :
344 : DYN Root *
345 0 : WinRootDir::CreateCopy() const
346 : {
347 0 : return new WinRootDir;
348 : }
349 :
350 : const char *
351 0 : WinRootDir::OwnDelimiter() const
352 : {
353 0 : return "\\";
354 : }
355 :
356 :
357 : //********************** WinDrive ****************************//
358 :
359 0 : WinDrive::WinDrive( char i_cDrive )
360 0 : : cDrive(static_cast< char >(toupper(i_cDrive)))
361 : {
362 0 : }
363 :
364 : void
365 0 : WinDrive::Get( ostream & o_rPath ) const
366 : {
367 0 : o_rPath << cDrive << ':';
368 0 : }
369 :
370 : void
371 0 : WinDrive::Get( bostream & o_rPath ) const
372 : {
373 : static char buf_[3] = " :";
374 0 : buf_[0] = cDrive;
375 0 : o_rPath.write( &buf_[0], 2 );
376 0 : }
377 :
378 : DYN Root *
379 0 : WinDrive::CreateCopy() const
380 : {
381 0 : return new WinDrive(cDrive);
382 : }
383 :
384 : const char *
385 0 : WinDrive::OwnDelimiter() const
386 : {
387 0 : return "\\";
388 : }
389 :
390 :
391 : //********************** WinDriveRootDir ****************************//
392 :
393 0 : WinDriveRootDir::WinDriveRootDir( const char * i_sPath )
394 0 : : cDrive(static_cast< char >(toupper(*i_sPath)))
395 : {
396 0 : if ( 'A' > cDrive OR 'Z' < cDrive )
397 0 : cDrive = 0;
398 0 : }
399 :
400 0 : WinDriveRootDir::WinDriveRootDir( char i_cDrive )
401 0 : : cDrive(i_cDrive)
402 : {
403 0 : }
404 :
405 : void
406 0 : WinDriveRootDir::Get( ostream & o_rPath ) const
407 : {
408 0 : o_rPath << cDrive << ":\\";
409 0 : }
410 :
411 : void
412 0 : WinDriveRootDir::Get( bostream & o_rPath ) const
413 : {
414 : static char buf_[4] = " :\\";
415 0 : buf_[0] = cDrive;
416 0 : o_rPath.write( &buf_[0], 3 );
417 0 : }
418 :
419 : DYN Root *
420 0 : WinDriveRootDir::CreateCopy() const
421 : {
422 0 : return new WinDriveRootDir(cDrive);
423 : }
424 :
425 : const char *
426 0 : WinDriveRootDir::OwnDelimiter() const
427 : {
428 0 : return "\\";
429 : }
430 :
431 :
432 : //********************** UNCRoot ****************************//
433 :
434 0 : UNCRoot::UNCRoot( const char * i_sPath )
435 : // : // sComputer,
436 : // sEntryPt
437 : {
438 0 : const char * pRestPath = i_sPath + 2;
439 0 : const char * pDirEnd = strchr(pRestPath, '\\');
440 0 : csv_assert(pDirEnd != 0);
441 :
442 0 : sComputer = String(pRestPath, pDirEnd - pRestPath);
443 0 : pRestPath = pDirEnd+1;
444 0 : pDirEnd = strchr(pRestPath, '\\');
445 :
446 0 : if ( pDirEnd != 0 )
447 : {
448 0 : sEntryPt = String(pRestPath, pDirEnd - pRestPath);
449 : }
450 : else
451 : {
452 0 : sEntryPt = pRestPath;
453 : }
454 0 : }
455 :
456 0 : UNCRoot::UNCRoot( const String & i_sComputer,
457 : const String & i_sEntryPt )
458 : : sComputer(i_sComputer),
459 0 : sEntryPt(i_sEntryPt)
460 : {
461 0 : }
462 :
463 : void
464 0 : UNCRoot::Get( ostream & o_rPath ) const
465 : {
466 0 : o_rPath << "\\\\" << sComputer << '\\' << sEntryPt << "\\";
467 0 : }
468 :
469 : void
470 0 : UNCRoot::Get( bostream & o_rPath ) const
471 : {
472 0 : o_rPath.write( "\\\\", 2 );
473 0 : o_rPath.write( sComputer );
474 0 : o_rPath.write( "\\", 1 );
475 0 : o_rPath.write( sEntryPt );
476 0 : o_rPath.write( "\\", 1 );
477 0 : }
478 :
479 : DYN Root *
480 0 : UNCRoot::CreateCopy() const
481 : {
482 0 : return new UNCRoot(sComputer,sEntryPt);
483 : }
484 :
485 : const char *
486 0 : UNCRoot::OwnDelimiter() const
487 : {
488 0 : return "\\";
489 : }
490 :
491 :
492 :
493 : //********************** InvalidRoot ****************************//
494 :
495 : void
496 0 : InvalidRoot::Get( ostream & ) const
497 : {
498 0 : }
499 :
500 : void
501 0 : InvalidRoot::Get( bostream & ) const
502 : {
503 0 : }
504 :
505 : DYN Root *
506 0 : InvalidRoot::CreateCopy() const
507 : {
508 0 : return new InvalidRoot;
509 : }
510 :
511 : const char *
512 0 : InvalidRoot::OwnDelimiter() const
513 : {
514 0 : return 0;
515 : }
516 :
517 :
518 :
519 :
520 : } // namespace ploc
521 3 : } // namespace csv
522 :
523 :
524 :
525 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
