src/OpenFOAM/primitives/strings/fileName/fileName.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::fileName
  26
  27 Description
  28     A class for handling file names.
  29
  30     A fileName is a string of characters without whitespace or quotes.
  31     A fileName can be
  32       - constructed from a char*, a string or a word
  33       - concatenated by adding a '/' separator
  34       - decomposed into the path, name or component list
  35       - interrogated for type and access mode
  36
  37     The string::expand() method expands environment variables, etc,
  38
  39 SourceFiles
  40     fileName.C
  41     fileNameIO.C
  42
  43 \*---------------------------------------------------------------------------*/
  44
  45 #ifndef fileName_H
  46 #define fileName_H
  47
  48 #include "word.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 template<class T> class List;
  56 typedef List<word> wordList;
  57
  58 // Forward declaration of friend functions and operators
  59
  60 class fileName;
  61
  62 Istream& operator>>(Istream&, fileName&);
  63 Ostream& operator<<(Ostream&, const fileName&);
  64
  65
  66 /*---------------------------------------------------------------------------*\
  67                           Class fileName Declaration
  68 \*---------------------------------------------------------------------------*/
  69
  70 class fileName
  71 :
  72     public string
  73 {
  74     // Private Member Functions
  75
  76         //- Strip invalid characters
  77         inline void stripInvalid();
  78
  79
  80 public:
  81
  82     //- Enumerations to handle file types and modes.
  83     enum Type
  84     {
  85         UNDEFINED,
  86         FILE,
  87         DIRECTORY,
  88         LINK
  89     };
  90
  91
  92     // Static data members
  93
  94         static const char* const typeName;
  95         static int debug;
  96
  97         //- An empty fileName
  98         static const fileName null;
  99
 100
 101     // Constructors
 102
 103         //- Construct null
 104         inline fileName();
 105
 106         //- Construct as copy
 107         inline fileName(const fileName&);
 108
 109         //- Construct as copy of word
 110         inline fileName(const word&);
 111
 112         //- Construct as copy of string
 113         inline fileName(const string&);
 114
 115         //- Construct as copy of std::string
 116         inline fileName(const std::string&);
 117
 118         //- Construct as copy of character array
 119         inline fileName(const char*);
 120
 121         //- Construct by concatenating elements of wordList separated by '/'
 122         explicit fileName(const wordList&);
 123
 124         //- Construct from Istream
 125         fileName(Istream&);
 126
 127
 128     // Member functions
 129
 130         //- Is this character valid for a fileName?
 131         inline static bool valid(char);
 132
 133         //- Cleanup file name
 134         //  eg, remove repeated slashes, etc.
 135         bool clean();
 136
 137         //- Cleanup file name
 138         //  eg, remove repeated slashes, etc.
 139         fileName clean() const;
 140
 141
 142         // Interrogation
 143
 144              //- Return the file type: FILE, DIRECTORY or UNDEFINED
 145              Type type() const;
 146
 147              //- Return true if file name is absolute
 148              bool isAbsolute() const;
 149
 150
 151         // Decomposition
 152
 153             //- Return file name (part beyond last /)
 154             word name() const;
 155
 156             //- Return file name, optionally without extension
 157             word name(const bool noExt) const;
 158
 159             //- Return directory path name (part before last /)
 160             fileName path() const;
 161
 162             //- Return file name without extension (part before last .)
 163             fileName lessExt() const;
 164
 165             //- Return file name extension (part after last .)
 166             word ext() const;
 167
 168             //- Return path components as wordList
 169             wordList components(const char delimiter='/') const;
 170
 171             //- Return a single component of the path
 172             word component(const size_type, const char delimiter='/') const;
 173
 174
 175     // Member operators
 176
 177         // Assignment
 178
 179             const fileName& operator=(const fileName&);
 180             const fileName& operator=(const word&);
 181             const fileName& operator=(const string&);
 182             const fileName& operator=(const std::string&);
 183             const fileName& operator=(const char*);
 184
 185
 186     // IOstream operators
 187
 188         friend Istream& operator>>(Istream&, fileName&);
 189         friend Ostream& operator<<(Ostream&, const fileName&);
 190 };
 191
 192
 193 //- Assemble words and fileNames as pathnames by adding a '/' separator
 194 fileName operator/(const string&, const string&);
 195
 196
 197 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 198
 199 } // End namespace Foam
 200
 201 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 202
 203 #include "fileNameI.H"
 204
 205 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 206
 207 #endif
 208
 209 // ************************************************************************* //