Commit ea4c8f4b authored by Mark Olesen's avatar Mark Olesen
Browse files

ENH: boolVector for specialized bundling of boolean values

- bundled of boolean values as a vector of 3 components with
  element access using x(), y() and z() member functions.
  It also has some methods similar to bitSet.

- Not derived from Vector or VectorSpace since it does not share very
  many vector-like characteristics.
parent bc9e97cf
Test-boolVector.C
EXE = $(FOAM_USER_APPBIN)/Test-boolVector
/* EXE_INC = */
/* EXE_LIBS = */
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 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/>.
Application
Test-boolVector
Description
Some simple tests for boolVector
\*---------------------------------------------------------------------------*/
#include "boolVector.H"
#include "IOstreams.H"
#include "Switch.H"
using namespace Foam;
void print(const boolVector& v)
{
Info<< v
<< " any:" << Switch::name(v.any())
<< " all:" << Switch::name(v.all())
<< " none:" << Switch::name(v.none())
<< " count:" << v.count() << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
Info<< "boolVector" << nl
<< " size = " << boolVector::size() << nl
<< " contiguous = " << is_contiguous<boolVector>::value << nl
<< nl;
{
boolVector vec;
Info<< "null: " << vec << nl;
}
Info<< "false: " << boolVector(false) << nl;
Info<< "true: " << boolVector(true) << nl;
Info<< "zero: " << boolVector(Zero) << nl;
Info<< nl;
{
boolVector vec{1, 0, 1};
print(vec);
vec.flip();
print(vec);
vec = false;
print(vec);
vec = true;
print(vec);
}
Info<< "\nEnd\n" << nl;
return 0;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 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::boolVector
Description
Specialized bundling of boolean values as a vector of 3 components,
element access using x(), y() and z() member functions.
It also has some methods similar to bitSet.
Note
The boolVector is not derived from Vector or VectorSpace since
it does not share very many vector-like characteristics.
SourceFiles
boolVectorI.H
\*---------------------------------------------------------------------------*/
#ifndef boolVector_H
#define boolVector_H
#include "FixedList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class boolVector Declaration
\*---------------------------------------------------------------------------*/
class boolVector
:
public FixedList<bool, 3>
{
public:
// Member Constants
//- Rank of a vector is 1
static constexpr direction rank = 1;
//- Component labeling enumeration
enum components { X, Y, Z };
// Generated Methods
//- Copy construct
boolVector(const boolVector&) = default;
//- Copy assignment
boolVector& operator=(const boolVector&) = default;
//- Move construct
boolVector(boolVector&&) = default;
//- Move assignment
boolVector& operator=(boolVector&&) = default;
// Constructors
//- Default construct, zero-initialized (ie, false)
inline boolVector();
//- Uniform construct with specified value
inline explicit boolVector(const bool val);
//- Construct from three components
inline boolVector(const bool vx, const bool vy, const bool vz);
//- Construct from Istream
inline explicit boolVector(Istream& is);
// Member Functions
// Query
//- True if all components are set
//
// \note Method name compatibility with bitSet
inline bool all() const;
//- True if any components are set
//
// \note Method name compatibility with bitSet
inline bool any() const;
//- True if no components are set
//
// \note Method name compatibility with bitSet
inline bool none() const;
//- Count number of items set.
// \param on can be set to false to count the number of unset bits
// instead.
//
// \note Method name compatibility with bitSet
inline unsigned int count(const bool on=true) const;
// Access
//- The x component
inline bool x() const;
//- The y component
inline bool y() const;
//- The z component
inline bool z() const;
//- The x component
inline bool& x();
//- The y component
inline bool& y();
//- The z component
inline bool& z();
// Edit
//- Invert all values
//
// \note Method name compatibility with bitSet
inline void flip();
// Operators
//- Assignment of all entries to the given value
inline void operator=(const bool value);
};
// * * * * * * * * * * * * * * * * * Traits * * * * * * * * * * * * * * * * //
//- A boolVector is contiguous (FixedList of bool)
template<> struct is_contiguous<boolVector> : std::true_type {};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "boolVectorI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
inline Foam::boolVector::boolVector()
:
FixedList<bool, 3>(false)
{}
inline Foam::boolVector::boolVector(const bool val)
:
FixedList<bool, 3>(val)
{}
inline Foam::boolVector::boolVector
(
const bool vx,
const bool vy,
const bool vz
)
:
FixedList<bool, 3>()
{
x() = vx;
y() = vy;
z() = vz;
}
inline Foam::boolVector::boolVector(Istream& is)
:
FixedList<bool, 3>(is)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool Foam::boolVector::all() const
{
for (const bool val : *this)
{
if (!val) return false;
}
return true;
}
inline bool Foam::boolVector::any() const
{
for (const bool val : *this)
{
if (val) return true;
}
return false;
}
inline bool Foam::boolVector::none() const
{
return !any();
}
inline unsigned int Foam::boolVector::count(const bool on) const
{
unsigned int total = 0;
for (const bool val : *this)
{
if (val) ++total;
}
if (!on)
{
// Return the number of bits that are OFF.
return (3u - total);
}
return total;
}
inline bool Foam::boolVector::x() const { return operator[](boolVector::X); }
inline bool Foam::boolVector::y() const { return operator[](boolVector::Y); }
inline bool Foam::boolVector::z() const { return operator[](boolVector::Z); }
inline bool& Foam::boolVector::x() { return operator[](boolVector::X); }
inline bool& Foam::boolVector::y() { return operator[](boolVector::Y); }
inline bool& Foam::boolVector::z() { return operator[](boolVector::Z); }
inline void Foam::boolVector::flip()
{
for (bool& val : *this)
{
val = !val;
}
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
inline void Foam::boolVector::operator=(const bool value)
{
FixedList<bool, 3>::operator=(value);
}
// ************************************************************************* //
  • Author Maintainer

    @vaggelisp - FYI: I also put this in for you (eg, NURBS3DVolume).

    Figured that it makes sense to have a List<boolVector> instead. It will also make it a bit more natural if you can use x(), y(), z() accessors. There are some additional methods such as all(), any(), none() for convenience.

    Let me know if there are any others that would be useful.

    /mark

  • Hi @mark

    This look very handy, thanks! I'll update NURBS3DVolume soon, but possibly after v2006 since things are a bit tight at the moment. If I think of something like this that would be useful, I'll let you know.

  • Author Maintainer

    yes definitely not for v2006 release (not a bug in the existing code), but figured I would jot it down here before forgetting.

    Edited by Mark Olesen
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment