cosv/source/storage/plocroot.cxx

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