word.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2011-2016 OpenFOAM Foundation
    Copyright (C) 2017-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Class
    Foam::word

Description
    A class for handling words, derived from Foam::string.

    A word is a string of characters without whitespace, quotes, slashes,
    semicolons or brace brackets. Words are delimited by whitespace.

SourceFiles
    wordI.H
    word.C
    wordIO.C

\*---------------------------------------------------------------------------*/

#ifndef Foam_word_H
#define Foam_word_H

#include "string.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward Declarations
class word;
Istream& operator>>(Istream& is, word& val);
Ostream& operator<<(Ostream& os, const word& val);

//- Hashing for word
template<> struct Hash<word> : string::hasher {};


/*---------------------------------------------------------------------------*\
                           Class word Declaration
\*---------------------------------------------------------------------------*/

class word
:
    public string
{
public:

    // Static Data Members

        //- The typeName
        static const char* const typeName;

        //- Debugging
        static int debug;

        //- An empty word
        static const word null;


    // Constructors

        //- Default construct
        word() = default;

        //- Copy construct
        word(const word&) = default;

        //- Move construct
        word(word&& w) = default;

        //- Copy construct from Foam::string
        inline word(const string& s, bool doStrip=true);

        //- Move construct from Foam::string
        inline word(string&& s, bool doStrip=true);

        //- Copy construct from std::string
        inline word(const std::string& s, bool doStrip=true);

        //- Move construct from std::string
        inline word(std::string&& s, bool doStrip=true);

        //- Copy from character array
        inline word(const char* s, bool doStrip=true);

        //- Copy from buffer for a maximum number of characters
        inline word(const char* s, size_type len, bool doStrip);

        //- Construct from Istream
        explicit word(Istream& is);


    // Member Functions

        //- Use a printf-style formatter for a primitive.
        //  The representation is not checked for valid characters -
        //  it is assumed that the caller knows what they are doing
        template<class PrimitiveType>
        inline static word printf
        (
            const char* fmt,
            const PrimitiveType& val
        );

        //- Use a printf-style formatter for a primitive.
        //  The representation is not checked for valid characters -
        //  it is assumed that the caller knows what they are doing
        template<class PrimitiveType>
        inline static word printf
        (
            const std::string& fmt,
            const PrimitiveType& val
        );

        //- Is this character valid for a word?
        inline static bool valid(char c);

        //- Construct validated word (no invalid characters).
        //  Optionally prefix any leading digit with '_' to have words
        //  that work nicely as dictionary keywords.
        static word validate(const std::string& s, const bool prefix=false);

        //- Construct validated word (no invalid characters) from a sequence
        //- of characters in the range [first,last),
        //  Optionally prefix any leading digit with '_'.
        static word validate
        (
            const char* first,
            const char* last,
            const bool prefix=false
        );

        //- Strip invalid characters from this word
        //  Trips an abort on invalid characters for debug 2 or greater
        inline void stripInvalid();


    // File-like Functions

        //- Return file name extension (part after last .)
        inline word ext() const;

        //- Append a '.' and the ending, and return the object.
        //  The '.' and ending will not be added when the ending is empty,
        //  or when the file name is empty or ended with a '/'.
        inline word& ext(const word& ending);

        //- Remove extension (if any) and append a new one
        inline word& replace_ext(const word& ending);

        //- Return word without extension (part before last .)
        inline word lessExt() const;

        //- Remove extension, return true if string changed.
        using string::remove_ext;

        //- Various checks for extensions
        using string::has_ext;


    // Member Operators

    // Assignment

        //- Copy assignment, no character validation required.
        //  Self-assignment is a no-op
        inline word& operator=(const word& s);

        //- Move assignment, no character validation required
        //  Self-assignment is a no-op
        inline word& operator=(word&& s);

        //- Copy assignment from Foam::string, stripping invalid characters
        inline word& operator=(const string& s);

        //- Move assignment from Foam::string, stripping invalid characters
        inline word& operator=(string&& s);

        //- Copy assignment from std::string, stripping invalid characters
        inline word& operator=(const std::string& s);

        //- Move assignment from std::string, stripping invalid characters
        inline word& operator=(std::string&& s);

        //- Copy, stripping invalid characters
        inline word& operator=(const char* s);


    // Housekeeping

        //- Same as has_ext()
        bool hasExt() const { return has_ext(); }

        //- Same as has_ext()
        bool hasExt(const std::string& s) const { return has_ext(s); }

        //- Same as remove_ext()
        bool removeExt() { return remove_ext(); }
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

// IOstream Operators

//- Read operator
Istream& operator>>(Istream& is, word& val);

//- Write operator
Ostream& operator<<(Ostream& os, const word& val);


// * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * * //

//- Join words as camelCase, capitalizing the first letter of b.
//  No effect if either argument is empty.
word operator&(const word& a, const word& b);


// * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //

//- A word representation of a memory address as hexadecimal.
//  No special handling of nullptr (renders as 0x0)
word name(const void* ptr);


//- Extract name (as a word) from an object, typically using its name() method.
template<class T>
struct nameOp
{
    word operator()(const T& obj) const
    {
        return obj.name();
    }

    //- Less-compare two objects by their name() method - for sorting
    bool operator()(const T& a, const T& b) const
    {
        return (a.name() < b.name());
    }
};


//- Extract type (as a word) from an object, typically using its type() method.
template<class T>
struct typeOp
{
    word operator()(const T& obj) const
    {
        return obj.type();
    }

    //- Less-compare two objects by their type() method - for sorting
    bool operator()(const T& a, const T& b) const
    {
        return (a.type() < b.type());
    }
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "wordI.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //