cosv/source/storage/plocroot.cxx

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