Skip to content
Snippets Groups Projects
int64.H 5.16 KiB
Newer Older
  • Learn to ignore specific revisions
  • /*---------------------------------------------------------------------------*\
      =========                 |
      \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
       \\    /   O peration     |
    
        \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
    
         \\/     M anipulation  |
    -------------------------------------------------------------------------------
                                | Copyright (C) 2014-2016 OpenFOAM Foundation
    
    -------------------------------------------------------------------------------
    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/>.
    
        int64.C
        int64IO.C
    
    
    \*---------------------------------------------------------------------------*/
    
    
    #ifndef int64_H
    #define int64_H
    
    
    #include <climits>
    #include <cstdlib>
    
    #include "pTraits.H"
    #include "direction.H"
    
    
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    namespace Foam
    {
    
    class Istream;
    class Ostream;
    
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    
    //- A word representation of int64 value
    
    inline word name(const int64_t val)
    {
    
        return word(std::to_string(val), false); // Needs no stripping
    
    //- A word representation of int64 value
    template<>
    struct nameOp<int64_t>
    {
        inline word operator()(const int64_t val) const
        {
            return word(std::to_string(val), false); // Needs no stripping
        }
    };
    
    
    
    // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
    
    
    //- Read int64_t from stream
    int64_t readInt64(Istream& is);
    
    //- Parse entire buffer as a int64_t, skipping leading/trailing whitespace.
    //  \return Parsed value or FatalIOError on any problem
    int64_t readInt64(const char* buf);
    
    //- Parse entire string as a int64_t, skipping leading/trailing whitespace.
    //  \return Parsed value or FatalIOError on any problem
    inline int64_t readInt64(const std::string& str)
    {
        return readInt64(str.c_str());
    }
    
    //- Read entire buffer as a int64_t, skipping leading/trailing whitespace.
    //  \return True if successful.
    bool readInt64(const char* buf, int64_t& val);
    
    //- Read entire string as a int64_t, skipping leading/trailing whitespace.
    //  \return True if successful.
    inline bool readInt64(const std::string& str, int64_t& val)
    {
        return readInt64(str.c_str(), val);
    }
    
    //- Same as readInt64
    //  \return True if successful.
    inline bool read(const char* buf, int64_t& val)
    {
        return readInt64(buf, val);
    }
    
    //- Same as readInt64
    //  \return True if successful.
    inline bool read(const std::string& str, int64_t& val)
    {
        return readInt64(str, val);
    }
    
    
    Istream& operator>>(Istream& is, int64_t& val);
    Ostream& operator<<(Ostream& os, const int64_t val);
    
    // long is not unambiguously (int32_t | int64_t)
    
    // - explicitly resolve for input and output
    
        Istream& operator>>(Istream& is, long& val);
    
        Ostream& operator<<(Ostream& os, const long val);
    #endif
    
    
    
    //- Template specialization for pTraits<int64_t>
    
    template<>
    class pTraits<int64_t>
    {
        int64_t p_;
    
    public:
    
        //- Component type
        typedef int64_t cmptType;
    
    
        //- Magnitude type
        typedef int64_t magType;
    
    
        // Member constants
    
    
            static constexpr direction dim = 3;
    
            static constexpr direction rank = 0;
    
    
            //- Number of components in int64_t is 1
    
            static constexpr direction nComponents = 1;
    
    
    
        // Static data members
    
            static const char* const typeName;
    
            static const char* const componentNames[];
    
            static const int64_t zero;
            static const int64_t one;
            static const int64_t min;
            static const int64_t max;
            static const int64_t rootMax;
            static const int64_t rootMin;
    
    
        // Constructors
    
    
            //- Copy construct from primitive
    
            explicit pTraits(const int64_t& val);
    
            //- Read construct from Istream
    
            //- Access to the value
    
            operator int64_t() const
            {
                return p_;
            }
    
    
            //- Access to the value
    
            operator int64_t&()
            {
                return p_;
            }
    };
    
    
    inline int64_t mag(const int64_t val)
    
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    } // End namespace Foam
    
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    #endif
    
    // ************************************************************************* //