Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:44
📄 bool_set // TR2 <bool_set> -- C++ -- // Copyright (C) 2009-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/bool_set * This is a TR2 C++ Library header. / #ifndef _GLIBCXX_TR2_BOOL_SET #define _GLIBCXX_TR2_BOOL_SET 1 #pragma GCC system_header #include <typeinfo> #include <iostream> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { /* * bool_set * * See N2136, Bool_set: multi-valued logic * by Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion. * * The implicit conversion to bool is slippery! I may use the new * explicit conversion. This has been specialized in the language * so that in contexts requiring a bool the conversion happens * implicitly. Thus most objections should be eliminated. */ class bool_set { public: /// Default constructor. constexpr bool_set() : _M_b(_S_false) { } /// Constructor from bool. constexpr bool_set(bool __t) : _M_b(_Bool_set_val(__t)) { } // I'm not sure about this. bool contains(bool_set __b) const { return this->is_singleton() && this->equals(__b); } /// Return true if states are equal. bool equals(bool_set __b) const { return __b._M_b == _M_b; } /// Return true if this is empty. bool is_emptyset() const { return _M_b == _S_empty; } /// Return true if this is indeterminate. bool is_indeterminate() const { return _M_b == _S_indet; } /// Return true if this is false or true (normal boolean). bool is_singleton() const { return _M_b == _S_false \|\| _M_b == _S_true_; } /// Conversion to bool. //explicit operator bool() const { if (! is_singleton()) throw std::bad_cast(); return _M_b; } /// static bool_set indeterminate() { bool_set __b; __b._M_b = _S_indet; return __b; } /// static bool_set emptyset() { bool_set __b; __b._M_b = _S_empty; return __b; } friend bool_set operator!(bool_set __b) { return __b._M_not(); } friend bool_set operator^(bool_set __s, bool_set __t) { return __s._M_xor(__t); } friend bool_set operator\|(bool_set __s, bool_set __t) { return __s._M_or(__t); } friend bool_set operator&(bool_set __s, bool_set __t) { return __s._M_and(__t); } friend bool_set operator==(bool_set __s, bool_set __t) { return __s._M_eq(__t); } // These overloads replace the facet additions in the paper! template<typename CharT, typename Traits> friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& __out, bool_set __b) { int __a = __b._M_b; __out << __a; } template<typename CharT, typename Traits> friend std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& __in, bool_set& __b) { long __c; __in >> __c; if (__c >= _S_false && __c < _S_empty) __b._M_b = static_cast<_Bool_set_val>(__c); } private: /// enum _Bool_set_val: unsigned char { _S_false = 0, _S_true_ = 1, _S_indet = 2, _S_empty = 3 }; /// Bool set state. _Bool_set_val _M_b; /// bool_set(_Bool_set_val __c) : _M_b(__c) { } /// bool_set _M_not() const { return _S_not[this->_M_b]; } /// bool_set _M_xor(bool_set __b) const { return _S_xor[this->_M_b][__b._M_b]; } /// bool_set _M_or(bool_set __b) const { return _S_or[this->_M_b][__b._M_b]; } /// bool_set _M_and(bool_set __b) const { return _S_and[this->_M_b][__b._M_b]; } /// bool_set _M_eq(bool_set __b) const { return _S_eq[this->_M_b][__b._M_b]; } /// static _Bool_set_val _S_not[4]; /// static _Bool_set_val _S_xor[4][4]; /// static _Bool_set_val _S_or[4][4]; /// static _Bool_set_val _S_and[4][4]; /// static _Bool_set_val _S_eq[4][4]; }; // 20.2.3.2 bool_set values inline bool contains(bool_set __s, bool_set __t) { return __s.contains(__t); } inline bool equals(bool_set __s, bool_set __t) { return __s.equals(__t); } inline bool is_emptyset(bool_set __b) { return __b.is_emptyset(); } inline bool is_indeterminate(bool_set __b) { return __b.is_indeterminate(); } inline bool is_singleton(bool_set __b) { return __b.is_singleton(); } inline bool certainly(bool_set __b) { return ! __b.contains(false); } inline bool possibly(bool_set __b) { return __b.contains(true); } // 20.2.3.3 bool_set set operations inline bool_set set_union(bool __s, bool_set __t) { return bool_set(__s) \| __t; } inline bool_set set_union(bool_set __s, bool __t) { return __s \| bool_set(__t); } inline bool_set set_union(bool_set __s, bool_set __t) { return __s \| __t; } inline bool_set set_intersection(bool __s, bool_set __t) { return bool_set(__s) & __t; } inline bool_set set_intersection(bool_set __s, bool __t) { return __s & bool_set(__t); } inline bool_set set_intersection(bool_set __s, bool_set __t) { return __s & __t; } inline bool_set set_complement(bool_set __b) { return ! __b; } // 20.2.3.4 bool_set logical operators inline bool_set operator^(bool __s, bool_set __t) { return bool_set(__s) ^ __t; } inline bool_set operator^(bool_set __s, bool __t) { return __s ^ bool_set(__t); } inline bool_set operator\|(bool __s, bool_set __t) { return bool_set(__s) \| __t; } inline bool_set operator\|(bool_set __s, bool __t) { return __s \| bool_set(__t); } inline bool_set operator&(bool __s, bool_set __t) { return bool_set(__s) & __t; } inline bool_set operator&(bool_set __s, bool __t) { return __s & bool_set(__t); } // 20.2.3.5 bool_set relational operators inline bool_set operator==(bool __s, bool_set __t) { return bool_set(__s) == __t; } inline bool_set operator==(bool_set __s, bool __t) { return __s == bool_set(__t); } inline bool_set operator!=(bool __s, bool_set __t) { return ! (__s == __t); } inline bool_set operator!=(bool_set __s, bool __t) { return ! (__s == __t); } inline bool_set operator!=(bool_set __s, bool_set __t) { return ! (__s == __t); } } _GLIBCXX_END_NAMESPACE_VERSION } #include <tr2/bool_set.tcc> #endif // _GLIBCXX_TR2_BOOL_SET	7.2 KB	2025-09-15 15:41
📄 bool_set.tcc // TR2 <bool_set> support files -- C++ -- // Copyright (C) 2009-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/bool_set.tcc * This is a TR2 C++ Library header. / #ifndef _GLIBCXX_TR2_BOOL_SET_TCC #define _GLIBCXX_TR2_BOOL_SET_TCC 1 #pragma GCC system_header namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { bool_set::_Bool_set_val bool_set::_S_not[4] = { _S_true_, _S_false, _S_indet, _S_empty }; bool_set::_Bool_set_val bool_set::_S_xor[4][4] = { { _S_false, _S_true_, _S_indet, _S_empty }, { _S_true_, _S_false, _S_indet, _S_empty }, { _S_indet, _S_indet, _S_indet, _S_empty }, { _S_empty, _S_empty, _S_empty, _S_empty } }; bool_set::_Bool_set_val bool_set::_S_or[4][4] = { { _S_false, _S_true_, _S_indet, _S_empty }, { _S_true_, _S_true_, _S_true_, _S_empty }, { _S_indet, _S_true_, _S_indet, _S_empty }, { _S_empty, _S_empty, _S_empty, _S_empty } }; bool_set::_Bool_set_val bool_set::_S_and[4][4] = { { _S_false, _S_false, _S_false, _S_empty }, { _S_false, _S_true_, _S_indet, _S_empty }, { _S_false, _S_indet, _S_indet, _S_empty }, { _S_empty, _S_empty, _S_empty, _S_empty } }; bool_set::_Bool_set_val bool_set::_S_eq[4][4] = { { _S_true_, _S_false, _S_indet, _S_empty }, { _S_false, _S_true_, _S_indet, _S_empty }, { _S_indet, _S_indet, _S_indet, _S_empty }, { _S_empty, _S_empty, _S_empty, _S_empty } }; } _GLIBCXX_END_NAMESPACE_VERSION } // I object to these things. // The stuff in locale facets are for basic types. // I think we could hack operator<< and operator>>. /* * @brief Numeric parsing. * * Parses the input stream into the bool @a v. It does so by calling * num_get::do_get(). * * If ios_base::boolalpha is set, attempts to read * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets * @a v to true or false if successful. Sets err to * ios_base::failbit if reading the string fails. Sets err to * ios_base::eofbit if the stream is emptied. * * If ios_base::boolalpha is not set, proceeds as with reading a long, * except if the value is 1, sets @a v to true, if the value is 0, sets * @a v to false, and otherwise set err to ios_base::failbit. * * @param in Start of input stream. * @param end End of input stream. * @param io Source of locale and flags. * @param err Error flags to set. * @param v Value to format and insert. * @return Iterator after reading. iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { return this->do_get(__in, __end, __io, __err, __v); } / / template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool_set& __v) const { if (!(__io.flags() & ios_base::boolalpha)) { // Parse bool values as long. // NB: We can't just call do_get(long) here, as it might // refer to a derived class. long __l = -1; __beg = _M_extract_int(__beg, __end, __io, __err, __l); if (__c >= _S_false && __c < _S_empty) __b._M_b = static_cast<_Bool_set_val>(__c); else { // What should we do here? __v = true; __err = ios_base::failbit; if (__beg == __end) __err \|= ios_base::eofbit; } } else { // Parse bool values as alphanumeric. typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); bool __testf = true; bool __testt = true; bool __donef = __lc->_M_falsename_size == 0; bool __donet = __lc->_M_truename_size == 0; bool __testeof = false; size_t __n = 0; while (!__donef \|\| !__donet) { if (__beg == __end) { __testeof = true; break; } const char_type __c = __beg; if (!__donef) __testf = __c == __lc->_M_falsename[__n]; if (!__testf && __donet) break; if (!__donet) __testt = __c == __lc->_M_truename[__n]; if (!__testt && __donef) break; if (!__testt && !__testf) break; ++__n; ++__beg; __donef = !__testf \|\| __n >= __lc->_M_falsename_size; __donet = !__testt \|\| __n >= __lc->_M_truename_size; } if (__testf && __n == __lc->_M_falsename_size && __n) { __v = false; if (__testt && __n == __lc->_M_truename_size) __err = ios_base::failbit; else __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else if (__testt && __n == __lc->_M_truename_size && __n) { __v = true; __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 23. Num_get overflow result. __v = false; __err = ios_base::failbit; if (__testeof) __err \|= ios_base::eofbit; } } return __beg; } / /** * @brief Numeric formatting. * * Formats the boolean @a v and inserts it into a stream. It does so * by calling num_put::do_put(). * * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or * ctype<CharT>::falsename(). Otherwise formats @a v as an int. * * @param s Stream to write to. * @param io Source of locale and flags. * @param fill Char_type to use for filling. * @param v Value to format and insert. * @return Iterator after writing. iter_type put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const { return this->do_put(__s, __f, __fill, __v); } / / template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, bool_set __v) const { const ios_base::fmtflags __flags = __io.flags(); if ((__flags & ios_base::boolalpha) == 0) { const long __l = __v; __s = _M_insert_int(__s, __io, __fill, __l); } else { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __name = __v ? __lc->_M_truename : __lc->_M_falsename; int __len = __v ? __lc->_M_truename_size : __lc->_M_falsename_size; const streamsize __w = __io.width(); if (__w > static_cast<streamsize>(__len)) { const streamsize __plen = __w - __len; _CharT* __ps = static_cast<_CharT>(__builtin_alloca(sizeof(_CharT) __plen)); char_traits<_CharT>::assign(__ps, __plen, __fill); __io.width(0); if ((__flags & ios_base::adjustfield) == ios_base::left) { __s = std::__write(__s, __name, __len); __s = std::__write(__s, __ps, __plen); } else { __s = std::__write(__s, __ps, __plen); __s = std::__write(__s, __name, __len); } return __s; } __io.width(0); __s = std::__write(__s, __name, __len); } return __s; } */ #endif // _GLIBCXX_TR2_BOOL_SET_TCC	8.12 KB	2025-09-15 15:41
📄 dynamic_bitset // TR2 <dynamic_bitset> -- C++ -- // Copyright (C) 2009-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/dynamic_bitset * This is a TR2 C++ Library header. / #ifndef _GLIBCXX_TR2_DYNAMIC_BITSET #define _GLIBCXX_TR2_DYNAMIC_BITSET 1 #pragma GCC system_header #include <limits> #include <vector> #include <string> #include <istream> #include <bits/functexcept.h> #include <bits/stl_algo.h> // For fill #include <bits/cxxabi_forced.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { /* * @defgroup dynamic_bitset Dynamic Bitset. * @ingroup extensions * * @{ / /* * Base class, general case. * * See documentation for dynamic_bitset. / template<typename _WordT = unsigned long long, typename _Alloc = std::allocator<_WordT>> struct __dynamic_bitset_base { static_assert(std::is_unsigned<_WordT>::value, "template argument " "_WordT not an unsigned integral type"); typedef _WordT block_type; typedef _Alloc allocator_type; typedef size_t size_type; static const size_type _S_bits_per_block = __CHAR_BIT__ sizeof(block_type); static const size_type npos = static_cast<size_type>(-1); /// 0 is the least significant word. std::vector<block_type, allocator_type> _M_w; explicit __dynamic_bitset_base(const allocator_type& __alloc) : _M_w(__alloc) { } __dynamic_bitset_base() = default; __dynamic_bitset_base(const __dynamic_bitset_base&) = default; __dynamic_bitset_base(__dynamic_bitset_base&& __b) = default; __dynamic_bitset_base& operator=(const __dynamic_bitset_base&) = default; __dynamic_bitset_base& operator=(__dynamic_bitset_base&&) = default; ~__dynamic_bitset_base() = default; explicit __dynamic_bitset_base(size_type __nbits, unsigned long long __val = 0ULL, const allocator_type& __alloc = allocator_type()) : _M_w(__nbits / _S_bits_per_block + (__nbits % _S_bits_per_block > 0), block_type(0), __alloc) { if (__nbits < std::numeric_limits<decltype(__val)>::digits) __val &= ~(-1ULL << __nbits); if (__val == 0) return; if _GLIBCXX17_CONSTEXPR (sizeof(__val) == sizeof(block_type)) _M_w[0] = __val; else { const size_t __n = std::min(_M_w.size(), sizeof(__val) / sizeof(block_type)); for (size_t __i = 0; __val && __i < __n; ++__i) { _M_w[__i] = static_cast<block_type>(__val); __val >>= _S_bits_per_block; } } } void _M_swap(__dynamic_bitset_base& __b) noexcept { this->_M_w.swap(__b._M_w); } void _M_clear() noexcept { this->_M_w.clear(); } void _M_resize(size_t __nbits, bool __value) { size_t __sz = __nbits / _S_bits_per_block; if (__nbits % _S_bits_per_block > 0) ++__sz; if (__sz != this->_M_w.size()) { block_type __val = 0; if (__value) __val = std::numeric_limits<block_type>::max(); this->_M_w.resize(__sz, __val); } } allocator_type _M_get_allocator() const noexcept { return this->_M_w.get_allocator(); } static size_type _S_whichword(size_type __pos) noexcept { return __pos / _S_bits_per_block; } static size_type _S_whichbyte(size_type __pos) noexcept { return (__pos % _S_bits_per_block) / __CHAR_BIT__; } static size_type _S_whichbit(size_type __pos) noexcept { return __pos % _S_bits_per_block; } static block_type _S_maskbit(size_type __pos) noexcept { return (static_cast<block_type>(1)) << _S_whichbit(__pos); } block_type& _M_getword(size_type __pos) noexcept { return this->_M_w[_S_whichword(__pos)]; } block_type _M_getword(size_type __pos) const noexcept { return this->_M_w[_S_whichword(__pos)]; } block_type& _M_hiword() noexcept { return this->_M_w[_M_w.size() - 1]; } block_type _M_hiword() const noexcept { return this->_M_w[_M_w.size() - 1]; } void _M_do_and(const __dynamic_bitset_base& __x) noexcept { if (__x._M_w.size() == this->_M_w.size()) for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] &= __x._M_w[__i]; else return; } void _M_do_or(const __dynamic_bitset_base& __x) noexcept { if (__x._M_w.size() == this->_M_w.size()) for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] \|= __x._M_w[__i]; else return; } void _M_do_xor(const __dynamic_bitset_base& __x) noexcept { if (__x._M_w.size() == this->_M_w.size()) for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] ^= __x._M_w[__i]; else return; } void _M_do_dif(const __dynamic_bitset_base& __x) noexcept { if (__x._M_w.size() == this->_M_w.size()) for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] &= ~__x._M_w[__i]; else return; } void _M_do_left_shift(size_t __shift); void _M_do_right_shift(size_t __shift); void _M_do_flip() noexcept { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] = ~this->_M_w[__i]; } void _M_do_set() noexcept { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) this->_M_w[__i] = static_cast<block_type>(-1); } void _M_do_reset() noexcept { std::fill(_M_w.begin(), _M_w.end(), static_cast<block_type>(0)); } bool _M_is_equal(const __dynamic_bitset_base& __x) const noexcept { if (__x._M_w.size() == this->_M_w.size()) { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) if (this->_M_w[__i] != __x._M_w[__i]) return false; return true; } else return false; } bool _M_is_less(const __dynamic_bitset_base& __x) const noexcept { if (__x._M_w.size() == this->_M_w.size()) { for (size_t __i = this->_M_w.size(); __i > 0; --__i) { if (this->_M_w[__i-1] < __x._M_w[__i-1]) return true; else if (this->_M_w[__i-1] > __x._M_w[__i-1]) return false; } return false; } else return false; } size_t _M_are_all_aux() const noexcept { for (size_t __i = 0; __i < this->_M_w.size() - 1; ++__i) if (_M_w[__i] != static_cast<block_type>(-1)) return 0; return ((this->_M_w.size() - 1) * _S_bits_per_block + __builtin_popcountll(this->_M_hiword())); } bool _M_is_any() const noexcept { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) if (this->_M_w[__i] != static_cast<block_type>(0)) return true; return false; } bool _M_is_subset_of(const __dynamic_bitset_base& __b) noexcept { if (__b._M_w.size() == this->_M_w.size()) { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) if (this->_M_w[__i] != (this->_M_w[__i] \| __b._M_w[__i])) return false; return true; } else return false; } bool _M_is_proper_subset_of(const __dynamic_bitset_base& __b) const noexcept { if (this->is_subset_of(__b)) { if (this == __b) return false; else return true; } else return false; } size_t _M_do_count() const noexcept { size_t __result = 0; for (size_t __i = 0; __i < this->_M_w.size(); ++__i) __result += __builtin_popcountll(this->_M_w[__i]); return __result; } size_type _M_size() const noexcept { return this->_M_w.size(); } unsigned long _M_do_to_ulong() const; unsigned long long _M_do_to_ullong() const; // find first "on" bit size_type _M_do_find_first(size_t __not_found) const; // find the next "on" bit that follows "prev" size_type _M_do_find_next(size_t __prev, size_t __not_found) const; // do append of block void _M_do_append_block(block_type __block, size_type __pos) { size_t __offset = __pos % _S_bits_per_block; if (__offset == 0) this->_M_w.push_back(__block); else { this->_M_hiword() \|= (__block << __offset); this->_M_w.push_back(__block >> (_S_bits_per_block - __offset)); } } }; /* * @brief The %dynamic_bitset class represents a sequence of bits. * * See N2050, * Proposal to Add a Dynamically Sizeable Bitset to the Standard Library. * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2050.pdf * * In the general unoptimized case, storage is allocated in * word-sized blocks. Let B be the number of bits in a word, then * (Nb+(B-1))/B words will be used for storage. B - Nb%B bits are * unused. (They are the high-order bits in the highest word.) It * is a class invariant that those unused bits are always zero. * * If you think of %dynamic_bitset as "a simple array of bits," be * aware that your mental picture is reversed: a %dynamic_bitset * behaves the same way as bits in integers do, with the bit at * index 0 in the "least significant / right-hand" position, and * the bit at index Nb-1 in the "most significant / left-hand" * position. Thus, unlike other containers, a %dynamic_bitset's * index "counts from right to left," to put it very loosely. * * This behavior is preserved when translating to and from strings. * For example, the first line of the following program probably * prints "b('a') is 0001100001" on a modern ASCII system. * * @code * #include <dynamic_bitset> * #include <iostream> * #include <sstream> * * using namespace std; * * int main() * { * long a = 'a'; * dynamic_bitset<> b(a); * * cout << "b('a') is " << b << endl; * * ostringstream s; * s << b; * string str = s.str(); * cout << "index 3 in the string is " << str[3] << " but\n" * << "index 3 in the bitset is " << b[3] << endl; * } * @endcode * * Most of the actual code isn't contained in %dynamic_bitset<> * itself, but in the base class __dynamic_bitset_base. The base * class works with whole words, not with individual bits. This * allows us to specialize __dynamic_bitset_base for the important * special case where the %dynamic_bitset is only a single word. * * Extra confusion can result due to the fact that the storage for * __dynamic_bitset_base @e is a vector, and is indexed as such. This is * carefully encapsulated. / template<typename _WordT = unsigned long long, typename _Alloc = std::allocator<_WordT>> class dynamic_bitset : private __dynamic_bitset_base<_WordT, _Alloc> { static_assert(std::is_unsigned<_WordT>::value, "template argument " "_WordT not an unsigned integral type"); public: typedef __dynamic_bitset_base<_WordT, _Alloc> _Base; typedef _WordT block_type; typedef _Alloc allocator_type; typedef size_t size_type; static const size_type bits_per_block = __CHAR_BIT__ sizeof(block_type); // Use this: constexpr size_type std::numeric_limits<size_type>::max(). static const size_type npos = static_cast<size_type>(-1); private: // Clear the unused bits in the uppermost word. void _M_do_sanitize() { size_type __shift = this->_M_Nb % bits_per_block; if (__shift > 0) this->_M_hiword() &= block_type(~(block_type(-1) << __shift)); } // Set the unused bits in the uppermost word. void _M_do_fill() { size_type __shift = this->_M_Nb % bits_per_block; if (__shift > 0) this->_M_hiword() \|= block_type(block_type(-1) << __shift); } /** * These versions of single-bit set, reset, flip, and test * do no range checking. / dynamic_bitset& _M_unchecked_set(size_type __pos) noexcept { this->_M_getword(__pos) \|= _Base::_S_maskbit(__pos); return this; } dynamic_bitset& _M_unchecked_set(size_type __pos, int __val) noexcept { if (__val) this->_M_getword(__pos) \|= _Base::_S_maskbit(__pos); else this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return this; } dynamic_bitset& _M_unchecked_reset(size_type __pos) noexcept { this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return this; } dynamic_bitset& _M_unchecked_flip(size_type __pos) noexcept { this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); return this; } bool _M_unchecked_test(size_type __pos) const noexcept { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) != static_cast<_WordT>(0)); } size_type _M_Nb = 0; public: /* * This encapsulates the concept of a single bit. An instance * of this class is a proxy for an actual bit; this way the * individual bit operations are done as faster word-size * bitwise instructions. * * Most users will never need to use this class directly; * conversions to and from bool are automatic and should be * transparent. Overloaded operators help to preserve the * illusion. * * (On a typical system, this "bit %reference" is 64 times the * size of an actual bit. Ha.) / class reference { friend class dynamic_bitset; block_type _M_wp; size_type _M_bpos; public: reference(dynamic_bitset& __b, size_type __pos) noexcept { this->_M_wp = &__b._M_getword(__pos); this->_M_bpos = _Base::_S_whichbit(__pos); } // For b[i] = __x; reference& operator=(bool __x) noexcept { if (__x) this->_M_wp \|= _Base::_S_maskbit(this->_M_bpos); else this->_M_wp &= ~_Base::_S_maskbit(this->_M_bpos); return this; } // For b[i] = b[__j]; reference& operator=(const reference& __j) noexcept { if (((__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) this->_M_wp \|= _Base::_S_maskbit(this->_M_bpos); else this->_M_wp &= ~_Base::_S_maskbit(this->_M_bpos); return this; } // Flips the bit bool operator~() const noexcept { return ((_M_wp) & _Base::_S_maskbit(this->_M_bpos)) == 0; } // For __x = b[i]; operator bool() const noexcept { return ((this->_M_wp) & _Base::_S_maskbit(this->_M_bpos)) != 0; } // For b[i].flip(); reference& flip() noexcept { this->_M_wp ^= _Base::_S_maskbit(this->_M_bpos); return this; } }; friend class reference; typedef bool const_reference; // 23.3.5.1 constructors: /// All bits set to zero. dynamic_bitset() = default; /// All bits set to zero. explicit dynamic_bitset(const allocator_type& __alloc) : _Base(__alloc) { } /// Initial bits bitwise-copied from a single word (others set to zero). explicit dynamic_bitset(size_type __nbits, unsigned long long __val = 0ULL, const allocator_type& __alloc = allocator_type()) : _Base(__nbits, __val, __alloc), _M_Nb(__nbits) { } dynamic_bitset(initializer_list<block_type> __il, const allocator_type& __alloc = allocator_type()) : _Base(__alloc) { this->append(__il); } /* * @brief Use a subset of a string. * @param __str A string of '0' and '1' characters. * @param __pos Index of the first character in @p __str to use. * @param __n The number of characters to copy. * @param __zero The character to use for unset bits. * @param __one The character to use for set bits. * @param __alloc An allocator. * @throw std::out_of_range If @p __pos is bigger the size of @p __str. * @throw std::invalid_argument If a character appears in the string * which is neither '0' nor '1'. / template<typename _CharT, typename _Traits, typename _Alloc1> explicit dynamic_bitset(const std::basic_string<_CharT, _Traits, _Alloc1>& __str, typename basic_string<_CharT,_Traits,_Alloc1>::size_type __pos = 0, typename basic_string<_CharT,_Traits,_Alloc1>::size_type __n = std::basic_string<_CharT, _Traits, _Alloc1>::npos, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'), const allocator_type& __alloc = allocator_type()) : _Base(__alloc) { if (__pos > __str.size()) __throw_out_of_range(__N("dynamic_bitset::bitset initial position " "not valid")); // Watch for npos. this->_M_Nb = (__n > __str.size() ? __str.size() - __pos : __n); this->resize(this->_M_Nb); this->_M_copy_from_string(__str, __pos, __n); } /* * @brief Construct from a string. * @param __str A string of '0' and '1' characters. * @param __alloc An allocator. * @throw std::invalid_argument If a character appears in the string * which is neither '0' nor '1'. / explicit dynamic_bitset(const char __str, const allocator_type& __alloc = allocator_type()) : _Base(__builtin_strlen(__str), 0ULL, __alloc), _M_Nb(__builtin_strlen(__str)) { this->_M_copy_from_ptr(__str, _M_Nb, 0, _M_Nb); } /// Copy constructor. dynamic_bitset(const dynamic_bitset&) = default; /// Move constructor. dynamic_bitset(dynamic_bitset&& __b) noexcept : _Base(std::move(__b)), _M_Nb(__b._M_Nb) { __b.clear(); } /// Swap with another bitset. void swap(dynamic_bitset& __b) noexcept { this->_M_swap(__b); std::swap(this->_M_Nb, __b._M_Nb); } /// Copy assignment operator. dynamic_bitset& operator=(const dynamic_bitset&) = default; /// Move assignment operator. dynamic_bitset& operator=(dynamic_bitset&& __b) noexcept(std::is_nothrow_move_assignable<_Base>::value) { static_cast<_Base&>(this) = static_cast<_Base&&>(__b); _M_Nb = __b._M_Nb; if _GLIBCXX17_CONSTEXPR (std::is_nothrow_move_assignable<_Base>::value) __b._M_Nb = 0; else if (get_allocator() == __b.get_allocator()) __b._M_Nb = 0; return this; } /** * @brief Return the allocator for the bitset. / allocator_type get_allocator() const noexcept { return this->_M_get_allocator(); } /* * @brief Resize the bitset. / void resize(size_type __nbits, bool __value = false) { if (__value) this->_M_do_fill(); this->_M_resize(__nbits, __value); this->_M_Nb = __nbits; this->_M_do_sanitize(); } /* * @brief Clear the bitset. / void clear() { this->_M_clear(); this->_M_Nb = 0; } /* * @brief Push a bit onto the high end of the bitset. / void push_back(bool __bit) { if (this->size() % bits_per_block == 0) this->_M_do_append_block(block_type(__bit), this->_M_Nb); else this->_M_unchecked_set(this->_M_Nb, __bit); ++this->_M_Nb; } // XXX why is there no pop_back() member in the proposal? /* * @brief Append a block. / void append(block_type __block) { this->_M_do_append_block(__block, this->_M_Nb); this->_M_Nb += bits_per_block; } /* * @brief / void append(initializer_list<block_type> __il) { this->append(__il.begin(), __il.end()); } /* * @brief Append an iterator range of blocks. / template <typename _BlockInputIterator> void append(_BlockInputIterator __first, _BlockInputIterator __last) { for (; __first != __last; ++__first) this->append(__first); } // 23.3.5.2 dynamic_bitset operations: ///@{ /** * @brief Operations on dynamic_bitsets. * @param __rhs A same-sized dynamic_bitset. * * These should be self-explanatory. / dynamic_bitset& operator&=(const dynamic_bitset& __rhs) { this->_M_do_and(__rhs); return this; } dynamic_bitset& operator&=(dynamic_bitset&& __rhs) { this->_M_do_and(std::move(__rhs)); return this; } dynamic_bitset& operator\|=(const dynamic_bitset& __rhs) { this->_M_do_or(__rhs); return this; } dynamic_bitset& operator^=(const dynamic_bitset& __rhs) { this->_M_do_xor(__rhs); return this; } dynamic_bitset& operator-=(const dynamic_bitset& __rhs) { this->_M_do_dif(__rhs); return this; } ///@} ///@{ /** * @brief Operations on dynamic_bitsets. * @param __pos The number of places to shift. * * These should be self-explanatory. / dynamic_bitset& operator<<=(size_type __pos) { if (__builtin_expect(__pos < this->_M_Nb, 1)) { this->_M_do_left_shift(__pos); this->_M_do_sanitize(); } else this->_M_do_reset(); return this; } dynamic_bitset& operator>>=(size_type __pos) { if (__builtin_expect(__pos < this->_M_Nb, 1)) { this->_M_do_right_shift(__pos); this->_M_do_sanitize(); } else this->_M_do_reset(); return this; } ///@} // Set, reset, and flip. /* * @brief Sets every bit to true. / dynamic_bitset& set() { this->_M_do_set(); this->_M_do_sanitize(); return this; } /** * @brief Sets a given bit to a particular value. * @param __pos The index of the bit. * @param __val Either true or false, defaults to true. * @throw std::out_of_range If @a __pos is bigger the size of the %set. / dynamic_bitset& set(size_type __pos, bool __val = true) { if (__pos >= _M_Nb) __throw_out_of_range(__N("dynamic_bitset::set")); return this->_M_unchecked_set(__pos, __val); } /* * @brief Sets every bit to false. / dynamic_bitset& reset() { this->_M_do_reset(); return this; } /** * @brief Sets a given bit to false. * @param __pos The index of the bit. * @throw std::out_of_range If @a __pos is bigger the size of the %set. * * Same as writing @c set(__pos, false). / dynamic_bitset& reset(size_type __pos) { if (__pos >= _M_Nb) __throw_out_of_range(__N("dynamic_bitset::reset")); return this->_M_unchecked_reset(__pos); } /* * @brief Toggles every bit to its opposite value. / dynamic_bitset& flip() { this->_M_do_flip(); this->_M_do_sanitize(); return this; } /** * @brief Toggles a given bit to its opposite value. * @param __pos The index of the bit. * @throw std::out_of_range If @a __pos is bigger the size of the %set. / dynamic_bitset& flip(size_type __pos) { if (__pos >= _M_Nb) __throw_out_of_range(__N("dynamic_bitset::flip")); return this->_M_unchecked_flip(__pos); } /// See the no-argument flip(). dynamic_bitset operator~() const { return dynamic_bitset<_WordT, _Alloc>(this).flip(); } ///@{ /** * @brief Array-indexing support. * @param __pos Index into the %dynamic_bitset. * @return A bool for a 'const %dynamic_bitset'. For non-const * bitsets, an instance of the reference proxy class. * @note These operators do no range checking and throw no * exceptions, as required by DR 11 to the standard. / reference operator[](size_type __pos) { return reference(this,__pos); } const_reference operator[](size_type __pos) const { return _M_unchecked_test(__pos); } ///@} /** * @brief Returns a numerical interpretation of the %dynamic_bitset. * @return The integral equivalent of the bits. * @throw std::overflow_error If there are too many bits to be * represented in an @c unsigned @c long. / unsigned long to_ulong() const { return this->_M_do_to_ulong(); } /* * @brief Returns a numerical interpretation of the %dynamic_bitset. * @return The integral equivalent of the bits. * @throw std::overflow_error If there are too many bits to be * represented in an @c unsigned @c long. / unsigned long long to_ullong() const { return this->_M_do_to_ullong(); } /* * @brief Returns a character interpretation of the %dynamic_bitset. * @return The string equivalent of the bits. * * Note the ordering of the bits: decreasing character positions * correspond to increasing bit positions (see the main class notes for * an example). / template<typename _CharT = char, typename _Traits = std::char_traits<_CharT>, typename _Alloc1 = std::allocator<_CharT>> std::basic_string<_CharT, _Traits, _Alloc1> to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const { std::basic_string<_CharT, _Traits, _Alloc1> __result; _M_copy_to_string(__result, __zero, __one); return __result; } // Helper functions for string operations. template<typename _Traits = std::char_traits<char>, typename _CharT = typename _Traits::char_type> void _M_copy_from_ptr(const _CharT, size_t, size_t, size_t, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')); template<typename _CharT, typename _Traits, typename _Alloc1> void _M_copy_from_string(const basic_string<_CharT, _Traits, _Alloc1>& __str, size_t __pos, size_t __n, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) { _M_copy_from_ptr<_Traits>(__str.data(), __str.size(), __pos, __n, __zero, __one); } template<typename _CharT, typename _Traits, typename _Alloc1> void _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc1>& __str, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const; /// Returns the number of bits which are set. size_type count() const noexcept { return this->_M_do_count(); } /// Returns the total number of bits. size_type size() const noexcept { return this->_M_Nb; } /// Returns the total number of blocks. size_type num_blocks() const noexcept { return this->_M_size(); } /// Returns true if the dynamic_bitset is empty. _GLIBCXX_NODISCARD bool empty() const noexcept { return (this->_M_Nb == 0); } /// Returns the maximum size of a dynamic_bitset object having the same /// type as this. /// The real answer is max() bits_per_block but is likely to overflow. constexpr size_type max_size() noexcept { return std::numeric_limits<block_type>::max(); } /** * @brief Tests the value of a bit. * @param __pos The index of a bit. * @return The value at @a __pos. * @throw std::out_of_range If @a __pos is bigger the size of the %set. / bool test(size_type __pos) const { if (__pos >= _M_Nb) __throw_out_of_range(__N("dynamic_bitset::test")); return _M_unchecked_test(__pos); } /* * @brief Tests whether all the bits are on. * @return True if all the bits are set. / bool all() const { return this->_M_are_all_aux() == _M_Nb; } /* * @brief Tests whether any of the bits are on. * @return True if at least one bit is set. / bool any() const { return this->_M_is_any(); } /* * @brief Tests whether any of the bits are on. * @return True if none of the bits are set. / bool none() const { return !this->_M_is_any(); } ///@{ /// Self-explanatory. dynamic_bitset operator<<(size_type __pos) const { return dynamic_bitset(this) <<= __pos; } dynamic_bitset operator>>(size_type __pos) const { return dynamic_bitset(this) >>= __pos; } ///@} /* * @brief Finds the index of the first "on" bit. * @return The index of the first bit set, or size() if not found. * @sa find_next / size_type find_first() const { return this->_M_do_find_first(this->_M_Nb); } /* * @brief Finds the index of the next "on" bit after prev. * @return The index of the next bit set, or size() if not found. * @param __prev Where to start searching. * @sa find_first / size_type find_next(size_t __prev) const { return this->_M_do_find_next(__prev, this->_M_Nb); } bool is_subset_of(const dynamic_bitset& __b) const { return this->_M_is_subset_of(__b); } bool is_proper_subset_of(const dynamic_bitset& __b) const { return this->_M_is_proper_subset_of(__b); } friend bool operator==(const dynamic_bitset& __lhs, const dynamic_bitset& __rhs) noexcept { return __lhs._M_Nb == __rhs._M_Nb && __lhs._M_is_equal(__rhs); } friend bool operator<(const dynamic_bitset& __lhs, const dynamic_bitset& __rhs) noexcept { return __lhs._M_is_less(__rhs) \|\| __lhs._M_Nb < __rhs._M_Nb; } }; template<typename _WordT, typename _Alloc> template<typename _CharT, typename _Traits, typename _Alloc1> inline void dynamic_bitset<_WordT, _Alloc>:: _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc1>& __str, _CharT __zero, _CharT __one) const { __str.assign(_M_Nb, __zero); for (size_t __i = _M_Nb; __i > 0; --__i) if (_M_unchecked_test(__i - 1)) _Traits::assign(__str[_M_Nb - __i], __one); } ///@{ /// These comparisons for equality/inequality are, well, @e bitwise. template<typename _WordT, typename _Alloc> inline bool operator!=(const dynamic_bitset<_WordT, _Alloc>& __lhs, const dynamic_bitset<_WordT, _Alloc>& __rhs) { return !(__lhs == __rhs); } template<typename _WordT, typename _Alloc> inline bool operator<=(const dynamic_bitset<_WordT, _Alloc>& __lhs, const dynamic_bitset<_WordT, _Alloc>& __rhs) { return !(__lhs > __rhs); } template<typename _WordT, typename _Alloc> inline bool operator>(const dynamic_bitset<_WordT, _Alloc>& __lhs, const dynamic_bitset<_WordT, _Alloc>& __rhs) { return __rhs < __lhs; } template<typename _WordT, typename _Alloc> inline bool operator>=(const dynamic_bitset<_WordT, _Alloc>& __lhs, const dynamic_bitset<_WordT, _Alloc>& __rhs) { return !(__lhs < __rhs); } ///@} // 23.3.5.3 bitset operations: ///@{ /* * @brief Global bitwise operations on bitsets. * @param __x A bitset. * @param __y A bitset of the same size as @a __x. * @return A new bitset. * * These should be self-explanatory. / template<typename _WordT, typename _Alloc> inline dynamic_bitset<_WordT, _Alloc> operator&(const dynamic_bitset<_WordT, _Alloc>& __x, const dynamic_bitset<_WordT, _Alloc>& __y) { dynamic_bitset<_WordT, _Alloc> __result(__x); __result &= __y; return __result; } template<typename _WordT, typename _Alloc> inline dynamic_bitset<_WordT, _Alloc> operator\|(const dynamic_bitset<_WordT, _Alloc>& __x, const dynamic_bitset<_WordT, _Alloc>& __y) { dynamic_bitset<_WordT, _Alloc> __result(__x); __result \|= __y; return __result; } template <typename _WordT, typename _Alloc> inline dynamic_bitset<_WordT, _Alloc> operator^(const dynamic_bitset<_WordT, _Alloc>& __x, const dynamic_bitset<_WordT, _Alloc>& __y) { dynamic_bitset<_WordT, _Alloc> __result(__x); __result ^= __y; return __result; } template <typename _WordT, typename _Alloc> inline dynamic_bitset<_WordT, _Alloc> operator-(const dynamic_bitset<_WordT, _Alloc>& __x, const dynamic_bitset<_WordT, _Alloc>& __y) { dynamic_bitset<_WordT, _Alloc> __result(__x); __result -= __y; return __result; } ///@} /// Stream output operator for dynamic_bitset. template <typename _CharT, typename _Traits, typename _WordT, typename _Alloc> inline std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const dynamic_bitset<_WordT, _Alloc>& __x) { std::basic_string<_CharT, _Traits> __tmp; const ctype<_CharT>& __ct = use_facet<ctype<_CharT>>(__os.getloc()); __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); return __os << __tmp; } /* * @} / } // tr2 _GLIBCXX_END_NAMESPACE_VERSION } // std #include <tr2/dynamic_bitset.tcc> #endif / _GLIBCXX_TR2_DYNAMIC_BITSET */	33.54 KB	2025-09-15 15:41
📄 dynamic_bitset.tcc // TR2 <dynamic_bitset> -- C++ -- // Copyright (C) 2009-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/dynamic_bitset.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr2/dynamic_bitset} / #ifndef _GLIBCXX_TR2_DYNAMIC_BITSET_TCC #define _GLIBCXX_TR2_DYNAMIC_BITSET_TCC 1 #pragma GCC system_header namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { // Definitions of non-inline functions from __dynamic_bitset_base. template<typename _WordT, typename _Alloc> void __dynamic_bitset_base<_WordT, _Alloc>::_M_do_left_shift(size_t __shift) { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _S_bits_per_block; const size_t __offset = __shift % _S_bits_per_block; if (__offset == 0) for (size_t __n = this->_M_w.size() - 1; __n >= __wshift; --__n) this->_M_w[__n] = this->_M_w[__n - __wshift]; else { const size_t __sub_offset = _S_bits_per_block - __offset; for (size_t __n = _M_w.size() - 1; __n > __wshift; --__n) this->_M_w[__n] = ((this->_M_w[__n - __wshift] << __offset) \| (this->_M_w[__n - __wshift - 1] >> __sub_offset)); this->_M_w[__wshift] = this->_M_w[0] << __offset; } //// std::fill(this->_M_w.begin(), this->_M_w.begin() + __wshift, //// static_cast<_WordT>(0)); } } template<typename _WordT, typename _Alloc> void __dynamic_bitset_base<_WordT, _Alloc>::_M_do_right_shift(size_t __shift) { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _S_bits_per_block; const size_t __offset = __shift % _S_bits_per_block; const size_t __limit = this->_M_w.size() - __wshift - 1; if (__offset == 0) for (size_t __n = 0; __n <= __limit; ++__n) this->_M_w[__n] = this->_M_w[__n + __wshift]; else { const size_t __sub_offset = (_S_bits_per_block - __offset); for (size_t __n = 0; __n < __limit; ++__n) this->_M_w[__n] = ((this->_M_w[__n + __wshift] >> __offset) \| (this->_M_w[__n + __wshift + 1] << __sub_offset)); this->_M_w[__limit] = this->_M_w[_M_w.size()-1] >> __offset; } ////std::fill(this->_M_w.begin() + __limit + 1, this->_M_w.end(), //// static_cast<_WordT>(0)); } } template<typename _WordT, typename _Alloc> unsigned long __dynamic_bitset_base<_WordT, _Alloc>::_M_do_to_ulong() const { size_t __n = sizeof(unsigned long) / sizeof(block_type); for (size_t __i = __n; __i < this->_M_w.size(); ++__i) if (this->_M_w[__i]) __throw_overflow_error(__N("__dynamic_bitset_base::_M_do_to_ulong")); unsigned long __res = 0UL; for (size_t __i = 0; __i < __n && __i < this->_M_w.size(); ++__i) __res += this->_M_w[__i] << (__i _S_bits_per_block); return __res; } template<typename _WordT, typename _Alloc> unsigned long long __dynamic_bitset_base<_WordT, _Alloc>::_M_do_to_ullong() const { size_t __n = sizeof(unsigned long long) / sizeof(block_type); for (size_t __i = __n; __i < this->_M_w.size(); ++__i) if (this->_M_w[__i]) __throw_overflow_error(__N("__dynamic_bitset_base::_M_do_to_ullong")); unsigned long long __res = 0ULL; for (size_t __i = 0; __i < __n && __i < this->_M_w.size(); ++__i) __res += this->_M_w[__i] << (__i * _S_bits_per_block); return __res; } template<typename _WordT, typename _Alloc> size_t __dynamic_bitset_base<_WordT, _Alloc> ::_M_do_find_first(size_t __not_found) const { for (size_t __i = 0; __i < this->_M_w.size(); ++__i) { _WordT __thisword = this->_M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * _S_bits_per_block + __builtin_ctzll(__thisword)); } // not found, so return an indication of failure. return __not_found; } template<typename _WordT, typename _Alloc> size_t __dynamic_bitset_base<_WordT, _Alloc> ::_M_do_find_next(size_t __prev, size_t __not_found) const { // make bound inclusive ++__prev; // check out of bounds if (__prev >= this->_M_w.size() * _S_bits_per_block) return __not_found; // search first word size_t __i = _S_whichword(__prev); _WordT __thisword = this->_M_w[__i]; // mask off bits below bound __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if (__thisword != static_cast<_WordT>(0)) return (__i * _S_bits_per_block + __builtin_ctzll(__thisword)); // check subsequent words for (++__i; __i < this->_M_w.size(); ++__i) { __thisword = this->_M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * _S_bits_per_block + __builtin_ctzll(__thisword)); } // not found, so return an indication of failure. return __not_found; } // end _M_do_find_next // Definitions of non-inline member functions. template<typename _WordT, typename _Alloc> template<typename _Traits, typename _CharT> void dynamic_bitset<_WordT, _Alloc>:: _M_copy_from_ptr(const _CharT* __str, size_t __len, size_t __pos, size_t __n, _CharT __zero, _CharT __one) { reset(); const size_t __nbits = std::min(_M_Nb, std::min(__n, __len - __pos)); for (size_t __i = __nbits; __i > 0; --__i) { const _CharT __c = __str[__pos + __nbits - __i]; if (_Traits::eq(__c, __zero)) ; else if (_Traits::eq(__c, __one)) _M_unchecked_set(__i - 1); else __throw_invalid_argument(__N("dynamic_bitset::_M_copy_from_ptr")); } } /** * @brief Stream input operator for dynamic_bitset. * @ingroup dynamic_bitset * * Input will skip whitespace and only accept '0' and '1' characters. * The %dynamic_bitset will grow as necessary to hold the string of bits. / template<typename _CharT, typename _Traits, typename _WordT, typename _Alloc> std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, dynamic_bitset<_WordT, _Alloc>& __x) { typedef typename _Traits::char_type char_type; typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; std::basic_string<_CharT, _Traits> __tmp; __tmp.reserve(__x.size()); const char_type __zero = __is.widen('0'); const char_type __one = __is.widen('1'); typename __ios_base::iostate __state = __ios_base::goodbit; typename __istream_type::sentry __sentry(__is); if (__sentry) { __try { while (1) { static typename _Traits::int_type __eof = _Traits::eof(); typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { __state \|= __ios_base::eofbit; break; } else { const char_type __c2 = _Traits::to_char_type(__c1); if (_Traits::eq(__c2, __zero)) __tmp.push_back(__zero); else if (_Traits::eq(__c2, __one)) __tmp.push_back(__one); else if (_Traits:: eq_int_type(__is.rdbuf()->sputbackc(__c2), __eof)) { __state \|= __ios_base::failbit; break; } else break; } } } __catch(__cxxabiv1::__forced_unwind&) { __is._M_setstate(__ios_base::badbit); __throw_exception_again; } __catch(...) { __is._M_setstate(__ios_base::badbit); } } __x.resize(__tmp.size()); if (__tmp.empty() && __x.size()) __state \|= __ios_base::failbit; else __x._M_copy_from_string(__tmp, static_cast<size_t>(0), __x.size(), __zero, __one); if (__state) __is.setstate(__state); return __is; } } // tr2 _GLIBCXX_END_NAMESPACE_VERSION } // std #endif / _GLIBCXX_TR2_DYNAMIC_BITSET_TCC */	8.72 KB	2025-09-15 15:41
📄 ratio // TR2 <ratio> -- C++ -- // Copyright (C) 2010-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/ratio * This is a TR2 C++ Library header. */ #include <ratio> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { template<intmax_t _Pn, size_t _Bit, bool = _Bit < static_cast<size_t> (std::numeric_limits<intmax_t>::digits)> struct __safe_lshift { static const intmax_t __value = 0; }; template<intmax_t _Pn, size_t _Bit> struct __safe_lshift<_Pn, _Bit, true> { static const intmax_t __value = _Pn << _Bit; }; /// Add binary prefixes (IEC 60027-2 A.2 and ISO/IEC 80000). typedef ratio<__safe_lshift<1, 10>::__value, 1> kibi; typedef ratio<__safe_lshift<1, 20>::__value, 1> mebi; typedef ratio<__safe_lshift<1, 30>::__value, 1> gibi; typedef ratio<__safe_lshift<1, 40>::__value, 1> tebi; typedef ratio<__safe_lshift<1, 50>::__value, 1> pebi; typedef ratio<__safe_lshift<1, 60>::__value, 1> exbi; //typedef ratio<__safe_lshift<1, 70>::__value, 1> zebi; //typedef ratio<__safe_lshift<1, 80>::__value, 1> yobi; } _GLIBCXX_END_NAMESPACE_VERSION }	2.08 KB	2025-09-15 15:41
📄 type_traits // TR2 <type_traits> -- C++ -- // Copyright (C) 2011-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file tr2/type_traits * This is a TR2 C++ Library header. / #ifndef _GLIBCXX_TR2_TYPE_TRAITS #define _GLIBCXX_TR2_TYPE_TRAITS 1 #pragma GCC system_header #include <type_traits> #include <bits/c++config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr2 { /* * @addtogroup metaprogramming * @{ / /* * See N2965: Type traits and base classes * by Michael Spertus / /* * Simple typelist. Compile-time list of types. */ template<typename... _Elements> struct __reflection_typelist; /// Specialization for an empty typelist. template<> struct __reflection_typelist<> { typedef std::true_type empty; }; /// Partial specialization. template<typename _First, typename... _Rest> struct __reflection_typelist<_First, _Rest...> { typedef std::false_type empty; struct first { typedef _First type; }; struct rest { typedef __reflection_typelist<_Rest...> type; }; }; /// Sequence abstraction metafunctions for manipulating a typelist. /// Enumerate all the base classes of a class. Form of a typelist. template<typename _Tp> struct bases { typedef __reflection_typelist<__bases(_Tp)...> type; }; /// Enumerate all the direct base classes of a class. Form of a typelist. template<typename _Tp> struct direct_bases { typedef __reflection_typelist<__direct_bases(_Tp)...> type; }; /// @} group metaprogramming } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR2_TYPE_TRAITS	2.64 KB	2025-09-15 15:41

Terminal