TRAVIS_OS_NAME=linux
<<<<<< ENV
.github/workflows/check.yaml
.gitignore
.travis.yml
Codecov.png
LICENSE
O_big.png
QtTicTacToeWidget.pri
R.png
README.md
RichelbilderbeekNlBackground.png
TicTacToe.css
TicTacToe.pri
TicTacToe.qrc
TicTacToeArchitecture_1_5.dia
TicTacToeComputer.png
TicTacToeConsole.pri
TicTacToeConsole.pro
TicTacToeConsoleTest.pri
TicTacToeConsoleTest.pro
TicTacToeDesktopQt.pri
TicTacToeDesktopQt.pro
TicTacToeHuman.png
TicTacToeModern.png
TicTacToeO.png
TicTacToeRetro.png
TicTacToeWebsite.pri
TicTacToeWebsite.pro
TicTacToeX.png
TravisCI.png
X_big.png
crosscompiletowindows.sh
do_oclint.sh
download_other_github_repos.sh
get_code_cov.sh
install_oclint.sh
main.cpp
main_test.cpp
pics/TravisCI.png
qtmain.cpp
qttictactoecanvas.cpp
qttictactoecanvas.h
qttictactoegamedialog.cpp
qttictactoegamedialog.h
qttictactoegamedialog.ui
qttictactoemenudialog.cpp
qttictactoemenudialog.h
qttictactoemenudialog.ui
qttictactoemenudialog_test.cpp
qttictactoewidget.cpp
qttictactoewidget.h
qttictactoewinnerdialog.cpp
qttictactoewinnerdialog.h
qttictactoewinnerdialog.ui
screenshots/QtGameDialog.png
scripts/check_dead_links.sh
tictactoeai.cpp
tictactoeai.h
tictactoeais.cpp
tictactoeais.h
tictactoeboard.cpp
tictactoeboard.h
tictactoeboard_test.cpp
tictactoefwd.h
tictactoegame.cpp
tictactoegame.h
tictactoegame_test.cpp
tictactoehelper.cpp
tictactoehelper.h
tictactoekey.cpp
tictactoekey.h
tictactoemenudialog.cpp
tictactoemenudialog.h
tictactoemenudialog_test.cpp
tictactoeplayer.cpp
tictactoeplayer.h
tictactoesquare.cpp
tictactoesquare.h
tictactoewidget.cpp
tictactoewidget.h
tictactoewinner.cpp
tictactoewinner.h
wt.css
wtmain.cpp
wttictactoegamedialog.cpp
wttictactoegamedialog.h
wttictactoemenudialog.cpp
wttictactoemenudialog.h
<<<<<< network
# path=/home/travis/build/richelbilderbeek/TicTacToe/#usr#include#c++#7#bits#allocator.h.gcov
-: 0:Source:/usr/include/c++/7/bits/allocator.h
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/dotmatrixchar.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/dotmatrixchar.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:// Allocators -*- C++ -*-
-: 2:
-: 3:// Copyright (C) 2001-2017 Free Software Foundation, Inc.
-: 4://
-: 5:// This file is part of the GNU ISO C++ Library. This library is free
-: 6:// software; you can redistribute it and/or modify it under the
-: 7:// terms of the GNU General Public License as published by the
-: 8:// Free Software Foundation; either version 3, or (at your option)
-: 9:// any later version.
-: 10:
-: 11:// This library is distributed in the hope that it will be useful,
-: 12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
-: 13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-: 14:// GNU General Public License for more details.
-: 15:
-: 16:// Under Section 7 of GPL version 3, you are granted additional
-: 17:// permissions described in the GCC Runtime Library Exception, version
-: 18:// 3.1, as published by the Free Software Foundation.
-: 19:
-: 20:// You should have received a copy of the GNU General Public License and
-: 21:// a copy of the GCC Runtime Library Exception along with this program;
-: 22:// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-: 23:// .
-: 24:
-: 25:/*
-: 26: * Copyright (c) 1996-1997
-: 27: * Silicon Graphics Computer Systems, Inc.
-: 28: *
-: 29: * Permission to use, copy, modify, distribute and sell this software
-: 30: * and its documentation for any purpose is hereby granted without fee,
-: 31: * provided that the above copyright notice appear in all copies and
-: 32: * that both that copyright notice and this permission notice appear
-: 33: * in supporting documentation. Silicon Graphics makes no
-: 34: * representations about the suitability of this software for any
-: 35: * purpose. It is provided "as is" without express or implied warranty.
-: 36: */
-: 37:
-: 38:/** @file bits/allocator.h
-: 39: * This is an internal header file, included by other library headers.
-: 40: * Do not attempt to use it directly. @headername{memory}
-: 41: */
-: 42:
-: 43:#ifndef _ALLOCATOR_H
-: 44:#define _ALLOCATOR_H 1
-: 45:
-: 46:#include // Define the base class to std::allocator.
-: 47:#include
-: 48:#if __cplusplus >= 201103L
-: 49:#include
-: 50:#endif
-: 51:
-: 52:#define __cpp_lib_incomplete_container_elements 201505
-: 53:#if __cplusplus >= 201103L
-: 54:# define __cpp_lib_allocator_is_always_equal 201411
-: 55:#endif
-: 56:
-: 57:namespace std _GLIBCXX_VISIBILITY(default)
-: 58:{
-: 59:_GLIBCXX_BEGIN_NAMESPACE_VERSION
-: 60:
-: 61: /**
-: 62: * @addtogroup allocators
-: 63: * @{
-: 64: */
-: 65:
-: 66: /// allocator specialization.
-: 67: template<>
-: 68: class allocator
-: 69: {
-: 70: public:
-: 71: typedef size_t size_type;
-: 72: typedef ptrdiff_t difference_type;
-: 73: typedef void* pointer;
-: 74: typedef const void* const_pointer;
-: 75: typedef void value_type;
-: 76:
-: 77: template
-: 78: struct rebind
-: 79: { typedef allocator<_Tp1> other; };
-: 80:
-: 81:#if __cplusplus >= 201103L
-: 82: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 83: // 2103. std::allocator propagate_on_container_move_assignment
-: 84: typedef true_type propagate_on_container_move_assignment;
-: 85:
-: 86: typedef true_type is_always_equal;
-: 87:
-: 88: template
-: 89: void
-: 90: construct(_Up* __p, _Args&&... __args)
-: 91: { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
-: 92:
-: 93: template
-: 94: void
-: 95: destroy(_Up* __p) { __p->~_Up(); }
-: 96:#endif
-: 97: };
-: 98:
-: 99: /**
-: 100: * @brief The @a standard allocator, as per [20.4].
-: 101: *
-: 102: * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/memory.html#std.util.memory.allocator
-: 103: * for further details.
-: 104: *
-: 105: * @tparam _Tp Type of allocated object.
-: 106: */
-: 107: template
-: 108: class allocator: public __allocator_base<_Tp>
-: 109: {
-: 110: public:
-: 111: typedef size_t size_type;
-: 112: typedef ptrdiff_t difference_type;
-: 113: typedef _Tp* pointer;
-: 114: typedef const _Tp* const_pointer;
-: 115: typedef _Tp& reference;
-: 116: typedef const _Tp& const_reference;
-: 117: typedef _Tp value_type;
-: 118:
-: 119: template
-: 120: struct rebind
-: 121: { typedef allocator<_Tp1> other; };
-: 122:
-: 123:#if __cplusplus >= 201103L
-: 124: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 125: // 2103. std::allocator propagate_on_container_move_assignment
-: 126: typedef true_type propagate_on_container_move_assignment;
-: 127:
-: 128: typedef true_type is_always_equal;
-: 129:#endif
-: 130:
function _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2Ev called 0 returned 0% blocks executed 0%
#####: 131: allocator() throw() { }
call 0 never executed
call 1 never executed
-: 132:
function _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2ERKS5_ called 0 returned 0% blocks executed 0%
#####: 133: allocator(const allocator& __a) throw()
#####: 134: : __allocator_base<_Tp>(__a) { }
call 0 never executed
call 1 never executed
call 2 never executed
-: 135:
-: 136: template
-: 137: allocator(const allocator<_Tp1>&) throw() { }
-: 138:
function _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev called 0 returned 0% blocks executed 0%
#####: 139: ~allocator() throw() { }
call 0 never executed
call 1 never executed
-: 140:
-: 141: // Inherit everything else.
-: 142: };
-: 143:
-: 144: template
-: 145: inline bool
-: 146: operator==(const allocator<_T1>&, const allocator<_T2>&)
-: 147: _GLIBCXX_USE_NOEXCEPT
-: 148: { return true; }
-: 149:
-: 150: template
-: 151: inline bool
-: 152: operator==(const allocator<_Tp>&, const allocator<_Tp>&)
-: 153: _GLIBCXX_USE_NOEXCEPT
-: 154: { return true; }
-: 155:
-: 156: template
-: 157: inline bool
-: 158: operator!=(const allocator<_T1>&, const allocator<_T2>&)
-: 159: _GLIBCXX_USE_NOEXCEPT
-: 160: { return false; }
-: 161:
-: 162: template
-: 163: inline bool
-: 164: operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
-: 165: _GLIBCXX_USE_NOEXCEPT
-: 166: { return false; }
-: 167:
-: 168: /// @} group allocator
-: 169:
-: 170: // Inhibit implicit instantiations for required instantiations,
-: 171: // which are defined via explicit instantiations elsewhere.
-: 172:#if _GLIBCXX_EXTERN_TEMPLATE
-: 173: extern template class allocator;
-: 174: extern template class allocator;
-: 175:#endif
-: 176:
-: 177: // Undefine.
-: 178:#undef __allocator_base
-: 179:
-: 180: // To implement Option 3 of DR 431.
-: 181: template
-: 182: struct __alloc_swap
-: 183: { static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } };
-: 184:
-: 185: template
-: 186: struct __alloc_swap<_Alloc, false>
-: 187: {
-: 188: static void
-: 189: _S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT
-: 190: {
-: 191: // Precondition: swappable allocators.
-: 192: if (__one != __two)
-: 193: swap(__one, __two);
-: 194: }
-: 195: };
-: 196:
-: 197: // Optimize for stateless allocators.
-: 198: template
-: 199: struct __alloc_neq
-: 200: {
-: 201: static bool
-: 202: _S_do_it(const _Alloc&, const _Alloc&)
-: 203: { return false; }
-: 204: };
-: 205:
-: 206: template
-: 207: struct __alloc_neq<_Alloc, false>
-: 208: {
-: 209: static bool
-: 210: _S_do_it(const _Alloc& __one, const _Alloc& __two)
-: 211: { return __one != __two; }
-: 212: };
-: 213:
-: 214:#if __cplusplus >= 201103L
-: 215: template,
-: 217: is_nothrow_move_constructible>::value>
-: 218: struct __shrink_to_fit_aux
-: 219: { static bool _S_do_it(_Tp&) noexcept { return false; } };
-: 220:
-: 221: template
-: 222: struct __shrink_to_fit_aux<_Tp, true>
-: 223: {
-: 224: static bool
-: 225: _S_do_it(_Tp& __c) noexcept
-: 226: {
-: 227:#if __cpp_exceptions
-: 228: try
-: 229: {
-: 230: _Tp(__make_move_if_noexcept_iterator(__c.begin()),
-: 231: __make_move_if_noexcept_iterator(__c.end()),
-: 232: __c.get_allocator()).swap(__c);
-: 233: return true;
-: 234: }
-: 235: catch(...)
-: 236: { return false; }
-: 237:#else
-: 238: return false;
-: 239:#endif
-: 240: }
-: 241: };
-: 242:#endif
-: 243:
-: 244:_GLIBCXX_END_NAMESPACE_VERSION
-: 245:} // namespace std
-: 246:
-: 247:#endif
<<<<<< EOF
# path=/home/travis/build/richelbilderbeek/TicTacToe/#usr#include#boost#xpressive#basic_regex.hpp.gcov
-: 0:Source:/usr/include/boost/xpressive/basic_regex.hpp
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/fileio.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/fileio.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:///////////////////////////////////////////////////////////////////////////////
-: 2:/// \file basic_regex.hpp
-: 3:/// Contains the definition of the basic_regex\<\> class template and its
-: 4:/// associated helper functions.
-: 5://
-: 6:// Copyright 2008 Eric Niebler. Distributed under the Boost
-: 7:// Software License, Version 1.0. (See accompanying file
-: 8:// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-: 9:
-: 10:#ifndef BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005
-: 11:#define BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005
-: 12:
-: 13:// MS compatible compilers support #pragma once
-: 14:#if defined(_MSC_VER)
-: 15:# pragma once
-: 16:#endif
-: 17:
-: 18:#include
-: 19:#include
-: 20:#include
-: 21:#include
-: 22:#include
-: 23:#include
-: 24:#include
-: 25:
-: 26:// Doxygen can't handle proto :-(
-: 27:#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
-: 28:# include
-: 29:# include
-: 30:#endif
-: 31:
-: 32:#if BOOST_XPRESSIVE_HAS_MS_STACK_GUARD
-: 33:# include // for _exception_code()
-: 34:# include // for _resetstkoflw()
-: 35:#endif
-: 36:
-: 37:namespace boost { namespace xpressive
-: 38:{
-: 39:
-: 40:namespace detail
-: 41:{
-: 42: inline void throw_on_stack_error(bool stack_error)
-: 43: {
-: 44: BOOST_XPR_ENSURE_(!stack_error, regex_constants::error_stack, "Regex stack space exhausted");
-: 45: }
-: 46:}
-: 47:
-: 48:///////////////////////////////////////////////////////////////////////////////
-: 49:// basic_regex
-: 50://
-: 51:/// \brief Class template basic_regex\<\> is a class for holding a compiled regular expression.
-: 52:template
function _ZN5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEED2Ev called 0 returned 0% blocks executed 0%
#####: 53:struct basic_regex
call 0 never executed
call 1 never executed
call 2 never executed
-: 54: : proto::extends<
-: 55: proto::expr > >, 0>
-: 56: , basic_regex
-: 57: , detail::regex_domain
-: 58: >
-: 59:{
-: 60:private:
-: 61: typedef proto::expr > >, 0> pimpl_type;
-: 62: typedef proto::extends, detail::regex_domain> base_type;
-: 63:
-: 64:public:
-: 65: typedef BidiIter iterator_type;
-: 66: typedef typename iterator_value::type char_type;
-: 67: // For compatibility with std::basic_regex
-: 68: typedef typename iterator_value::type value_type;
-: 69: typedef typename detail::string_type::type string_type;
-: 70: typedef regex_constants::syntax_option_type flag_type;
-: 71:
-: 72: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, ECMAScript = regex_constants::ECMAScript);
-: 73: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, icase = regex_constants::icase_);
-: 74: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, nosubs = regex_constants::nosubs);
-: 75: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, optimize = regex_constants::optimize);
-: 76: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, collate = regex_constants::collate);
-: 77: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, single_line = regex_constants::single_line);
-: 78: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, not_dot_null = regex_constants::not_dot_null);
-: 79: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, not_dot_newline = regex_constants::not_dot_newline);
-: 80: BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, ignore_white_space = regex_constants::ignore_white_space);
-: 81:
-: 82: /// \post regex_id() == 0
-: 83: /// \post mark_count() == 0
function _ZN5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEC2Ev called 0 returned 0% blocks executed 0%
#####: 84: basic_regex()
call 0 never executed
#####: 85: : base_type()
call 0 never executed
-: 86: {
#####: 87: }
-: 88:
-: 89: /// \param that The basic_regex object to copy.
-: 90: /// \post regex_id() == that.regex_id()
-: 91: /// \post mark_count() == that.mark_count()
function _ZN5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEC2ERKSD_ called 0 returned 0% blocks executed 0%
#####: 92: basic_regex(basic_regex const &that)
call 0 never executed
#####: 93: : base_type(that)
call 0 never executed
call 1 never executed
-: 94: {
#####: 95: }
-: 96:
-: 97: /// \param that The basic_regex object to copy.
-: 98: /// \post regex_id() == that.regex_id()
-: 99: /// \post mark_count() == that.mark_count()
-: 100: /// \return *this
-: 101: basic_regex &operator =(basic_regex const &that)
-: 102: {
-: 103: proto::value(*this) = proto::value(that);
-: 104: return *this;
-: 105: }
-: 106:
-: 107: /// Construct from a static regular expression.
-: 108: ///
-: 109: /// \param expr The static regular expression
-: 110: /// \pre Expr is the type of a static regular expression.
-: 111: /// \post regex_id() != 0
-: 112: /// \post mark_count() \>= 0
-: 113: template
-: 114: basic_regex(Expr const &expr)
-: 115: : base_type()
-: 116: {
-: 117: BOOST_XPRESSIVE_CHECK_REGEX(Expr, char_type);
-: 118: this->compile_(expr, is_valid_regex());
-: 119: }
-: 120:
-: 121: /// Construct from a static regular expression.
-: 122: ///
-: 123: /// \param expr The static regular expression.
-: 124: /// \pre Expr is the type of a static regular expression.
-: 125: /// \post regex_id() != 0
-: 126: /// \post mark_count() \>= 0
-: 127: /// \throw std::bad_alloc on out of memory
-: 128: /// \return *this
-: 129: template
-: 130: basic_regex &operator =(Expr const &expr)
-: 131: {
-: 132: BOOST_XPRESSIVE_CHECK_REGEX(Expr, char_type);
-: 133: this->compile_(expr, is_valid_regex());
-: 134: return *this;
-: 135: }
-: 136:
-: 137: /// Returns the count of capturing sub-expressions in this regular expression
-: 138: ///
-: 139: std::size_t mark_count() const
-: 140: {
-: 141: return proto::value(*this) ? proto::value(*this)->mark_count_ : 0;
-: 142: }
-: 143:
-: 144: /// Returns a token which uniquely identifies this regular expression.
-: 145: ///
function _ZNK5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE8regex_idEv called 0 returned 0% blocks executed 0%
#####: 146: regex_id_type regex_id() const
-: 147: {
#####: 148: return proto::value(*this) ? proto::value(*this)->xpr_.get() : 0;
call 0 never executed
call 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
call 9 never executed
-: 149: }
-: 150:
-: 151: /// Swaps the contents of this basic_regex object with another.
-: 152: ///
-: 153: /// \param that The other basic_regex object.
-: 154: /// \attention This is a shallow swap that does not do reference tracking.
-: 155: /// If you embed a basic_regex object by reference in another
-: 156: /// regular expression and then swap its contents with another
-: 157: /// basic_regex object, the change will not be visible to the
-: 158: /// enclosing regular expression. It is done this way to ensure
-: 159: /// that swap() cannot throw.
-: 160: /// \throw nothrow
-: 161: void swap(basic_regex &that) // throw()
-: 162: {
-: 163: proto::value(*this).swap(proto::value(that));
-: 164: }
-: 165:
-: 166: /// Factory method for building a regex object from a range of characters.
-: 167: /// Equivalent to regex_compiler\< BidiIter \>().compile(begin, end, flags);
-: 168: ///
-: 169: /// \param begin The beginning of a range of characters representing the
-: 170: /// regular expression to compile.
-: 171: /// \param end The end of a range of characters representing the
-: 172: /// regular expression to compile.
-: 173: /// \param flags Optional bitmask that determines how the pat string is
-: 174: /// interpreted. (See syntax_option_type.)
-: 175: /// \return A basic_regex object corresponding to the regular expression
-: 176: /// represented by the character range.
-: 177: /// \pre [begin,end) is a valid range.
-: 178: /// \pre The range of characters specified by [begin,end) contains a
-: 179: /// valid string-based representation of a regular expression.
-: 180: /// \throw regex_error when the range of characters has invalid regular
-: 181: /// expression syntax.
-: 182: template
-: 183: static basic_regex compile(InputIter begin, InputIter end, flag_type flags = regex_constants::ECMAScript)
-: 184: {
-: 185: return regex_compiler().compile(begin, end, flags);
-: 186: }
-: 187:
-: 188: /// \overload
-: 189: ///
-: 190: template
function _ZN5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE7compileISB_EESD_RKT_NS0_15regex_constants18syntax_option_typeE called 0 returned 0% blocks executed 0%
#####: 191: static basic_regex compile(InputRange const &pat, flag_type flags = regex_constants::ECMAScript)
-: 192: {
#####: 193: return regex_compiler().compile(pat, flags);
call 0 never executed
call 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
call 5 never executed
call 6 never executed
branch 7 never executed
branch 8 never executed
call 9 never executed
call 10 never executed
call 11 never executed
call 12 never executed
-: 194: }
-: 195:
-: 196: /// \overload
-: 197: ///
function _ZN5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE7compileES5_NS0_15regex_constants18syntax_option_typeE called 0 returned 0% blocks executed 0%
#####: 198: static basic_regex compile(char_type const *begin, flag_type flags = regex_constants::ECMAScript)
-: 199: {
#####: 200: return regex_compiler().compile(begin, flags);
call 0 never executed
call 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
call 5 never executed
call 6 never executed
branch 7 never executed
branch 8 never executed
call 9 never executed
call 10 never executed
call 11 never executed
call 12 never executed
-: 201: }
-: 202:
-: 203: /// \overload
-: 204: ///
-: 205: static basic_regex compile(char_type const *begin, std::size_t len, flag_type flags)
-: 206: {
-: 207: return regex_compiler().compile(begin, len, flags);
-: 208: }
-: 209:
-: 210:private:
-: 211: friend struct detail::core_access;
-: 212:
-: 213: // Avoid a common programming mistake. Construction from a string is
-: 214: // ambiguous. It could mean:
-: 215: // sregex rx = sregex::compile(str); // compile the string into a regex
-: 216: // or
-: 217: // sregex rx = as_xpr(str); // treat the string as a literal
-: 218: // Since there is no easy way to disambiguate, it is disallowed. You must
-: 219: // say what you mean.
-: 220:
-: 221: /// INTERNAL ONLY
-: 222: basic_regex(char_type const *);
-: 223: /// INTERNAL ONLY
-: 224: basic_regex(string_type const &);
-: 225:
-: 226: /// INTERNAL ONLY
function _ZNK5boost9xpressive11basic_regexIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE6match_ERNS0_6detail11match_stateISC_EE called 0 returned 0% blocks executed 0%
#####: 227: bool match_(detail::match_state &state) const
-: 228: {
-: 229: #if BOOST_XPRESSIVE_HAS_MS_STACK_GUARD
-: 230: bool success = false, stack_error = false;
-: 231: __try
-: 232: {
-: 233: success = proto::value(*this)->xpr_->match(state);
-: 234: }
-: 235: __except(_exception_code() == 0xC00000FDUL)
-: 236: {
-: 237: stack_error = true;
-: 238: _resetstkoflw();
-: 239: }
-: 240: detail::throw_on_stack_error(stack_error);
-: 241: return success;
-: 242: #else
#####: 243: return proto::value(*this)->xpr_->match(state);
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
call 9 never executed
call 10 never executed
-: 244: #endif
-: 245: }
-: 246:
-: 247: // Compiles valid static regexes into a state machine.
-: 248: /// INTERNAL ONLY
-: 249: template
-: 250: void compile_(Expr const &expr, mpl::true_)
-: 251: {
-: 252: detail::static_compile(expr, proto::value(*this).get());
-: 253: }
-: 254:
-: 255: // No-op for invalid static regexes.
-: 256: /// INTERNAL ONLY
-: 257: template
-: 258: void compile_(Expr const &, mpl::false_)
-: 259: {
-: 260: }
-: 261:};
-: 262:
-: 263:#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-: 264:template regex_constants::syntax_option_type const basic_regex::ECMAScript;
-: 265:template regex_constants::syntax_option_type const basic_regex::icase;
-: 266:template regex_constants::syntax_option_type const basic_regex::nosubs;
-: 267:template regex_constants::syntax_option_type const basic_regex::optimize;
-: 268:template regex_constants::syntax_option_type const basic_regex::collate;
-: 269:template regex_constants::syntax_option_type const basic_regex::single_line;
-: 270:template regex_constants::syntax_option_type const basic_regex::not_dot_null;
-: 271:template regex_constants::syntax_option_type const basic_regex::not_dot_newline;
-: 272:template regex_constants::syntax_option_type const basic_regex::ignore_white_space;
-: 273:#endif
-: 274:
-: 275:///////////////////////////////////////////////////////////////////////////////
-: 276:// swap
-: 277:/// \brief Swaps the contents of two basic_regex objects.
-: 278:/// \param left The first basic_regex object.
-: 279:/// \param right The second basic_regex object.
-: 280:/// \attention This is a shallow swap that does not do reference tracking.
-: 281:/// If you embed a basic_regex object by reference in another
-: 282:/// regular expression and then swap its contents with another
-: 283:/// basic_regex object, the change will not be visible to the
-: 284:/// enclosing regular expression. It is done this way to ensure
-: 285:/// that swap() cannot throw.
-: 286:/// \throw nothrow
-: 287:template
-: 288:inline void swap(basic_regex &left, basic_regex &right) // throw()
-: 289:{
-: 290: left.swap(right);
-: 291:}
-: 292:
-: 293:}} // namespace boost::xpressive
-: 294:
-: 295:#endif // BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005
<<<<<< EOF
# path=/home/travis/build/richelbilderbeek/TicTacToe/^#RibiClasses#CppMenuDialog#menudialog.cpp.gcov
-: 0:Source:../RibiClasses/CppMenuDialog/menudialog.cpp
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/menudialog.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/menudialog.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:#include "menudialog.h"
-: 2:#include
-: 3:#include
-: 4:#include
-: 5:
function _ZN4ribi10MenuDialogC2Ev called 1 returned 100% blocks executed 100%
1: 6:ribi::MenuDialog::MenuDialog()
call 0 returned 100%
call 1 returned 100%
call 2 returned 100%
-: 7:{
-: 8:
1: 9:}
-: 10:
function _ZN4ribi10MenuDialogD0Ev called 0 returned 0% blocks executed 0%
function _ZN4ribi10MenuDialogD2Ev called 1 returned 100% blocks executed 100%
1: 11:ribi::MenuDialog::~MenuDialog() noexcept
call 0 returned 100%
call 1 returned 100%
-: 12:{
-: 13:
1: 14:}
call 0 never executed
call 1 never executed
-: 15:
function _ZN4ribi10MenuDialog16ConvertArgumentsB5cxx11EiPKPKc called 0 returned 0% blocks executed 0%
#####: 16:std::vector ribi::MenuDialog::ConvertArguments(
-: 17: const int argc, const char * const argv[]) noexcept
-: 18:{
#####: 19: std::vector v;
call 0 never executed
#####: 20: v.reserve(argc);
call 0 never executed
#####: 21: for (int i=0; i!=argc; ++i)
branch 0 never executed
branch 1 never executed
-: 22: {
#####: 23: v.push_back(std::string(argv[i]));
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
-: 24: }
#####: 25: assert(argc == static_cast(v.size()));
call 0 never executed
branch 1 never executed
branch 2 never executed
call 3 never executed
#####: 26: return v;
-: 27:}
-: 28:
function _ZN4ribi10MenuDialog7ExecuteERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EE called 1 returned 100% blocks executed 40%
1: 29:int ribi::MenuDialog::Execute(
-: 30: const std::vector& argv
-: 31:) noexcept
-: 32:{
1: 33: const int argc = static_cast(argv.size());
call 0 returned 100%
call 1 returned 100%
1: 34: if (argc <= 1)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
-: 35: {
#####: 36: return ExecuteSpecific(argv);
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
-: 37: }
2: 38: const std::string s = argv[1];
call 0 returned 100%
call 1 returned 100%
call 2 returned 100%
call 3 returned 100%
call 4 returned 100%
1: 39: if (s == "--about" || s == "-a")
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
call 3 returned 100%
branch 4 taken 0% (fallthrough)
branch 5 taken 100%
branch 6 taken 0% (fallthrough)
branch 7 taken 100%
-: 40: {
#####: 41: const std::vector v { GetAbout().CreateAboutText() };
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
#####: 42: std::copy(
call 0 never executed
call 1 never executed
call 2 never executed
-: 43: std::begin(v),
-: 44: std::end(v),
#####: 45: std::ostream_iterator(std::cout,"\n")
call 0 never executed
-: 46: );
-: 47: std::cout
-: 48: << "\n"
-: 49: << "Source code built on "
-: 50: << __DATE__
-: 51: << " "
-: 52: << __TIME__
-: 53: << " ("
-: 54: #ifdef NDEBUG
-: 55: << "release"
-: 56: #else
-: 57: << "debug"
-: 58: #endif
-: 59: << " version)"
#####: 60: << '\n';
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
#####: 61: return 0;
-: 62: }
1: 63: else if (s == "--help" || s == "-h")
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
call 3 returned 100%
branch 4 taken 0% (fallthrough)
branch 5 taken 100%
branch 6 taken 0% (fallthrough)
branch 7 taken 100%
-: 64: {
#####: 65: std::cout << GetHelp() << '\n';
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
#####: 66: return 0;
-: 67: }
1: 68: else if (s == "--history" || s == "-i")
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
call 3 returned 100%
branch 4 taken 0% (fallthrough)
branch 5 taken 100%
branch 6 taken 0% (fallthrough)
branch 7 taken 100%
-: 69: {
#####: 70: const std::vector v { GetVersionHistory() };
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
#####: 71: std::copy(
call 0 never executed
call 1 never executed
call 2 never executed
-: 72: std::begin(v),
-: 73: std::end(v),
#####: 74: std::ostream_iterator(std::cout,"\n")
call 0 never executed
-: 75: );
#####: 76: return 0;
-: 77: }
1: 78: else if (s == "--license" || s == "--licence" || s == "-l")
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
call 3 returned 100%
branch 4 taken 100% (fallthrough)
branch 5 taken 0%
call 6 returned 100%
branch 7 taken 0% (fallthrough)
branch 8 taken 100%
branch 9 taken 0% (fallthrough)
branch 10 taken 100%
-: 79: {
#####: 80: const std::vector v { GetAbout().CreateLicenceText() };
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
#####: 81: std::copy(
call 0 never executed
call 1 never executed
call 2 never executed
-: 82: std::begin(v),
-: 83: std::end(v),
#####: 84: std::ostream_iterator(std::cout,"\n")
call 0 never executed
-: 85: );
#####: 86: return 0;
-: 87: }
1: 88: else if (s == "--version" || s == "-v")
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
call 3 returned 100%
branch 4 taken 0% (fallthrough)
branch 5 taken 100%
branch 6 taken 0% (fallthrough)
branch 7 taken 100%
-: 89: {
#####: 90: const std::vector v = { GetAbout().CreateLibrariesUsedText() };
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
#####: 91: std::copy(
call 0 never executed
call 1 never executed
call 2 never executed
-: 92: std::begin(v),
-: 93: std::end(v),
#####: 94: std::ostream_iterator(std::cout,"\n")
call 0 never executed
-: 95: );
#####: 96: return 0;
-: 97: }
1: 98: return ExecuteSpecific(argv);
call 0 returned 100%
call 1 returned 100%
call 2 returned 100%
call 3 returned 100%
call 4 returned 100%
call 5 returned 100%
function _GLOBAL__sub_I_menudialog.cpp called 1 returned 100% blocks executed 100%
function _Z41__static_initialization_and_destruction_0ii called 1 returned 100% blocks executed 100%
3: 99:}
call 0 returned 100%
branch 1 taken 100% (fallthrough)
branch 2 taken 0%
branch 3 taken 100% (fallthrough)
branch 4 taken 0%
<<<<<< EOF
# path=/home/travis/build/richelbilderbeek/TicTacToe/#usr#include#c++#7#bits#stl_iterator.h.gcov
-: 0:Source:/usr/include/c++/7/bits/stl_iterator.h
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/dotmatrixtext.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/dotmatrixtext.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:// Iterators -*- C++ -*-
-: 2:
-: 3:// Copyright (C) 2001-2017 Free Software Foundation, Inc.
-: 4://
-: 5:// This file is part of the GNU ISO C++ Library. This library is free
-: 6:// software; you can redistribute it and/or modify it under the
-: 7:// terms of the GNU General Public License as published by the
-: 8:// Free Software Foundation; either version 3, or (at your option)
-: 9:// any later version.
-: 10:
-: 11:// This library is distributed in the hope that it will be useful,
-: 12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
-: 13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-: 14:// GNU General Public License for more details.
-: 15:
-: 16:// Under Section 7 of GPL version 3, you are granted additional
-: 17:// permissions described in the GCC Runtime Library Exception, version
-: 18:// 3.1, as published by the Free Software Foundation.
-: 19:
-: 20:// You should have received a copy of the GNU General Public License and
-: 21:// a copy of the GCC Runtime Library Exception along with this program;
-: 22:// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-: 23:// .
-: 24:
-: 25:/*
-: 26: *
-: 27: * Copyright (c) 1994
-: 28: * Hewlett-Packard Company
-: 29: *
-: 30: * Permission to use, copy, modify, distribute and sell this software
-: 31: * and its documentation for any purpose is hereby granted without fee,
-: 32: * provided that the above copyright notice appear in all copies and
-: 33: * that both that copyright notice and this permission notice appear
-: 34: * in supporting documentation. Hewlett-Packard Company makes no
-: 35: * representations about the suitability of this software for any
-: 36: * purpose. It is provided "as is" without express or implied warranty.
-: 37: *
-: 38: *
-: 39: * Copyright (c) 1996-1998
-: 40: * Silicon Graphics Computer Systems, Inc.
-: 41: *
-: 42: * Permission to use, copy, modify, distribute and sell this software
-: 43: * and its documentation for any purpose is hereby granted without fee,
-: 44: * provided that the above copyright notice appear in all copies and
-: 45: * that both that copyright notice and this permission notice appear
-: 46: * in supporting documentation. Silicon Graphics makes no
-: 47: * representations about the suitability of this software for any
-: 48: * purpose. It is provided "as is" without express or implied warranty.
-: 49: */
-: 50:
-: 51:/** @file bits/stl_iterator.h
-: 52: * This is an internal header file, included by other library headers.
-: 53: * Do not attempt to use it directly. @headername{iterator}
-: 54: *
-: 55: * This file implements reverse_iterator, back_insert_iterator,
-: 56: * front_insert_iterator, insert_iterator, __normal_iterator, and their
-: 57: * supporting functions and overloaded operators.
-: 58: */
-: 59:
-: 60:#ifndef _STL_ITERATOR_H
-: 61:#define _STL_ITERATOR_H 1
-: 62:
-: 63:#include
-: 64:#include
-: 65:#include
-: 66:#include
-: 67:
-: 68:#if __cplusplus > 201402L
-: 69:# define __cpp_lib_array_constexpr 201603
-: 70:#endif
-: 71:
-: 72:namespace std _GLIBCXX_VISIBILITY(default)
-: 73:{
-: 74:_GLIBCXX_BEGIN_NAMESPACE_VERSION
-: 75:
-: 76: /**
-: 77: * @addtogroup iterators
-: 78: * @{
-: 79: */
-: 80:
-: 81: // 24.4.1 Reverse iterators
-: 82: /**
-: 83: * Bidirectional and random access iterators have corresponding reverse
-: 84: * %iterator adaptors that iterate through the data structure in the
-: 85: * opposite direction. They have the same signatures as the corresponding
-: 86: * iterators. The fundamental relation between a reverse %iterator and its
-: 87: * corresponding %iterator @c i is established by the identity:
-: 88: * @code
-: 89: * &*(reverse_iterator(i)) == &*(i - 1)
-: 90: * @endcode
-: 91: *
-: 92: * This mapping is dictated by the fact that while there is always a
-: 93: * pointer past the end of an array, there might not be a valid pointer
-: 94: * before the beginning of an array. [24.4.1]/1,2
-: 95: *
-: 96: * Reverse iterators can be tricky and surprising at first. Their
-: 97: * semantics make sense, however, and the trickiness is a side effect of
-: 98: * the requirement that the iterators must be safe.
-: 99: */
-: 100: template
-: 101: class reverse_iterator
-: 102: : public iterator::iterator_category,
-: 103: typename iterator_traits<_Iterator>::value_type,
-: 104: typename iterator_traits<_Iterator>::difference_type,
-: 105: typename iterator_traits<_Iterator>::pointer,
-: 106: typename iterator_traits<_Iterator>::reference>
-: 107: {
-: 108: protected:
-: 109: _Iterator current;
-: 110:
-: 111: typedef iterator_traits<_Iterator> __traits_type;
-: 112:
-: 113: public:
-: 114: typedef _Iterator iterator_type;
-: 115: typedef typename __traits_type::difference_type difference_type;
-: 116: typedef typename __traits_type::pointer pointer;
-: 117: typedef typename __traits_type::reference reference;
-: 118:
-: 119: /**
-: 120: * The default constructor value-initializes member @p current.
-: 121: * If it is a pointer, that means it is zero-initialized.
-: 122: */
-: 123: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 124: // 235 No specification of default ctor for reverse_iterator
-: 125: // 1012. reverse_iterator default ctor should value initialize
-: 126: _GLIBCXX17_CONSTEXPR
-: 127: reverse_iterator() : current() { }
-: 128:
-: 129: /**
-: 130: * This %iterator will move in the opposite direction that @p x does.
-: 131: */
-: 132: explicit _GLIBCXX17_CONSTEXPR
-: 133: reverse_iterator(iterator_type __x) : current(__x) { }
-: 134:
-: 135: /**
-: 136: * The copy constructor is normal.
-: 137: */
-: 138: _GLIBCXX17_CONSTEXPR
-: 139: reverse_iterator(const reverse_iterator& __x)
-: 140: : current(__x.current) { }
-: 141:
-: 142: /**
-: 143: * A %reverse_iterator across other types can be copied if the
-: 144: * underlying %iterator can be converted to the type of @c current.
-: 145: */
-: 146: template
-: 147: _GLIBCXX17_CONSTEXPR
-: 148: reverse_iterator(const reverse_iterator<_Iter>& __x)
-: 149: : current(__x.base()) { }
-: 150:
-: 151: /**
-: 152: * @return @c current, the %iterator used for underlying work.
-: 153: */
-: 154: _GLIBCXX17_CONSTEXPR iterator_type
-: 155: base() const
-: 156: { return current; }
-: 157:
-: 158: /**
-: 159: * @return A reference to the value at @c --current
-: 160: *
-: 161: * This requires that @c --current is dereferenceable.
-: 162: *
-: 163: * @warning This implementation requires that for an iterator of the
-: 164: * underlying iterator type, @c x, a reference obtained by
-: 165: * @c *x remains valid after @c x has been modified or
-: 166: * destroyed. This is a bug: http://gcc.gnu.org/PR51823
-: 167: */
-: 168: _GLIBCXX17_CONSTEXPR reference
-: 169: operator*() const
-: 170: {
-: 171: _Iterator __tmp = current;
-: 172: return *--__tmp;
-: 173: }
-: 174:
-: 175: /**
-: 176: * @return A pointer to the value at @c --current
-: 177: *
-: 178: * This requires that @c --current is dereferenceable.
-: 179: */
-: 180: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 181: // 2188. Reverse iterator does not fully support targets that overload &
-: 182: _GLIBCXX17_CONSTEXPR pointer
-: 183: operator->() const
-: 184: { return std::__addressof(operator*()); }
-: 185:
-: 186: /**
-: 187: * @return @c *this
-: 188: *
-: 189: * Decrements the underlying iterator.
-: 190: */
-: 191: _GLIBCXX17_CONSTEXPR reverse_iterator&
-: 192: operator++()
-: 193: {
-: 194: --current;
-: 195: return *this;
-: 196: }
-: 197:
-: 198: /**
-: 199: * @return The original value of @c *this
-: 200: *
-: 201: * Decrements the underlying iterator.
-: 202: */
-: 203: _GLIBCXX17_CONSTEXPR reverse_iterator
-: 204: operator++(int)
-: 205: {
-: 206: reverse_iterator __tmp = *this;
-: 207: --current;
-: 208: return __tmp;
-: 209: }
-: 210:
-: 211: /**
-: 212: * @return @c *this
-: 213: *
-: 214: * Increments the underlying iterator.
-: 215: */
-: 216: _GLIBCXX17_CONSTEXPR reverse_iterator&
-: 217: operator--()
-: 218: {
-: 219: ++current;
-: 220: return *this;
-: 221: }
-: 222:
-: 223: /**
-: 224: * @return A reverse_iterator with the previous value of @c *this
-: 225: *
-: 226: * Increments the underlying iterator.
-: 227: */
-: 228: _GLIBCXX17_CONSTEXPR reverse_iterator
-: 229: operator--(int)
-: 230: {
-: 231: reverse_iterator __tmp = *this;
-: 232: ++current;
-: 233: return __tmp;
-: 234: }
-: 235:
-: 236: /**
-: 237: * @return A reverse_iterator that refers to @c current - @a __n
-: 238: *
-: 239: * The underlying iterator must be a Random Access Iterator.
-: 240: */
-: 241: _GLIBCXX17_CONSTEXPR reverse_iterator
-: 242: operator+(difference_type __n) const
-: 243: { return reverse_iterator(current - __n); }
-: 244:
-: 245: /**
-: 246: * @return *this
-: 247: *
-: 248: * Moves the underlying iterator backwards @a __n steps.
-: 249: * The underlying iterator must be a Random Access Iterator.
-: 250: */
-: 251: _GLIBCXX17_CONSTEXPR reverse_iterator&
-: 252: operator+=(difference_type __n)
-: 253: {
-: 254: current -= __n;
-: 255: return *this;
-: 256: }
-: 257:
-: 258: /**
-: 259: * @return A reverse_iterator that refers to @c current - @a __n
-: 260: *
-: 261: * The underlying iterator must be a Random Access Iterator.
-: 262: */
-: 263: _GLIBCXX17_CONSTEXPR reverse_iterator
-: 264: operator-(difference_type __n) const
-: 265: { return reverse_iterator(current + __n); }
-: 266:
-: 267: /**
-: 268: * @return *this
-: 269: *
-: 270: * Moves the underlying iterator forwards @a __n steps.
-: 271: * The underlying iterator must be a Random Access Iterator.
-: 272: */
-: 273: _GLIBCXX17_CONSTEXPR reverse_iterator&
-: 274: operator-=(difference_type __n)
-: 275: {
-: 276: current += __n;
-: 277: return *this;
-: 278: }
-: 279:
-: 280: /**
-: 281: * @return The value at @c current - @a __n - 1
-: 282: *
-: 283: * The underlying iterator must be a Random Access Iterator.
-: 284: */
-: 285: _GLIBCXX17_CONSTEXPR reference
-: 286: operator[](difference_type __n) const
-: 287: { return *(*this + __n); }
-: 288: };
-: 289:
-: 290: //@{
-: 291: /**
-: 292: * @param __x A %reverse_iterator.
-: 293: * @param __y A %reverse_iterator.
-: 294: * @return A simple bool.
-: 295: *
-: 296: * Reverse iterators forward many operations to their underlying base()
-: 297: * iterators. Others are implemented in terms of one another.
-: 298: *
-: 299: */
-: 300: template
-: 301: inline _GLIBCXX17_CONSTEXPR bool
-: 302: operator==(const reverse_iterator<_Iterator>& __x,
-: 303: const reverse_iterator<_Iterator>& __y)
-: 304: { return __x.base() == __y.base(); }
-: 305:
-: 306: template
-: 307: inline _GLIBCXX17_CONSTEXPR bool
-: 308: operator<(const reverse_iterator<_Iterator>& __x,
-: 309: const reverse_iterator<_Iterator>& __y)
-: 310: { return __y.base() < __x.base(); }
-: 311:
-: 312: template
-: 313: inline _GLIBCXX17_CONSTEXPR bool
-: 314: operator!=(const reverse_iterator<_Iterator>& __x,
-: 315: const reverse_iterator<_Iterator>& __y)
-: 316: { return !(__x == __y); }
-: 317:
-: 318: template
-: 319: inline _GLIBCXX17_CONSTEXPR bool
-: 320: operator>(const reverse_iterator<_Iterator>& __x,
-: 321: const reverse_iterator<_Iterator>& __y)
-: 322: { return __y < __x; }
-: 323:
-: 324: template
-: 325: inline _GLIBCXX17_CONSTEXPR bool
-: 326: operator<=(const reverse_iterator<_Iterator>& __x,
-: 327: const reverse_iterator<_Iterator>& __y)
-: 328: { return !(__y < __x); }
-: 329:
-: 330: template
-: 331: inline _GLIBCXX17_CONSTEXPR bool
-: 332: operator>=(const reverse_iterator<_Iterator>& __x,
-: 333: const reverse_iterator<_Iterator>& __y)
-: 334: { return !(__x < __y); }
-: 335:
-: 336: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 337: // DR 280. Comparison of reverse_iterator to const reverse_iterator.
-: 338: template
-: 339: inline _GLIBCXX17_CONSTEXPR bool
-: 340: operator==(const reverse_iterator<_IteratorL>& __x,
-: 341: const reverse_iterator<_IteratorR>& __y)
-: 342: { return __x.base() == __y.base(); }
-: 343:
-: 344: template
-: 345: inline _GLIBCXX17_CONSTEXPR bool
-: 346: operator<(const reverse_iterator<_IteratorL>& __x,
-: 347: const reverse_iterator<_IteratorR>& __y)
-: 348: { return __y.base() < __x.base(); }
-: 349:
-: 350: template
-: 351: inline _GLIBCXX17_CONSTEXPR bool
-: 352: operator!=(const reverse_iterator<_IteratorL>& __x,
-: 353: const reverse_iterator<_IteratorR>& __y)
-: 354: { return !(__x == __y); }
-: 355:
-: 356: template
-: 357: inline _GLIBCXX17_CONSTEXPR bool
-: 358: operator>(const reverse_iterator<_IteratorL>& __x,
-: 359: const reverse_iterator<_IteratorR>& __y)
-: 360: { return __y < __x; }
-: 361:
-: 362: template
-: 363: inline _GLIBCXX17_CONSTEXPR bool
-: 364: operator<=(const reverse_iterator<_IteratorL>& __x,
-: 365: const reverse_iterator<_IteratorR>& __y)
-: 366: { return !(__y < __x); }
-: 367:
-: 368: template
-: 369: inline _GLIBCXX17_CONSTEXPR bool
-: 370: operator>=(const reverse_iterator<_IteratorL>& __x,
-: 371: const reverse_iterator<_IteratorR>& __y)
-: 372: { return !(__x < __y); }
-: 373: //@}
-: 374:
-: 375:#if __cplusplus < 201103L
-: 376: template
-: 377: inline typename reverse_iterator<_Iterator>::difference_type
-: 378: operator-(const reverse_iterator<_Iterator>& __x,
-: 379: const reverse_iterator<_Iterator>& __y)
-: 380: { return __y.base() - __x.base(); }
-: 381:
-: 382: template
-: 383: inline typename reverse_iterator<_IteratorL>::difference_type
-: 384: operator-(const reverse_iterator<_IteratorL>& __x,
-: 385: const reverse_iterator<_IteratorR>& __y)
-: 386: { return __y.base() - __x.base(); }
-: 387:#else
-: 388: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 389: // DR 685. reverse_iterator/move_iterator difference has invalid signatures
-: 390: template
-: 391: inline _GLIBCXX17_CONSTEXPR auto
-: 392: operator-(const reverse_iterator<_IteratorL>& __x,
-: 393: const reverse_iterator<_IteratorR>& __y)
-: 394: -> decltype(__y.base() - __x.base())
-: 395: { return __y.base() - __x.base(); }
-: 396:#endif
-: 397:
-: 398: template
-: 399: inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
-: 400: operator+(typename reverse_iterator<_Iterator>::difference_type __n,
-: 401: const reverse_iterator<_Iterator>& __x)
-: 402: { return reverse_iterator<_Iterator>(__x.base() - __n); }
-: 403:
-: 404:#if __cplusplus >= 201103L
-: 405: // Same as C++14 make_reverse_iterator but used in C++03 mode too.
-: 406: template
-: 407: inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
-: 408: __make_reverse_iterator(_Iterator __i)
-: 409: { return reverse_iterator<_Iterator>(__i); }
-: 410:
-: 411:# if __cplusplus > 201103L
-: 412:# define __cpp_lib_make_reverse_iterator 201402
-: 413:
-: 414: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 415: // DR 2285. make_reverse_iterator
-: 416: /// Generator function for reverse_iterator.
-: 417: template
-: 418: inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
-: 419: make_reverse_iterator(_Iterator __i)
-: 420: { return reverse_iterator<_Iterator>(__i); }
-: 421:# endif
-: 422:#endif
-: 423:
-: 424:#if __cplusplus >= 201103L
-: 425: template
-: 426: auto
-: 427: __niter_base(reverse_iterator<_Iterator> __it)
-: 428: -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
-: 429: { return __make_reverse_iterator(__niter_base(__it.base())); }
-: 430:
-: 431: template
-: 432: struct __is_move_iterator >
-: 433: : __is_move_iterator<_Iterator>
-: 434: { };
-: 435:
-: 436: template
-: 437: auto
-: 438: __miter_base(reverse_iterator<_Iterator> __it)
-: 439: -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
-: 440: { return __make_reverse_iterator(__miter_base(__it.base())); }
-: 441:#endif
-: 442:
-: 443: // 24.4.2.2.1 back_insert_iterator
-: 444: /**
-: 445: * @brief Turns assignment into insertion.
-: 446: *
-: 447: * These are output iterators, constructed from a container-of-T.
-: 448: * Assigning a T to the iterator appends it to the container using
-: 449: * push_back.
-: 450: *
-: 451: * Tip: Using the back_inserter function to create these iterators can
-: 452: * save typing.
-: 453: */
-: 454: template
-: 455: class back_insert_iterator
-: 456: : public iterator
-: 457: {
-: 458: protected:
-: 459: _Container* container;
-: 460:
-: 461: public:
-: 462: /// A nested typedef for the type of whatever container you used.
-: 463: typedef _Container container_type;
-: 464:
-: 465: /// The only way to create this %iterator is with a container.
-: 466: explicit
-: 467: back_insert_iterator(_Container& __x)
-: 468: : container(std::__addressof(__x)) { }
-: 469:
-: 470: /**
-: 471: * @param __value An instance of whatever type
-: 472: * container_type::const_reference is; presumably a
-: 473: * reference-to-const T for container.
-: 474: * @return This %iterator, for chained operations.
-: 475: *
-: 476: * This kind of %iterator doesn't really have a @a position in the
-: 477: * container (you can think of the position as being permanently at
-: 478: * the end, if you like). Assigning a value to the %iterator will
-: 479: * always append the value to the end of the container.
-: 480: */
-: 481:#if __cplusplus < 201103L
-: 482: back_insert_iterator&
-: 483: operator=(typename _Container::const_reference __value)
-: 484: {
-: 485: container->push_back(__value);
-: 486: return *this;
-: 487: }
-: 488:#else
-: 489: back_insert_iterator&
-: 490: operator=(const typename _Container::value_type& __value)
-: 491: {
-: 492: container->push_back(__value);
-: 493: return *this;
-: 494: }
-: 495:
-: 496: back_insert_iterator&
-: 497: operator=(typename _Container::value_type&& __value)
-: 498: {
-: 499: container->push_back(std::move(__value));
-: 500: return *this;
-: 501: }
-: 502:#endif
-: 503:
-: 504: /// Simply returns *this.
-: 505: back_insert_iterator&
-: 506: operator*()
-: 507: { return *this; }
-: 508:
-: 509: /// Simply returns *this. (This %iterator does not @a move.)
-: 510: back_insert_iterator&
-: 511: operator++()
-: 512: { return *this; }
-: 513:
-: 514: /// Simply returns *this. (This %iterator does not @a move.)
-: 515: back_insert_iterator
-: 516: operator++(int)
-: 517: { return *this; }
-: 518: };
-: 519:
-: 520: /**
-: 521: * @param __x A container of arbitrary type.
-: 522: * @return An instance of back_insert_iterator working on @p __x.
-: 523: *
-: 524: * This wrapper function helps in creating back_insert_iterator instances.
-: 525: * Typing the name of the %iterator requires knowing the precise full
-: 526: * type of the container, which can be tedious and impedes generic
-: 527: * programming. Using this function lets you take advantage of automatic
-: 528: * template parameter deduction, making the compiler match the correct
-: 529: * types for you.
-: 530: */
-: 531: template
-: 532: inline back_insert_iterator<_Container>
-: 533: back_inserter(_Container& __x)
-: 534: { return back_insert_iterator<_Container>(__x); }
-: 535:
-: 536: /**
-: 537: * @brief Turns assignment into insertion.
-: 538: *
-: 539: * These are output iterators, constructed from a container-of-T.
-: 540: * Assigning a T to the iterator prepends it to the container using
-: 541: * push_front.
-: 542: *
-: 543: * Tip: Using the front_inserter function to create these iterators can
-: 544: * save typing.
-: 545: */
-: 546: template
-: 547: class front_insert_iterator
-: 548: : public iterator
-: 549: {
-: 550: protected:
-: 551: _Container* container;
-: 552:
-: 553: public:
-: 554: /// A nested typedef for the type of whatever container you used.
-: 555: typedef _Container container_type;
-: 556:
-: 557: /// The only way to create this %iterator is with a container.
-: 558: explicit front_insert_iterator(_Container& __x)
-: 559: : container(std::__addressof(__x)) { }
-: 560:
-: 561: /**
-: 562: * @param __value An instance of whatever type
-: 563: * container_type::const_reference is; presumably a
-: 564: * reference-to-const T for container.
-: 565: * @return This %iterator, for chained operations.
-: 566: *
-: 567: * This kind of %iterator doesn't really have a @a position in the
-: 568: * container (you can think of the position as being permanently at
-: 569: * the front, if you like). Assigning a value to the %iterator will
-: 570: * always prepend the value to the front of the container.
-: 571: */
-: 572:#if __cplusplus < 201103L
-: 573: front_insert_iterator&
-: 574: operator=(typename _Container::const_reference __value)
-: 575: {
-: 576: container->push_front(__value);
-: 577: return *this;
-: 578: }
-: 579:#else
-: 580: front_insert_iterator&
-: 581: operator=(const typename _Container::value_type& __value)
-: 582: {
-: 583: container->push_front(__value);
-: 584: return *this;
-: 585: }
-: 586:
-: 587: front_insert_iterator&
-: 588: operator=(typename _Container::value_type&& __value)
-: 589: {
-: 590: container->push_front(std::move(__value));
-: 591: return *this;
-: 592: }
-: 593:#endif
-: 594:
-: 595: /// Simply returns *this.
-: 596: front_insert_iterator&
-: 597: operator*()
-: 598: { return *this; }
-: 599:
-: 600: /// Simply returns *this. (This %iterator does not @a move.)
-: 601: front_insert_iterator&
-: 602: operator++()
-: 603: { return *this; }
-: 604:
-: 605: /// Simply returns *this. (This %iterator does not @a move.)
-: 606: front_insert_iterator
-: 607: operator++(int)
-: 608: { return *this; }
-: 609: };
-: 610:
-: 611: /**
-: 612: * @param __x A container of arbitrary type.
-: 613: * @return An instance of front_insert_iterator working on @p x.
-: 614: *
-: 615: * This wrapper function helps in creating front_insert_iterator instances.
-: 616: * Typing the name of the %iterator requires knowing the precise full
-: 617: * type of the container, which can be tedious and impedes generic
-: 618: * programming. Using this function lets you take advantage of automatic
-: 619: * template parameter deduction, making the compiler match the correct
-: 620: * types for you.
-: 621: */
-: 622: template
-: 623: inline front_insert_iterator<_Container>
-: 624: front_inserter(_Container& __x)
-: 625: { return front_insert_iterator<_Container>(__x); }
-: 626:
-: 627: /**
-: 628: * @brief Turns assignment into insertion.
-: 629: *
-: 630: * These are output iterators, constructed from a container-of-T.
-: 631: * Assigning a T to the iterator inserts it in the container at the
-: 632: * %iterator's position, rather than overwriting the value at that
-: 633: * position.
-: 634: *
-: 635: * (Sequences will actually insert a @e copy of the value before the
-: 636: * %iterator's position.)
-: 637: *
-: 638: * Tip: Using the inserter function to create these iterators can
-: 639: * save typing.
-: 640: */
-: 641: template
-: 642: class insert_iterator
-: 643: : public iterator
-: 644: {
-: 645: protected:
-: 646: _Container* container;
-: 647: typename _Container::iterator iter;
-: 648:
-: 649: public:
-: 650: /// A nested typedef for the type of whatever container you used.
-: 651: typedef _Container container_type;
-: 652:
-: 653: /**
-: 654: * The only way to create this %iterator is with a container and an
-: 655: * initial position (a normal %iterator into the container).
-: 656: */
-: 657: insert_iterator(_Container& __x, typename _Container::iterator __i)
-: 658: : container(std::__addressof(__x)), iter(__i) {}
-: 659:
-: 660: /**
-: 661: * @param __value An instance of whatever type
-: 662: * container_type::const_reference is; presumably a
-: 663: * reference-to-const T for container.
-: 664: * @return This %iterator, for chained operations.
-: 665: *
-: 666: * This kind of %iterator maintains its own position in the
-: 667: * container. Assigning a value to the %iterator will insert the
-: 668: * value into the container at the place before the %iterator.
-: 669: *
-: 670: * The position is maintained such that subsequent assignments will
-: 671: * insert values immediately after one another. For example,
-: 672: * @code
-: 673: * // vector v contains A and Z
-: 674: *
-: 675: * insert_iterator i (v, ++v.begin());
-: 676: * i = 1;
-: 677: * i = 2;
-: 678: * i = 3;
-: 679: *
-: 680: * // vector v contains A, 1, 2, 3, and Z
-: 681: * @endcode
-: 682: */
-: 683:#if __cplusplus < 201103L
-: 684: insert_iterator&
-: 685: operator=(typename _Container::const_reference __value)
-: 686: {
-: 687: iter = container->insert(iter, __value);
-: 688: ++iter;
-: 689: return *this;
-: 690: }
-: 691:#else
-: 692: insert_iterator&
-: 693: operator=(const typename _Container::value_type& __value)
-: 694: {
-: 695: iter = container->insert(iter, __value);
-: 696: ++iter;
-: 697: return *this;
-: 698: }
-: 699:
-: 700: insert_iterator&
-: 701: operator=(typename _Container::value_type&& __value)
-: 702: {
-: 703: iter = container->insert(iter, std::move(__value));
-: 704: ++iter;
-: 705: return *this;
-: 706: }
-: 707:#endif
-: 708:
-: 709: /// Simply returns *this.
-: 710: insert_iterator&
-: 711: operator*()
-: 712: { return *this; }
-: 713:
-: 714: /// Simply returns *this. (This %iterator does not @a move.)
-: 715: insert_iterator&
-: 716: operator++()
-: 717: { return *this; }
-: 718:
-: 719: /// Simply returns *this. (This %iterator does not @a move.)
-: 720: insert_iterator&
-: 721: operator++(int)
-: 722: { return *this; }
-: 723: };
-: 724:
-: 725: /**
-: 726: * @param __x A container of arbitrary type.
-: 727: * @return An instance of insert_iterator working on @p __x.
-: 728: *
-: 729: * This wrapper function helps in creating insert_iterator instances.
-: 730: * Typing the name of the %iterator requires knowing the precise full
-: 731: * type of the container, which can be tedious and impedes generic
-: 732: * programming. Using this function lets you take advantage of automatic
-: 733: * template parameter deduction, making the compiler match the correct
-: 734: * types for you.
-: 735: */
-: 736: template
-: 737: inline insert_iterator<_Container>
-: 738: inserter(_Container& __x, _Iterator __i)
-: 739: {
-: 740: return insert_iterator<_Container>(__x,
-: 741: typename _Container::iterator(__i));
-: 742: }
-: 743:
-: 744: // @} group iterators
-: 745:
-: 746:_GLIBCXX_END_NAMESPACE_VERSION
-: 747:} // namespace
-: 748:
-: 749:namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
-: 750:{
-: 751:_GLIBCXX_BEGIN_NAMESPACE_VERSION
-: 752:
-: 753: // This iterator adapter is @a normal in the sense that it does not
-: 754: // change the semantics of any of the operators of its iterator
-: 755: // parameter. Its primary purpose is to convert an iterator that is
-: 756: // not a class, e.g. a pointer, into an iterator that is a class.
-: 757: // The _Container parameter exists solely so that different containers
-: 758: // using this template can instantiate different types, even if the
-: 759: // _Iterator parameter is the same.
-: 760: using std::iterator_traits;
-: 761: using std::iterator;
-: 762: template
-: 763: class __normal_iterator
-: 764: {
-: 765: protected:
-: 766: _Iterator _M_current;
-: 767:
-: 768: typedef iterator_traits<_Iterator> __traits_type;
-: 769:
-: 770: public:
-: 771: typedef _Iterator iterator_type;
-: 772: typedef typename __traits_type::iterator_category iterator_category;
-: 773: typedef typename __traits_type::value_type value_type;
-: 774: typedef typename __traits_type::difference_type difference_type;
-: 775: typedef typename __traits_type::reference reference;
-: 776: typedef typename __traits_type::pointer pointer;
-: 777:
-: 778: _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
-: 779: : _M_current(_Iterator()) { }
-: 780:
-: 781: explicit
function _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEC2ERKS7_ called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxx17__normal_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEC2ERKS7_ called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxx17__normal_iteratorIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEC2ERKS8_ called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEC2ERKS8_ called 0 returned 0% blocks executed 0%
#####: 782: __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
#####: 783: : _M_current(__i) { }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
-: 784:
-: 785: // Allow iterator to const_iterator conversion
-: 786: template
-: 787: __normal_iterator(const __normal_iterator<_Iter,
-: 788: typename __enable_if<
-: 789: (std::__are_same<_Iter, typename _Container::pointer>::__value),
-: 790: _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
-: 791: : _M_current(__i.base()) { }
-: 792:
-: 793: // Forward iterator requirements
-: 794: reference
function _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv called 0 returned 0% blocks executed 0%
function _ZNK9__gnu_cxx17__normal_iteratorIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEdeEv called 0 returned 0% blocks executed 0%
function _ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv called 0 returned 0% blocks executed 0%
#####: 795: operator*() const _GLIBCXX_NOEXCEPT
#####: 796: { return *_M_current; }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
-: 797:
-: 798: pointer
-: 799: operator->() const _GLIBCXX_NOEXCEPT
-: 800: { return _M_current; }
-: 801:
-: 802: __normal_iterator&
function _ZN9__gnu_cxx17__normal_iteratorIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEppEv called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv called 0 returned 0% blocks executed 0%
#####: 803: operator++() _GLIBCXX_NOEXCEPT
-: 804: {
#####: 805: ++_M_current;
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
#####: 806: return *this;
call 0 never executed
call 1 never executed
-: 807: }
-: 808:
-: 809: __normal_iterator
-: 810: operator++(int) _GLIBCXX_NOEXCEPT
-: 811: { return __normal_iterator(_M_current++); }
-: 812:
-: 813: // Bidirectional iterator requirements
-: 814: __normal_iterator&
-: 815: operator--() _GLIBCXX_NOEXCEPT
-: 816: {
-: 817: --_M_current;
-: 818: return *this;
-: 819: }
-: 820:
-: 821: __normal_iterator
-: 822: operator--(int) _GLIBCXX_NOEXCEPT
-: 823: { return __normal_iterator(_M_current--); }
-: 824:
-: 825: // Random access iterator requirements
-: 826: reference
-: 827: operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
-: 828: { return _M_current[__n]; }
-: 829:
-: 830: __normal_iterator&
-: 831: operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
-: 832: { _M_current += __n; return *this; }
-: 833:
-: 834: __normal_iterator
-: 835: operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
-: 836: { return __normal_iterator(_M_current + __n); }
-: 837:
-: 838: __normal_iterator&
-: 839: operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
-: 840: { _M_current -= __n; return *this; }
-: 841:
-: 842: __normal_iterator
function _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEmiEl called 0 returned 0% blocks executed 0%
#####: 843: operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
#####: 844: { return __normal_iterator(_M_current - __n); }
call 0 never executed
call 1 never executed
call 2 never executed
-: 845:
-: 846: const _Iterator&
function _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEE4baseEv called 0 returned 0% blocks executed 0%
function _ZNK9__gnu_cxx17__normal_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEE4baseEv called 0 returned 0% blocks executed 0%
function _ZNK9__gnu_cxx17__normal_iteratorIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEE4baseEv called 0 returned 0% blocks executed 0%
function _ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEE4baseEv called 0 returned 0% blocks executed 0%
#####: 847: base() const _GLIBCXX_NOEXCEPT
#####: 848: { return _M_current; }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
-: 849: };
-: 850:
-: 851: // Note: In what follows, the left- and right-hand-side iterators are
-: 852: // allowed to vary in types (conceptually in cv-qualification) so that
-: 853: // comparison between cv-qualified and non-cv-qualified iterators be
-: 854: // valid. However, the greedy and unfriendly operators in std::rel_ops
-: 855: // will make overload resolution ambiguous (when in scope) if we don't
-: 856: // provide overloads whose operands are of the same type. Can someone
-: 857: // remind me what generic programming is about? -- Gaby
-: 858:
-: 859: // Forward iterator requirements
-: 860: template
-: 861: inline bool
-: 862: operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 863: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 864: _GLIBCXX_NOEXCEPT
-: 865: { return __lhs.base() == __rhs.base(); }
-: 866:
-: 867: template
-: 868: inline bool
function _ZN9__gnu_cxxeqIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_ called 0 returned 0% blocks executed 0%
#####: 869: operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 870: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 871: _GLIBCXX_NOEXCEPT
#####: 872: { return __lhs.base() == __rhs.base(); }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
-: 873:
-: 874: template
-: 875: inline bool
-: 876: operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 877: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 878: _GLIBCXX_NOEXCEPT
-: 879: { return __lhs.base() != __rhs.base(); }
-: 880:
-: 881: template
-: 882: inline bool
function _ZN9__gnu_cxxneIPKN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_ called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxxneIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_ called 0 returned 0% blocks executed 0%
#####: 883: operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 884: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 885: _GLIBCXX_NOEXCEPT
#####: 886: { return __lhs.base() != __rhs.base(); }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
call 9 never executed
call 10 never executed
call 11 never executed
-: 887:
-: 888: // Random access iterator requirements
-: 889: template
-: 890: inline bool
-: 891: operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 892: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 893: _GLIBCXX_NOEXCEPT
-: 894: { return __lhs.base() < __rhs.base(); }
-: 895:
-: 896: template
-: 897: inline bool
-: 898: operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 899: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 900: _GLIBCXX_NOEXCEPT
-: 901: { return __lhs.base() < __rhs.base(); }
-: 902:
-: 903: template
-: 904: inline bool
-: 905: operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 906: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 907: _GLIBCXX_NOEXCEPT
-: 908: { return __lhs.base() > __rhs.base(); }
-: 909:
-: 910: template
-: 911: inline bool
-: 912: operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 913: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 914: _GLIBCXX_NOEXCEPT
-: 915: { return __lhs.base() > __rhs.base(); }
-: 916:
-: 917: template
-: 918: inline bool
-: 919: operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 920: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 921: _GLIBCXX_NOEXCEPT
-: 922: { return __lhs.base() <= __rhs.base(); }
-: 923:
-: 924: template
-: 925: inline bool
-: 926: operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 927: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 928: _GLIBCXX_NOEXCEPT
-: 929: { return __lhs.base() <= __rhs.base(); }
-: 930:
-: 931: template
-: 932: inline bool
-: 933: operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 934: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 935: _GLIBCXX_NOEXCEPT
-: 936: { return __lhs.base() >= __rhs.base(); }
-: 937:
-: 938: template
-: 939: inline bool
-: 940: operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 941: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 942: _GLIBCXX_NOEXCEPT
-: 943: { return __lhs.base() >= __rhs.base(); }
-: 944:
-: 945: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 946: // According to the resolution of DR179 not only the various comparison
-: 947: // operators but also operator- must accept mixed iterator/const_iterator
-: 948: // parameters.
-: 949: template
-: 950:#if __cplusplus >= 201103L
-: 951: // DR 685.
-: 952: inline auto
-: 953: operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 954: const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-: 955: -> decltype(__lhs.base() - __rhs.base())
-: 956:#else
-: 957: inline typename __normal_iterator<_IteratorL, _Container>::difference_type
-: 958: operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
-: 959: const __normal_iterator<_IteratorR, _Container>& __rhs)
-: 960:#endif
-: 961: { return __lhs.base() - __rhs.base(); }
-: 962:
-: 963: template
-: 964: inline typename __normal_iterator<_Iterator, _Container>::difference_type
function _ZN9__gnu_cxxmiIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEENS_17__normal_iteratorIT_T0_E15difference_typeERKSE_SH_ called 0 returned 0% blocks executed 0%
function _ZN9__gnu_cxxmiIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt6vectorIS6_SaIS6_EEEENS_17__normal_iteratorIT_T0_E15difference_typeERKSE_SH_ called 0 returned 0% blocks executed 0%
#####: 965: operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
-: 966: const __normal_iterator<_Iterator, _Container>& __rhs)
-: 967: _GLIBCXX_NOEXCEPT
#####: 968: { return __lhs.base() - __rhs.base(); }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
call 8 never executed
call 9 never executed
call 10 never executed
call 11 never executed
-: 969:
-: 970: template
-: 971: inline __normal_iterator<_Iterator, _Container>
-: 972: operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
-: 973: __n, const __normal_iterator<_Iterator, _Container>& __i)
-: 974: _GLIBCXX_NOEXCEPT
-: 975: { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
-: 976:
-: 977:_GLIBCXX_END_NAMESPACE_VERSION
-: 978:} // namespace
-: 979:
-: 980:namespace std _GLIBCXX_VISIBILITY(default)
-: 981:{
-: 982:_GLIBCXX_BEGIN_NAMESPACE_VERSION
-: 983:
-: 984: template
-: 985: _Iterator
function _ZSt12__niter_baseIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS5_SaIS5_EEET_N9__gnu_cxx17__normal_iteratorISB_T0_EE called 0 returned 0% blocks executed 0%
#####: 986: __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
#####: 987: { return __it.base(); }
call 0 never executed
call 1 never executed
-: 988:
-: 989:_GLIBCXX_END_NAMESPACE_VERSION
-: 990:} // namespace
-: 991:
-: 992:#if __cplusplus >= 201103L
-: 993:
-: 994:namespace std _GLIBCXX_VISIBILITY(default)
-: 995:{
-: 996:_GLIBCXX_BEGIN_NAMESPACE_VERSION
-: 997:
-: 998: /**
-: 999: * @addtogroup iterators
-: 1000: * @{
-: 1001: */
-: 1002:
-: 1003: // 24.4.3 Move iterators
-: 1004: /**
-: 1005: * Class template move_iterator is an iterator adapter with the same
-: 1006: * behavior as the underlying iterator except that its dereference
-: 1007: * operator implicitly converts the value returned by the underlying
-: 1008: * iterator's dereference operator to an rvalue reference. Some
-: 1009: * generic algorithms can be called with move iterators to replace
-: 1010: * copying with moving.
-: 1011: */
-: 1012: template
-: 1013: class move_iterator
-: 1014: {
-: 1015: protected:
-: 1016: _Iterator _M_current;
-: 1017:
-: 1018: typedef iterator_traits<_Iterator> __traits_type;
-: 1019: typedef typename __traits_type::reference __base_ref;
-: 1020:
-: 1021: public:
-: 1022: typedef _Iterator iterator_type;
-: 1023: typedef typename __traits_type::iterator_category iterator_category;
-: 1024: typedef typename __traits_type::value_type value_type;
-: 1025: typedef typename __traits_type::difference_type difference_type;
-: 1026: // NB: DR 680.
-: 1027: typedef _Iterator pointer;
-: 1028: // _GLIBCXX_RESOLVE_LIB_DEFECTS
-: 1029: // 2106. move_iterator wrapping iterators returning prvalues
-: 1030: typedef typename conditional::value,
-: 1031: typename remove_reference<__base_ref>::type&&,
-: 1032: __base_ref>::type reference;
-: 1033:
-: 1034: _GLIBCXX17_CONSTEXPR
-: 1035: move_iterator()
-: 1036: : _M_current() { }
-: 1037:
-: 1038: explicit _GLIBCXX17_CONSTEXPR
function _ZNSt13move_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2ES6_ called 0 returned 0% blocks executed 0%
function _ZNSt13move_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEEC2ES6_ called 0 returned 0% blocks executed 0%
#####: 1039: move_iterator(iterator_type __i)
call 0 never executed
call 1 never executed
#####: 1040: : _M_current(__i) { }
call 0 never executed
call 1 never executed
-: 1041:
-: 1042: template
-: 1043: _GLIBCXX17_CONSTEXPR
-: 1044: move_iterator(const move_iterator<_Iter>& __i)
-: 1045: : _M_current(__i.base()) { }
-: 1046:
-: 1047: _GLIBCXX17_CONSTEXPR iterator_type
function _ZNKSt13move_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4baseEv called 0 returned 0% blocks executed 0%
function _ZNKSt13move_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEE4baseEv called 0 returned 0% blocks executed 0%
#####: 1048: base() const
#####: 1049: { return _M_current; }
call 0 never executed
call 1 never executed
-: 1050:
-: 1051: _GLIBCXX17_CONSTEXPR reference
function _ZNKSt13move_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv called 0 returned 0% blocks executed 0%
function _ZNKSt13move_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEEdeEv called 0 returned 0% blocks executed 0%
#####: 1052: operator*() const
#####: 1053: { return static_cast(*_M_current); }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
-: 1054:
-: 1055: _GLIBCXX17_CONSTEXPR pointer
-: 1056: operator->() const
-: 1057: { return _M_current; }
-: 1058:
-: 1059: _GLIBCXX17_CONSTEXPR move_iterator&
function _ZNSt13move_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv called 0 returned 0% blocks executed 0%
function _ZNSt13move_iteratorIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEEppEv called 0 returned 0% blocks executed 0%
#####: 1060: operator++()
-: 1061: {
#####: 1062: ++_M_current;
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
#####: 1063: return *this;
call 0 never executed
call 1 never executed
-: 1064: }
-: 1065:
-: 1066: _GLIBCXX17_CONSTEXPR move_iterator
-: 1067: operator++(int)
-: 1068: {
-: 1069: move_iterator __tmp = *this;
-: 1070: ++_M_current;
-: 1071: return __tmp;
-: 1072: }
-: 1073:
-: 1074: _GLIBCXX17_CONSTEXPR move_iterator&
-: 1075: operator--()
-: 1076: {
-: 1077: --_M_current;
-: 1078: return *this;
-: 1079: }
-: 1080:
-: 1081: _GLIBCXX17_CONSTEXPR move_iterator
-: 1082: operator--(int)
-: 1083: {
-: 1084: move_iterator __tmp = *this;
-: 1085: --_M_current;
-: 1086: return __tmp;
-: 1087: }
-: 1088:
-: 1089: _GLIBCXX17_CONSTEXPR move_iterator
-: 1090: operator+(difference_type __n) const
-: 1091: { return move_iterator(_M_current + __n); }
-: 1092:
-: 1093: _GLIBCXX17_CONSTEXPR move_iterator&
-: 1094: operator+=(difference_type __n)
-: 1095: {
-: 1096: _M_current += __n;
-: 1097: return *this;
-: 1098: }
-: 1099:
-: 1100: _GLIBCXX17_CONSTEXPR move_iterator
-: 1101: operator-(difference_type __n) const
-: 1102: { return move_iterator(_M_current - __n); }
-: 1103:
-: 1104: _GLIBCXX17_CONSTEXPR move_iterator&
-: 1105: operator-=(difference_type __n)
-: 1106: {
-: 1107: _M_current -= __n;
-: 1108: return *this;
-: 1109: }
-: 1110:
-: 1111: _GLIBCXX17_CONSTEXPR reference
-: 1112: operator[](difference_type __n) const
-: 1113: { return std::move(_M_current[__n]); }
-: 1114: };
-: 1115:
-: 1116: // Note: See __normal_iterator operators note from Gaby to understand
-: 1117: // why there are always 2 versions for most of the move_iterator
-: 1118: // operators.
-: 1119: template
-: 1120: inline _GLIBCXX17_CONSTEXPR bool
-: 1121: operator==(const move_iterator<_IteratorL>& __x,
-: 1122: const move_iterator<_IteratorR>& __y)
-: 1123: { return __x.base() == __y.base(); }
-: 1124:
-: 1125: template
-: 1126: inline _GLIBCXX17_CONSTEXPR bool
function _ZSteqIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEbRKSt13move_iteratorIT_ESB_ called 0 returned 0% blocks executed 0%
function _ZSteqIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEEbRKSt13move_iteratorIT_ESB_ called 0 returned 0% blocks executed 0%
#####: 1127: operator==(const move_iterator<_Iterator>& __x,
-: 1128: const move_iterator<_Iterator>& __y)
#####: 1129: { return __x.base() == __y.base(); }
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
call 4 never executed
call 5 never executed
call 6 never executed
call 7 never executed
-: 1130:
-: 1131: template
-: 1132: inline _GLIBCXX17_CONSTEXPR bool
-: 1133: operator!=(const move_iterator<_IteratorL>& __x,
-: 1134: const move_iterator<_IteratorR>& __y)
-: 1135: { return !(__x == __y); }
-: 1136:
-: 1137: template
-: 1138: inline _GLIBCXX17_CONSTEXPR bool
function _ZStneIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEbRKSt13move_iteratorIT_ESB_ called 0 returned 0% blocks executed 0%
function _ZStneIPN5boost10shared_ptrIKN4ribi15DotMatrixStringEEEEbRKSt13move_iteratorIT_ESB_ called 0 returned 0% blocks executed 0%
#####: 1139: operator!=(const move_iterator<_Iterator>& __x,
-: 1140: const move_iterator<_Iterator>& __y)
#####: 1141: { return !(__x == __y); }
call 0 never executed
call 1 never executed
-: 1142:
-: 1143: template
-: 1144: inline _GLIBCXX17_CONSTEXPR bool
-: 1145: operator<(const move_iterator<_IteratorL>& __x,
-: 1146: const move_iterator<_IteratorR>& __y)
-: 1147: { return __x.base() < __y.base(); }
-: 1148:
-: 1149: template
-: 1150: inline _GLIBCXX17_CONSTEXPR bool
-: 1151: operator<(const move_iterator<_Iterator>& __x,
-: 1152: const move_iterator<_Iterator>& __y)
-: 1153: { return __x.base() < __y.base(); }
-: 1154:
-: 1155: template
-: 1156: inline _GLIBCXX17_CONSTEXPR bool
-: 1157: operator<=(const move_iterator<_IteratorL>& __x,
-: 1158: const move_iterator<_IteratorR>& __y)
-: 1159: { return !(__y < __x); }
-: 1160:
-: 1161: template
-: 1162: inline _GLIBCXX17_CONSTEXPR bool
-: 1163: operator<=(const move_iterator<_Iterator>& __x,
-: 1164: const move_iterator<_Iterator>& __y)
-: 1165: { return !(__y < __x); }
-: 1166:
-: 1167: template
-: 1168: inline _GLIBCXX17_CONSTEXPR bool
-: 1169: operator>(const move_iterator<_IteratorL>& __x,
-: 1170: const move_iterator<_IteratorR>& __y)
-: 1171: { return __y < __x; }
-: 1172:
-: 1173: template
-: 1174: inline _GLIBCXX17_CONSTEXPR bool
-: 1175: operator>(const move_iterator<_Iterator>& __x,
-: 1176: const move_iterator<_Iterator>& __y)
-: 1177: { return __y < __x; }
-: 1178:
-: 1179: template
-: 1180: inline _GLIBCXX17_CONSTEXPR bool
-: 1181: operator>=(const move_iterator<_IteratorL>& __x,
-: 1182: const move_iterator<_IteratorR>& __y)
-: 1183: { return !(__x < __y); }
-: 1184:
-: 1185: template
-: 1186: inline _GLIBCXX17_CONSTEXPR bool
-: 1187: operator>=(const move_iterator<_Iterator>& __x,
-: 1188: const move_iterator<_Iterator>& __y)
-: 1189: { return !(__x < __y); }
-: 1190:
-: 1191: // DR 685.
-: 1192: template
-: 1193: inline _GLIBCXX17_CONSTEXPR auto
-: 1194: operator-(const move_iterator<_IteratorL>& __x,
-: 1195: const move_iterator<_IteratorR>& __y)
-: 1196: -> decltype(__x.base() - __y.base())
-: 1197: { return __x.base() - __y.base(); }
-: 1198:
-: 1199: template
-: 1200: inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
-: 1201: operator+(typename move_iterator<_Iterator>::difference_type __n,
-: 1202: const move_iterator<_Iterator>& __x)
-: 1203: { return __x + __n; }
-: 1204:
-: 1205: template
-: 1206: inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
-: 1207: make_move_iterator(_Iterator __i)
-: 1208: { return move_iterator<_Iterator>(__i); }
-: 1209:
-: 1210: template::value_type>::value,
-: 1213: _Iterator, move_iterator<_Iterator>>::type>
-: 1214: inline _GLIBCXX17_CONSTEXPR _ReturnType
-: 1215: __make_move_if_noexcept_iterator(_Iterator __i)
-: 1216: { return _ReturnType(__i); }
-: 1217:
-: 1218: // Overload for pointers that matches std::move_if_noexcept more closely,
-: 1219: // returning a constant iterator when we don't want to move.
-: 1220: template::value,
-: 1222: const _Tp*, move_iterator<_Tp*>>::type>
-: 1223: inline _GLIBCXX17_CONSTEXPR _ReturnType
function _ZSt32__make_move_if_noexcept_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt13move_iteratorIPS5_EET0_PT_ called 0 returned 0% blocks executed 0%
function _ZSt32__make_move_if_noexcept_iteratorIN5boost10shared_ptrIKN4ribi15DotMatrixStringEEESt13move_iteratorIPS5_EET0_PT_ called 0 returned 0% blocks executed 0%
#####: 1224: __make_move_if_noexcept_iterator(_Tp* __i)
#####: 1225: { return _ReturnType(__i); }
call 0 never executed
call 1 never executed
-: 1226:
-: 1227: // @} group iterators
-: 1228:
-: 1229: template
-: 1230: auto
-: 1231: __niter_base(move_iterator<_Iterator> __it)
-: 1232: -> decltype(make_move_iterator(__niter_base(__it.base())))
-: 1233: { return make_move_iterator(__niter_base(__it.base())); }
-: 1234:
-: 1235: template
-: 1236: struct __is_move_iterator >
-: 1237: {
-: 1238: enum { __value = 1 };
-: 1239: typedef __true_type __type;
-: 1240: };
-: 1241:
-: 1242: template
-: 1243: auto
-: 1244: __miter_base(move_iterator<_Iterator> __it)
-: 1245: -> decltype(__miter_base(__it.base()))
-: 1246: { return __miter_base(__it.base()); }
-: 1247:
-: 1248:_GLIBCXX_END_NAMESPACE_VERSION
-: 1249:} // namespace
-: 1250:
-: 1251:#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
-: 1252:#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
-: 1253: std::__make_move_if_noexcept_iterator(_Iter)
-: 1254:#else
-: 1255:#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
-: 1256:#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
-: 1257:#endif // C++11
-: 1258:
-: 1259:#ifdef _GLIBCXX_DEBUG
-: 1260:# include
-: 1261:#endif
-: 1262:
-: 1263:#endif
<<<<<< EOF
# path=/home/travis/build/richelbilderbeek/TicTacToe/#usr#include#boost#bimap#relation#detail#mutant.hpp.gcov
-: 0:Source:/usr/include/boost/bimap/relation/detail/mutant.hpp
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/canvascolorsystems.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/canvascolorsystems.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:// Boost.Bimap
-: 2://
-: 3:// Copyright (c) 2006-2007 Matias Capeletto
-: 4://
-: 5:// Distributed under the Boost Software License, Version 1.0.
-: 6:// (See accompanying file LICENSE_1_0.txt or copy at
-: 7:// http://www.boost.org/LICENSE_1_0.txt)
-: 8:
-: 9:/// \file relation/detail/mutant.hpp
-: 10:/// \brief Mutate functions to extract views of mutant classes.
-: 11:
-: 12:#ifndef BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
-: 13:#define BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
-: 14:
-: 15:#if defined(_MSC_VER)
-: 16:#pragma once
-: 17:#endif
-: 18:
-: 19:#include
-: 20:
-: 21:#include
-: 22:#include
-: 23:#include
-: 24:#include
-: 25:#include
-: 26:#include
-: 27:#include
-: 28:#include
-: 29:
-: 30:namespace boost {
-: 31:namespace bimaps {
-: 32:namespace relation {
-: 33:
-: 34:/// \brief Relation details, mutant idiom and symmetrical metafunctions builders.
-: 35:
-: 36:namespace detail {
-: 37:
-: 38://@{
-: 39:/// \brief Converts a mutant class to a view with zero overhead.
-: 40:/**
-: 41:
-: 42:This function is a safe wrapper around reinterpret_cast. It checks at
-: 43:compile time that the desired view is supported by the mutant class.
-: 44:See also mutant, can_mutate_in.
-: 45:\ingroup mutant_group
-: 46: **/
-: 47:
-: 48:
-: 49:template< class View, class Type >
-: 50:BOOST_DEDUCED_TYPENAME enable_if< mpl::not_< is_const< Type > >,
-: 51:
-: 52:View&
-: 53:
function _ZN5boost6bimaps8relation6detail6mutateINS1_15structured_pairINS0_4tags6taggedIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS1_9member_at5rightEEENS6_IKN4ribi17CanvasColorSystemENSE_4leftEEEN4mpl_2naENS1_13mirror_layoutEEENS1_15mutant_relationISL_SG_SN_Lb1EEEEENS_9enable_ifINS_3mpl4not_INS_8is_constIT0_EEEERT_E4typeERSW_ called 0 returned 0% blocks executed 0%
function _ZN5boost6bimaps8relation6detail6mutateINS1_15structured_pairINS0_4tags6taggedIKN4ribi17CanvasColorSystemENS1_9member_at4leftEEENS6_IKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENSA_5rightEEEN4mpl_2naENS1_13normal_layoutEEENS1_15mutant_relationISC_SL_SN_Lb1EEEEENS_9enable_ifINS_3mpl4not_INS_8is_constIT0_EEEERT_E4typeERSW_ called 0 returned 0% blocks executed 0%
#####: 54:>::type mutate( Type & m )
-: 55:{
-: 56: BOOST_MPL_ASSERT((
-: 57: ::boost::mpl::contains
-: 58: ));
#####: 59: return *reinterpret_cast< View* >(boost::addressof(m));
call 0 never executed
call 1 never executed
call 2 never executed
call 3 never executed
-: 60:}
-: 61:
-: 62:template< class View, class Type >
-: 63:BOOST_DEDUCED_TYPENAME enable_if< is_const< Type >,
-: 64:
-: 65:const View&
-: 66:
function _ZN5boost6bimaps8relation6detail6mutateINS1_15mutant_relationINS0_4tags6taggedIKN4ribi17CanvasColorSystemENS1_9member_at4leftEEENS6_IKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENSA_5rightEEEN4mpl_2naELb1EEEKNS4_ISC_SL_SN_Lb0EEEEENS_9enable_ifINS_8is_constIT0_EERKT_E4typeERST_ called 0 returned 0% blocks executed 0%
#####: 67:>::type mutate( Type & m )
-: 68:{
-: 69: BOOST_MPL_ASSERT((
-: 70: ::boost::mpl::contains
-: 71: ));
#####: 72: return *reinterpret_cast< const View* >(boost::addressof(m));
call 0 never executed
call 1 never executed
-: 73:}
-: 74:
-: 75://@}
-: 76:
-: 77:} // namespace detail
-: 78:} // namespace relation
-: 79:} // namespace bimaps
-: 80:} // namespace boost
-: 81:
-: 82:#endif // BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
-: 83:
<<<<<< EOF
# path=/home/travis/build/richelbilderbeek/TicTacToe/#usr#include#boost#function#function_template.hpp.gcov
-: 0:Source:/usr/include/boost/function/function_template.hpp
-: 0:Graph:/home/travis/build/richelbilderbeek/TicTacToe/debug/tictactoegame.gcno
-: 0:Data:/home/travis/build/richelbilderbeek/TicTacToe/debug/tictactoegame.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:// Boost.Function library
-: 2:
-: 3:// Copyright Douglas Gregor 2001-2006
-: 4:// Copyright Emil Dotchevski 2007
-: 5:// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
-: 6:// (See accompanying file LICENSE_1_0.txt or copy at
-: 7:// http://www.boost.org/LICENSE_1_0.txt)
-: 8:
-: 9:// For more information, see http://www.boost.org
-: 10:
-: 11:// Note: this header is a header template and must NOT have multiple-inclusion
-: 12:// protection.
-: 13:#include
-: 14:#include
-: 15:
-: 16:#if defined(BOOST_MSVC)
-: 17:# pragma warning( push )
-: 18:# pragma warning( disable : 4127 ) // "conditional expression is constant"
-: 19:#endif
-: 20:
-: 21:#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
-: 22:
-: 23:#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
-: 24:
-: 25:#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
-: 26:
-: 27:#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
-: 28:
-: 29:#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-: 30:# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
-: 31:#else
-: 32:# include
-: 33:# define BOOST_FUNCTION_ARG(J,I,D) ::boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I))
-: 34:# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
-: 35:#endif
-: 36:
-: 37:#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
-: 38: typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
-: 39:
-: 40:#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
-: 41:
-: 42:// Comma if nonzero number of arguments
-: 43:#if BOOST_FUNCTION_NUM_ARGS == 0
-: 44:# define BOOST_FUNCTION_COMMA
-: 45:#else
-: 46:# define BOOST_FUNCTION_COMMA ,
-: 47:#endif // BOOST_FUNCTION_NUM_ARGS > 0
-: 48:
-: 49:// Class names used in this version of the code
-: 50:#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
-: 51:#define BOOST_FUNCTION_FUNCTION_INVOKER \
-: 52: BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 53:#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
-: 54: BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 55:#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
-: 56: BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 57:#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
-: 58: BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 59:#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
-: 60: BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 61:#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
-: 62: BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 63:#define BOOST_FUNCTION_MEMBER_INVOKER \
-: 64: BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 65:#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
-: 66: BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 67:#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
-: 68: BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 69:#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
-: 70: BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 71:#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
-: 72: BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 73:#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
-: 74: BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 75:#define BOOST_FUNCTION_GET_INVOKER \
-: 76: BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
-: 77:#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
-: 78:
-: 79:#ifndef BOOST_NO_VOID_RETURNS
-: 80:# define BOOST_FUNCTION_VOID_RETURN_TYPE void
-: 81:# define BOOST_FUNCTION_RETURN(X) X
-: 82:#else
-: 83:# define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
-: 84:# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
-: 85:#endif
-: 86:
-: 87:namespace boost {
-: 88: namespace detail {
-: 89: namespace function {
-: 90: template<
-: 91: typename FunctionPtr,
-: 92: typename R BOOST_FUNCTION_COMMA
-: 93: BOOST_FUNCTION_TEMPLATE_PARMS
-: 94: >
-: 95: struct BOOST_FUNCTION_FUNCTION_INVOKER
-: 96: {
-: 97: static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-: 98: BOOST_FUNCTION_PARMS)
-: 99: {
-: 100: FunctionPtr f = reinterpret_cast(function_ptr.members.func_ptr);
-: 101: return f(BOOST_FUNCTION_ARGS);
-: 102: }
-: 103: };
-: 104:
-: 105: template<
-: 106: typename FunctionPtr,
-: 107: typename R BOOST_FUNCTION_COMMA
-: 108: BOOST_FUNCTION_TEMPLATE_PARMS
-: 109: >
-: 110: struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-: 111: {
-: 112: static BOOST_FUNCTION_VOID_RETURN_TYPE
-: 113: invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-: 114: BOOST_FUNCTION_PARMS)
-: 115:
-: 116: {
-: 117: FunctionPtr f = reinterpret_cast(function_ptr.members.func_ptr);
-: 118: BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
-: 119: }
-: 120: };
-: 121:
-: 122: template<
-: 123: typename FunctionObj,
-: 124: typename R BOOST_FUNCTION_COMMA
-: 125: BOOST_FUNCTION_TEMPLATE_PARMS
-: 126: >
-: 127: struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-: 128: {
-: 129: static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 130: BOOST_FUNCTION_PARMS)
-: 131:
-: 132: {
-: 133: FunctionObj* f;
-: 134: if (function_allows_small_object_optimization::value)
-: 135: f = reinterpret_cast(function_obj_ptr.data);
-: 136: else
-: 137: f = reinterpret_cast(function_obj_ptr.members.obj_ptr);
-: 138: return (*f)(BOOST_FUNCTION_ARGS);
-: 139: }
-: 140: };
-: 141:
-: 142: template<
-: 143: typename FunctionObj,
-: 144: typename R BOOST_FUNCTION_COMMA
-: 145: BOOST_FUNCTION_TEMPLATE_PARMS
-: 146: >
-: 147: struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-: 148: {
-: 149: static BOOST_FUNCTION_VOID_RETURN_TYPE
-: 150: invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 151: BOOST_FUNCTION_PARMS)
-: 152:
-: 153: {
-: 154: FunctionObj* f;
-: 155: if (function_allows_small_object_optimization::value)
-: 156: f = reinterpret_cast(function_obj_ptr.data);
-: 157: else
-: 158: f = reinterpret_cast(function_obj_ptr.members.obj_ptr);
-: 159: BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
-: 160: }
-: 161: };
-: 162:
-: 163: template<
-: 164: typename FunctionObj,
-: 165: typename R BOOST_FUNCTION_COMMA
-: 166: BOOST_FUNCTION_TEMPLATE_PARMS
-: 167: >
-: 168: struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
-: 169: {
-: 170: static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 171: BOOST_FUNCTION_PARMS)
-: 172:
-: 173: {
-: 174: FunctionObj* f =
-: 175: reinterpret_cast(function_obj_ptr.members.obj_ptr);
-: 176: return (*f)(BOOST_FUNCTION_ARGS);
-: 177: }
-: 178: };
-: 179:
-: 180: template<
-: 181: typename FunctionObj,
-: 182: typename R BOOST_FUNCTION_COMMA
-: 183: BOOST_FUNCTION_TEMPLATE_PARMS
-: 184: >
-: 185: struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-: 186: {
-: 187: static BOOST_FUNCTION_VOID_RETURN_TYPE
-: 188: invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 189: BOOST_FUNCTION_PARMS)
-: 190:
-: 191: {
-: 192: FunctionObj* f =
-: 193: reinterpret_cast(function_obj_ptr.members.obj_ptr);
-: 194: BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
-: 195: }
-: 196: };
-: 197:
-: 198:#if BOOST_FUNCTION_NUM_ARGS > 0
-: 199: /* Handle invocation of member pointers. */
-: 200: template<
-: 201: typename MemberPtr,
-: 202: typename R BOOST_FUNCTION_COMMA
-: 203: BOOST_FUNCTION_TEMPLATE_PARMS
-: 204: >
-: 205: struct BOOST_FUNCTION_MEMBER_INVOKER
-: 206: {
-: 207: static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 208: BOOST_FUNCTION_PARMS)
-: 209:
-: 210: {
-: 211: MemberPtr* f =
-: 212: reinterpret_cast(function_obj_ptr.data);
-: 213: return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
-: 214: }
-: 215: };
-: 216:
-: 217: template<
-: 218: typename MemberPtr,
-: 219: typename R BOOST_FUNCTION_COMMA
-: 220: BOOST_FUNCTION_TEMPLATE_PARMS
-: 221: >
-: 222: struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
-: 223: {
-: 224: static BOOST_FUNCTION_VOID_RETURN_TYPE
-: 225: invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-: 226: BOOST_FUNCTION_PARMS)
-: 227:
-: 228: {
-: 229: MemberPtr* f =
-: 230: reinterpret_cast(function_obj_ptr.data);
-: 231: BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
-: 232: }
-: 233: };
-: 234:#endif
-: 235:
-: 236: template<
-: 237: typename FunctionPtr,
-: 238: typename R BOOST_FUNCTION_COMMA
-: 239: BOOST_FUNCTION_TEMPLATE_PARMS
-: 240: >
-: 241: struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
-: 242: {
-: 243: typedef typename mpl::if_c<(is_void::value),
-: 244: BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
-: 245: FunctionPtr,
-: 246: R BOOST_FUNCTION_COMMA
-: 247: BOOST_FUNCTION_TEMPLATE_ARGS
-: 248: >,
-: 249: BOOST_FUNCTION_FUNCTION_INVOKER<
-: 250: FunctionPtr,
-: 251: R BOOST_FUNCTION_COMMA
-: 252: BOOST_FUNCTION_TEMPLATE_ARGS
-: 253: >
-: 254: >::type type;
-: 255: };
-: 256:
-: 257: template<
-: 258: typename FunctionObj,
-: 259: typename R BOOST_FUNCTION_COMMA
-: 260: BOOST_FUNCTION_TEMPLATE_PARMS
-: 261: >
-: 262: struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-: 263: {
-: 264: typedef typename mpl::if_c<(is_void::value),
-: 265: BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
-: 266: FunctionObj,
-: 267: R BOOST_FUNCTION_COMMA
-: 268: BOOST_FUNCTION_TEMPLATE_ARGS
-: 269: >,
-: 270: BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
-: 271: FunctionObj,
-: 272: R BOOST_FUNCTION_COMMA
-: 273: BOOST_FUNCTION_TEMPLATE_ARGS
-: 274: >
-: 275: >::type type;
-: 276: };
-: 277:
-: 278: template<
-: 279: typename FunctionObj,
-: 280: typename R BOOST_FUNCTION_COMMA
-: 281: BOOST_FUNCTION_TEMPLATE_PARMS
-: 282: >
-: 283: struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-: 284: {
-: 285: typedef typename mpl::if_c<(is_void::value),
-: 286: BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
-: 287: FunctionObj,
-: 288: R BOOST_FUNCTION_COMMA
-: 289: BOOST_FUNCTION_TEMPLATE_ARGS
-: 290: >,
-: 291: BOOST_FUNCTION_FUNCTION_REF_INVOKER<
-: 292: FunctionObj,
-: 293: R BOOST_FUNCTION_COMMA
-: 294: BOOST_FUNCTION_TEMPLATE_ARGS
-: 295: >
-: 296: >::type type;
-: 297: };
-: 298:
-: 299:#if BOOST_FUNCTION_NUM_ARGS > 0
-: 300: /* Retrieve the appropriate invoker for a member pointer. */
-: 301: template<
-: 302: typename MemberPtr,
-: 303: typename R BOOST_FUNCTION_COMMA
-: 304: BOOST_FUNCTION_TEMPLATE_PARMS
-: 305: >
-: 306: struct BOOST_FUNCTION_GET_MEMBER_INVOKER
-: 307: {
-: 308: typedef typename mpl::if_c<(is_void::value),
-: 309: BOOST_FUNCTION_VOID_MEMBER_INVOKER<
-: 310: MemberPtr,
-: 311: R BOOST_FUNCTION_COMMA
-: 312: BOOST_FUNCTION_TEMPLATE_ARGS
-: 313: >,
-: 314: BOOST_FUNCTION_MEMBER_INVOKER<
-: 315: MemberPtr,
-: 316: R BOOST_FUNCTION_COMMA
-: 317: BOOST_FUNCTION_TEMPLATE_ARGS
-: 318: >
-: 319: >::type type;
-: 320: };
-: 321:#endif
-: 322:
-: 323: /* Given the tag returned by get_function_tag, retrieve the
-: 324: actual invoker that will be used for the given function
-: 325: object.
-: 326:
-: 327: Each specialization contains an "apply" nested class template
-: 328: that accepts the function object, return type, function
-: 329: argument types, and allocator. The resulting "apply" class
-: 330: contains two typedefs, "invoker_type" and "manager_type",
-: 331: which correspond to the invoker and manager types. */
-: 332: template
-: 333: struct BOOST_FUNCTION_GET_INVOKER { };
-: 334:
-: 335: /* Retrieve the invoker for a function pointer. */
-: 336: template<>
-: 337: struct BOOST_FUNCTION_GET_INVOKER
-: 338: {
-: 339: template
-: 341: struct apply
-: 342: {
-: 343: typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-: 344: FunctionPtr,
-: 345: R BOOST_FUNCTION_COMMA
-: 346: BOOST_FUNCTION_TEMPLATE_ARGS
-: 347: >::type
-: 348: invoker_type;
-: 349:
-: 350: typedef functor_manager manager_type;
-: 351: };
-: 352:
-: 353: template
-: 356: struct apply_a
-: 357: {
-: 358: typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-: 359: FunctionPtr,
-: 360: R BOOST_FUNCTION_COMMA
-: 361: BOOST_FUNCTION_TEMPLATE_ARGS
-: 362: >::type
-: 363: invoker_type;
-: 364:
-: 365: typedef functor_manager manager_type;
-: 366: };
-: 367: };
-: 368:
-: 369:#if BOOST_FUNCTION_NUM_ARGS > 0
-: 370: /* Retrieve the invoker for a member pointer. */
-: 371: template<>
-: 372: struct BOOST_FUNCTION_GET_INVOKER
-: 373: {
-: 374: template
-: 376: struct apply
-: 377: {
-: 378: typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
-: 379: MemberPtr,
-: 380: R BOOST_FUNCTION_COMMA
-: 381: BOOST_FUNCTION_TEMPLATE_ARGS
-: 382: >::type
-: 383: invoker_type;
-: 384:
-: 385: typedef functor_manager manager_type;
-: 386: };
-: 387:
-: 388: template
-: 391: struct apply_a
-: 392: {
-: 393: typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
-: 394: MemberPtr,
-: 395: R BOOST_FUNCTION_COMMA
-: 396: BOOST_FUNCTION_TEMPLATE_ARGS
-: 397: >::type
-: 398: invoker_type;
-: 399:
-: 400: typedef functor_manager manager_type;
-: 401: };
-: 402: };
-: 403:#endif
-: 404:
-: 405: /* Retrieve the invoker for a function object. */
-: 406: template<>
-: 407: struct BOOST_FUNCTION_GET_INVOKER
-: 408: {
-: 409: template
-: 411: struct apply
-: 412: {
-: 413: typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-: 414: FunctionObj,
-: 415: R BOOST_FUNCTION_COMMA
-: 416: BOOST_FUNCTION_TEMPLATE_ARGS
-: 417: >::type
-: 418: invoker_type;
-: 419:
-: 420: typedef functor_manager manager_type;
-: 421: };
-: 422:
-: 423: template
-: 426: struct apply_a
-: 427: {
-: 428: typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-: 429: FunctionObj,
-: 430: R BOOST_FUNCTION_COMMA
-: 431: BOOST_FUNCTION_TEMPLATE_ARGS
-: 432: >::type
-: 433: invoker_type;
-: 434:
-: 435: typedef functor_manager_a manager_type;
-: 436: };
-: 437: };
-: 438:
-: 439: /* Retrieve the invoker for a reference to a function object. */
-: 440: template<>
-: 441: struct BOOST_FUNCTION_GET_INVOKER
-: 442: {
-: 443: template
-: 445: struct apply
-: 446: {
-: 447: typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
-: 448: typename RefWrapper::type,
-: 449: R BOOST_FUNCTION_COMMA
-: 450: BOOST_FUNCTION_TEMPLATE_ARGS
-: 451: >::type
-: 452: invoker_type;
-: 453:
-: 454: typedef reference_manager manager_type;
-: 455: };
-: 456:
-: 457: template
-: 460: struct apply_a
-: 461: {
-: 462: typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
-: 463: typename RefWrapper::type,
-: 464: R BOOST_FUNCTION_COMMA
-: 465: BOOST_FUNCTION_TEMPLATE_ARGS
-: 466: >::type
-: 467: invoker_type;
-: 468:
-: 469: typedef reference_manager manager_type;
-: 470: };
-: 471: };
-: 472:
-: 473:
-: 474: /**
-: 475: * vtable for a specific boost::function instance. This
-: 476: * structure must be an aggregate so that we can use static
-: 477: * initialization in boost::function's assign_to and assign_to_a
-: 478: * members. It therefore cannot have any constructors,
-: 479: * destructors, base classes, etc.
-: 480: */
-: 481: template
-: 482: struct BOOST_FUNCTION_VTABLE
-: 483: {
-: 484:#ifndef BOOST_NO_VOID_RETURNS
-: 485: typedef R result_type;
-: 486:#else
-: 487: typedef typename function_return_type::type result_type;
-: 488:#endif // BOOST_NO_VOID_RETURNS
-: 489:
-: 490: typedef result_type (*invoker_type)(function_buffer&
-: 491: BOOST_FUNCTION_COMMA
-: 492: BOOST_FUNCTION_TEMPLATE_ARGS);
-: 493:
-: 494: template
-: 495: bool assign_to(F f, function_buffer& functor) const
-: 496: {
-: 497: typedef typename get_function_tag::type tag;
-: 498: return assign_to(f, functor, tag());
-: 499: }
-: 500: template
-: 501: bool assign_to_a(F f, function_buffer& functor, Allocator a) const
-: 502: {
-: 503: typedef typename get_function_tag::type tag;
-: 504: return assign_to_a(f, functor, a, tag());
-: 505: }
-: 506:
-: 507: void clear(function_buffer& functor) const
-: 508: {
-: 509: if (base.manager)
-: 510: base.manager(functor, functor, destroy_functor_tag);
-: 511: }
-: 512:
-: 513: private:
-: 514: // Function pointers
-: 515: template
-: 516: bool
-: 517: assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
-: 518: {
-: 519: this->clear(functor);
-: 520: if (f) {
-: 521: // should be a reinterpret cast, but some compilers insist
-: 522: // on giving cv-qualifiers to free functions
-: 523: functor.members.func_ptr = reinterpret_cast(f);
-: 524: return true;
-: 525: } else {
-: 526: return false;
-: 527: }
-: 528: }
-: 529: template
-: 530: bool
-: 531: assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
-: 532: {
-: 533: return assign_to(f,functor,function_ptr_tag());
-: 534: }
-: 535:
-: 536: // Member pointers
-: 537:#if BOOST_FUNCTION_NUM_ARGS > 0
-: 538: template
-: 539: bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
-: 540: {
-: 541: // DPG TBD: Add explicit support for member function
-: 542: // objects, so we invoke through mem_fn() but we retain the
-: 543: // right target_type() values.
-: 544: if (f) {
-: 545: this->assign_to(boost::mem_fn(f), functor);
-: 546: return true;
-: 547: } else {
-: 548: return false;
-: 549: }
-: 550: }
-: 551: template
-: 552: bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
-: 553: {
-: 554: // DPG TBD: Add explicit support for member function
-: 555: // objects, so we invoke through mem_fn() but we retain the
-: 556: // right target_type() values.
-: 557: if (f) {
-: 558: this->assign_to_a(boost::mem_fn(f), functor, a);
-: 559: return true;
-: 560: } else {
-: 561: return false;
-: 562: }
-: 563: }
-: 564:#endif // BOOST_FUNCTION_NUM_ARGS > 0
-: 565:
-: 566: // Function objects
-: 567: // Assign to a function object using the small object optimization
-: 568: template
-: 569: void
-: 570: assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
-: 571: {
-: 572: new (reinterpret_cast(functor.data)) FunctionObj(f);
-: 573: }
-: 574: template
-: 575: void
-: 576: assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
-: 577: {
-: 578: assign_functor(f,functor,mpl::true_());
-: 579: }
-: 580:
-: 581: // Assign to a function object allocated on the heap.
-: 582: template
-: 583: void
-: 584: assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
-: 585: {
-: 586: functor.members.obj_ptr = new FunctionObj(f);
-: 587: }
-: 588: template