int64.H 5.16 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
OpenFOAM bot's avatar
OpenFOAM bot committed
6
7
8
     \\/     M anipulation  |
-------------------------------------------------------------------------------
                            | Copyright (C) 2014-2016 OpenFOAM Foundation
9
10
11
12
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

13
14
15
16
    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.
17
18
19
20
21
22
23

    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
24
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
25
26

Primitive
27
    int64_t
28
29

Description
30
    64bit signed integer
31
32

SourceFiles
33
34
    int64.C
    int64IO.C
35
36
37

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

38
39
40
#ifndef int64_H
#define int64_H

41
#include <cstdint>
42
43
#include <climits>
#include <cstdlib>
44
45

#include "word.H"
46
47
48
#include "pTraits.H"
#include "direction.H"

49
50
51
52
53
54
55
56
57
58
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

class Istream;
class Ostream;

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

59
//- A word representation of int64 value
60
61
inline word name(const int64_t val)
{
62
    return word(std::to_string(val), false); // Needs no stripping
63
64
65
}


66
67
68
69
70
71
72
73
74
75
76
//- 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
    }
};


77
78
// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //

79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//- 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);
121

122
// On Darwin:
123
// long is not unambiguously (int32_t | int64_t)
124
// - explicitly resolve for input and output
125
#if defined(__APPLE__)
126
    Istream& operator>>(Istream& is, long& val);
127
128
129
130
    Ostream& operator<<(Ostream& os, const long val);
#endif


131
//- Template specialization for pTraits<int64_t>
132
133
134
135
136
137
138
139
140
141
template<>
class pTraits<int64_t>
{
    int64_t p_;

public:

    //- Component type
    typedef int64_t cmptType;

142
143
144
    //- Magnitude type
    typedef int64_t magType;

145

146
147
    // Member constants

148
        //- Dimensionality of space
149
        static constexpr direction dim = 3;
150
151

        //- Rank of int64_t is 0
152
        static constexpr direction rank = 0;
153
154

        //- Number of components in int64_t is 1
155
        static constexpr direction nComponents = 1;
156
157
158
159
160


    // Static data members

        static const char* const typeName;
161
        static const char* const componentNames[];
162
163
164
165
166
167
168
169
170
171
        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

172
        //- Copy construct from primitive
173
        explicit pTraits(const int64_t& val);
174

175
        //- Read construct from Istream
176
        pTraits(Istream& is);
177
178
179
180


    // Member Functions

181
        //- Access to the value
182
183
184
185
186
        operator int64_t() const
        {
            return p_;
        }

187
        //- Access to the value
188
189
190
191
192
193
        operator int64_t&()
        {
            return p_;
        }
};

194

195
inline int64_t mag(const int64_t val)
196
{
197
    return ::labs(val);
198
199
200
}


201
202
203
204
205
206
207
208
209
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

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

#endif

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