├── .appveyor.yml
├── .codecov.yml
├── .gitattributes
├── .github
    └── workflows
    │   └── ci.yml
├── CMakeLists.txt
├── LICENSE
├── README.md
├── bad_error_eg.cpp
├── bibliography.htm
├── build.jam
├── concept_check.htm
├── concept_covering.htm
├── creating_concepts.htm
├── doc
    ├── Jamfile.v2
    └── reference
    │   ├── Assignable.xml
    │   ├── BidirectionalIterator.xml
    │   ├── CopyConstructible.xml
    │   ├── DefaultConstructible.xml
    │   ├── EqualityComparable.xml
    │   ├── ForwardIterator.xml
    │   ├── InputIterator.xml
    │   ├── LessThanComparable.xml
    │   ├── OutputIterator.xml
    │   ├── RandomAccessIterator.xml
    │   ├── SignedInteger.xml
    │   └── concepts.xml
├── implementation.htm
├── include
    └── boost
    │   ├── concept
    │       ├── assert.hpp
    │       ├── detail
    │       │   ├── backward_compatibility.hpp
    │       │   ├── borland.hpp
    │       │   ├── concept_def.hpp
    │       │   ├── concept_undef.hpp
    │       │   ├── general.hpp
    │       │   ├── has_constraints.hpp
    │       │   └── msvc.hpp
    │       ├── requires.hpp
    │       └── usage.hpp
    │   ├── concept_archetype.hpp
    │   ├── concept_check.hpp
    │   └── concept_check
    │       ├── borland.hpp
    │       ├── general.hpp
    │       ├── has_constraints.hpp
    │       └── msvc.hpp
├── index.html
├── meta
    ├── explicit-failures-markup.xml
    └── libraries.json
├── prog_with_concepts.htm
├── reference.htm
├── test
    ├── Jamfile.v2
    ├── class_concept_check_test.cpp
    ├── class_concept_fail_expected.cpp
    ├── cmake_test
    │   ├── CMakeLists.txt
    │   └── main.cpp
    ├── concept_check_fail_expected.cpp
    ├── concept_check_test.cpp
    ├── fake_sort.hpp
    ├── function_requires_fail.cpp
    ├── old_concept_class_fail.cpp
    ├── old_concept_function_fail.cpp
    ├── old_concept_pass.cpp
    ├── old_concepts.hpp
    ├── stl_concept_check.cpp
    ├── stl_concept_covering.cpp
    ├── usage_fail.cpp
    ├── where.cpp
    └── where_fail.cpp
└── using_concept_check.htm


/.appveyor.yml:
--------------------------------------------------------------------------------
 1 | # Copyright 2016, 2017 Peter Dimov
 2 | # Copyright 2017 - 2019 James E. King III
 3 | # Copyright 2019 - 2021 Alexander Grund
 4 | # Distributed under the Boost Software License, Version 1.0.
 5 | # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 6 | 
 7 | #
 8 | # Generic Appveyor build script for boostorg repositories
 9 | # See: https://github.com/boostorg/boost-ci/
10 | #
11 | # Instructions for customizing this script for your library:
12 | #
13 | # 1. Customize the compilers and language levels you want.
14 | # 2. If you have more than include/, src/, test/, example/, examples/,
15 | #    benchmark/ or tools/ directories, set the environment variable DEPINST.
16 | #    For example if your build uses code in "bench/" and "fog/" directories:
17 | #      - DEPINST: --include bench --include fog
18 | # 3. Enable pull request builds in your boostorg/<library> account.
19 | #
20 | # That's it - the script will do everything else for you.
21 | #
22 | 
23 | version: 1.0.{build}-{branch}
24 | 
25 | shallow_clone: true
26 | 
27 | branches:
28 |   only:
29 |     - master
30 |     - develop
31 |     - /bugfix\/.*/
32 |     - /feature\/.*/
33 |     - /fix\/.*/
34 |     - /pr\/.*/
35 | 
36 | skip_commits:
37 |   files:
38 |     - LICENSE
39 |     - meta/*
40 |     - README.md
41 | 
42 | matrix:
43 |   fast_finish: false
44 |   # Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
45 |   allow_failures:
46 |     - MAYFAIL: true
47 | 
48 | environment:
49 |   global:
50 |     B2_CI_VERSION: 1
51 |     GIT_FETCH_JOBS: 4
52 |     # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
53 |     # to use the default for a given environment, comment it out; recommend you build debug and release however:
54 |     # on Windows it is important to exercise all the possibilities, especially shared vs static, however most
55 |     # libraries that care about this exercise it in their Jamfiles...
56 |     B2_ADDRESS_MODEL: 32,64
57 |     B2_LINK: shared,static
58 |     # B2_THREADING: threading=multi,single
59 |     B2_VARIANT: release
60 | 
61 |   matrix:
62 |     - FLAVOR: Visual Studio 2017 C++2a Strict
63 |       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
64 |       B2_CXXFLAGS: -permissive-
65 |       B2_CXXSTD: 2a
66 |       B2_TOOLSET: msvc-14.1
67 | 
68 |     - FLAVOR: Visual Studio 2017 C++14/17
69 |       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
70 |       B2_CXXSTD: 14,17
71 |       B2_TOOLSET: msvc-14.1
72 | 
73 |     - FLAVOR: cygwin (32-bit)
74 |       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
75 |       ADDPATH: C:\cygwin\bin;
76 |       B2_ADDRESS_MODEL: 32
77 |       B2_CXXSTD: 03,11,14,1z
78 |       B2_TOOLSET: gcc
79 | 
80 |     - FLAVOR: cygwin (64-bit)
81 |       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
82 |       ADDPATH: C:\cygwin64\bin;
83 |       B2_ADDRESS_MODEL: 64
84 |       B2_CXXSTD: 03,11,14,1z
85 |       B2_TOOLSET: gcc
86 | 
87 | install:
88 |   - git clone --depth 1 https://github.com/boostorg/boost-ci.git C:\boost-ci-cloned
89 |   # Copy ci folder if not testing Boost.CI
90 |   - if NOT "%APPVEYOR_PROJECT_NAME%" == "boost-ci" xcopy /s /e /q /i /y C:\boost-ci-cloned\ci .\ci
91 |   - rmdir /s /q C:\boost-ci-cloned
92 |   - ci\appveyor\install.bat
93 | 
94 | build: off
95 | 
96 | test_script: ci\build.bat
97 | 
98 | 


--------------------------------------------------------------------------------
/.codecov.yml:
--------------------------------------------------------------------------------
 1 | # Copyright 2019 - 2021 Alexander Grund
 2 | # Distributed under the Boost Software License, Version 1.0.
 3 | # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 4 | #
 5 | # Sample codecov configuration file. Edit as required
 6 | 
 7 | codecov:
 8 |   max_report_age: off
 9 |   require_ci_to_pass: yes
10 |   notify:
11 |     # Increase this if you have multiple coverage collection jobs
12 |     after_n_builds: 2
13 |     wait_for_ci: yes
14 | 
15 | parsers:
16 |   gcov:
17 |     branch_detection:
18 |       conditional: yes
19 |       loop: yes
20 |       method: no
21 |       macro: no
22 | 
23 | # Change how pull request comments look
24 | comment:
25 |   layout: "reach,diff,flags,files,footer"
26 | 
27 | # Ignore specific files or folders. Glob patterns are supported.
28 | # See https://docs.codecov.com/docs/ignoring-paths
29 | ignore:
30 |   - libs/concept_check/test/
31 |   - test/
32 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | * text=auto !eol svneol=native#text/plain
 2 | *.gitattributes text svneol=native#text/plain
 3 | 
 4 | # Scriptish formats
 5 | *.bat        text svneol=native#text/plain
 6 | *.bsh        text svneol=native#text/x-beanshell
 7 | *.cgi        text svneol=native#text/plain
 8 | *.cmd        text svneol=native#text/plain
 9 | *.js         text svneol=native#text/javascript
10 | *.php        text svneol=native#text/x-php
11 | *.pl         text svneol=native#text/x-perl
12 | *.pm         text svneol=native#text/x-perl
13 | *.py         text svneol=native#text/x-python
14 | *.sh         eol=lf svneol=LF#text/x-sh
15 | configure    eol=lf svneol=LF#text/x-sh
16 | 
17 | # Image formats
18 | *.bmp        binary svneol=unset#image/bmp
19 | *.gif        binary svneol=unset#image/gif
20 | *.ico        binary svneol=unset#image/ico
21 | *.jpeg       binary svneol=unset#image/jpeg
22 | *.jpg        binary svneol=unset#image/jpeg
23 | *.png        binary svneol=unset#image/png
24 | *.tif        binary svneol=unset#image/tiff
25 | *.tiff       binary svneol=unset#image/tiff
26 | *.svg        text svneol=native#image/svg%2Bxml
27 | 
28 | # Data formats
29 | *.pdf        binary svneol=unset#application/pdf
30 | *.avi        binary svneol=unset#video/avi
31 | *.doc        binary svneol=unset#application/msword
32 | *.dsp        text svneol=crlf#text/plain
33 | *.dsw        text svneol=crlf#text/plain
34 | *.eps        binary svneol=unset#application/postscript
35 | *.gz         binary svneol=unset#application/gzip
36 | *.mov        binary svneol=unset#video/quicktime
37 | *.mp3        binary svneol=unset#audio/mpeg
38 | *.ppt        binary svneol=unset#application/vnd.ms-powerpoint
39 | *.ps         binary svneol=unset#application/postscript
40 | *.psd        binary svneol=unset#application/photoshop
41 | *.rdf        binary svneol=unset#text/rdf
42 | *.rss        text svneol=unset#text/xml
43 | *.rtf        binary svneol=unset#text/rtf
44 | *.sln        text svneol=native#text/plain
45 | *.swf        binary svneol=unset#application/x-shockwave-flash
46 | *.tgz        binary svneol=unset#application/gzip
47 | *.vcproj     text svneol=native#text/xml
48 | *.vcxproj    text svneol=native#text/xml
49 | *.vsprops    text svneol=native#text/xml
50 | *.wav        binary svneol=unset#audio/wav
51 | *.xls        binary svneol=unset#application/vnd.ms-excel
52 | *.zip        binary svneol=unset#application/zip
53 | 
54 | # Text formats
55 | .htaccess    text svneol=native#text/plain
56 | *.bbk        text svneol=native#text/xml
57 | *.cmake      text svneol=native#text/plain
58 | *.css        text svneol=native#text/css
59 | *.dtd        text svneol=native#text/xml
60 | *.htm        text svneol=native#text/html
61 | *.html       text svneol=native#text/html
62 | *.ini        text svneol=native#text/plain
63 | *.log        text svneol=native#text/plain
64 | *.mak        text svneol=native#text/plain
65 | *.qbk        text svneol=native#text/plain
66 | *.rst        text svneol=native#text/plain
67 | *.sql        text svneol=native#text/x-sql
68 | *.txt        text svneol=native#text/plain
69 | *.xhtml      text svneol=native#text/xhtml%2Bxml
70 | *.xml        text svneol=native#text/xml
71 | *.xsd        text svneol=native#text/xml
72 | *.xsl        text svneol=native#text/xml
73 | *.xslt       text svneol=native#text/xml
74 | *.xul        text svneol=native#text/xul
75 | *.yml        text svneol=native#text/plain
76 | boost-no-inspect text svneol=native#text/plain
77 | CHANGES      text svneol=native#text/plain
78 | COPYING      text svneol=native#text/plain
79 | INSTALL      text svneol=native#text/plain
80 | Jamfile      text svneol=native#text/plain
81 | Jamroot      text svneol=native#text/plain
82 | Jamfile.v2   text svneol=native#text/plain
83 | Jamrules     text svneol=native#text/plain
84 | Makefile*    text svneol=native#text/plain
85 | README       text svneol=native#text/plain
86 | TODO         text svneol=native#text/plain
87 | 
88 | # Code formats
89 | *.c          text svneol=native#text/plain
90 | *.cpp        text svneol=native#text/plain
91 | *.h          text svneol=native#text/plain
92 | *.hpp        text svneol=native#text/plain
93 | *.ipp        text svneol=native#text/plain
94 | *.tpp        text svneol=native#text/plain
95 | *.jam        text svneol=native#text/plain
96 | *.java       text svneol=native#text/plain
97 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright 2018 Glen Joseph Fernandes
 2 | # (glenjofe@gmail.com)
 3 | #
 4 | # Distributed under the Boost Software License, Version 1.0.
 5 | # (http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | cmake_minimum_required(VERSION 3.5...3.20)
 8 | 
 9 | project(boost_concept_check VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
10 | 
11 | add_library(boost_concept_check INTERFACE)
12 | 
13 | add_library(Boost::concept_check ALIAS boost_concept_check)
14 | 
15 | target_include_directories(boost_concept_check INTERFACE include)
16 | 
17 | target_link_libraries(boost_concept_check INTERFACE
18 |     Boost::config
19 |     Boost::preprocessor
20 |     Boost::static_assert
21 |     Boost::type_traits
22 | )
23 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Boost Software License - Version 1.0 - August 17th, 2003
 2 | 
 3 | Permission is hereby granted, free of charge, to any person or organization
 4 | obtaining a copy of the software and accompanying documentation covered by
 5 | this license (the "Software") to use, reproduce, display, distribute,
 6 | execute, and transmit the Software, and to prepare derivative works of the
 7 | Software, and to permit third-parties to whom the Software is furnished to
 8 | do so, all subject to the following:
 9 | 
10 | The copyright notices in the Software and this entire statement, including
11 | the above license grant, this restriction and the following disclaimer,
12 | must be included in all copies of the Software, in whole or in part, and
13 | all derivative works of the Software, unless such copies or derivative
14 | works are solely in the form of machine-executable object code generated by
15 | a source language processor.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 | DEALINGS IN THE SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ConceptCheck, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), 
 2 | allows one to add explicit statement and checking of concepts in the style of the proposed C++ language extension.
 3 | 
 4 | ### License
 5 | 
 6 | Distributed under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
 7 | 
 8 | ### Properties
 9 | 
10 | * C++03
11 | * Header-only
12 | 
13 | ### Build Status
14 | 
15 | <!-- boost-ci/tools/makebadges.sh --project concept_check --appveyor qj0837owatwej9ws --codecov 4FWH598KON --coverity 16317 -->
16 | | Branch          | GHA CI | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
17 | | :-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
18 | | [`master`](https://github.com/boostorg/concept_check/tree/master) | [![Build Status](https://github.com/boostorg/concept_check/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/concept_check/actions?query=branch:master) | [![Build status](https://ci.appveyor.com/api/projects/status/qj0837owatwej9ws/branch/master?svg=true)](https://ci.appveyor.com/project/cppalliance/concept-check/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/16317/badge.svg)](https://scan.coverity.com/projects/boostorg-concept_check) | [![codecov](https://codecov.io/gh/boostorg/concept_check/branch/master/graph/badge.svg?token=4FWH598KON)](https://codecov.io/gh/boostorg/concept_check/tree/master) | [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/concept_check.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](https://www.boost.org/doc/libs/master/libs/concept_check) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](https://www.boost.org/development/tests/master/developer/concept_check.html)
19 | | [`develop`](https://github.com/boostorg/concept_check/tree/develop) | [![Build Status](https://github.com/boostorg/concept_check/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/concept_check/actions?query=branch:develop) | [![Build status](https://ci.appveyor.com/api/projects/status/qj0837owatwej9ws/branch/develop?svg=true)](https://ci.appveyor.com/project/cppalliance/concept-check/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/16317/badge.svg)](https://scan.coverity.com/projects/boostorg-concept_check) | [![codecov](https://codecov.io/gh/boostorg/concept_check/branch/develop/graph/badge.svg?token=4FWH598KON)](https://codecov.io/gh/boostorg/concept_check/tree/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/concept_check.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](https://www.boost.org/doc/libs/develop/libs/concept_check) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](https://www.boost.org/development/tests/develop/developer/concept_check.html)
20 | 
21 | ### Directories
22 | 
23 | | Name        | Purpose                        |
24 | | ----------- | ------------------------------ |
25 | | `doc`       | documentation                  |
26 | | `include`   | headers                        |
27 | | `test`      | unit tests                     |
28 | 
29 | ### More information
30 | 
31 | * [Ask questions](https://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-concept_check)
32 | * [Report bugs](https://github.com/boostorg/concept_check/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
33 | * Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
34 | * Discussions about the library are held on the [Boost developers mailing list](https://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](https://www.boost.org/community/policy.html) before posting and add the `[concept_check]` tag at the beginning of the subject line.
35 | 
36 | 


--------------------------------------------------------------------------------
/bad_error_eg.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <complex>
 3 | #include "algorithm"
 4 | 
 5 | int main()
 6 | {
 7 |     std::vector<std::complex<float> > v;
 8 |     std_::stable_sort(v.begin(), v.end());
 9 | }
10 | 
11 | // (C) Copyright Jeremy Siek 2000.
12 | // Distributed under the Boost Software License, Version 1.0. (See
13 | // accompanying file LICENSE_1_0.txt or copy at
14 | // http://www.boost.org/LICENSE_1_0.txt)
15 | 


--------------------------------------------------------------------------------
/bibliography.htm:
--------------------------------------------------------------------------------
 1 | <HTML>
 2 | <!-- Copyright (c) Jeremy Siek 2000 -->
 3 | <!-- Distributed under the Boost -->
 4 | <!-- Software License, Version 1.0. (See accompanying -->
 5 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 6 | <Head>
 7 | <Title>Boost Concept Checking Library: Bibliography</Title>
 8 | <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 9 |         ALINK="#ff0000"> 
10 | <IMG SRC="../../boost.png" 
11 |      ALT="C++ Boost" width="277" height="86"> 
12 | 
13 | <BR Clear>
14 | 
15 | 
16 | <H2>Bibliography</H2>
17 | 
18 | <DL COMMapCT>
19 | 
20 | <DD><P></P><DT><a name="alexandrescu99:_better_templ_error_messag">1</a>
21 | <DD>Andrei Alexandrescu<BR>
22 | <EM>Better Template Error Messages</EM>.<BR>
23 | C/C++ Users Journal, March, 1999.
24 | 
25 | 
26 | <DD><P></P><DT><a name="stroustrup94:_design_evolution">2</a>
27 | <DD>Bjarne Stroustrup<BR>
28 | <EM>Design and Evolution of C++</EM>.<BR>
29 | Addison-Wesley, 1994
30 | 
31 | <P></P><DT><A NAME="austern99:_gener_progr_stl">3</A>
32 | <DD>
33 | M.&nbsp;H. Austern.
34 | <BR><EM>Generic Programming and the STL</EM>.
35 | <BR>Professional computing series. Addison-Wesley, 1999.
36 | 
37 | <P></P><DT><A NAME="IB-H965502">4</A>
38 | <DD>
39 | David R. Musser and Atul Saini
40 | <BR><EM>STL Tutorial and Reference Guide</EM>.
41 | <BR>Professional computing series. Addison-Wesley, 1996.
42 | 
43 | <P></P><DT><A NAME="stepa.lee-1994:the.s:TR">5</A>
44 | <DD>
45 | A. A. Stepanov and M. Lee
46 | <BR><EM>The Standard Template Library</EM>.
47 | <BR>ISO Programming Language C++ Project, May 1994.
48 | <BR>X3J16/94-0095, WG21/N0482
49 | 
50 | 
51 | 
52 | </DL>
53 | 
54 | <br>
55 | <HR>
56 | <TABLE>
57 | <TR valign=top>
58 | <TD nowrap>Copyright &copy 2000</TD><TD>
59 | <A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>(<A
60 | HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
61 | Andrew Lumsdaine</A>(<A HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
62 | </TD></TR></TABLE>
63 | 
64 | </BODY>
65 | </HTML> 
66 | 


--------------------------------------------------------------------------------
/build.jam:
--------------------------------------------------------------------------------
 1 | # Copyright René Ferdinand Rivera Morell 2023-2024
 2 | # Distributed under the Boost Software License, Version 1.0.
 3 | # (See accompanying file LICENSE_1_0.txt or copy at
 4 | # http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | require-b2 5.2 ;
 7 | 
 8 | constant boost_dependencies :
 9 |     /boost/config//boost_config
10 |     /boost/preprocessor//boost_preprocessor
11 |     /boost/static_assert//boost_static_assert
12 |     /boost/type_traits//boost_type_traits ;
13 | 
14 | project /boost/concept_check
15 |     : common-requirements
16 |         <include>include
17 |     ;
18 | 
19 | explicit
20 |     [ alias boost_concept_check : : : : <library>$(boost_dependencies) ]
21 |     [ alias all : boost_concept_check test ]
22 |     ;
23 | 
24 | call-if : boost-library concept_check
25 |     ;
26 | 
27 | 


--------------------------------------------------------------------------------
/concept_check.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) 2000 Jeremy Siek and Andrew Lumsdaine, 2007 David Abrahams -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 14 | 
 15 |   <title>Concept Check Library</title>
 16 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h1>The Boost Concept Check Library (BCCL)</h1>
 25 | 
 26 |   <blockquote>
 27 |     The Concept Check library allows one to add explicit statement and
 28 |     checking of <a href=
 29 |     "http://www.boost.org/more/generic_programming.html#concept">concepts</a> in the style
 30 |     of the <a href=
 31 |     "http://www.generic-programming.org/languages/conceptcpp/specification/">proposed
 32 |     C++ language extension</a>.
 33 |   </blockquote>
 34 | 
 35 |   <h2><a name="sec:concept-checking" id="sec:concept-checking"></a>Synopsis</a></h2>
 36 | 
 37 |   <p>Generic programming in C++ is characterized by the use of template
 38 |   parameters to represent abstract data types (or “<a href=
 39 |   "http://www.boost.org/more/generic_programming.html#concept">concepts</a>”). However, the
 40 |   C++ language itself does not provide a mechanism for the writer of a class
 41 |   or function template to explicitly state the concept that the user-supplied
 42 |   template argument should model (or conform to). Template parameters are
 43 |   commonly named after the concept they're required to model as a hint to the
 44 |   user, and to make the concept requirements explicit in code. However, the
 45 |   compiler doesn't treat these special names specially: a parameter named
 46 |   <code>RandomAccessIterator</code> is no different to the compiler than one
 47 |   named <code>T</code>. Furthermore,</p>
 48 | 
 49 |   <ul>
 50 |     <li>Compiler error messages resulting from incorrect template arguments
 51 |     can be particularly difficult to decipher. Often times the error does not
 52 |     point to the location of the template call-site, but instead exposes the
 53 |     internals of the template, which the user should never have to see.</li>
 54 | 
 55 |     <li>Without checking from the compiler, the documented requirements are
 56 |     oftentimes vague, incorrect, or nonexistent, so a user cannot know
 57 |     exactly what kind of arguments are expected.</li>
 58 | 
 59 |     <li>The documented concept requirements may not fully <i>cover</i> the
 60 |     needs of the actual template, meaning the user could get a compiler error
 61 |     even though the supplied template arguments meet the documented
 62 |     requirements.</li>
 63 | 
 64 |     <li>The documented concept requirements may be too stringent, requiring
 65 |     more than is really needed by the template.</li>
 66 | 
 67 |     <li>Concept names in code may drift out-of-sync with the documented
 68 |     requirements.</li>
 69 |   </ul><p>The Boost Concept Checking Library provides:
 70 | 
 71 |   <ul>
 72 |     <li>A mechanism for inserting compile-time checks on template parameters
 73 |     at their point of use.</li>
 74 | 
 75 |     <li>A framework for specifying concept requirements through concept
 76 |     checking classes.</li>
 77 | 
 78 |     <li>A mechanism for verifying that concept requirements cover the
 79 |     template.</li>
 80 | 
 81 |     <li>A suite of concept checking classes and archetype classes that match
 82 |     the concept requirements in the C++ Standard Library.</li>
 83 | 
 84 |     <li>An alternative to the use of traits classes for accessing associated
 85 |     types that mirrors the syntax proposed for the next C++ standard.</li>
 86 |   </ul><p>The mechanisms use standard C++ and introduce no run-time overhead.
 87 |   The main cost of using the mechanism is in compile-time.</p>
 88 | 
 89 |   <p><strong>Every programmer writing class or function templates ought to
 90 |   make concept checking a normal part of their code writing routine.</strong>
 91 |   A concept check should be inserted for each template parameter in a
 92 |   component's public interface. If the concept is one of the ones from the
 93 |   Standard Library, then simply use the matching concept checking class in
 94 |   the BCCL. If not, then write a new concept checking class - after all, they
 95 |   are typically only a few lines long. For new concepts, a matching archetype
 96 |   class should also be created, which is a minimal skeleton-implementation of
 97 |   the concept</p>
 98 | 
 99 |   <p>The documentation is organized into the following sections.</p>
100 | 
101 |   <ol>
102 |     <li><a href="#introduction">Introduction</a></li>
103 | 
104 |     <li><a href="#motivating-example">Motivating Example</a></li>
105 | 
106 |     <li><a href="#history">History</a></li>
107 | 
108 |     <li><a href="#publications">Publications</a></li>
109 | 
110 |     <li><a href="#acknowledgements">Acknowledgements</a></li>
111 | 
112 |     <li><a href="./using_concept_check.htm">Using Concept Checks</a></li>
113 | 
114 |     <li><a href="creating_concepts.htm">Creating Concept Checking
115 |     Classes</a></li>
116 | 
117 |     <li><a href="./concept_covering.htm">Concept Covering and
118 |     Archetypes</a></li>
119 | 
120 |     <li><a href="./prog_with_concepts.htm">Programming With Concepts</a></li>
121 | 
122 |     <li><a href="./implementation.htm">Implementation</a></li>
123 | 
124 |     <li><a href="./reference.htm">Reference</a></li>
125 |   </ol>
126 | 
127 |   <p><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a> contributed this
128 |   library. <a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a> managed
129 |   the formal review. <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
130 |   Abrahams</a> contributed a rewrite that updated syntax to be more
131 |   compatible with proposed syntax for concept support the C++ core
132 |   language.</p>
133 | 
134 |   <h2><a name="introduction" id="introduction">Introduction</a></h2><p>A
135 |   <i>concept</i> is a set of requirements (valid expressions, associated
136 |   types, semantic invariants, complexity guarantees, etc.) that a type must
137 |   fulfill to be correctly used as arguments in a call to a generic algorithm.
138 |   In C++, concepts are represented by formal template parameters to function
139 |   templates (generic algorithms). However, C++ has no explicit mechanism for
140 |   representing concepts—template parameters are merely placeholders. By
141 |   convention, these parameters are given names corresponding to the concept
142 |   that is required, but a C++ compiler does not enforce compliance to the
143 |   concept when the template parameter is bound to an actual type.
144 | 
145 |   <p>Naturally, if a generic algorithm is invoked with a type that does not
146 |   fulfill at least the syntactic requirements of the concept, a compile-time
147 |   error will occur. However, this error will not <i>per se</i> reflect the
148 |   fact that the type did not meet all of the requirements of the concept.
149 |   Rather, the error may occur deep inside the instantiation hierarchy at the
150 |   point where an expression is not valid for the type, or where a presumed
151 |   associated type is not available. The resulting error messages are largely
152 |   uninformative and basically impenetrable.</p>
153 | 
154 |   <p>What is required is a mechanism for enforcing
155 |   “concept safety” at (or close to) the point
156 |   of instantiation. The Boost Concept Checking Library uses some standard C++
157 |   constructs to enforce early concept compliance and that provides more
158 |   informative error messages upon non-compliance.</p>
159 | 
160 |   <p>Note that this technique only addresses the syntactic requirements of
161 |   concepts (the valid expressions and associated types). We do not address
162 |   the semantic invariants or complexity guarantees, which are also part of
163 |   concept requirements..</p>
164 | 
165 |   <h2><a name="motivating-example" id="motivating-example">Motivating
166 |   Example</a></h2>
167 | 
168 |   <p>We present a simple example to illustrate incorrect usage of a template
169 |   library and the resulting error messages. In the code below, the generic
170 |   <tt>std::stable_sort()</tt> algorithm from the Standard Template Library
171 |   (STL)[<a href="bibliography.htm#austern99:_gener_progr_stl">3</a>, <a href=
172 |   "bibliography.htm#IB-H965502">4</a>,<a href=
173 |   "bibliography.htm#stepa.lee-1994:the.s:TR">5</a>] is applied to a linked
174 |   list.</p>
175 |   <pre>
176 |   <a href="./bad_error_eg.cpp">bad_error_eg.cpp</a>:
177 | <font color="gray">1</font> #include &lt;vector&gt;
178 | <font color="gray">2</font color="gray"> #include &lt;complex&gt;
179 | <font color="gray">3</font color="gray"> #include &lt;algorithm&gt;
180 | <font color="gray">4</font color="gray"> 
181 | <font color="gray">5</font color="gray"> int main()
182 | <font color="gray">6</font color="gray"> {
183 | <font color="gray">7</font color="gray">     std::vector&lt;std::complex&lt;float&gt; &gt; v;
184 | <font color="gray">8</font color="gray">     std::stable_sort(v.begin(), v.end());
185 | <font color="gray">9</font color="gray"> }
186 | </pre>
187 | 
188 |   <p>Here, the <tt>std::stable_sort()</tt> algorithm is prototyped as
189 |   follows:</p>
190 |   <pre>
191 |   template &lt;class RandomAccessIterator&gt;
192 |   void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
193 | </pre>
194 | 
195 |   <p>Attempting to compile this code with Gnu C++ produces the following
196 |   compiler error:</p>
197 |   <pre>
198 | /usr/include/c++/4.1.2/bits/stl_algo.h: In function ‘void std::
199 |   __insertion_sort(_RandomAccessIterator, _RandomAccessIterator) [with 
200 |   _RandomAccessIterator = __gnu_cxx::__normal_iterator&lt;std::complex&lt;float
201 |   &gt;*, std::vector&lt;std::complex&lt;float&gt;, std::allocator&lt;std::complex&lt;
202 |   float&gt; &gt; &gt; &gt;]’:
203 | /usr/include/c++/4.1.2/bits/stl_algo.h:3066:   instantiated from ‘void 
204 |   std::__inplace_stable_sort(_RandomAccessIterator, 
205 |   _RandomAccessIterator) [with _RandomAccessIterator = __gnu_cxx::
206 |   __normal_iterator&lt;std::complex&lt;float&gt;*, std::vector&lt;std::complex&lt;
207 |   float&gt;, std::allocator&lt;std::complex&lt;float&gt; &gt; &gt; &gt;]’
208 | /usr/include/c++/4.1.2/bits/stl_algo.h:3776:   instantiated from ‘void 
209 |   std::stable_sort(_RandomAccessIterator, _RandomAccessIterator) [with 
210 |   _RandomAccessIterator = __gnu_cxx::__normal_iterator&lt;std::complex&lt;float
211 |   &gt;*, std::vector&lt;std::complex&lt;float&gt;, std::allocator&lt;std::complex&lt;
212 |   float&gt; &gt; &gt; &gt;]’
213 | bad_error_eg.cpp:8:   instantiated from here
214 | /usr/include/c++/4.1.2/bits/stl_algo.h:2277: error: no match for 
215 |   ‘operator&lt;’ in ‘__val &lt; __first. __gnu_cxx::__normal_iterator&lt;
216 |   _Iterator, _Container&gt;::operator* [with _Iterator = std::complex&lt;float
217 |   &gt;*, _Container = std::vector&lt;std::complex&lt;float&gt;, std::allocator&lt;
218 |   std::complex&lt;float&gt; &gt; &gt;]()’
219 | </pre>
220 | 
221 |   <p>In this case, the fundamental error is
222 |   that <tt>std:complex&lt;float&gt;</tt> does not model the <a href=
223 |   "http://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</a>
224 |   concept.  Unfortunately, there is nothing in the error message to
225 |   indicate that to the user.</p>
226 | 
227 |   <p>The error may be obvious to a C++ programmer having enough
228 |   experience with template libraries, but there are several reasons
229 |   why this message could be hard for the uninitiated to
230 |   understand:</p>
231 | 
232 |   <ol>
233 |     <li>There is no textual correlation between the error message and the
234 |     documented requirements for <tt>std::stable_sort()</tt> and for <a href=
235 |     "http://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</a>.</li>
236 | 
237 |     <li>The error message is overly long, listing functions internal
238 |     to the STL (e.g. <code>__insertion_sort</code>) that the user
239 |     does not (and should not!) know or care about.</li>
240 | 
241 |     <li>With so many internal library functions listed in the error message,
242 |     the programmer could easily infer that the problem is in the library,
243 |     rather than in his or her own code.</li>
244 |   </ol>
245 | 
246 |   <p>The following is an example of what we might expect from a more
247 |   informative message (and is in fact what the Boost Concept Checking Library
248 |   produces):</p>
249 |   <pre>
250 | boost/concept_check.hpp: In destructor ‘boost::LessThanComparable&lt;TT&gt;::~
251 |   LessThanComparable() [with TT = std::complex&lt;float&gt;]’:
252 | boost/concept/detail/general.hpp:29:   instantiated from ‘static void boost::
253 |   concepts::requirement&lt;Model&gt;::failed() [with Model = boost::
254 |   LessThanComparable&lt;std::complex&lt;float&gt; &gt;]’
255 | boost/concept/requires.hpp:30:   instantiated from ‘boost::_requires_&lt;void
256 |   (*)(boost::LessThanComparable&lt;std::complex&lt;float&gt; &gt;)&gt;’
257 | bad_error_eg.cpp:8:   instantiated from here
258 | boost/concept_check.hpp:236: error: no match for ‘operator&lt;’ in ‘((boost::
259 |   LessThanComparable&lt;std::complex&lt;float&gt; &gt;*)this)-&gt;boost::
260 |   LessThanComparable&lt;std::complex&lt;float&gt; &gt;::a &lt; ((boost::
261 |   LessThanComparable&lt;std::complex&lt;float&gt; &gt;*)this)-&gt;boost::
262 |   LessThanComparable&lt;std::complex&lt;float&gt; &gt;::b’
263 | </pre>
264 | 
265 |   <p>This message rectifies several of the shortcomings of the standard error
266 |   messages.</p>
267 | 
268 |   <ul>
269 |     <li>The message refers explicitly to concepts that the user can look up
270 |     in the STL documentation (<a href=
271 |     "http://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</a>).</li>
272 | 
273 |     <li>The error message is now much shorter and does not reveal
274 |     internal STL functions, nor indeed does it even point
275 |     to <code>std::stable_sort</code>.</li>
276 | 
277 |     <li>The presence of <tt>concept_check.hpp</tt> in the error message
278 |     alerts the user to the fact that the error lies in the user code and not
279 |     in the library implementation.</li>
280 |   </ul>
281 | 
282 |   <h2><a name="history" id="history">History</a></h2>
283 | 
284 |   <p>The first version of this concept checking system was developed
285 |   by Jeremy Siek while working at SGI in their C++ compiler and
286 |   library group. That version is now part of the SGI STL
287 |   distribution. The system originally introduced as the boost concept
288 |   checking library differs from concept checking in the SGI STL in
289 |   that the definition of concept checking classes was greatly
290 |   simplified, at the price of less helpful verbiage in the error
291 |   messages. In 2006 the system was rewritten (preserving backward
292 |   compatibility) by Dave Abrahams to be easier to use, more similar to
293 |   the proposed concept support the C++ core language, and to give
294 |   better error messages.
295 | </p>
296 | 
297 |   <h2><a name="publications" id="publications">Publications</a></h2>
298 | 
299 |   <ul>
300 |     <li><a href="http://www.oonumerics.org/tmpw00/">C++ Template Workshop
301 |     2000</a>, Concept Checking</li>
302 |   </ul>
303 | 
304 |   <h2><a name="acknowledgements" id=
305 |   "acknowledgements">Acknowledgements</a></h2><p>The idea to use function
306 |   pointers to cause instantiation is due to Alexander Stepanov. We are not sure
307 |   of the origin of the idea to use expressions to do up-front checking of
308 |   templates, but it did appear in D&amp;E[ <a href=
309 |   "bibliography.htm#stroustrup94:_design_evolution">2</a>]. Thanks to Matt
310 |   Austern for his excellent documentation and organization of the STL
311 |   concepts, upon which these concept checks are based. Thanks to Boost
312 |   members for helpful comments and reviews.
313 | 
314 |   <p><a href="./using_concept_check.htm">Next: Using Concept
315 |   Checks</a><br /></p>
316 |   <hr />
317 | 
318 |   <table>
319 |     <tr valign="top">
320 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
321 | 
322 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
323 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
324 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>),
325 |         2007 <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.
326 | </td>
327 |     </tr>
328 |   </table>
329 | </body>
330 | </html>
331 | 


--------------------------------------------------------------------------------
/concept_covering.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 | 
 14 |   <title>Concept Covering and Archetypes</title>
 15 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 16 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="concept-covering" id="concept-covering">Concept Covering and
 25 |   Archetypes</a></h2>
 26 | 
 27 |   <p>We have discussed how it is important to select the minimal requirements
 28 |   (concepts) for the inputs to a component, but it is equally important to
 29 |   verify that the chosen concepts <i>cover</i> the algorithm. That is, any
 30 |   possible user error should be caught by the concept checks and not let slip
 31 |   through. Concept coverage can be verified through the use of <i>archetype
 32 |   classes</i>. An archetype class is an exact implementation of the interface
 33 |   associated with a particular concept. The run-time behavior of the
 34 |   archetype class is not important, the functions can be left empty. A simple
 35 |   test program can then be compiled with the archetype classes as the inputs
 36 |   to the component. If the program compiles then one can be sure that the
 37 |   concepts cover the component. The following code shows the archetype class
 38 |   for the <a href="http://www.boost.org/sgi/stl/InputIterator.html">Input
 39 |   Iterator</a> concept. Some care must be taken to ensure that the archetype
 40 |   is an exact match to the concept. For example, the concept states that the
 41 |   return type of <tt>operator*()</tt> must be convertible to the value type.
 42 |   It does not state the more stringent requirement that the return type be
 43 |   <tt>T&amp;</tt> or <tt>const T&amp;</tt>. That means it would be a mistake
 44 |   to use <tt>T&amp;</tt> or <tt>const T&amp;</tt> for the return type of the
 45 |   archetype class. The correct approach is to create an artificial return
 46 |   type that is convertible to <tt>T</tt>, as we have done here with
 47 |   <tt>reference</tt>. The validity of the archetype class test is completely
 48 |   dependent on it being an exact match with the concept, which must be
 49 |   verified by careful (manual) inspection.</p>
 50 |   <pre>
 51 | template &lt;class T&gt;
 52 | class input_iterator_archetype
 53 | {
 54 | private:
 55 |   typedef input_iterator_archetype self;
 56 | public:
 57 |   typedef std::input_iterator_tag iterator_category;
 58 |   typedef T value_type;
 59 |   struct reference {
 60 |     operator const value_type&amp;() const { return static_object&lt;T&gt;::get(); }
 61 |   };
 62 |   typedef const T* pointer;
 63 |   typedef std::ptrdiff_t difference_type;
 64 |   self&amp; operator=(const self&amp;) { return *this;  }
 65 |   bool operator==(const self&amp;) const { return true; }
 66 |   bool operator!=(const self&amp;) const { return true; }
 67 |   reference operator*() const { return reference(); }
 68 |   self&amp; operator++() { return *this; }
 69 |   self operator++(int) { return *this; }
 70 | };
 71 | </pre>
 72 | 
 73 |   <p>Generic algorithms are often tested by being instantiated with a number
 74 |   of common input types. For example, one might apply
 75 |   <tt>std::stable_sort()</tt> with basic pointer types as the iterators.
 76 |   Though appropriate for testing the run-time behavior of the algorithm, this
 77 |   is not helpful for ensuring concept coverage because C++ types never match
 78 |   particular concepts exactly. Instead, they often provide more than the
 79 |   minimal functionality required by any one concept. Even though the function
 80 |   template has concept checks, and compiles with a given type, the checks may
 81 |   still fall short of covering all the functionality that is actually used.
 82 |   This is why it is important to compile with archetype classes in addition
 83 |   to testing with common input types.</p>
 84 | 
 85 |   <p>The following is an excerpt from <a href=
 86 |   "./stl_concept_covering.cpp"><tt>stl_concept_covering.cpp</tt></a> that
 87 |   shows how archetypes can be used to check the requirement documentation for
 88 |   <a href=
 89 |   "http://www.boost.org/sgi/stl/stable_sort.html"><tt>std::stable_sort()</tt></a>.
 90 |   In this case, it looks like the <a href=
 91 |   "../utility/CopyConstructible.html">CopyConstructible</a> and <a href=
 92 |   "../utility/Assignable.html">Assignable</a> requirements were forgotten in
 93 |   the SGI STL documentation (try removing those archetypes). The Boost
 94 |   archetype classes have been designed so that they can be layered. In this
 95 |   example the value type of the iterator is composed out of three archetypes.
 96 |   In the <a href="reference.htm#basic-archetype">archetype class
 97 |   reference</a>, template parameters named <tt>Base</tt> indicate where the
 98 |   layered archetype paradigm can be used.</p>
 99 |   <pre>
100 | {
101 |   typedef less_than_comparable_archetype&lt; 
102 |       sgi_assignable_archetype&lt;&gt; &gt; ValueType;
103 |   random_access_iterator_archetype&lt;ValueType&gt; ri;
104 |   std::stable_sort(ri, ri);
105 | }
106 | </pre>
107 | 
108 |   <p><a href="./prog_with_concepts.htm">Next: Programming with
109 |   Concepts</a><br />
110 |   <a href="./creating_concepts.htm">Prev: Creating Concept Checking
111 |   Classes</a><br />
112 |   <hr />
113 | 
114 |   <table>
115 |     <tr valign="top">
116 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
117 | 
118 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
119 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
120 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>),
121 |         2007 <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.
122 |     </tr>
123 |   </table>
124 | </body>
125 | </html>
126 | 


--------------------------------------------------------------------------------
/creating_concepts.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 12 |   <meta name="generator" content=
 13 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 14 | 
 15 |   <title>Creating Concept Checking Classes</title>
 16 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="creating-concept-checks" id="creating-concept-checks">Creating
 25 |   Concept Checking Classes</a></h2>
 26 | 
 27 |   <p>As an example of how to create a concept checking class template, we
 28 |   look at how to create the corresponding checks for the <a href=
 29 |   "http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a> concept.
 30 |   The complete definition is here:</p>
 31 |   <pre>
 32 | template &lt;class X&gt;
 33 | struct InputIterator
 34 |   : Assignable&lt;X&gt;, EqualityComparable&lt;X&gt;
 35 | {
 36 |  private:
 37 |     typedef std::iterator_traits&lt;X&gt; t;
 38 |  public:
 39 |     typedef typename t::value_type value_type;
 40 |     typedef typename t::difference_type difference_type;
 41 |     typedef typename t::reference reference;
 42 |     typedef typename t::pointer pointer;
 43 |     typedef typename t::iterator_category iterator_category;
 44 | 
 45 |     BOOST_CONCEPT_ASSERT((SignedInteger&lt;difference_type&gt;));
 46 |     BOOST_CONCEPT_ASSERT((Convertible&lt;iterator_category, std::input_iterator_tag&gt;));
 47 |         
 48 |     BOOST_CONCEPT_USAGE(InputIterator)
 49 |     {
 50 |         X j(i);             <font color=
 51 | "green">// require copy construction</font>
 52 |         same_type(*i++,v);  <font color=
 53 | "green">// require postincrement-dereference returning value_type</font>
 54 |         X&amp; x = ++j;         <font color=
 55 | "green">// require preincrement returning X&amp;</font>
 56 |     }
 57 |     
 58 |  private:
 59 |     X i;
 60 |     value_type v;
 61 | 
 62 |     <font color=
 63 | "green">// Type deduction will fail unless the arguments have the same type.</font>
 64 |     template &lt;typename T&gt;
 65 |     void same_type(T const&amp;, T const&amp;);
 66 | };
 67 | </pre>
 68 | 
 69 |   <h3>Walkthrough</h3>
 70 | 
 71 |   <p>First, as a convention we name the concept checking class after the
 72 |   concept. Next, since InputIterator is a refinement of Assignable and
 73 |   EqualityComparable, we derive its concept checking class from the checking
 74 |   classes for those other concepts. The library will automatically check for
 75 |   conformance to Assignable and EqualityComparable whenever it checks the
 76 |   InputIterator concept.</p>
 77 | 
 78 |   <p>Next, we declare the concept's <a href=
 79 |   "http://www.boost.org/more/generic_programming.html#associated_type">associated types</a>
 80 |   as member typedefs. The associated difference type is required to be a
 81 |   signed integer, and the iterator category has to be convertible to
 82 |   std::input_iterator_tag, so we assert those relationships. The syntax for
 83 |   accessing associated types through the concept-checking template mirrors
 84 |   the <a href=
 85 |   "http://www.generic-programming.org/languages/conceptcpp/">proposed</a>
 86 |   syntax for associated type access in C++0x Finally, we use the
 87 |   <code>BOOST_CONCEPT_USAGE</code> macro to declare the function that
 88 |   exercises all the concept's valid expressions. Note that at this point you
 89 |   may sometimes need to be a little creative: for example, to check that
 90 |   <code>*i++</code> returns the iterator's value type, we pass both values to
 91 |   the <code>same_type</code> member function template, which requires both
 92 |   arguments to have the same type, modulo references and cv-qualification.
 93 |   It's an imperfect check, but it's better than nothing.</p>
 94 | 
 95 |   <h3>Values for Usage Patterns Should Be Data Members</h3>
 96 | 
 97 |   <p>You may be wondering why we declared <code>i</code> and <code>v</code>
 98 |   as data members in the example above. Why didn't we simply write the
 99 |   following?</p>
100 |   <pre>
101 | BOOST_CONCEPT_USAGE(InputIterator)
102 | {
103 |     X i;                <font color=
104 | "green">// create the values we need</font>
105 |     value_type v;
106 | 
107 |     X j(i);             <font color=
108 | "green">// require copy construction</font>
109 |     same_type(*i++,v);  <font color=
110 | "green">// require postincrement-dereference returning value_type</font>
111 |     X&amp; x = ++j;         <font color=
112 | "green">// require preincrement returning X&amp;</font>
113 | }
114 | </pre>
115 | 
116 |   <p>Unfortunately, that code wouldn't have worked out so well, because it
117 |   unintentionally imposes the requirement that <code>X</code> and its value
118 |   type are both default-constructible. On the other hand, since instances of
119 |   the <code>InputIterator</code> template will never be constructed, the
120 |   compiler never has to check how its data members will be constructed (C++
121 |   Standard Section 14.7.1 9). For that reason you should <strong>always
122 |   declare values needed for usage patterns as data members</strong>.</p>
123 | 
124 |   <p>These sorts of errors in concept definitions can be detected by the use
125 |   of <a href="concept_covering.htm">Concept Archetypes</a>, but it's always
126 |   better to avoid them pre-emptively.</p>
127 | 
128 |   <h3>Similarity to Proposed C++0x Language Support for Concepts</h3>
129 | 
130 |   <p>This library's syntaxes for concept refinement and for access of
131 |   associated types mirrors the corresponding <a href=
132 |   "http://www.generic-programming.org/languages/conceptcpp/">proposed</a>
133 |   syntaxes in C++0x. However, C++0x will use
134 |   “signatures” rather than usage patterns to
135 |   describe the valid operations on types participating in a concept, so when
136 |   converting your concept checking classes into language-supported concepts,
137 |   you'll need to translate your usage function into a series of
138 |   signatures.</p>
139 | 
140 |   <p><a href="./concept_covering.htm">Next: Concept Covering and
141 |   Archetypes</a><br />
142 |   <a href="./using_concept_check.htm">Prev: Using Concept
143 |   Checks</a><br /></p>
144 |   <hr />
145 | 
146 |   <table>
147 |     <tr valign="top">
148 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
149 | 
150 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
151 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
152 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>),
153 |         2007 <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.
154 |     </tr>
155 |   </table>
156 | </body>
157 | </html>
158 | 


--------------------------------------------------------------------------------
/doc/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | project boost/concepts ;
 2 | import boostbook : boostbook ;
 3 | 
 4 | boostbook concepts : reference/concepts.xml 
 5 | 	:
 6 |         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
 7 |         <xsl:param>boost.root=../../../..
 8 | 	;
 9 | 
10 | ###############################################################################
11 | alias boostdoc ;
12 | explicit boostdoc ;
13 | alias boostrelease : concepts ;
14 | explicit boostrelease ;
15 | 


--------------------------------------------------------------------------------
/doc/reference/Assignable.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <concept name="Assignable" category="Utility"><!--
 3 | Based on concepts from the SGI Standard Template Library documentation:
 4 | Copyright (c) 1996-1999
 5 | Silicon Graphics Computer Systems, Inc.
 6 | 
 7 | Copyright (c) 1994
 8 | Hewlett-Packard Company
 9 | --><!--
10 | Copyright 2000-2001 University of Notre Dame du Lac.
11 | Copyright 2001-2002 Indiana University.
12 | Some concepts based on versions from the MTL draft manual and Boost Graph
13 | and Property Map documentation:
14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
15 | -->
16 |   <param name="X" role="assignable-type"/>
17 | 
18 |   <models-sentence>The type <arg num="1"/> must be a model of <self/>.</models-sentence>
19 | 
20 |   <description>
21 |     <para>Assignable types must have copy constructors,
22 |     <code>operator=</code> for assignment, and the <code>swap()</code>
23 |     function defined.</para>
24 |   </description>
25 | 
26 |   <notation variables="x y">
27 |     <sample-value>
28 |       <type name="X"/>
29 |     </sample-value>
30 |   </notation>
31 | 
32 |   <refines const="no" concept="CopyConstructible"/>
33 | 
34 |   <valid-expression name="Assignment">
35 |     <assign>
36 |       <sample-value><reference-to><type name="X"/></reference-to></sample-value>
37 |       <sample-value><const><reference-to><type name="X"/></reference-to></const></sample-value>
38 |     </assign>
39 |     <return-type>
40 |       <require-same-type testable="yes">
41 | 	<reference-to><type name="X"/></reference-to>
42 |       </require-same-type>
43 |     </return-type>
44 |     <semantics>Require <code>operator=</code></semantics>
45 |   </valid-expression>
46 | 
47 |   <valid-expression name="Swap">
48 |     <apply-function name="swap">
49 |       <sample-value><reference-to><type name="X"/></reference-to></sample-value>
50 |       <sample-value><reference-to><type name="X"/></reference-to></sample-value>
51 |     </apply-function>
52 |     <return-type><require-same-type><type name="void"/></require-same-type></return-type>
53 |     <semantics>Require <code>swap()</code> function</semantics>
54 |   </valid-expression>
55 | 
56 |   <example-model>
57 |     <type name="int"/>
58 |   </example-model>
59 | </concept>
60 | 


--------------------------------------------------------------------------------
/doc/reference/BidirectionalIterator.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="BidirectionalIterator" category="Iterator"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="Iter" role="iterator-type"/>
 17 | 
 18 |   <use-header name="iterator"/>
 19 | 
 20 |   <models-sentence>The iterator type <arg num="1"/> must be a model of <self/>.</models-sentence>
 21 | 
 22 |   <description>
 23 |   <para>A bidirectional iterator is an iterator that can read through a sequence
 24 |   of values.  It can move in either direction through the sequence, and can
 25 |   be either mutable (data pointed to by it can be changed) or not mutable.</para>
 26 | 
 27 |   <para>An iterator represents a position in a sequence.  Therefore, the
 28 |   iterator can point into the sequence (returning a value when dereferenced
 29 |   and being incrementable), or be off-the-end (and not dereferenceable or
 30 |   incrementable).</para>
 31 |   </description>
 32 | 
 33 |   <associated-type name="value_type">
 34 |     <get-member-type name="value_type">
 35 |       <apply-template name="std::iterator_traits">
 36 | 	<type name="Iter"/>
 37 |       </apply-template>
 38 |     </get-member-type>
 39 |     <description><simpara>The value type of the iterator</simpara></description>
 40 |   </associated-type>
 41 | 
 42 |   <refines const="no" concept="ForwardIterator"/>
 43 | 
 44 |   <notation variables="i j">
 45 |     <sample-value>
 46 |       <type name="Iter"/>
 47 |     </sample-value>
 48 |   </notation>
 49 | 
 50 |   <associated-type name="category">
 51 |     <get-member-type name="iterator_category">
 52 |       <apply-template name="std::iterator_traits">
 53 | 	<type name="Iter"/>
 54 |       </apply-template>
 55 |     </get-member-type>
 56 |     <description><simpara>The category of the iterator</simpara></description>
 57 |   </associated-type>
 58 | 
 59 |   <notation variables="x">
 60 |     <sample-value>
 61 |       <type name="value_type"/>
 62 |     </sample-value>
 63 |   </notation>
 64 | 
 65 |   <valid-type-expression name="Category tag">
 66 |     <description/>
 67 |     <type name="category"/>
 68 |     <return-type>
 69 |       <derived-from testable="yes">
 70 | 	<type name="std::bidirectional_iterator_tag"/>
 71 |       </derived-from>
 72 |     </return-type>
 73 |   </valid-type-expression>
 74 | 
 75 |   <valid-expression name="Predecrement">
 76 |     <predecrement>
 77 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
 78 |     </predecrement>
 79 |     <return-type>
 80 |       <require-same-type testable="yes">
 81 | 	<reference-to><type name="Iter"/></reference-to>
 82 |       </require-same-type>
 83 |     </return-type>
 84 |     <precondition><code>i</code> is incrementable (not
 85 |     off-the-end) and some dereferenceable iterator <code>j</code> exists
 86 |     such that <code>i == ++j</code></precondition>
 87 |   </valid-expression>
 88 | 
 89 |   <valid-expression name="Postdecrement">
 90 |     <postdecrement>
 91 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
 92 |     </postdecrement>
 93 |     <return-type>
 94 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
 95 |     </return-type>
 96 |     <precondition>Same as for predecrement</precondition>
 97 |     <semantics>Equivalent to <code>{Iter j = i; --i; return j;}</code></semantics>
 98 |     <postcondition><code>i</code> is dereferenceable or
 99 |     off-the-end</postcondition>
100 |   </valid-expression>
101 | 
102 |   <complexity>
103 |   All iterator operations must take amortized constant time.
104 |   </complexity>
105 | 
106 |   <invariant name="Predecrement must return object">
107 |   <code>&amp;i = &amp;(--i)</code>
108 |   </invariant>
109 | 
110 |   <invariant name="Unique path through sequence">
111 |   <code>i == j</code> implies <code>--i == --j</code>
112 |   </invariant>
113 | 
114 |   <invariant name="Increment and decrement are inverses">
115 |   <code>++i; --i;</code> and <code>--i; ++i;</code> must end up with the
116 |   value of <code>i</code> unmodified, if <code>i</code> both of the
117 |   operations in the pair are valid.
118 |   </invariant>
119 | 
120 |   <example-model>
121 |     <pointer-to>
122 |       <type name="T"/>
123 |     </pointer-to>
124 |   </example-model>
125 | 
126 |   <example-model>
127 |     <get-member-type name="iterator">
128 |       <apply-template name="std::list">
129 | 	<type name="T"/>
130 |       </apply-template>
131 |     </get-member-type>
132 |   </example-model>
133 | 
134 |   <see-also concept="RandomAccessIterator"/>
135 | 
136 | </concept>
137 | 


--------------------------------------------------------------------------------
/doc/reference/CopyConstructible.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <concept name="CopyConstructible" category="Utility"><!--
 3 | Based on concepts from the SGI Standard Template Library documentation:
 4 | Copyright (c) 1996-1999
 5 | Silicon Graphics Computer Systems, Inc.
 6 | 
 7 | Copyright (c) 1994
 8 | Hewlett-Packard Company
 9 | --><!--
10 | Copyright 2000-2001 University of Notre Dame du Lac.
11 | Copyright 2001-2002 Indiana University.
12 | Some concepts based on versions from the MTL draft manual and Boost Graph
13 | and Property Map documentation:
14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
15 | -->
16 |   <param name="X" role="copy-constructible-type"/>
17 | 
18 |   <models-sentence>The type <arg num="1"/> must be a model of <self/>.</models-sentence>
19 | 
20 |   <description>
21 |   <para>Copy constructible types must be able to be constructed from another
22 |   member of the type.</para>
23 |   </description>
24 | 
25 |   <notation variables="x y">
26 |     <sample-value>
27 |       <type name="X"/>
28 |     </sample-value>
29 |   </notation>
30 | 
31 |   <valid-expression name="Copy construction">
32 |     <construct template-parameters="">
33 |       <type name="X"/>
34 |       <sample-value><const><reference-to><type name="X"/></reference-to></const></sample-value>
35 |     </construct>
36 |     <return-type>
37 |       <require-same-type testable="yes">
38 | 	<type name="X"/>
39 |       </require-same-type>
40 |     </return-type>
41 |     <semantics>Require copy constructor.</semantics>
42 |   </valid-expression>
43 | 
44 |   <example-model>
45 |     <type name="int"/>
46 |   </example-model>
47 | </concept>
48 | 


--------------------------------------------------------------------------------
/doc/reference/DefaultConstructible.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <concept name="DefaultConstructible" category="Utility"><!--
 3 | Based on concepts from the SGI Standard Template Library documentation:
 4 | Copyright (c) 1996-1999
 5 | Silicon Graphics Computer Systems, Inc.
 6 | 
 7 | Copyright (c) 1994
 8 | Hewlett-Packard Company
 9 | --><!--
10 | Copyright 2000-2001 University of Notre Dame du Lac.
11 | Copyright 2001-2002 Indiana University.
12 | Some concepts based on versions from the MTL draft manual and Boost Graph
13 | and Property Map documentation:
14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
15 | -->
16 |   <param name="X" role="default-constructible-type"/>
17 | 
18 |   <models-sentence>The type <arg num="1"/> must be a model of <self/>.</models-sentence>
19 | 
20 |   <description><para>DefaultConstructible objects only need to have a default
21 |   constructor.</para></description>
22 | 
23 |   <valid-expression name="Construction">
24 |     <construct template-parameters="">
25 |       <type name="X"/>
26 |     </construct>
27 |     <return-type><require-same-type testable="yes"><type name="X"/></require-same-type></return-type>
28 |     <semantics>Construct an instance of the type with default parameters.</semantics>
29 |   </valid-expression>
30 | 
31 |   <example-model>
32 |     <type name="int"/>
33 |   </example-model>
34 | 
35 |   <example-model>
36 |     <apply-template name="std::vector">
37 |       <type name="double"/>
38 |     </apply-template>
39 |   </example-model>
40 | </concept>
41 | 


--------------------------------------------------------------------------------
/doc/reference/EqualityComparable.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <concept name="EqualityComparable" category="Utility"><!--
 3 | Based on concepts from the SGI Standard Template Library documentation:
 4 | Copyright (c) 1996-1999
 5 | Silicon Graphics Computer Systems, Inc.
 6 | 
 7 | Copyright (c) 1994
 8 | Hewlett-Packard Company
 9 | --><!--
10 | Copyright 2000-2001 University of Notre Dame du Lac.
11 | Copyright 2001-2002 Indiana University.
12 | Some concepts based on versions from the MTL draft manual and Boost Graph
13 | and Property Map documentation:
14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
15 | -->
16 |   <param name="X" role="comparable-type"/>
17 | 
18 |   <models-sentence>The type <arg num="1"/> must be a model of
19 |   <self/>.</models-sentence>
20 | 
21 |   <description><para>Equality Comparable types must have <code>==</code> and
22 |   <code>!=</code> operators.</para></description>
23 | 
24 |   <notation variables="x y">
25 |     <sample-value>
26 |       <type name="X"/>
27 |     </sample-value>
28 |   </notation>
29 | 
30 |   <valid-expression name="Equality test">
31 |     <equal-to>
32 |       <sample-value><type name="X"/></sample-value>
33 |       <sample-value><type name="X"/></sample-value>
34 |     </equal-to>
35 |     <return-type>
36 |       <convertible-to testable="yes">
37 | 	<type name="bool"/>
38 |       </convertible-to>
39 |     </return-type>
40 |   </valid-expression>
41 | 
42 |   <valid-expression name="Inequality test">
43 |     <not-equal-to>
44 |       <sample-value><type name="X"/></sample-value>
45 |       <sample-value><type name="X"/></sample-value>
46 |     </not-equal-to>
47 |     <return-type>
48 |       <convertible-to testable="yes">
49 | 	<type name="bool"/>
50 |       </convertible-to>
51 |     </return-type>
52 |   </valid-expression>
53 | 
54 |   <example-model>
55 |     <type name="int"/>
56 |   </example-model>
57 | 
58 |   <example-model>
59 |     <apply-template name="std::vector">
60 |       <type name="int"/>
61 |     </apply-template>
62 |   </example-model>
63 | </concept>
64 | 


--------------------------------------------------------------------------------
/doc/reference/ForwardIterator.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="ForwardIterator" category="Iterator"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="Iter" role="iterator-type"/>
 17 | 
 18 |   <use-header name="iterator"/>
 19 | 
 20 |   <models-sentence>The iterator type <arg num="1"/> must be a model of <self/>.</models-sentence>
 21 | 
 22 |   <description>
 23 |   <para>A forward iterator is an iterator that can read through a sequence of
 24 |   values.  It is multi-pass (old values of the iterator can be
 25 |   re-used), and can be either mutable (data pointed to by it can be
 26 |   changed) or not mutable.</para>
 27 | 
 28 |   <para>An iterator represents a position in a sequence.  Therefore, the
 29 |   iterator can point into the sequence (returning a value when dereferenced
 30 |   and being incrementable), or be off-the-end (and not dereferenceable or
 31 |   incrementable).</para>
 32 |   </description>
 33 | 
 34 |   <associated-type name="value_type">
 35 |     <get-member-type name="value_type">
 36 |       <apply-template name="std::iterator_traits">
 37 | 	<type name="Iter"/>
 38 |       </apply-template>
 39 |     </get-member-type>
 40 |     <description><simpara>The value type of the iterator</simpara></description>
 41 |   </associated-type>
 42 | 
 43 |   <refines const="no" concept="InputIterator"/>
 44 |   <refines const="no" concept="OutputIterator"/>
 45 | 
 46 | <!-- DPG doesn't understand this
 47 |   <models const="no" testable="yes" concept="Input Iterator">
 48 |     <type name="Iter"/>
 49 |   </models>
 50 | -->
 51 | <!--
 52 |   <models-when-mutable concept="Output Iterator">
 53 |     <type name="Iter"/>
 54 |     <type name="value_type"/>
 55 |   </models-when-mutable>
 56 | -->
 57 | 
 58 |   <notation variables="i j">
 59 |     <sample-value>
 60 |       <type name="Iter"/>
 61 |     </sample-value>
 62 |   </notation>
 63 | 
 64 |   <associated-type name="category">
 65 |     <get-member-type name="iterator_category">
 66 |       <apply-template name="std::iterator_traits">
 67 | 	<type name="Iter"/>
 68 |       </apply-template>
 69 |     </get-member-type>
 70 |     <description><simpara>The category of the iterator</simpara></description>
 71 |   </associated-type>
 72 | 
 73 |   <notation variables="x">
 74 |     <sample-value>
 75 |       <type name="value_type"/>
 76 |     </sample-value>
 77 |   </notation>
 78 | 
 79 |   <valid-type-expression name="Category tag">
 80 |     <description/>
 81 |     <type name="category"/>
 82 |     <return-type>
 83 |       <derived-from testable="yes">
 84 | 	<type name="std::forward_iterator_tag"/>
 85 |       </derived-from>
 86 |     </return-type>
 87 |   </valid-type-expression>
 88 | 
 89 |   <valid-expression name="Dereference">
 90 |     <dereference>
 91 |       <sample-value><type name="Iter"/></sample-value>
 92 |     </dereference>
 93 |     <return-type>
 94 |       <require-same-type testable="yes">
 95 | 	<const-if-not-mutable>
 96 | 	  <reference-to><type name="value_type"/></reference-to>
 97 | 	</const-if-not-mutable>
 98 |       </require-same-type>
 99 |     </return-type>
100 |     <precondition><code>i</code> is incrementable (not
101 |     off-the-end)</precondition>
102 |   </valid-expression>
103 | 
104 |   <valid-expression name="Member access">
105 |     <pointer-member>
106 |       <sample-value><type name="Iter"/></sample-value>
107 |     </pointer-member>
108 |     <return-type>
109 |       <require-same-type testable="yes">
110 | 	<const-if-not-mutable>
111 | 	  <pointer-to><type name="value_type"/></pointer-to>
112 | 	</const-if-not-mutable>
113 |       </require-same-type>
114 |     </return-type>
115 |     <precondition><code>i</code> is incrementable (not
116 |     off-the-end)</precondition>
117 |   </valid-expression>
118 | 
119 |   <valid-expression name="Preincrement">
120 |     <preincrement>
121 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
122 |     </preincrement>
123 |     <return-type>
124 |       <require-same-type testable="yes">
125 | 	<reference-to><type name="Iter"/></reference-to>
126 |       </require-same-type>
127 |     </return-type>
128 |     <precondition><code>i</code> is incrementable (not
129 |     off-the-end)</precondition>
130 |   </valid-expression>
131 | 
132 |   <valid-expression name="Postincrement">
133 |     <postincrement>
134 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
135 |     </postincrement>
136 |     <return-type>
137 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
138 |     </return-type>
139 |     <precondition><code>i</code> is incrementable (not
140 |     off-the-end)</precondition>
141 |     <semantics>Equivalent to <code>{Iter j = i; ++i; return j;}</code></semantics>
142 |     <postcondition><code>i</code> is dereferenceable or
143 |     off-the-end</postcondition>
144 |   </valid-expression>
145 | 
146 |   <complexity>
147 |   All iterator operations must take amortized constant time.
148 |   </complexity>
149 | 
150 |   <invariant name="Predecrement must return object">
151 |   <code>&amp;i = &amp;(++i)</code>
152 |   </invariant>
153 | 
154 |   <invariant name="Unique path through sequence">
155 |   <code>i == j</code> implies <code>++i == ++j</code>
156 |   </invariant>
157 | 
158 |   <example-model>
159 |     <pointer-to>
160 |       <type name="T"/>
161 |     </pointer-to>
162 |   </example-model>
163 | 
164 |   <example-model>
165 |     <get-member-type name="iterator">
166 |       <apply-template name="std::hash_set">
167 | 	<type name="T"/>
168 |       </apply-template>
169 |     </get-member-type>
170 |   </example-model>
171 | 
172 |   <see-also concept="BidirectionalIterator"/>
173 | 
174 | </concept>
175 | 


--------------------------------------------------------------------------------
/doc/reference/InputIterator.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="InputIterator" category="Iterator"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="Iter" role="iterator-type"/>
 17 | 
 18 |   <use-header name="iterator"/>
 19 | 
 20 |   <models-sentence>The iterator type <arg num="1"/> must be a model of <self/>.</models-sentence>
 21 | 
 22 |   <description>
 23 |   <para>An input iterator is an iterator that can read through a sequence of
 24 |   values.  It is single-pass (old values of the iterator cannot be
 25 |   re-used), and read-only.</para>
 26 | 
 27 |   <para>An input iterator represents a position in a sequence.  Therefore, the
 28 |   iterator can point into the sequence (returning a value when dereferenced
 29 |   and being incrementable), or be off-the-end (and not dereferenceable or
 30 |   incrementable).</para>
 31 |   </description>
 32 | 
 33 |   <refines const="no" concept="Assignable"/>
 34 |   <refines const="no" concept="DefaultConstructible"/>
 35 |   <refines const="no" concept="EqualityComparable"/>
 36 | 
 37 |   <notation variables="i j">
 38 |     <sample-value>
 39 |       <type name="Iter"/>
 40 |     </sample-value>
 41 |   </notation>
 42 | 
 43 |   <associated-type name="value_type">
 44 |     <get-member-type name="value_type">
 45 |       <apply-template name="std::iterator_traits">
 46 | 	<type name="Iter"/>
 47 |       </apply-template>
 48 |     </get-member-type>
 49 |     <description><simpara>The value type of the iterator (not necessarily what
 50 |     <code>*i</code> returns)</simpara></description>
 51 |   </associated-type>
 52 | 
 53 |   <associated-type name="difference_type">
 54 |     <get-member-type name="difference_type">
 55 |       <apply-template name="std::iterator_traits">
 56 | 	<type name="Iter"/>
 57 |       </apply-template>
 58 |     </get-member-type>
 59 |     <description><simpara>The difference type of the iterator</simpara></description>
 60 |   </associated-type>
 61 | 
 62 |   <associated-type name="category">
 63 |     <get-member-type name="iterator_category">
 64 |       <apply-template name="std::iterator_traits">
 65 | 	<type name="Iter"/>
 66 |       </apply-template>
 67 |     </get-member-type>
 68 |     <description><simpara>The category of the iterator</simpara></description>
 69 |   </associated-type>
 70 | 
 71 |   <notation variables="x">
 72 |     <sample-value>
 73 |       <type name="value_type"/>
 74 |     </sample-value>
 75 |   </notation>
 76 | 
 77 |   <valid-type-expression name="Category tag">
 78 |     <description/>
 79 |     <type name="category"/>
 80 |     <return-type>
 81 |       <derived-from testable="yes">
 82 | 	<type name="std::input_iterator_tag"/>
 83 |       </derived-from>
 84 |       <models-as-first-arg const="no" testable="yes" concept="DefaultConstructible"/>
 85 |       <models-as-first-arg const="no" testable="yes" concept="CopyConstructible"/>
 86 |     </return-type>
 87 |   </valid-type-expression>
 88 | 
 89 |   <valid-type-expression name="Value type copy constructibility">
 90 |     <description/>
 91 |     <type name="value_type"/>
 92 |     <return-type>
 93 |       <models-as-first-arg const="no" testable="yes" concept="CopyConstructible"/>
 94 |     </return-type>
 95 |   </valid-type-expression>
 96 | 
 97 |   <valid-type-expression name="Difference type properties">
 98 |     <description/>
 99 |     <type name="difference_type"/>
100 |     <return-type>
101 |       <models-as-first-arg const="no" testable="yes" concept="SignedInteger"/>
102 |     </return-type>
103 |   </valid-type-expression>
104 | 
105 |   <valid-expression name="Dereference">
106 |     <dereference>
107 |       <sample-value><type name="Iter"/></sample-value>
108 |     </dereference>
109 |     <return-type>
110 |       <convertible-to testable="yes"><type name="value_type"/></convertible-to>
111 |     </return-type>
112 |     <precondition><code>i</code> is incrementable (not
113 |     off-the-end)</precondition>
114 |   </valid-expression>
115 | 
116 |   <valid-expression name="Preincrement">
117 |     <preincrement>
118 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
119 |     </preincrement>
120 |     <return-type>
121 |       <require-same-type testable="yes">
122 | 	<reference-to><type name="Iter"/></reference-to>
123 |       </require-same-type>
124 |     </return-type>
125 |     <precondition><code>i</code> is incrementable (not
126 |     off-the-end)</precondition>
127 |   </valid-expression>
128 | 
129 |   <valid-expression name="Postincrement">
130 |     <postincrement>
131 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
132 |     </postincrement>
133 |     <return-type/>
134 |     <precondition><code>i</code> is incrementable (not
135 |     off-the-end)</precondition>
136 |     <semantics>Equivalent to <code>(void)(++i)</code></semantics>
137 |     <postcondition><code>i</code> is dereferenceable or
138 |     off-the-end</postcondition>
139 |   </valid-expression>
140 | 
141 |   <valid-expression name="Postincrement and dereference">
142 |     <dereference>
143 |       <postincrement>
144 | 	<sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
145 |       </postincrement>
146 |     </dereference>
147 |     <return-type>
148 |       <convertible-to testable="yes"><type name="value_type"/></convertible-to>
149 |     </return-type>
150 |     <precondition><code>i</code> is incrementable (not
151 |     off-the-end)</precondition>
152 |     <semantics>Equivalent to <code>{value_type t = *i; ++i; return t;}</code></semantics>
153 |     <postcondition><code>i</code> is dereferenceable or
154 |     off-the-end</postcondition>
155 |   </valid-expression>
156 | 
157 |   <complexity>
158 |   All iterator operations must take amortized constant time.
159 |   </complexity>
160 | 
161 |   <example-model>
162 |     <type name="std::istream_iterator"/>
163 |   </example-model>
164 | 
165 |   <see-also concept="OutputIterator"/>
166 |   <see-also concept="ForwardIterator"/>
167 | 
168 | </concept>
169 | 


--------------------------------------------------------------------------------
/doc/reference/LessThanComparable.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <concept name="LessThanComparable" category="Utility"><!--
 3 | Based on concepts from the SGI Standard Template Library documentation:
 4 | Copyright (c) 1996-1999
 5 | Silicon Graphics Computer Systems, Inc.
 6 | 
 7 | Copyright (c) 1994
 8 | Hewlett-Packard Company
 9 | --><!--
10 | Copyright 2000-2001 University of Notre Dame du Lac.
11 | Copyright 2001-2002 Indiana University.
12 | Some concepts based on versions from the MTL draft manual and Boost Graph
13 | and Property Map documentation:
14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
15 | -->
16 |   <param name="X" role="comparable-type"/>
17 | 
18 |   <models-sentence>The type <arg num="1"/> must be a model of <self/>.</models-sentence>
19 | 
20 |   <description><para>LessThanComparable types must have <code>&lt;</code>,
21 |   <code>&gt;</code>, <code>&lt;=</code>, and <code>&gt;=</code>
22 |   operators.</para></description>
23 | 
24 |   <notation variables="x y"><sample-value><type name="X"/></sample-value></notation>
25 | 
26 |   <valid-expression name="Less than">
27 |     <less-than>
28 |       <sample-value><type name="X"/></sample-value>
29 |       <sample-value><type name="X"/></sample-value>
30 |     </less-than>
31 |     <return-type>
32 |       <convertible-to testable="yes">
33 | 	<type name="bool"/>
34 |       </convertible-to>
35 |     </return-type>
36 |     <semantics>Determine if one value is less than another.</semantics>
37 |   </valid-expression>
38 | 
39 |   <valid-expression name="Less than or equal">
40 |     <less-than-or-equal>
41 |       <sample-value><type name="X"/></sample-value>
42 |       <sample-value><type name="X"/></sample-value>
43 |     </less-than-or-equal>
44 |     <return-type>
45 |       <convertible-to testable="yes">
46 | 	<type name="bool"/>
47 |       </convertible-to>
48 |     </return-type>
49 |     <semantics>Determine if one value is less than or equal to another.</semantics>
50 |   </valid-expression>
51 | 
52 |   <valid-expression name="Greater than">
53 |     <greater-than>
54 |       <sample-value><type name="X"/></sample-value>
55 |       <sample-value><type name="X"/></sample-value>
56 |     </greater-than>
57 |     <return-type>
58 |       <convertible-to testable="yes">
59 | 	<type name="bool"/>
60 |       </convertible-to>
61 |     </return-type>
62 |     <semantics>Determine if one value is greater than another.</semantics>
63 |   </valid-expression>
64 | 
65 |   <valid-expression name="Greater than or equal to">
66 |     <greater-than-or-equal>
67 |       <sample-value><type name="X"/></sample-value>
68 |       <sample-value><type name="X"/></sample-value>
69 |     </greater-than-or-equal>
70 |     <return-type>
71 |       <convertible-to testable="yes">
72 | 	<type name="bool"/>
73 |       </convertible-to>
74 |     </return-type>
75 |     <semantics>Determine if one value is greater than or equal to another.</semantics>
76 |   </valid-expression>
77 | 
78 |   <example-model>
79 |     <type name="int"/>
80 |   </example-model>
81 | </concept>
82 | 


--------------------------------------------------------------------------------
/doc/reference/OutputIterator.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="OutputIterator" category="Iterator"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="Iter" role="iterator-type"/>
 17 |   <param name="ValueType" role="value-type"/>
 18 | 
 19 |   <use-header name="iterator"/>
 20 | 
 21 |   <models-sentence>The iterator type <arg num="1"/> (with value type <arg num="2"/>) must be a model of <self/>.</models-sentence>
 22 | 
 23 |   <description>
 24 |   <para>An output iterator is an iterator that can write a sequence of
 25 |   values.  It is single-pass (old values of the iterator cannot be
 26 |   re-used), and write-only.</para>
 27 | 
 28 |   <para>An output iterator represents a position in a (possibly infinite)
 29 |   sequence.  Therefore, the iterator can point into the sequence (returning
 30 |   a value when dereferenced and being incrementable), or be off-the-end
 31 |   (and not dereferenceable or incrementable).</para>
 32 |   </description>
 33 | 
 34 |   <models const="no" testable="yes" concept="Assignable">
 35 |     <type name="Iter"/>
 36 |   </models>
 37 | 
 38 |   <models const="no" testable="yes" concept="Assignable">
 39 |     <type name="ValueType"/>
 40 |   </models>
 41 | 
 42 |   <models const="no" testable="yes" concept="DefaultConstructible">
 43 |     <type name="Iter"/>
 44 |   </models>
 45 | 
 46 |   <models const="no" testable="yes" concept="EqualityComparable">
 47 |     <type name="Iter"/>
 48 |   </models>
 49 | 
 50 |   <associated-type name="value_type">
 51 |     <get-member-type name="value_type">
 52 |       <apply-template name="std::iterator_traits">
 53 | 	<type name="Iter"/>
 54 |       </apply-template>
 55 |     </get-member-type>
 56 |     <description><simpara>The stated value type of the iterator (should be
 57 |     <code>void</code> for an output iterator that does not model some other
 58 |     iterator concept).</simpara></description>
 59 |   </associated-type>
 60 | 
 61 |   <associated-type name="difference_type">
 62 |     <get-member-type name="difference_type">
 63 |       <apply-template name="std::iterator_traits">
 64 | 	<type name="Iter"/>
 65 |       </apply-template>
 66 |     </get-member-type>
 67 |     <description><simpara>The difference type of the iterator</simpara></description>
 68 |   </associated-type>
 69 | 
 70 |   <associated-type name="category">
 71 |     <get-member-type name="iterator_category">
 72 |       <apply-template name="std::iterator_traits">
 73 | 	<type name="Iter"/>
 74 |       </apply-template>
 75 |     </get-member-type>
 76 |     <description><simpara>The category of the iterator</simpara></description>
 77 |   </associated-type>
 78 | 
 79 |   <notation variables="i j">
 80 |     <sample-value>
 81 |       <type name="Iter"/>
 82 |     </sample-value>
 83 |   </notation>
 84 | 
 85 |   <notation variables="x">
 86 |     <sample-value>
 87 |       <type name="ValueType"/>
 88 |     </sample-value>
 89 |   </notation>
 90 | 
 91 |   <valid-type-expression name="Category tag">
 92 |     <description/>
 93 |     <type name="category"/>
 94 |     <return-type>
 95 |       <derived-from testable="yes">
 96 | 	<type name="std::output_iterator_tag"/>
 97 |       </derived-from>
 98 |       <models-as-first-arg const="no" testable="yes" concept="DefaultConstructible"/>
 99 |       <models-as-first-arg const="no" testable="yes" concept="CopyConstructible"/>
100 |     </return-type>
101 |   </valid-type-expression>
102 | 
103 |   <valid-type-expression name="Difference type properties">
104 |     <description/>
105 |     <type name="difference_type"/>
106 |     <return-type>
107 |       <models-as-first-arg const="no" testable="yes" concept="SignedInteger"/>
108 |     </return-type>
109 |   </valid-type-expression>
110 | 
111 |   <valid-expression name="Dereference">
112 |     <dereference>
113 |       <sample-value><type name="Iter"/></sample-value>
114 |     </dereference>
115 |     <return-type/>
116 |     <precondition><code>i</code> is incrementable (not
117 |     off-the-end)</precondition>
118 |   </valid-expression>
119 | 
120 |   <valid-expression name="Dereference and assign">
121 |     <assign>
122 |       <dereference>
123 | 	<sample-value><type name="Iter"/></sample-value>
124 |       </dereference>
125 |       <sample-value><const><reference-to><type name="ValueType"/></reference-to></const></sample-value>
126 |     </assign>
127 |     <return-type/>
128 |     <precondition><code>i</code> is incrementable (not
129 |     off-the-end)</precondition>
130 |     <postcondition><code>*i</code> may not be written to again until it has
131 |     been incremented.</postcondition>
132 |   </valid-expression>
133 | 
134 |   <valid-expression name="Preincrement">
135 |     <preincrement>
136 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
137 |     </preincrement>
138 |     <return-type>
139 |       <require-same-type testable="yes">
140 | 	<reference-to><type name="Iter"/></reference-to>
141 |       </require-same-type>
142 |     </return-type>
143 |     <precondition><code>i</code> is incrementable (not
144 |     off-the-end)</precondition>
145 |   </valid-expression>
146 | 
147 |   <valid-expression name="Postincrement">
148 |     <postincrement>
149 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
150 |     </postincrement>
151 |     <return-type/>
152 |     <precondition><code>i</code> is incrementable (not
153 |     off-the-end)</precondition>
154 |     <semantics>Equivalent to <code>(void)(++i)</code></semantics>
155 |     <postcondition><code>i</code> is dereferenceable or
156 |     off-the-end</postcondition>
157 |   </valid-expression>
158 | 
159 |   <valid-expression name="Postincrement, dereference, and assign">
160 |     <assign>
161 |       <dereference>
162 | 	<postincrement>
163 | 	  <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
164 | 	</postincrement>
165 |       </dereference>
166 |       <sample-value><const><reference-to><type name="ValueType"/></reference-to></const></sample-value>
167 |     </assign>
168 |     <return-type/>
169 |     <precondition><code>i</code> is incrementable (not
170 |     off-the-end)</precondition>
171 |     <semantics>Equivalent to <code>{*i = t; ++i;}</code></semantics>
172 |     <postcondition><code>i</code> is dereferenceable or
173 |     off-the-end</postcondition>
174 |   </valid-expression>
175 | 
176 |   <complexity>
177 |   All iterator operations must take amortized constant time.
178 |   </complexity>
179 | 
180 |   <example-model>
181 |     <type name="std::ostream_iterator"/>
182 |     <type name="..."/>
183 |   </example-model>
184 | 
185 |   <example-model>
186 |     <type name="std::insert_iterator"/>
187 |     <type name="..."/>
188 |   </example-model>
189 | 
190 |   <example-model>
191 |     <type name="std::front_insert_iterator"/>
192 |     <type name="..."/>
193 |   </example-model>
194 | 
195 |   <example-model>
196 |     <type name="std::back_insert_iterator"/>
197 |     <type name="..."/>
198 |   </example-model>
199 | 
200 |   <see-also concept="InputIterator"/>
201 |   <see-also concept="ForwardIterator"/>
202 | 
203 | </concept>
204 | 


--------------------------------------------------------------------------------
/doc/reference/RandomAccessIterator.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="RandomAccessIterator" category="Iterator"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="Iter" role="iterator-type"/>
 17 | 
 18 |   <use-header name="iterator"/>
 19 | 
 20 |   <models-sentence>The iterator type <arg num="1"/> must be a model of <self/>.</models-sentence>
 21 | 
 22 |   <description>
 23 |   <para>A random access iterator is an iterator that can read through
 24 |   a sequence of values.  It can move in either direction through the
 25 |   sequence (by any amount in constant time), and can be either mutable
 26 |   (data pointed to by it can be changed) or not mutable.</para>
 27 | 
 28 |   <para>An iterator represents a position in a sequence.  Therefore,
 29 |   the iterator can point into the sequence (returning a value when
 30 |   dereferenced and being incrementable), or be off-the-end (and not
 31 |   dereferenceable or incrementable).</para>
 32 |   </description>
 33 | 
 34 |   <associated-type name="value_type">
 35 |     <get-member-type name="value_type">
 36 |       <apply-template name="std::iterator_traits">
 37 | 	<type name="Iter"/>
 38 |       </apply-template>
 39 |     </get-member-type>
 40 |     <description><simpara>The value type of the iterator</simpara></description>
 41 |   </associated-type>
 42 | 
 43 |   <refines const="no" concept="BidirectionalIterator"/>
 44 |   <refines const="no" concept="LessThanComparable"/>
 45 | 
 46 |   <notation variables="i j">
 47 |     <sample-value>
 48 |       <type name="Iter"/>
 49 |     </sample-value>
 50 |   </notation>
 51 | 
 52 |   <associated-type name="category">
 53 |     <get-member-type name="iterator_category">
 54 |       <apply-template name="std::iterator_traits">
 55 | 	<type name="Iter"/>
 56 |       </apply-template>
 57 |     </get-member-type>
 58 |     <description><simpara>The category of the iterator</simpara></description>
 59 |   </associated-type>
 60 | 
 61 |   <associated-type name="difference_type">
 62 |     <get-member-type name="difference_type">
 63 |       <apply-template name="std::iterator_traits">
 64 | 	<type name="Iter"/>
 65 |       </apply-template>
 66 |     </get-member-type>
 67 |     <description><simpara>The difference type of the iterator (measure of the number
 68 |     of steps between two iterators)</simpara></description>
 69 |   </associated-type>
 70 | 
 71 |   <notation variables="x">
 72 |     <sample-value>
 73 |       <type name="value_type"/>
 74 |     </sample-value>
 75 |   </notation>
 76 | 
 77 |   <notation variables="n">
 78 |     <sample-value>
 79 |       <type name="difference_type"/>
 80 |     </sample-value>
 81 |   </notation>
 82 | 
 83 |   <notation variables="int_off">
 84 |     <sample-value>
 85 |       <type name="int"/>
 86 |     </sample-value>
 87 |   </notation>
 88 | 
 89 |   <valid-type-expression name="Category tag">
 90 |     <description/>
 91 |     <type name="category"/>
 92 |     <return-type>
 93 |       <derived-from testable="yes">
 94 | 	<type name="std::random_access_iterator_tag"/>
 95 |       </derived-from>
 96 |     </return-type>
 97 |   </valid-type-expression>
 98 | 
 99 |   <valid-expression name="Motion">
100 |     <add-assign>
101 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
102 |       <sample-value><type name="difference_type"/></sample-value>
103 |     </add-assign>
104 |     <return-type>
105 |       <require-same-type testable="yes">
106 | 	<reference-to><type name="Iter"/></reference-to>
107 |       </require-same-type>
108 |     </return-type>
109 |     <semantics>Equivalent to applying <code>i++</code> <code>n</code> times
110 |     if <code>n</code> is positive, applying <code>i--</code>
111 |     <code>-n</code> times if <code>n</code> is negative, and to a null
112 |     operation if <code>n</code> is zero.</semantics>
113 |   </valid-expression>
114 | 
115 |   <valid-expression name="Motion (with integer offset)">
116 |     <add-assign>
117 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
118 |       <sample-value><type name="int"/></sample-value>
119 |     </add-assign>
120 |     <return-type>
121 |       <require-same-type testable="yes">
122 | 	<reference-to><type name="Iter"/></reference-to>
123 |       </require-same-type>
124 |     </return-type>
125 |     <semantics>Equivalent to applying <code>i++</code> <code>n</code> times
126 |     if <code>n</code> is positive, applying <code>i--</code>
127 |     <code>-n</code> times if <code>n</code> is negative, and to a null
128 |     operation if <code>n</code> is zero.</semantics>
129 |   </valid-expression>
130 | 
131 |   <valid-expression name="Subtractive motion">
132 |     <subtract-assign>
133 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
134 |       <sample-value><type name="difference_type"/></sample-value>
135 |     </subtract-assign>
136 |     <return-type>
137 |       <require-same-type testable="yes">
138 | 	<reference-to><type name="Iter"/></reference-to>
139 |       </require-same-type>
140 |     </return-type>
141 |     <semantics>Equivalent to <code>i+=(-n)</code></semantics>
142 |   </valid-expression>
143 | 
144 |   <valid-expression name="Subtractive motion (with integer offset)">
145 |     <subtract-assign>
146 |       <sample-value><reference-to><type name="Iter"/></reference-to></sample-value>
147 |       <sample-value><type name="int"/></sample-value>
148 |     </subtract-assign>
149 |     <return-type>
150 |       <require-same-type testable="yes">
151 | 	<reference-to><type name="Iter"/></reference-to>
152 |       </require-same-type>
153 |     </return-type>
154 |     <semantics>Equivalent to <code>i+=(-n)</code></semantics>
155 |   </valid-expression>
156 | 
157 |   <valid-expression name="Addition">
158 |     <add>
159 |       <sample-value><type name="Iter"/></sample-value>
160 |       <sample-value><type name="difference_type"/></sample-value>
161 |     </add>
162 |     <return-type>
163 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
164 |     </return-type>
165 |     <semantics>Equivalent to <code>{Iter j = i; j += n; return j;}</code></semantics>
166 |   </valid-expression>
167 | 
168 |   <valid-expression name="Addition with integer">
169 |     <add>
170 |       <sample-value><type name="Iter"/></sample-value>
171 |       <sample-value><type name="int"/></sample-value>
172 |     </add>
173 |     <return-type>
174 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
175 |     </return-type>
176 |     <semantics>Equivalent to <code>{Iter j = i; j += n; return j;}</code></semantics>
177 |   </valid-expression>
178 | 
179 |   <valid-expression name="Addition (count first)">
180 |     <add>
181 |       <sample-value><type name="difference_type"/></sample-value>
182 |       <sample-value><type name="Iter"/></sample-value>
183 |     </add>
184 |     <return-type>
185 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
186 |     </return-type>
187 |     <semantics>Equivalent to <code>i + n</code></semantics>
188 |   </valid-expression>
189 | 
190 |   <valid-expression name="Addition with integer (count first)">
191 |     <add>
192 |       <sample-value><type name="int"/></sample-value>
193 |       <sample-value><type name="Iter"/></sample-value>
194 |     </add>
195 |     <return-type>
196 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
197 |     </return-type>
198 |     <semantics>Equivalent to <code>i + n</code></semantics>
199 |   </valid-expression>
200 | 
201 |   <valid-expression name="Subtraction">
202 |     <subtract>
203 |       <sample-value><type name="Iter"/></sample-value>
204 |       <sample-value><type name="difference_type"/></sample-value>
205 |     </subtract>
206 |     <return-type>
207 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
208 |     </return-type>
209 |     <semantics>Equivalent to <code>i + (-n)</code></semantics>
210 |   </valid-expression>
211 | 
212 |   <valid-expression name="Subtraction with integer">
213 |     <subtract>
214 |       <sample-value><type name="Iter"/></sample-value>
215 |       <sample-value><type name="int"/></sample-value>
216 |     </subtract>
217 |     <return-type>
218 |       <require-same-type testable="yes"><type name="Iter"/></require-same-type>
219 |     </return-type>
220 |     <semantics>Equivalent to <code>i + (-n)</code></semantics>
221 |   </valid-expression>
222 | 
223 |   <valid-expression name="Distance">
224 |     <subtract>
225 |       <sample-value><type name="Iter"/></sample-value>
226 |       <sample-value><type name="Iter"/></sample-value>
227 |     </subtract>
228 |     <return-type>
229 |       <require-same-type testable="yes"><type name="difference_type"/></require-same-type>
230 |     </return-type>
231 |     <semantics>The number of times <code>i</code> must be incremented (or
232 |     decremented if the result is negative) to reach <code>j</code>.  Not
233 |     defined if <code>j</code> is not reachable from
234 |     <code>i</code>.</semantics>
235 |   </valid-expression>
236 | 
237 |   <valid-expression name="Element access">
238 |     <subscript>
239 |       <sample-value><type name="Iter"/></sample-value>
240 |       <sample-value><type name="difference_type"/></sample-value>
241 |     </subscript>
242 |     <return-type>
243 |       <require-same-type testable="yes">
244 | 	<const-if-not-mutable>
245 | 	  <reference-to>
246 | 	    <type name="value_type"/>
247 | 	  </reference-to>
248 | 	</const-if-not-mutable>
249 |       </require-same-type>
250 |     </return-type>
251 |     <semantics>Equivalent to <code>*(i + n)</code></semantics>
252 |   </valid-expression>
253 | 
254 |   <valid-expression name="Element access with integer index">
255 |     <subscript>
256 |       <sample-value><type name="Iter"/></sample-value>
257 |       <sample-value><type name="int"/></sample-value>
258 |     </subscript>
259 |     <return-type>
260 |       <require-same-type testable="yes">
261 | 	<const-if-not-mutable>
262 | 	  <reference-to>
263 | 	    <type name="value_type"/>
264 | 	  </reference-to>
265 | 	</const-if-not-mutable>
266 |       </require-same-type>
267 |     </return-type>
268 |     <semantics>Equivalent to <code>*(i + n)</code></semantics>
269 |   </valid-expression>
270 | 
271 |   <complexity>
272 |   All iterator operations must take amortized constant time.
273 |   </complexity>
274 | 
275 |   <example-model>
276 |     <pointer-to>
277 |       <type name="T"/>
278 |     </pointer-to>
279 |   </example-model>
280 | 
281 |   <example-model>
282 |     <get-member-type name="iterator">
283 |       <apply-template name="std::vector">
284 | 	<type name="T"/>
285 |       </apply-template>
286 |     </get-member-type>
287 |   </example-model>
288 | 
289 |   <example-model>
290 |     <get-member-type name="const_iterator">
291 |       <apply-template name="std::vector">
292 | 	<type name="T"/>
293 |       </apply-template>
294 |     </get-member-type>
295 |   </example-model>
296 | 
297 |   <example-model>
298 |     <get-member-type name="iterator">
299 |       <apply-template name="std::deque">
300 | 	<type name="T"/>
301 |       </apply-template>
302 |     </get-member-type>
303 |   </example-model>
304 | 
305 |   <example-model>
306 |     <get-member-type name="const_iterator">
307 |       <apply-template name="std::deque">
308 | 	<type name="T"/>
309 |       </apply-template>
310 |     </get-member-type>
311 |   </example-model>
312 | 
313 | </concept>
314 | 


--------------------------------------------------------------------------------
/doc/reference/SignedInteger.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <concept name="SignedInteger" category="Utility"><!--
  3 | Based on concepts from the SGI Standard Template Library documentation:
  4 | Copyright (c) 1996-1999
  5 | Silicon Graphics Computer Systems, Inc.
  6 | 
  7 | Copyright (c) 1994
  8 | Hewlett-Packard Company
  9 | --><!--
 10 | Copyright 2000-2001 University of Notre Dame du Lac.
 11 | Copyright 2001-2002 Indiana University.
 12 | Some concepts based on versions from the MTL draft manual and Boost Graph
 13 | and Property Map documentation:
 14 | Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
 15 | -->
 16 |   <param name="T" role="integral-type"/>
 17 | 
 18 |   <models-sentence>Integer type <arg num="1"/> must be a model of <self/>.</models-sentence>
 19 | 
 20 |   <refines const="no" concept="CopyConstructible"/>
 21 |   <refines const="no" concept="Assignable"/>
 22 |   <refines const="no" concept="DefaultConstructible"/>
 23 |   <refines const="no" concept="EqualityComparable"/>
 24 |   <refines const="no" concept="LessThanComparable"/>
 25 | 
 26 |   <notation variables="x y z">
 27 |     <sample-value><type name="T"/></sample-value>
 28 |   </notation>
 29 |   <notation variables="a b">
 30 |     <sample-value><type name="int"/></sample-value>
 31 |   </notation>
 32 | 
 33 |   <!--
 34 |   <valid-type-expression name="int-ness">
 35 |     <documentation>Should this really be required?</documentation>
 36 |     <type name="T"/>
 37 |     <return-type>
 38 |       <require-same-type>
 39 | 	<type name="int"/>
 40 |       </require-same-type>
 41 |     </return-type>
 42 |   </valid-type-expression>
 43 |   -->
 44 | 
 45 |   <valid-expression name="Conversion from int">
 46 |     <construct template-parameters="">
 47 |       <type name="T"/>
 48 |       <sample-value><type name="int"/></sample-value>
 49 |     </construct>
 50 |     <return-type><require-same-type testable="yes">
 51 |       <type name="T"/>
 52 |     </require-same-type></return-type>
 53 |   </valid-expression>
 54 | 
 55 |   <valid-expression name="Preincrement">
 56 |     <preincrement>
 57 |       <sample-value>
 58 | 	<reference-to><type name="T"/></reference-to>
 59 |       </sample-value>
 60 |     </preincrement>
 61 |     <return-type>
 62 |       <require-same-type testable="yes">
 63 | 	<reference-to><type name="T"/></reference-to>
 64 |       </require-same-type>
 65 |     </return-type>
 66 |   </valid-expression>
 67 | 
 68 |   <valid-expression name="Predecrement">
 69 |     <predecrement>
 70 |       <sample-value>
 71 | 	<reference-to><type name="T"/></reference-to>
 72 |       </sample-value>
 73 |     </predecrement>
 74 |     <return-type>
 75 |       <require-same-type testable="yes">
 76 | 	<reference-to><type name="T"/></reference-to>
 77 |       </require-same-type>
 78 |     </return-type>
 79 |   </valid-expression>
 80 | 
 81 |   <valid-expression name="Postincrement">
 82 |     <postincrement>
 83 |       <sample-value>
 84 | 	<reference-to><type name="T"/></reference-to>
 85 |       </sample-value>
 86 |     </postincrement>
 87 |     <return-type>
 88 |       <require-same-type testable="yes">
 89 | 	<type name="T"/>
 90 |       </require-same-type>
 91 |     </return-type>
 92 |   </valid-expression>
 93 | 
 94 |   <valid-expression name="Postdecrement">
 95 |     <postdecrement>
 96 |       <sample-value>
 97 | 	<reference-to><type name="T"/></reference-to>
 98 |       </sample-value>
 99 |     </postdecrement>
100 |     <return-type>
101 |       <require-same-type testable="yes">
102 | 	<type name="T"/>
103 |       </require-same-type>
104 |     </return-type>
105 |   </valid-expression>
106 | 
107 |   <valid-expression name="Sum">
108 |     <add>
109 |       <sample-value>
110 | 	<type name="T"/>
111 |       </sample-value>
112 |       <sample-value>
113 | 	<type name="T"/>
114 |       </sample-value>
115 |     </add>
116 |     <return-type>
117 |       <require-same-type testable="yes">
118 | 	<type name="T"/>
119 |       </require-same-type>
120 |     </return-type>
121 |   </valid-expression>
122 | 
123 |   <valid-expression name="Sum with int">
124 |     <add>
125 |       <sample-value>
126 | 	<type name="T"/>
127 |       </sample-value>
128 |       <sample-value>
129 | 	<type name="int"/>
130 |       </sample-value>
131 |     </add>
132 |     <return-type>
133 |       <require-same-type testable="yes">
134 | 	<type name="T"/>
135 |       </require-same-type>
136 |     </return-type>
137 |   </valid-expression>
138 | 
139 |   <valid-expression name="Sum-assignment">
140 |     <add-assign>
141 |       <sample-value>
142 | 	<reference-to><type name="T"/></reference-to>
143 |       </sample-value>
144 |       <sample-value>
145 | 	<type name="T"/>
146 |       </sample-value>
147 |     </add-assign>
148 |     <return-type>
149 |       <require-same-type testable="yes">
150 | 	<reference-to><type name="T"/></reference-to>
151 |       </require-same-type>
152 |     </return-type>
153 |   </valid-expression>
154 | 
155 |   <valid-expression name="Sum-assignment with int">
156 |     <add-assign>
157 |       <sample-value>
158 | 	<reference-to><type name="T"/></reference-to>
159 |       </sample-value>
160 |       <sample-value>
161 | 	<type name="int"/>
162 |       </sample-value>
163 |     </add-assign>
164 |     <return-type>
165 |       <require-same-type testable="yes">
166 | 	<reference-to><type name="T"/></reference-to>
167 |       </require-same-type>
168 |     </return-type>
169 |   </valid-expression>
170 | 
171 |   <valid-expression name="Difference">
172 |     <subtract>
173 |       <sample-value>
174 | 	<type name="T"/>
175 |       </sample-value>
176 |       <sample-value>
177 | 	<type name="T"/>
178 |       </sample-value>
179 |     </subtract>
180 |     <return-type>
181 |       <require-same-type testable="yes">
182 | 	<type name="T"/>
183 |       </require-same-type>
184 |     </return-type>
185 |   </valid-expression>
186 | 
187 |   <valid-expression name="Difference with int">
188 |     <subtract>
189 |       <sample-value>
190 | 	<type name="T"/>
191 |       </sample-value>
192 |       <sample-value>
193 | 	<type name="int"/>
194 |       </sample-value>
195 |     </subtract>
196 |     <return-type>
197 |       <require-same-type testable="yes">
198 | 	<type name="T"/>
199 |       </require-same-type>
200 |     </return-type>
201 |   </valid-expression>
202 | 
203 |   <valid-expression name="Product">
204 |     <multiply>
205 |       <sample-value>
206 | 	<type name="T"/>
207 |       </sample-value>
208 |       <sample-value>
209 | 	<type name="T"/>
210 |       </sample-value>
211 |     </multiply>
212 |     <return-type>
213 |       <require-same-type testable="yes">
214 | 	<type name="T"/>
215 |       </require-same-type>
216 |     </return-type>
217 |   </valid-expression>
218 | 
219 |   <valid-expression name="Product with int">
220 |     <multiply>
221 |       <sample-value>
222 | 	<type name="T"/>
223 |       </sample-value>
224 |       <sample-value>
225 | 	<type name="int"/>
226 |       </sample-value>
227 |     </multiply>
228 |     <return-type>
229 |       <require-same-type testable="yes">
230 | 	<type name="T"/>
231 |       </require-same-type>
232 |     </return-type>
233 |   </valid-expression>
234 | 
235 |   <valid-expression name="Product-assignment with int">
236 |     <multiply-assign>
237 |       <sample-value>
238 | 	<reference-to><type name="T"/></reference-to>
239 |       </sample-value>
240 |       <sample-value>
241 | 	<type name="int"/>
242 |       </sample-value>
243 |     </multiply-assign>
244 |     <return-type>
245 |       <require-same-type testable="yes">
246 | 	<reference-to><type name="T"/></reference-to>
247 |       </require-same-type>
248 |     </return-type>
249 |   </valid-expression>
250 | 
251 |   <valid-expression name="Product with int on left">
252 |     <multiply>
253 |       <sample-value>
254 | 	<type name="int"/>
255 |       </sample-value>
256 |       <sample-value>
257 | 	<type name="T"/>
258 |       </sample-value>
259 |     </multiply>
260 |     <return-type>
261 |       <require-same-type testable="yes">
262 | 	<type name="T"/>
263 |       </require-same-type>
264 |     </return-type>
265 |   </valid-expression>
266 | 
267 |   <valid-expression name="Quotient">
268 |     <divide>
269 |       <sample-value>
270 | 	<type name="T"/>
271 |       </sample-value>
272 |       <sample-value>
273 | 	<type name="T"/>
274 |       </sample-value>
275 |     </divide>
276 |     <return-type>
277 |       <require-same-type testable="yes">
278 | 	<type name="T"/>
279 |       </require-same-type>
280 |     </return-type>
281 |   </valid-expression>
282 | 
283 |   <valid-expression name="Quotient with int">
284 |     <divide>
285 |       <sample-value>
286 | 	<type name="T"/>
287 |       </sample-value>
288 |       <sample-value>
289 | 	<type name="int"/>
290 |       </sample-value>
291 |     </divide>
292 |     <return-type>
293 |       <require-same-type testable="yes">
294 | 	<type name="T"/>
295 |       </require-same-type>
296 |     </return-type>
297 |   </valid-expression>
298 | 
299 |   <valid-expression name="Right-shift">
300 |     <shift-right>
301 |       <sample-value>
302 | 	<type name="T"/>
303 |       </sample-value>
304 |       <sample-value>
305 | 	<type name="T"/>
306 |       </sample-value>
307 |     </shift-right>
308 |     <return-type>
309 |       <require-same-type testable="yes">
310 | 	<type name="T"/>
311 |       </require-same-type>
312 |     </return-type>
313 |   </valid-expression>
314 | 
315 |   <valid-expression name="Right-shift with int">
316 |     <shift-right>
317 |       <sample-value>
318 | 	<type name="T"/>
319 |       </sample-value>
320 |       <sample-value>
321 | 	<type name="int"/>
322 |       </sample-value>
323 |     </shift-right>
324 |     <return-type>
325 |       <require-same-type testable="yes">
326 | 	<type name="T"/>
327 |       </require-same-type>
328 |     </return-type>
329 |   </valid-expression>
330 | 
331 |   <valid-expression name="Right-shift-assignment with int">
332 |     <shift-right-assign>
333 |       <sample-value>
334 | 	<reference-to><type name="T"/></reference-to>
335 |       </sample-value>
336 |       <sample-value>
337 | 	<type name="int"/>
338 |       </sample-value>
339 |     </shift-right-assign>
340 |     <return-type>
341 |       <require-same-type testable="yes">
342 | 	<reference-to><type name="T"/></reference-to>
343 |       </require-same-type>
344 |     </return-type>
345 |   </valid-expression>
346 | 
347 |   <valid-expression name="Less-than comparison">
348 |     <less-than>
349 |       <sample-value>
350 | 	<type name="T"/>
351 |       </sample-value>
352 |       <sample-value>
353 | 	<type name="T"/>
354 |       </sample-value>
355 |     </less-than>
356 |     <return-type>
357 |       <convertible-to testable="yes">
358 | 	<type name="bool"/>
359 |       </convertible-to>
360 |     </return-type>
361 |   </valid-expression>
362 | 
363 |   <valid-expression name="Less-than comparison with int">
364 |     <less-than>
365 |       <sample-value>
366 | 	<type name="T"/>
367 |       </sample-value>
368 |       <sample-value>
369 | 	<type name="int"/>
370 |       </sample-value>
371 |     </less-than>
372 |     <return-type>
373 |       <convertible-to testable="yes">
374 | 	<type name="bool"/>
375 |       </convertible-to>
376 |     </return-type>
377 |   </valid-expression>
378 | 
379 |   <valid-expression name="Less-than comparison with size_t">
380 |     <less-than>
381 |       <sample-value>
382 | 	<type name="T"/>
383 |       </sample-value>
384 |       <sample-value>
385 | 	<type name="std::size_t"/>
386 |       </sample-value>
387 |     </less-than>
388 |     <return-type>
389 |       <convertible-to testable="yes">
390 | 	<type name="bool"/>
391 |       </convertible-to>
392 |     </return-type>
393 |   </valid-expression>
394 | 
395 |   <valid-expression name="Greater-than comparison">
396 |     <greater-than>
397 |       <sample-value>
398 | 	<type name="T"/>
399 |       </sample-value>
400 |       <sample-value>
401 | 	<type name="T"/>
402 |       </sample-value>
403 |     </greater-than>
404 |     <return-type>
405 |       <convertible-to testable="yes">
406 | 	<type name="bool"/>
407 |       </convertible-to>
408 |     </return-type>
409 |   </valid-expression>
410 | 
411 |   <valid-expression name="Greater-than comparison with int">
412 |     <greater-than>
413 |       <sample-value>
414 | 	<type name="T"/>
415 |       </sample-value>
416 |       <sample-value>
417 | 	<type name="int"/>
418 |       </sample-value>
419 |     </greater-than>
420 |     <return-type>
421 |       <convertible-to testable="yes">
422 | 	<type name="bool"/>
423 |       </convertible-to>
424 |     </return-type>
425 |   </valid-expression>
426 | 
427 |   <valid-expression name="Less-than-or-equal comparison">
428 |     <less-than-or-equal>
429 |       <sample-value>
430 | 	<type name="T"/>
431 |       </sample-value>
432 |       <sample-value>
433 | 	<type name="T"/>
434 |       </sample-value>
435 |     </less-than-or-equal>
436 |     <return-type>
437 |       <convertible-to testable="yes">
438 | 	<type name="bool"/>
439 |       </convertible-to>
440 |     </return-type>
441 |   </valid-expression>
442 | 
443 |   <valid-expression name="Less-than-or-equal comparison with int">
444 |     <less-than-or-equal>
445 |       <sample-value>
446 | 	<type name="T"/>
447 |       </sample-value>
448 |       <sample-value>
449 | 	<type name="int"/>
450 |       </sample-value>
451 |     </less-than-or-equal>
452 |     <return-type>
453 |       <convertible-to testable="yes">
454 | 	<type name="bool"/>
455 |       </convertible-to>
456 |     </return-type>
457 |   </valid-expression>
458 | 
459 |   <valid-expression name="Greater-than-or-equal comparison">
460 |     <greater-than-or-equal>
461 |       <sample-value>
462 | 	<type name="T"/>
463 |       </sample-value>
464 |       <sample-value>
465 | 	<type name="T"/>
466 |       </sample-value>
467 |     </greater-than-or-equal>
468 |     <return-type>
469 |       <convertible-to testable="yes">
470 | 	<type name="bool"/>
471 |       </convertible-to>
472 |     </return-type>
473 |   </valid-expression>
474 | 
475 |   <valid-expression name="Greater-than-or-equal comparison with int">
476 |     <greater-than-or-equal>
477 |       <sample-value>
478 | 	<type name="T"/>
479 |       </sample-value>
480 |       <sample-value>
481 | 	<type name="int"/>
482 |       </sample-value>
483 |     </greater-than-or-equal>
484 |     <return-type>
485 |       <convertible-to testable="yes">
486 | 	<type name="bool"/>
487 |       </convertible-to>
488 |     </return-type>
489 |   </valid-expression>
490 | 
491 |   <valid-expression name="Greater-than-or-equal comparison with int on left">
492 |     <greater-than-or-equal>
493 |       <sample-value>
494 | 	<type name="int"/>
495 |       </sample-value>
496 |       <sample-value>
497 | 	<type name="T"/>
498 |       </sample-value>
499 |     </greater-than-or-equal>
500 |     <return-type>
501 |       <convertible-to testable="yes">
502 | 	<type name="bool"/>
503 |       </convertible-to>
504 |     </return-type>
505 |   </valid-expression>
506 | 
507 |   <valid-expression name="Equality comparison">
508 |     <equal-to>
509 |       <sample-value>
510 | 	<type name="T"/>
511 |       </sample-value>
512 |       <sample-value>
513 | 	<type name="T"/>
514 |       </sample-value>
515 |     </equal-to>
516 |     <return-type>
517 |       <convertible-to testable="yes">
518 | 	<type name="bool"/>
519 |       </convertible-to>
520 |     </return-type>
521 |   </valid-expression>
522 | 
523 |   <valid-expression name="Equality comparison with int">
524 |     <equal-to>
525 |       <sample-value>
526 | 	<type name="T"/>
527 |       </sample-value>
528 |       <sample-value>
529 | 	<type name="int"/>
530 |       </sample-value>
531 |     </equal-to>
532 |     <return-type>
533 |       <convertible-to testable="yes">
534 | 	<type name="bool"/>
535 |       </convertible-to>
536 |     </return-type>
537 |   </valid-expression>
538 | 
539 |   <valid-type-expression name="Conversion to int">
540 |     <documentation/>
541 |     <type name="T"/>
542 |     <return-type>
543 |       <convertible-to testable="yes">
544 | 	<type name="int"/>
545 |       </convertible-to>
546 |     </return-type>
547 |   </valid-type-expression>
548 | 
549 | </concept>
550 | 


--------------------------------------------------------------------------------
/doc/reference/concepts.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!DOCTYPE library-reference PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
 3 |   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 4 | <library-reference id="concepts.reference" 
 5 |          xmlns:xi="http://www.w3.org/2001/XInclude" 
 6 |          last-revision="$Date$">
 7 |   <sectioninfo>
 8 |     <copyright>
 9 |       <year>2001</year>
10 |       <year>2002</year>
11 |       <holder>Indiana University</holder>
12 |     </copyright>
13 | 
14 |     <copyright>
15 |       <year>2000</year>
16 |       <year>2001</year>
17 |       <holder>University of Notre Dame du Lac</holder>
18 |     </copyright>
19 | 
20 |     <copyright>
21 |       <year>2000</year>
22 |       <holder>Jeremy Siek</holder>
23 |       <holder>Lie-Quan Lee</holder>
24 |       <holder>Andrew Lumsdaine</holder>
25 |     </copyright>
26 | 
27 |     <copyright>
28 |       <year>1996</year>
29 |       <year>1997</year>
30 |       <year>1998</year>
31 |       <year>1999</year>
32 |       <holder>Silicon Graphics Computer Systems, Inc.</holder>
33 |     </copyright>
34 | 
35 |     <copyright>
36 |       <year>1994</year>
37 |       <holder>Hewlett-Packard Company</holder>
38 |     </copyright>
39 | 
40 |     <legalnotice>
41 |       <para>Distributed under the Boost Software License, Version 1.0.
42 |       (See accompanying file <filename>LICENSE_1_0.txt</filename> or copy at 
43 |       <ulink
44 |       url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)
45 |       </para>
46 | 
47 |       <para>This product includes software developed at the University
48 |       of Notre Dame and the Pervasive Technology Labs at Indiana
49 |       University. For technical information contact Andrew Lumsdaine
50 |       at the Pervasive Technology Labs at Indiana University.  For
51 |       administrative and license questions contact the Advanced
52 |       Research and Technology Institute at 351 West 10th Street.
53 |       Indianapolis, Indiana 46202, phone 317-278-4100, fax
54 |       317-274-5902.</para>
55 | 
56 |       <para>Some concepts based on versions from the MTL draft manual
57 |       and Boost Graph and Property Map documentation, the SGI Standard
58 |       Template Library documentation and the Hewlett-Packard STL,
59 |       under the following license: 
60 |         <blockquote><simpara>Permission to use, copy, modify, distribute and
61 |         sell this software and its documentation for any purpose is
62 |         hereby granted without fee, provided that the above copyright
63 |         notice appears in all copies and that both that copyright
64 |         notice and this permission notice appear in supporting
65 |         documentation.  Silicon Graphics makes no representations
66 |         about the suitability of this software for any purpose.  It is
67 |         provided "as is" without express or implied
68 |         warranty.</simpara></blockquote></para>
69 |     </legalnotice>
70 |   </sectioninfo>
71 |   <title>Concept reference</title>
72 | 
73 |   <xi:include href="Assignable.xml"/>
74 |   <xi:include href="InputIterator.xml"/>
75 |   <xi:include href="OutputIterator.xml"/>
76 |   <xi:include href="ForwardIterator.xml"/>
77 |   <xi:include href="BidirectionalIterator.xml"/>
78 |   <xi:include href="RandomAccessIterator.xml"/>
79 |   <xi:include href="DefaultConstructible.xml"/>
80 |   <xi:include href="CopyConstructible.xml"/>
81 |   <xi:include href="EqualityComparable.xml"/>
82 |   <xi:include href="LessThanComparable.xml"/>
83 |   <xi:include href="SignedInteger.xml"/>
84 | </library-reference>
85 | 


--------------------------------------------------------------------------------
/implementation.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000, David Abrahams 2007 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 14 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 15 | 
 16 |   <title>Concept Checking Implementation</title>
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="warning" id="warning"><font color=
 25 |   "red">Warning</font></a></h2>
 26 | 
 27 |   <p><font color="red">This documentation is out-of-date; similar but
 28 |   newer implementation techniques are now used.  This documentation
 29 |   also refers to components and protocols in the library's old
 30 |   interface such as <code>BOOST_CLASS_REQUIRES</code>
 31 |   and <code>constraints()</code> functions, which are still supported
 32 |   but deprecated.</font></p>
 33 | 
 34 |   <h2><a name="implementation" id="implementation">Implementation</a></h2>
 35 | 
 36 |   <p>Ideally we would like to catch, and indicate, the concept violation at
 37 |   the point of instantiation. As mentioned in D&amp;E[<a href=
 38 |   "bibliography.htm#stroustrup94:_design_evolution">2</a>], the error can be
 39 |   caught by exercising all of the requirements needed by the function
 40 |   template. Exactly how the requirements (the valid expressions in
 41 |   particular) are exercised is a tricky issue, since we want the code to be
 42 |   compiled—<i>but not executed</i>. Our approach is to exercise the
 43 |   requirements in a separate function that is assigned to a function pointer.
 44 |   In this case, the compiler will instantiate the function but will not
 45 |   actually invoke it. In addition, an optimizing compiler will remove the
 46 |   pointer assignment as ``dead code'' (though the run-time overhead added by
 47 |   the assignment would be trivial in any case). It might be conceivable for a
 48 |   compiler to skip the semantic analysis and compilation of the constraints
 49 |   function in the first place, which would make our function pointer
 50 |   technique ineffective. However, this is unlikely because removal of
 51 |   unnecessary code and functions is typically done in later stages of a
 52 |   compiler. We have successfully used the function pointer technique with GNU
 53 |   C++, Microsoft Visual C++, and several EDG-based compilers (KAI C++, SGI
 54 |   MIPSpro). The following code shows how this technique can be applied to the
 55 |   <tt>std::stable_sort()</tt> function:</p>
 56 |   <pre>
 57 |   template &lt;class RandomAccessIterator&gt;
 58 |   void stable_sort_constraints(RandomAccessIterator i)
 59 |   {
 60 |     typename std::iterator_traits&lt;RandomAccessIterator&gt;
 61 |       ::difference_type n;
 62 |     i += n;  // exercise the requirements for RandomAccessIterator
 63 |     ...
 64 |   }
 65 |   template &lt;class RandomAccessIterator&gt;
 66 |   void stable_sort(RandomAccessIterator first, RandomAccessIterator last)
 67 |   {
 68 |     typedef void (*fptr_type)(RandomAccessIterator);
 69 |     fptr_type x = &amp;stable_sort_constraints;
 70 |     ...
 71 |   }
 72 | </pre>
 73 | 
 74 |   <p>There is often a large set of requirements that need to be checked, and
 75 |   it would be cumbersome for the library implementor to write constraint
 76 |   functions like <tt>stable_sort_constraints()</tt> for every public
 77 |   function. Instead, we group sets of valid expressions together, according
 78 |   to the definitions of the corresponding concepts. For each concept we
 79 |   define a concept checking class template where the template parameter is
 80 |   for the type to be checked. The class contains a <tt>constraints()</tt>
 81 |   member function which exercises all of the valid expressions of the
 82 |   concept. The objects used in the constraints function, such as <tt>n</tt>
 83 |   and <tt>i</tt>, are declared as data members of the concept checking
 84 |   class.</p>
 85 |   <pre>
 86 |   template &lt;class Iter&gt;
 87 |   struct RandomAccessIteratorConcept
 88 |   {
 89 |     void constraints()
 90 |     {
 91 |       i += n;
 92 |       ...
 93 |     }
 94 |     typename std::iterator_traits&lt;RandomAccessIterator&gt;
 95 |       ::difference_type n;
 96 |     Iter i;
 97 |     ...
 98 |   };
 99 | </pre>
100 | 
101 |   <p>We can still use the function pointer mechanism to cause instantiation
102 |   of the constraints function, however now it will be a member function
103 |   pointer. To make it easy for the library implementor to invoke the concept
104 |   checks, we wrap the member function pointer mechanism in a function named
105 |   <tt>function_requires()</tt>. The following code snippet shows how to use
106 |   <tt>function_requires()</tt> to make sure that the iterator is a <a href=
107 |   "http://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>.</p>
108 |   <pre>
109 |   template &lt;class Iter&gt;
110 |   void stable_sort(Iter first, Iter last)
111 |   {
112 |     function_requires&lt; RandomAccessIteratorConcept&lt;Iter&gt; &gt;();
113 |     ...
114 |   }
115 | </pre>
116 | 
117 |   <p>The definition of the <tt>function_requires()</tt> is as follows. The
118 |   <tt>Concept</tt> is the concept checking class that has been instantiated
119 |   with the modeling type. We assign the address of the constraints member
120 |   function to the function pointer <tt>x</tt>, which causes the instantiation
121 |   of the constraints function and checking of the concept's valid
122 |   expressions. We then assign <tt>x</tt> to <tt>x</tt> to avoid unused
123 |   variable compiler warnings, and wrap everything in a do-while loop to
124 |   prevent name collisions.</p>
125 |   <pre>
126 |   template &lt;class Concept&gt;
127 |   void function_requires()
128 |   {
129 |     void (Concept::*x)() = BOOST_FPTR Concept::constraints;
130 |     ignore_unused_variable_warning(x);
131 |   }
132 | </pre>
133 | 
134 |   <p>To check the type parameters of class templates, we provide the
135 |   <tt>BOOST_CLASS_REQUIRE</tt> macro which can be used inside the body of a
136 |   class definition (whereas <tt>function_requires()</tt> can only be used
137 |   inside of a function body). This macro declares a nested class template,
138 |   where the template parameter is a function pointer. We then use the nested
139 |   class type in a typedef with the function pointer type of the constraint
140 |   function as the template argument. We use the <tt>type_var</tt> and
141 |   <tt>concept</tt> names in the nested class and typedef names to help
142 |   prevent name collisions.</p>
143 |   <pre>
144 | #define BOOST_CLASS_REQUIRE(type_var, ns, concept) \
145 |   typedef void (ns::concept &lt;type_var&gt;::* func##type_var##concept)(); \
146 |   template &lt;func##type_var##concept _Tp1&gt; \
147 |   struct concept_checking_##type_var##concept { }; \
148 |   typedef concept_checking_##type_var##concept&lt; \
149 |     BOOST_FPTR ns::concept&lt;type_var&gt;::constraints&gt; \
150 |     concept_checking_typedef_##type_var##concept
151 | </pre>
152 | 
153 |   <p>In addition, there are versions of <tt>BOOST_CLASS_REQUIRE</tt> that
154 |   take more arguments, to handle concepts that include interactions between
155 |   two or more types. <tt>BOOST_CLASS_REQUIRE</tt> was not used in the
156 |   implementation of the BCCL concept checks because some compilers do not
157 |   implement template parameters of function pointer type. 
158 |   <!-- We decided not to go with this version since it is easier to misuse
159 | 
160 | To check the type parameters of class templates, we provide the
161 | <tt>class_requires</tt> class which can be used inside the body of a
162 | class definition (whereas <tt>function_requires()</tt> can only be
163 | used inside of a function body).  <tt>class_requires</tt> declares a
164 | nested class template, where the template parameter is a function
165 | pointer. We then use the nested class type in a typedef with the
166 | function pointer type of the constraint function as the template
167 | argument.
168 | 
169 | <pre>
170 |   template &lt;class Concept&gt;
171 |   class class_requires
172 |   {
173 |     typedef void (Concept::* function_pointer)();
174 | 
175 |     template &lt;function_pointer Fptr&gt;
176 |     struct dummy_struct { };
177 |   public:
178 |     typedef dummy_struct&lt; BOOST_FPTR Concept::constraints &gt; check;
179 |   };
180 | </pre>
181 | 
182 | <tt>class_requires</tt> was not used in the implementation of the
183 | Boost Concept Checking Library concept checks because several
184 | compilers do not implement template parameters of function pointer
185 | type.
186 | 
187 | --></p>
188 | 
189 |   <p><a href="./reference.htm">Next: Reference</a><br />
190 |   <a href="prog_with_concepts.htm">Prev: Programming With
191 |   Concepts</a><br /></p>
192 |   <hr />
193 | 
194 |   <table>
195 |     <tr valign="top">
196 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
197 | 
198 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
199 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
200 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>),
201 |         2007 <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.
202 |     </tr>
203 |   </table>
204 | </body>
205 | </html>
206 | 


--------------------------------------------------------------------------------
/include/boost/concept/assert.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_ASSERT_DWA2006430_HPP
 5 | # define BOOST_CONCEPT_ASSERT_DWA2006430_HPP
 6 | 
 7 | # include <boost/config.hpp>
 8 | # include <boost/config/workaround.hpp>
 9 | 
10 | // The old protocol used a constraints() member function in concept
11 | // checking classes.  If the compiler supports SFINAE, we can detect
12 | // that function and seamlessly support the old concept checking
13 | // classes.  In this release, backward compatibility with the old
14 | // concept checking classes is enabled by default, where available.
15 | // The old protocol is deprecated, though, and backward compatibility
16 | // will no longer be the default in the next release.
17 | 
18 | # if !defined(BOOST_NO_OLD_CONCEPT_SUPPORT)                                         \
19 |     && !defined(BOOST_NO_SFINAE)                                                    \
20 |                                                                                     \
21 |     && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4))
22 | 
23 | // Note: gcc-2.96 through 3.3.x have some SFINAE, but no ability to
24 | // check for the presence of particularmember functions.
25 | 
26 | #  define BOOST_OLD_CONCEPT_SUPPORT
27 | 
28 | # endif
29 | 
30 | # ifdef BOOST_MSVC
31 | #  include <boost/concept/detail/msvc.hpp>
32 | # elif BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
33 | #  include <boost/concept/detail/borland.hpp>
34 | # else 
35 | #  include <boost/concept/detail/general.hpp>
36 | # endif
37 | 
38 |   // Usage, in class or function context:
39 |   //
40 |   //     BOOST_CONCEPT_ASSERT((UnaryFunctionConcept<F,bool,int>));
41 |   //
42 | # define BOOST_CONCEPT_ASSERT(ModelInParens) \
43 |     BOOST_CONCEPT_ASSERT_FN(void(*)ModelInParens)
44 | 
45 | #endif // BOOST_CONCEPT_ASSERT_DWA2006430_HPP
46 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/backward_compatibility.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2009. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
 5 | # define BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
 6 | 
 7 | namespace boost
 8 | {
 9 |   namespace concepts {}
10 | 
11 | # if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
12 |   namespace concept = concepts;
13 | # endif 
14 | } // namespace boost::concept
15 | 
16 | #endif // BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
17 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/borland.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
 6 | 
 7 | # include <boost/preprocessor/cat.hpp>
 8 | # include <boost/concept/detail/backward_compatibility.hpp>
 9 | 
10 | namespace boost { namespace concepts {
11 | 
12 | template <class ModelFnPtr>
13 | struct require;
14 | 
15 | template <class Model>
16 | struct require<void(*)(Model)>
17 | {
18 |     enum { instantiate = sizeof((((Model*)0)->~Model()), 3) };
19 | };
20 | 
21 | #  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )         \
22 |   enum                                                  \
23 |   {                                                     \
24 |       BOOST_PP_CAT(boost_concept_check,__LINE__) =      \
25 |       boost::concepts::require<ModelFnPtr>::instantiate  \
26 |   }
27 | 
28 | }} // namespace boost::concept
29 | 
30 | #endif // BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
31 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/concept_def.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
 5 | # define BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
 6 | # include <boost/preprocessor/seq/for_each_i.hpp>
 7 | # include <boost/preprocessor/seq/enum.hpp>
 8 | # include <boost/preprocessor/comma_if.hpp>
 9 | # include <boost/preprocessor/cat.hpp>
10 | #endif // BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
11 | 
12 | // BOOST_concept(SomeName, (p1)(p2)...(pN))
13 | //
14 | // Expands to "template <class p1, class p2, ...class pN> struct SomeName"
15 | //
16 | // Also defines an equivalent SomeNameConcept for backward compatibility.
17 | // Maybe in the next release we can kill off the "Concept" suffix for good.
18 | # define BOOST_concept(name, params)                                            \
19 |     template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
20 |     struct name; /* forward declaration */                                      \
21 |                                                                                 \
22 |     template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
23 |     struct BOOST_PP_CAT(name,Concept)                                           \
24 |       : name< BOOST_PP_SEQ_ENUM(params) >                                       \
25 |     {                                                                           \
26 |     };                                                                          \
27 |                                                                                 \
28 |     template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
29 |     struct name                                                                
30 |     
31 | // Helper for BOOST_concept, above.
32 | # define BOOST_CONCEPT_typename(r, ignored, index, t) \
33 |     BOOST_PP_COMMA_IF(index) typename t
34 | 
35 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/concept_undef.hpp:
--------------------------------------------------------------------------------
1 | // Copyright David Abrahams 2006. Distributed under the Boost
2 | // Software License, Version 1.0. (See accompanying
3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
4 | # undef BOOST_concept_typename
5 | # undef BOOST_concept
6 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/general.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
 6 | 
 7 | # include <boost/config.hpp>
 8 | # include <boost/preprocessor/cat.hpp>
 9 | # include <boost/concept/detail/backward_compatibility.hpp>
10 | 
11 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
12 | #  include <boost/concept/detail/has_constraints.hpp>
13 | #  include <boost/type_traits/conditional.hpp>
14 | # endif
15 | 
16 | // This implementation works on Comeau and GCC, all the way back to
17 | // 2.95
18 | namespace boost { namespace concepts {
19 | 
20 | template <class ModelFn>
21 | struct requirement_;
22 | 
23 | namespace detail
24 | {
25 |   template <void(*)()> struct instantiate {};
26 | }
27 | 
28 | template <class Model>
29 | struct requirement
30 | {
31 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
32 | #   pragma GCC diagnostic push
33 | #   pragma GCC diagnostic ignored "-Wnonnull"
34 | #   endif
35 |     static void failed() { ((Model*)0)->~Model(); }
36 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
37 | #   pragma GCC diagnostic pop
38 | #   endif
39 | };
40 | 
41 | struct failed {};
42 | 
43 | template <class Model>
44 | struct requirement<failed ************ Model::************>
45 | {
46 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
47 | #   pragma GCC diagnostic push
48 | #   pragma GCC diagnostic ignored "-Wnonnull"
49 | #   endif
50 |     static void failed() { ((Model*)0)->~Model(); }
51 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
52 | #   pragma GCC diagnostic pop
53 | #   endif
54 | };
55 | 
56 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
57 | 
58 | template <class Model>
59 | struct constraint
60 | {
61 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
62 | #   pragma GCC diagnostic push
63 | #   pragma GCC diagnostic ignored "-Wnonnull"
64 | #   endif
65 |     static void failed() { ((Model*)0)->constraints(); }
66 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
67 | #   pragma GCC diagnostic pop
68 | #   endif
69 | };
70 |   
71 | template <class Model>
72 | struct requirement_<void(*)(Model)>
73 |   : boost::conditional<
74 |         concepts::not_satisfied<Model>::value
75 |       , constraint<Model>
76 |       , requirement<failed ************ Model::************>
77 |     >::type
78 | {};
79 |   
80 | # else
81 | 
82 | // For GCC-2.x, these can't have exactly the same name
83 | template <class Model>
84 | struct requirement_<void(*)(Model)>
85 |     : requirement<failed ************ Model::************>
86 | {};
87 |   
88 | # endif
89 | 
90 | #  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )             \
91 |     typedef ::boost::concepts::detail::instantiate<          \
92 |     &::boost::concepts::requirement_<ModelFnPtr>::failed>    \
93 |       BOOST_PP_CAT(boost_concept_check,__LINE__)             \
94 |       BOOST_ATTRIBUTE_UNUSED
95 | 
96 | }}
97 | 
98 | #endif // BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
99 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/has_constraints.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
 6 | 
 7 | # include <boost/type_traits/integral_constant.hpp>
 8 | # include <boost/config/workaround.hpp>
 9 | # include <boost/concept/detail/backward_compatibility.hpp>
10 | 
11 | namespace boost { namespace concepts {
12 | 
13 | namespace detail
14 | { 
15 | 
16 | // Here we implement the metafunction that detects whether a
17 | // constraints metafunction exists
18 |   typedef char yes;
19 |   typedef char (&no)[2];
20 | 
21 |   template <class Model, void (Model::*)()>
22 |   struct wrap_constraints {};
23 |     
24 | #if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580) || defined(__CUDACC__)
25 |   // Work around the following bogus error in Sun Studio 11, by
26 |   // turning off the has_constraints function entirely:
27 |   //    Error: complex expression not allowed in dependent template
28 |   //    argument expression
29 |   inline no has_constraints_(...);
30 | #else
31 |   template <class Model>
32 |   inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
33 |   inline no has_constraints_(...);
34 | #endif
35 | }
36 | 
37 | // This would be called "detail::has_constraints," but it has a strong
38 | // tendency to show up in error messages.
39 | template <class Model>
40 | struct not_satisfied
41 | {
42 |     BOOST_STATIC_CONSTANT(
43 |         bool
44 |       , value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes) );
45 |     typedef boost::integral_constant<bool, value> type;
46 | };
47 | 
48 | }} // namespace boost::concepts::detail
49 | 
50 | #endif // BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
51 | 


--------------------------------------------------------------------------------
/include/boost/concept/detail/msvc.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright David Abrahams 2006. Distributed under the Boost
  2 | // Software License, Version 1.0. (See accompanying
  3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  4 | #ifndef BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
  5 | # define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
  6 | 
  7 | # include <boost/preprocessor/cat.hpp>
  8 | # include <boost/concept/detail/backward_compatibility.hpp>
  9 | # include <boost/config.hpp>
 10 | 
 11 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
 12 | #  include <boost/concept/detail/has_constraints.hpp>
 13 | #  include <boost/type_traits/conditional.hpp>
 14 | # endif
 15 | 
 16 | # ifdef BOOST_MSVC
 17 | #  pragma warning(push)
 18 | #  pragma warning(disable:4100)
 19 | # endif
 20 | 
 21 | namespace boost { namespace concepts {
 22 | 
 23 | 
 24 | template <class Model>
 25 | struct check
 26 | {
 27 |     virtual void failed(Model* x)
 28 |     {
 29 |         x->~Model();
 30 |     }
 31 | };
 32 | 
 33 | # ifndef BOOST_NO_PARTIAL_SPECIALIZATION
 34 | struct failed {};
 35 | template <class Model>
 36 | struct check<failed ************ Model::************>
 37 | {
 38 |     virtual void failed(Model* x)
 39 |     {
 40 |         x->~Model();
 41 |     }
 42 | };
 43 | # endif
 44 | 
 45 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
 46 |   
 47 | namespace detail
 48 | {
 49 |   // No need for a virtual function here, since evaluating
 50 |   // not_satisfied below will have already instantiated the
 51 |   // constraints() member.
 52 |   struct constraint {};
 53 | }
 54 | 
 55 | template <class Model>
 56 | struct require
 57 |   : boost::conditional<
 58 |         not_satisfied<Model>::value
 59 |       , detail::constraint
 60 | # ifndef BOOST_NO_PARTIAL_SPECIALIZATION
 61 |       , check<Model>
 62 | # else
 63 |       , check<failed ************ Model::************>
 64 | # endif 
 65 |         >::type
 66 | {};
 67 |       
 68 | # else
 69 |   
 70 | template <class Model>
 71 | struct require
 72 | # ifndef BOOST_NO_PARTIAL_SPECIALIZATION
 73 |     : check<Model>
 74 | # else
 75 |     : check<failed ************ Model::************>
 76 | # endif 
 77 | {};
 78 |   
 79 | # endif
 80 |     
 81 | # if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
 82 | 
 83 | //
 84 | // The iterator library sees some really strange errors unless we
 85 | // do things this way.
 86 | //
 87 | template <class Model>
 88 | struct require<void(*)(Model)>
 89 | {
 90 |     virtual void failed(Model*)
 91 |     {
 92 |         require<Model>();
 93 |     }
 94 | };
 95 | 
 96 | # define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )      \
 97 | enum                                                \
 98 | {                                                   \
 99 |     BOOST_PP_CAT(boost_concept_check,__LINE__) =    \
100 |     sizeof(::boost::concepts::require<ModelFnPtr>)    \
101 | }
102 |   
103 | # else // Not vc-7.1
104 |   
105 | template <class Model>
106 | require<Model>
107 | require_(void(*)(Model));
108 |   
109 | # define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )          \
110 | enum                                                    \
111 | {                                                       \
112 |     BOOST_PP_CAT(boost_concept_check,__LINE__) =        \
113 |       sizeof(::boost::concepts::require_((ModelFnPtr)0)) \
114 | }
115 |   
116 | # endif
117 | }}
118 | 
119 | # ifdef BOOST_MSVC
120 | #  pragma warning(pop)
121 | # endif
122 | 
123 | #endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
124 | 


--------------------------------------------------------------------------------
/include/boost/concept/requires.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
 5 | # define BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
 6 | 
 7 | # include <boost/config.hpp>
 8 | # include <boost/concept/assert.hpp>
 9 | # include <boost/preprocessor/seq/for_each.hpp>
10 | 
11 | namespace boost { 
12 | 
13 | // unaryfunptr_arg_type from parameter/aux_/parenthesized_type.hpp
14 | 
15 | namespace ccheck_aux {
16 | 
17 | // A metafunction that transforms void(*)(T) -> T
18 | template <class UnaryFunctionPointer>
19 | struct unaryfunptr_arg_type;
20 | 
21 | template <class Arg>
22 | struct unaryfunptr_arg_type<void(*)(Arg)>
23 | {
24 |     typedef Arg type;
25 | };
26 | 
27 | template <>
28 | struct unaryfunptr_arg_type<void(*)(void)>
29 | {
30 |     typedef void type;
31 | };
32 | 
33 | } // namespace ccheck_aux
34 | 
35 | // Template for use in handwritten assertions
36 | template <class Model, class More>
37 | struct requires_ : More
38 | {
39 |     BOOST_CONCEPT_ASSERT((Model));
40 | };
41 | 
42 | // Template for use by macros, where models must be wrapped in parens.
43 | // This isn't in namespace detail to keep extra cruft out of resulting
44 | // error messages.
45 | template <class ModelFn>
46 | struct _requires_
47 | {
48 |     enum { value = 0 };
49 |     BOOST_CONCEPT_ASSERT_FN(ModelFn);
50 | };
51 | 
52 | template <int check, class Result>
53 | struct Requires_ : ::boost::ccheck_aux::unaryfunptr_arg_type<Result>
54 | {
55 | };
56 | 
57 | # if BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1010))
58 | #  define BOOST_CONCEPT_REQUIRES_(r,data,t) | (::boost::_requires_<void(*)t>::value)
59 | # else 
60 | #  define BOOST_CONCEPT_REQUIRES_(r,data,t) + (::boost::_requires_<void(*)t>::value)
61 | # endif
62 | 
63 | #if defined(NDEBUG)
64 | 
65 | # define BOOST_CONCEPT_REQUIRES(models, result)                                    \
66 |     typename ::boost::ccheck_aux::unaryfunptr_arg_type<void(*)result>::type
67 | 
68 | #elif BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
69 | 
70 | // Same thing as below without the initial typename
71 | # define BOOST_CONCEPT_REQUIRES(models, result)                                \
72 |     ::boost::Requires_<                                                        \
73 |       (0 BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_REQUIRES_, ~, models)),           \
74 |       ::boost::ccheck_aux::unaryfunptr_arg_type<void(*)result>          \
75 |                      >::type
76 | 
77 | #else
78 | 
79 | // This just ICEs on MSVC6 :(
80 | # define BOOST_CONCEPT_REQUIRES(models, result)                                        \
81 |     typename ::boost::Requires_<                                                       \
82 |       (0 BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_REQUIRES_, ~, models)),                   \
83 |       void(*)result                                                                 \
84 |     >::type
85 | 
86 | #endif 
87 | 
88 | // C++0x proposed syntax changed.  This supports an older usage
89 | #define BOOST_CONCEPT_WHERE(models,result) BOOST_CONCEPT_REQUIRES(models,result)
90 | 
91 | } // namespace boost::concept_check
92 | 
93 | #endif // BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
94 | 


--------------------------------------------------------------------------------
/include/boost/concept/usage.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_USAGE_DWA2006919_HPP
 5 | # define BOOST_CONCEPT_USAGE_DWA2006919_HPP
 6 | 
 7 | # include <boost/concept/assert.hpp>
 8 | # include <boost/config/workaround.hpp>
 9 | # include <boost/concept/detail/backward_compatibility.hpp>
10 | 
11 | namespace boost { namespace concepts { 
12 | 
13 | template <class Model>
14 | struct usage_requirements
15 | {
16 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
17 | #   pragma GCC diagnostic push
18 | #   pragma GCC diagnostic ignored "-Wnonnull"
19 | #   endif
20 |     ~usage_requirements() { ((Model*)0)->~Model(); }
21 | #   if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
22 | #   pragma GCC diagnostic pop
23 | #   endif
24 | };
25 | 
26 | #  if BOOST_WORKAROUND(__GNUC__, <= 3)
27 | 
28 | #   define BOOST_CONCEPT_USAGE(model)                                    \
29 |       model(); /* at least 2.96 and 3.4.3 both need this :( */           \
30 |       BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
31 |       ~model()
32 | 
33 | #  else
34 | 
35 | #   define BOOST_CONCEPT_USAGE(model)                                    \
36 |       BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
37 |       ~model()
38 | 
39 | #  endif
40 | 
41 | }} // namespace boost::concepts
42 | 
43 | #endif // BOOST_CONCEPT_USAGE_DWA2006919_HPP
44 | 


--------------------------------------------------------------------------------
/include/boost/concept_check/borland.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_CHECK_BORLAND_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_CHECK_BORLAND_DWA2006429_HPP
 6 | 
 7 | namespace boost {
 8 | 
 9 | template <class ModelFn>
10 | struct concept_check;
11 | 
12 | template <class Model>
13 | struct concept_check<void(*)(Model)>
14 | {
15 |     enum { instantiate = sizeof((((Model*)0)->~Model()), 3) };
16 | };
17 | 
18 | #  define BOOST_CONCEPT_ASSERT( ModelInParens )                     \
19 |   enum { BOOST_PP_CAT(boost_concept_check,__LINE__) =               \
20 |          boost::concept_check<void(*)ModelInParens>::instantiate    \
21 |   }
22 | 
23 | } // namespace boost::concept_checking
24 | 
25 | #endif // BOOST_CONCEPT_CHECK_BORLAND_DWA2006429_HPP
26 | 


--------------------------------------------------------------------------------
/include/boost/concept_check/general.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
 6 | 
 7 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
 8 | #  include <boost/concept_check/has_constraints.hpp>
 9 | #  include <boost/type_traits/conditional.hpp>
10 | # endif
11 | 
12 | 
13 | // This implementation works on GCC and Comeau, but has actually been
14 | // fairly carefully tuned to work on GCC versions starting with
15 | // gcc-2.95.x.  If you're trying to get an additional compiler to pass
16 | // the tests you might consider breaking out a separate gcc.hpp and
17 | // starting over on the general case.
18 | namespace boost
19 | {
20 |   namespace concept_checking
21 |   {
22 |     template <void(*)()> struct instantiate {};
23 |   }
24 |   
25 |   template <class ModelFn> struct concept_check_;
26 | 
27 |   template <class Model>
28 |   void concept_check_failed()
29 |   {
30 |       ((Model*)0)->~Model();
31 |   }
32 | 
33 |   template <class Model>
34 |   struct concept_check
35 |   {
36 |       concept_checking::instantiate<concept_check_failed<Model> > x;
37 |       enum { instantiate = 1 };
38 |   };
39 | 
40 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
41 |   
42 |   template <class Model>
43 |   void constraint_check_failed()
44 |   {
45 |       ((Model*)0)->constraints();
46 |   }
47 | 
48 |   template <class Model>
49 |   struct constraint_check
50 |   {
51 |       concept_checking::instantiate<constraint_check_failed<Model> > x;
52 |       enum { instantiate = 1 };
53 |   };
54 |   
55 |   template <class Model>
56 |   struct concept_check_<void(*)(Model)>
57 |     : conditional<
58 |           concept_checking::has_constraints<Model>::value
59 |         , constraint_check<Model>
60 |         , concept_check<Model>
61 |       >::type
62 |   {};
63 |   
64 | # else
65 |   
66 |   template <class Model>
67 |   struct concept_check_<void(*)(Model)>
68 |     : concept_check<Model>
69 |   {};
70 |   
71 | # endif
72 |   
73 |   // Usage, in class or function context:
74 |   //
75 |   //     BOOST_CONCEPT_ASSERT((UnaryFunctionConcept<F,bool,int>));
76 | #  define BOOST_CONCEPT_ASSERT( ModelInParens )                             \
77 |   enum { BOOST_PP_CAT(boost_concept_check,__LINE__) =                       \
78 |          ::boost::concept_check_<void(*) ModelInParens>::instantiate        \
79 |   }
80 | }
81 | 
82 | #endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
83 | 


--------------------------------------------------------------------------------
/include/boost/concept_check/has_constraints.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_CHECK_HAS_CONSTRAINTS_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_CHECK_HAS_CONSTRAINTS_DWA2006429_HPP
 6 | 
 7 | namespace boost { namespace concept_checking { 
 8 | 
 9 | // Here we implement the "metafunction" that detects whether a
10 | // constraints metafunction exists
11 | typedef char yes;
12 | typedef char (&no)[2];
13 | 
14 | template <class Model, void (Model::*)()>
15 | struct wrap_constraints {};
16 |     
17 | template <class Model>
18 | inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
19 | inline no has_constraints_(...);
20 | 
21 | template <class Model>
22 | struct has_constraints
23 | {
24 |     BOOST_STATIC_CONSTANT(
25 |         bool
26 |       , value = sizeof( concept_checking::has_constraints_((Model*)0) ) == 1 );
27 | };
28 | 
29 | }} // namespace boost::concept_checking
30 | 
31 | #endif // BOOST_CONCEPT_CHECK_HAS_CONSTRAINTS_DWA2006429_HPP
32 | 


--------------------------------------------------------------------------------
/include/boost/concept_check/msvc.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
 5 | # define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
 6 | 
 7 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
 8 | #  include <boost/concept_check/has_constraints.hpp>
 9 | #  include <boost/type_traits/conditional.hpp>
10 | # endif
11 | 
12 | 
13 | namespace boost
14 | {
15 |   namespace concept_checking
16 |   {
17 |     template <class Model>
18 |     struct concept_check_
19 |     {
20 |         virtual void failed(Model* x)
21 |         {
22 |             x->~Model();
23 |         }
24 |     };
25 |   }
26 |   
27 | # ifdef BOOST_OLD_CONCEPT_SUPPORT
28 |   
29 |   namespace concept_checking
30 |   {
31 |     template <class Model>
32 |     struct constraint_check
33 |     {
34 |         virtual void failed(Model* x)
35 |         {
36 |             x->constraints();
37 |         }
38 |     };
39 |   }
40 | 
41 |   template <class Model>
42 |   struct concept_check
43 |     : conditional<
44 |           concept_checking::has_constraints<Model>::value
45 |         , concept_checking::constraint_check<Model>
46 |         , concept_checking::concept_check_<Model>
47 |       >::type
48 |   {};
49 |       
50 | # else
51 |   
52 |   template <class Model>
53 |   struct concept_check
54 |     : concept_checking::concept_check_<Model>
55 |   {};
56 |   
57 | # endif
58 | 
59 | # if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
60 | 
61 |   //
62 |   // The iterator library sees some really strange errors unless we
63 |   // use partial specialization to extract the model type with
64 |   // msvc-7.1
65 |   // 
66 |   template <class Model>
67 |   struct concept_check<void(*)(Model)>
68 |     : concept_check<Model>
69 |   { };
70 | 
71 | # define BOOST_CONCEPT_ASSERT( ModelInParens )                          \
72 |   enum { BOOST_PP_CAT(boost_concept_check,__LINE__) =                   \
73 |          sizeof(::boost::concept_check<void(*) ModelInParens>)          \
74 |   }
75 |   
76 | # else
77 |   
78 |   template <class Model>
79 |   concept_check<Model>
80 |   concept_check_(void(*)(Model));
81 |   
82 | # define BOOST_CONCEPT_ASSERT( ModelInParens )                          \
83 |   enum { BOOST_PP_CAT(boost_concept_check,__LINE__) =                   \
84 |          sizeof(::boost::concept_check_((void(*) ModelInParens)0))      \
85 |   }
86 |   
87 | # endif 
88 | }
89 | 
90 | #endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
91 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boostorg/concept_check/0ef7f2b5daeaa125a53d98affba8f40091d24b17/index.html


--------------------------------------------------------------------------------
/meta/explicit-failures-markup.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <explicit-failures-markup>
 3 |     <!-- concept_check -->
 4 |     <library name="concept_check">
 5 |         <test name="class_concept_fail_expected">
 6 |             <mark-failure>
 7 |                 <toolset name="cw-8.3*"/>
 8 |                 <note author="B. Dawes" refid="3"/>
 9 |             </mark-failure>
10 |         </test>
11 |         <test name="class_concept_fail_expected">
12 |             <mark-failure>
13 |                 <toolset name="borland-5*"/>
14 |                 <toolset name="msvc-6.5*"/>
15 |                 <toolset name="msvc-7.0"/>
16 |                 <note author="Jeremy Siek"/>
17 |             </mark-failure>
18 |         </test>
19 |         <test name="stl_concept_check">
20 |           <mark-failure>
21 |             <toolset name="hp_cxx*"/>
22 |             <note author="Markus Schoepflin" date="09 Dec 2007">
23 |               This version of the Rogue Wave library fails to provide all
24 |               needed addition operators for the iterator type and the
25 |               difference type of std::deque.
26 |             </note>
27 |           </mark-failure>
28 |         </test>
29 |     </library>
30 | </explicit-failures-markup>
31 | 


--------------------------------------------------------------------------------
/meta/libraries.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "key": "concept_check",
 3 |     "name": "Concept Check",
 4 |     "authors": [
 5 |         "Jeremy Siek"
 6 |     ],
 7 |     "description": "Tools for generic programming.",
 8 |     "category": [
 9 |         "Correctness",
10 |         "Generic"
11 |     ],
12 |     "maintainers": [
13 |         "Jeremy Siek <jeremy.siek -at- gmail.com>"
14 |     ],
15 |     "cxxstd": "03"
16 | }
17 | 


--------------------------------------------------------------------------------
/prog_with_concepts.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 | 
 14 |   <title>Programming With Concepts</title>
 15 |   <meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
 16 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="programming-with-concepts" id=
 25 |   "programming-with-concepts">Programming with Concepts</a></h2>
 26 | 
 27 |   <p>The process of deciding how to group requirements into concepts and
 28 |   deciding which concepts to use in each algorithm is perhaps the most
 29 |   difficult (yet most important) part of building a generic library. A
 30 |   guiding principle to use during this process is one we call the
 31 |   <i>requirement minimization principle</i>.</p>
 32 | 
 33 |   <p><b>Requirement Minimization Principle:</b> Minimize the requirements on
 34 |   the input parameters of a component to increase its reusability.</p>
 35 | 
 36 |   <p>There is natural tension in this statement. By definition, the input
 37 |   parameters must be used by the component in order for the component to
 38 |   accomplish its task (by ``component'' we mean a function or class
 39 |   template). The challenge then is to implement the component in such a way
 40 |   that makes the fewest assumptions (the minimum requirements) about the
 41 |   inputs while still accomplishing the task.</p>
 42 | 
 43 |   <p>The traditional notions of <i>abstraction</i> tie in directly to the
 44 |   idea of minimal requirements. The more abstract the input, the fewer the
 45 |   requirements. Thus, concepts are simply the embodiment of generic abstract
 46 |   data types in C++ template programming.</p>
 47 | 
 48 |   <p>When designing the concepts for some problem domain it is important to
 49 |   keep in mind their purpose, namely to express the requirements for the
 50 |   input to the components. With respect to the requirement minimization
 51 |   principle, this means we want to minimize concepts. 
 52 |   <!-- the following discussion does not match the Standard definition
 53 |  of LessThanComparable and needs to be changed -Jeremy
 54 | 
 55 | <p>
 56 | It is important to note, however, that
 57 | minimizing concepts does not mean simply 
 58 | reducing the number of valid expressions
 59 | in the concept.
 60 | For example, the
 61 | <tt>std::stable_sort()</tt> function requires that the value type of
 62 | the iterator be <a
 63 | href="http://www.boost.org/sgi/stl/LessThanComparable.html">
 64 | LessThanComparable</a>, which not only
 65 | includes <tt>operator&lt;()</tt>, but also <tt>operator&gt;()</tt>,
 66 | <tt>operator&lt;=()</tt>, and <tt>operator&gt;=()</tt>.  
 67 | It turns out that <tt>std::stable_sort()</tt> only uses
 68 | <tt>operator&lt;()</tt>.  The question then arises: should 
 69 | <tt>std::stable_sort()</tt> be specified in terms of the concept
 70 | <a
 71 | href="http://www.boost.org/sgi/stl/LessThanComparable.html">
 72 | LessThanComparable</a> or in terms of a concept that only
 73 | requires <tt>operator&lt;()</tt>?
 74 | 
 75 | <p>
 76 | We remark first that the use of <a
 77 | href="http://www.boost.org/sgi/stl/LessThanComparable.html">
 78 | LessThanComparable</a> does not really violate the requirement
 79 | minimization principle because all of the other operators can be
 80 | trivially implemented in terms of <tt>operator&lt;()</tt>. By
 81 | ``trivial'' we mean one line of code and a constant run-time cost.  
 82 | More fundamentally, however, the use of <a
 83 | href="http://www.boost.org/sgi/stl/LessThanComparable.html">
 84 | LessThanComparable</a> does not violate the requirement minimization
 85 | principle because all of the comparison operators (<tt>&lt;</tt>,
 86 | <tt>></tt>, <tt><=</tt>, <tt>>=</tt>) are conceptually equivalent (in
 87 | a mathematical sense).  Adding conceptually equivalent valid
 88 | expressions is not a violation of the requirement minimization
 89 | principle because no new semantics are being added === only new
 90 | syntax. The added syntax increases re-usability.
 91 | 
 92 | <p>
 93 | For example,
 94 | the
 95 | maintainer of the <tt>std::stable_sort()</tt> may some day change the
 96 | implementation in places to use <tt>operator>()</tt> instead of
 97 | <tt>operator<()</tt>, since, after all, they are equivalent.  Since the
 98 | requirements are part of the public interface, such a change could
 99 | potentially break client code.  If instead
100 | <a
101 | href="http://www.boost.org/sgi/stl/LessThanComparable.html">
102 | LessThanComparable</a> is given as the requirement for
103 | <tt>std::stable_sort()</tt>, then the maintainer is given a reasonable
104 | amount of flexibility within which to work.
105 | 
106 | --></p>
107 | 
108 |   <p>Minimality in concepts is a property associated with the underlying
109 |   semantics of the problem domain being represented. In the problem domain of
110 |   basic containers, requiring traversal in a single direction is a smaller
111 |   requirement than requiring traversal in both directions (hence the
112 |   distinction between <a href=
113 |   "http://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a> and
114 |   <a href=
115 |   "http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>).
116 |   The semantic difference can be easily seen in the difference between the
117 |   set of concrete data structures that have forward iterators versus the set
118 |   that has bidirectional iterators. For example, singly-linked lists would
119 |   fall in the set of data structures having forward iterators, but not
120 |   bidirectional iterators. In addition, the set of algorithms that one can
121 |   implement using only forward iterators is quite different than the set that
122 |   can be implemented with bidirectional iterators. Because of this, it is
123 |   important to factor families of requirements into rather fine-grained
124 |   concepts. For example, the requirements for iterators are factored into the
125 |   six STL iterator concepts (trivial, output, input, forward, bidirectional,
126 |   and random access).</p>
127 | 
128 |   <p><a href="./implementation.htm">Next: Implementation</a><br />
129 |   <a href="./concept_covering.htm">Prev: Concept Covering and
130 |   Archetypes</a><br /></p>
131 |   <hr />
132 | 
133 |   <table>
134 |     <tr valign="top">
135 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
136 | 
137 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
138 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
139 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>),
140 |         2007 <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.
141 |     </tr>
142 |   </table>
143 | </body>
144 | </html>
145 | 


--------------------------------------------------------------------------------
/reference.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 14 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 15 | 
 16 |   <title>Boost Concept Checking Reference</title>
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="reference" id="reference">Reference</a></h2>
 25 | 
 26 |   <ol>
 27 |     <li><a href="#macros">Macros</a></li>
 28 | 
 29 |     <li><a href="#basic-concepts">Basic Concept Checking Classes</a></li>
 30 | 
 31 |     <li><a href="#iterator-concepts">Iterator Concept Checking
 32 |     Classes</a></li>
 33 | 
 34 |     <li><a href="#function-object-concepts">Function Object Concept Checking
 35 |     Classes</a></li>
 36 | 
 37 |     <li><a href="#container-concepts">Container Concept Checking
 38 |     Classes</a></li>
 39 | 
 40 |     <li><a href="#basic-archetype">Basic Archetype Classes</a></li>
 41 | 
 42 |     <li><a href="#iterator-archetype">Iterator Archetype Classes</a></li>
 43 | 
 44 |     <li><a href="#function-object-archetype">Function Object Archetype
 45 |     Classes</a></li>
 46 | 
 47 |     <li><a href="#container-archetype">Container Archetype Classes</a></li>
 48 | 
 49 |     <li><a href="#deprecated-functions">Deprecated Functions</a></li>
 50 | 
 51 |     <li><a href="#deprecated-macros">Deprecated Macros</a></li>
 52 | 
 53 |     <li><a href="#deprecated-concept-checking-classes">Deprecated Concept
 54 |     Checking Classes</a></li>
 55 |   </ol>
 56 | 
 57 |   <h3><a name="macros" id="macros">Macros</a></h3>
 58 |   <pre>
 59 | #include "boost/concept/assert.hpp"
 60 | 
 61 | BOOST_CONCEPT_ASSERT((<em>concept checking class template specialization</em>));
 62 | </pre>
 63 | 
 64 |   <p><strong>Effects:</strong> causes a compilation failure if the concept is
 65 |   not satisfied.<br />
 66 |   <strong>Note:</strong> this macro can be used at global, class, or function
 67 |   scope.</p>
 68 | 
 69 |   <pre>
 70 | #include "boost/concept/requires.hpp"
 71 | 
 72 | <font color="gray">template &lt;…<em>template parameters</em>…&gt;</font>
 73 | BOOST_CONCEPT_REQUIRES(
 74 |   ((<em>concept checking class template specialization<sub>1</sub></em>)) 
 75 |   ((<em>concept checking class template specialization<sub>2</sub></em>))… 
 76 |   ((<em>concept checking class template specialization<sub>n</sub></em>))<strong>,</strong>
 77 |   (<em>function return type</em>)
 78 | ) <font color="gray"><em>function_template_name</em>(…<em>function parameters</em>…)</font>
 79 | </pre>
 80 | 
 81 |   <p><strong>Effects:</strong> causes a compilation failure if the
 82 |   given concepts are not satisfied.<br />
 83 |   <strong>Note:</strong> this macro is intended to be used in place of
 84 |   a function template's return type.</p>
 85 | 
 86 |   <h3><a name="basic-concepts" id="basic-concepts">Basic Concept Checking
 87 |   Classes</a></h3>
 88 |   <pre>
 89 | #include "boost/concept_check.hpp"
 90 | 
 91 | template &lt;class T&gt;
 92 | struct Integer; // Is T a built-in integer type?
 93 | 
 94 | template &lt;class T&gt;
 95 | struct SignedInteger; // Is T a built-in signed integer type?
 96 | 
 97 | template &lt;class T&gt;
 98 | struct UnsignedInteger; // Is T a built-in unsigned integer type?
 99 | 
100 | template &lt;class X, class Y&gt;
101 | struct Convertible; // Is X convertible to Y?
102 | 
103 | template &lt;class T&gt;
104 | struct <a href=
105 | "../utility/Assignable.html">Assignable</a>; // Standard ref 23.1
106 | 
107 | template &lt;class T&gt;
108 | struct SGI<a href=
109 | "http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>;
110 | 
111 | template &lt;class T&gt;
112 | struct <a href=
113 | "http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>;
114 | 
115 | template &lt;class T&gt; 
116 | struct <a href=
117 | "../utility/CopyConstructible.html">CopyConstructible</a>; // Standard ref 20.1.3
118 | 
119 | template &lt;class T&gt; 
120 | struct <a href=
121 | "http://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a>; // Standard ref 20.1.1
122 | 
123 | template &lt;class T&gt;
124 | struct <a href=
125 | "../utility/LessThanComparable.html">LessThanComparable</a>; // Standard ref 20.1.2
126 | 
127 | template &lt;class T&gt;
128 | struct Comparable; // The SGI STL <a href=
129 | "http://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</a> concept
130 | </pre>
131 | 
132 |   <h3><a name="iterator-concepts" id="iterator-concepts">Iterator Concept
133 |   Checking Classes</a></h3>
134 |   <pre>
135 | template &lt;class Iter&gt;
136 | struct <a href=
137 | "http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>; // Standard ref 24.1.1 Table 72
138 | 
139 | template &lt;class Iter, class T&gt; 
140 | struct <a href=
141 | "http://www.boost.org/sgi/stl/OutputIterator.html">OutputIterator</a>; // Standard ref 24.1.2 Table 73
142 | 
143 | template &lt;class Iter&gt; 
144 | struct <a href=
145 | "http://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>; // Standard ref 24.1.3 Table 74
146 | 
147 | template &lt;class Iter&gt; 
148 | struct Mutable_ForwardIterator;
149 | 
150 | template &lt;class Iter&gt; 
151 | struct <a href=
152 | "http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>; // Standard ref 24.1.4 Table 75
153 | 
154 | template &lt;class Iter&gt; 
155 | struct Mutable_BidirectionalIterator;
156 | 
157 | template &lt;class Iter&gt; 
158 | struct <a href=
159 | "http://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>; // Standard ref 24.1.5 Table 76
160 | 
161 | template &lt;class Iter&gt; 
162 | struct Mutable_RandomAccessIterator;
163 | </pre>
164 | 
165 |   <h3><a name="function-object-concepts" id=
166 |   "function-object-concepts">Function Object Concept Checking
167 |   Classes</a></h3>
168 |   <pre>
169 | #include "boost/concept_check.hpp"
170 | 
171 | template &lt;class Func, class Return&gt;
172 | struct <a href="http://www.boost.org/sgi/stl/Generator.html">Generator</a>;
173 | 
174 | template &lt;class Func, class Return, class Arg&gt;
175 | struct <a href=
176 | "http://www.boost.org/sgi/stl/UnaryFunction.html">UnaryFunction</a>;
177 | 
178 | template &lt;class Func, class Return, class First, class Second&gt;
179 | struct <a href=
180 | "http://www.boost.org/sgi/stl/BinaryFunction.html">BinaryFunction</a>;
181 | 
182 | template &lt;class Func, class Arg&gt;
183 | struct Unary<a href=
184 | "http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>;
185 | 
186 | template &lt;class Func, class First, class Second&gt;
187 | struct <a href=
188 | "http://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>;
189 | 
190 | template &lt;class Func, class First, class Second&gt;
191 | struct Const_BinaryPredicate;
192 | 
193 | template &lt;class Func, class Return&gt;
194 | struct <a href=
195 | "http://www.boost.org/sgi/stl/AdaptableGenerator.html">AdaptableGenerator</a>;
196 | 
197 | template &lt;class Func, class Return, class Arg&gt;
198 | struct <a href=
199 | "http://www.boost.org/sgi/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>;
200 | 
201 | template &lt;class Func, class First, class Second&gt;
202 | struct <a href=
203 | "http://www.boost.org/sgi/stl/AdaptableBinaryFunction.html">AdaptableBinaryFunction</a>;
204 | 
205 | template &lt;class Func, class Arg&gt;
206 | struct <a href=
207 | "http://www.boost.org/sgi/stl/AdaptablePredicate.html">AdaptablePredicate</a>;
208 | 
209 | template &lt;class Func, class First, class Second&gt;
210 | struct <a href=
211 | "http://www.boost.org/sgi/stl/AdaptableBinaryPredicate.html">AdaptableBinaryPredicate</a>;
212 | </pre>
213 | 
214 |   <h3><a name="container-concepts" id="container-concepts">Container Concept
215 |   Checking Classes</a></h3>
216 |   <pre>
217 | #include "boost/concept_check.hpp"
218 | 
219 | template &lt;class C&gt;
220 | struct <a href=
221 | "http://www.boost.org/sgi/stl/Container.html">Container</a>; // Standard ref 23.1 Table 65
222 | 
223 | template &lt;class C&gt;
224 | struct Mutable_Container;
225 | 
226 | template &lt;class C&gt;
227 | struct <a href=
228 | "http://www.boost.org/sgi/stl/ForwardContainer.html">ForwardContainer</a>;
229 | 
230 | template &lt;class C&gt;
231 | struct Mutable_ForwardContainer;
232 | 
233 | template &lt;class C&gt;
234 | struct <a href=
235 | "http://www.boost.org/sgi/stl/ReversibleContainer.html">ReversibleContainer</a>; // Standard ref 23.1 Table 66
236 | 
237 | template &lt;class C&gt;
238 | struct Mutable_ReversibleContainer;
239 | 
240 | template &lt;class C&gt;
241 | struct <a href=
242 | "http://www.boost.org/sgi/stl/RandomAccessContainer.html">RandomAccessContainer</a>;
243 | 
244 | template &lt;class C&gt;
245 | struct Mutable_RandomAccessContainer;
246 | 
247 | template &lt;class C&gt;
248 | struct <a href=
249 | "http://www.boost.org/sgi/stl/Sequence.html">Sequence</a>; // Standard ref 23.1.1
250 | 
251 | template &lt;class C&gt;
252 | struct <a href=
253 | "http://www.boost.org/sgi/stl/FrontInsertionSequence.html">FrontInsertionSequence</a>;
254 | 
255 | template &lt;class C&gt;
256 | struct <a href=
257 | "http://www.boost.org/sgi/stl/BackInsertionSequence.html">BackInsertionSequence</a>;
258 | 
259 | template &lt;class C&gt;
260 | struct <a href=
261 | "http://www.boost.org/sgi/stl/AssociativeContainer.html">AssociativeContainer</a>; // Standard ref 23.1.2 Table 69
262 | 
263 | template &lt;class C&gt;
264 | struct <a href=
265 | "http://www.boost.org/sgi/stl/UniqueAssociativeContainer.html">UniqueAssociativeContainer</a>;
266 | 
267 | template &lt;class C&gt;
268 | struct <a href=
269 | "http://www.boost.org/sgi/stl/MultipleAssociativeContainer.html">MultipleAssociativeContainer</a>;
270 | 
271 | template &lt;class C&gt;
272 | struct <a href=
273 | "http://www.boost.org/sgi/stl/SimpleAssociativeContainer.html">SimpleAssociativeContainer</a>;
274 | 
275 | template &lt;class C&gt;
276 | struct <a href=
277 | "http://www.boost.org/sgi/stl/PairAssociativeContainer.html">PairAssociativeContainer</a>;
278 | 
279 | template &lt;class C&gt;
280 | struct <a href=
281 | "http://www.boost.org/sgi/stl/SortedAssociativeContainer.html">SortedAssociativeContainer</a>;
282 | 
283 | template &lt;class C&gt;
284 | struct <a href=
285 | "../utility/Collection.html">Collection</a>;
286 | </pre>
287 | 
288 |   <h3><a name="basic-archetype" id="basic-archetype">Basic Archetype
289 |   Classes</a></h3>
290 |   <pre>
291 | #include "boost/concept_archetype.hpp"
292 | 
293 | template &lt;class T = int&gt;
294 | class null_archetype; // A type that models no concepts.
295 | 
296 | template &lt;class Base = null_archetype&gt;
297 | class default_constructible_archetype;
298 | 
299 | template &lt;class Base = null_archetype&gt;
300 | class assignable_archetype;
301 | 
302 | template &lt;class Base = null_archetype&gt;
303 | class copy_constructible_archetype;
304 | 
305 | template &lt;class Base = null_archetype&gt;
306 | class equality_comparable_archetype;
307 | 
308 | template &lt;class T, class Base = null_archetype&gt;
309 | class convertible_to_archetype;
310 | </pre>
311 | 
312 |   <h3><a name="iterator-archetype" id="iterator-archetype">Iterator Archetype
313 |   Classes</a></h3>
314 |   <pre>
315 | #include "boost/concept_archetype.hpp"
316 | 
317 | template &lt;class ValueType&gt;
318 | class trivial_iterator_archetype;
319 | 
320 | template &lt;class ValueType&gt;
321 | class mutable_trivial_iterator_archetype;
322 | 
323 | template &lt;class ValueType&gt;
324 | class input_iterator_archetype;
325 | 
326 | template &lt;class ValueType&gt;
327 | class forward_iterator_archetype;
328 | 
329 | template &lt;class ValueType&gt;
330 | class bidirectional_iterator_archetype;
331 | 
332 | template &lt;class ValueType&gt;
333 | class random_access_iterator_archetype;
334 | </pre>
335 | 
336 |   <h3><a name="function-object-archetype" id=
337 |   "function-object-archetype">Function Object Archetype Classes</a></h3>
338 |   <pre>
339 | #include "boost/concept_archetype.hpp"
340 | 
341 | template &lt;class Arg, class Return&gt;
342 | class unary_function_archetype;
343 | 
344 | template &lt;class Arg1, class Arg2, class Return&gt;
345 | class binary_function_archetype;
346 | 
347 | template &lt;class Arg&gt;
348 | class predicate_archetype;
349 | 
350 | template &lt;class Arg1, class Arg2&gt;
351 | class binary_predicate_archetype;
352 | </pre>
353 | 
354 |   <h3><a name="container-archetype" id="container-archetype">Container
355 |   Archetype Classes</a></h3>
356 |   <pre>
357 | UNDER CONSTRUCTION
358 | </pre>
359 | 
360 |   <h3><a name="deprecated-functions" id="deprecated-functions">Deprecated
361 |   Functions</a></h3>
362 |   <pre>
363 | #include "boost/concept_check.hpp"
364 | 
365 | template &lt;class Concept&gt;
366 | void function_requires();
367 | </pre>
368 | 
369 |   <p><code>function_requires()</code> has been deprecated in favor of <code>BOOST_CONCEPT_ASSERT</code>.
370 |    This means that <del><code>function_requires< Concept<Type> >();</code></del>
371 |    becomes <code>BOOST_CONCEPT_ASSERT((Concept<Type>));</code>
372 |    (don't forget to <code>#include &quot;boost/concept/assert.hpp&quot;</code>).
373 | 
374 | 
375 |   <h3><a name="deprecated-macros" id="deprecated-macros">Deprecated
376 |   Macros</a></h3>
377 |   <pre>
378 | #include "boost/concept_check.hpp"
379 | 
380 | // Apply concept checks in class definitions.
381 | BOOST_CLASS_REQUIRE(<i>type</i>, <i>namespace-of-concept</i>, <i>concept</i>);
382 | BOOST_CLASS_REQUIRE2(<i>type1</i>, <i>type2</i>, <i>namespace-of-concept</i>, <i>concept</i>);
383 | BOOST_CLASS_REQUIRE3(<i>type1</i>, <i>type2</i>, <i>type3</i>, <i>namespace-of-concept</i>, <i>concept</i>);
384 | BOOST_CLASS_REQUIRE4(<i>type1</i>, <i>type2</i>, <i>type3</i>, <i>type4</i>, <i>namespace-of-concept</i>, <i>concept</i>);
385 | 
386 | // Apply concept checks in class definitions.
387 | BOOST_CLASS_REQUIRES(<i>type</i>, <i>concept</i>);
388 | BOOST_CLASS_REQUIRES2(<i>type1</i>, <i>type2</i>, <i>concept</i>);
389 | BOOST_CLASS_REQUIRES3(<i>type1</i>, <i>type2</i>, <i>type3</i>, <i>concept</i>);
390 | BOOST_CLASS_REQUIRES4(<i>type1</i>, <i>type2</i>, <i>type3</i>, <i>type4</i>, <i>concept</i>);
391 | </pre>
392 | 
393 |   <h3><a name="deprecated-concept-checking-classes" id=
394 |   "deprecated-concept-checking-classes">Deprecated Concept Checking
395 |   Classes</a></h3>
396 | 
397 |   <p>For each of the concepts documented here, the library includes an
398 |   identical concept checking class whose name ends in
399 |   “<code>Concept</code>” For example, in
400 |   addition to <code>RandomAccessIterator</code>, the library defines a
401 |   <code>RandomAccessIteratorConcept</code> class template.</p>
402 | 
403 |   <p><a href="./concept_check.htm">Back to Introduction</a><br />
404 |   <a href="./implementation.htm">Prev: Implementation</a><br /></p>
405 |   <hr />
406 | 
407 |   <table>
408 |     <tr valign="top">
409 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
410 | 
411 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
412 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
413 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>), 2007
414 |       <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.</td>
415 |     </tr>
416 |   </table>
417 | </body>
418 | </html>
419 | 


--------------------------------------------------------------------------------
/test/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | # Copyright David Abrahams, Jeremy Siek, Vladimir Prus
 2 | # 2006. Distributed under the Boost Software License, Version
 3 | # 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 4 | # http://www.boost.org/LICENSE_1_0.txt)
 5 | import testing ;
 6 | 
 7 | project : requirements
 8 |     <library>/boost/core//boost_core
 9 |     <library>/boost/concept_check//boost_concept_check
10 |     ;
11 | 
12 | test-suite concept_check
13 |   : [ link stl_concept_covering.cpp ]
14 |     [ run stl_concept_check.cpp ]
15 |     [ run concept_check_test.cpp  ]
16 |     [ run class_concept_check_test.cpp ]
17 |     [ compile-fail concept_check_fail_expected.cpp ]
18 |     [ compile-fail class_concept_fail_expected.cpp ]
19 | 
20 |     [ run where.cpp ]
21 |     [ compile-fail where_fail.cpp ]
22 |     [ compile-fail usage_fail.cpp ]
23 | 
24 |       # Backward compatibility tests
25 |     [ run old_concept_pass.cpp ]
26 |     [ compile-fail function_requires_fail.cpp ]
27 |     [ compile-fail old_concept_function_fail.cpp ]
28 |     [ compile-fail old_concept_class_fail.cpp ]
29 |   ;
30 | 
31 | 


--------------------------------------------------------------------------------
/test/class_concept_check_test.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek 2000.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include <boost/concept_check.hpp>
 7 | 
 8 | /*
 9 | 
10 |   This file verifies that the BOOST_CLASS_REQUIRE macro of the Boost
11 |   Concept Checking Library does not cause errors when it is not suppose
12 |   to.
13 | 
14 | */
15 | 
16 | struct foo { bool operator()(int) { return true; } };
17 | struct bar { bool operator()(int, char) { return true; } };
18 | 
19 | class class_requires_test
20 | {
21 |     BOOST_CONCEPT_ASSERT((boost::EqualityComparable<int>));
22 |     typedef int* int_ptr; typedef const int* const_int_ptr;
23 |     BOOST_CONCEPT_ASSERT((boost::EqualOp<int_ptr,const_int_ptr>));
24 |     BOOST_CONCEPT_ASSERT((boost::UnaryFunction<foo,bool,int>));
25 |     BOOST_CONCEPT_ASSERT((boost::BinaryFunction<bar,bool,int,char>));
26 | };
27 | 
28 | int
29 | main()
30 | {
31 |     class_requires_test x;
32 |     boost::ignore_unused_variable_warning(x);
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/test/class_concept_fail_expected.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | //
 6 | // Change Log:
 7 | // 20 Jan 2001 - Added warning suppression (David Abrahams)
 8 | 
 9 | #include <boost/concept_check.hpp>
10 | 
11 | /*
12 | 
13 |   This file verifies that class_requires of the Boost Concept Checking
14 |   Library catches errors when it is supposed to.
15 | 
16 | */
17 | 
18 | struct foo { };
19 | 
20 | template <class T>
21 | class class_requires_test
22 | {
23 |     BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
24 | };
25 | 
26 | int
27 | main()
28 | {
29 |     class_requires_test<int> x;
30 |     (void)x; // suppress unused variable warning
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/test/cmake_test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright 2021-2024 Alexander Grund
 2 | # Distributed under the Boost Software License, Version 1.0.
 3 | # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 4 | 
 5 | cmake_minimum_required(VERSION 3.5...3.16)
 6 | 
 7 | project(cmake_subdir_test LANGUAGES CXX)
 8 | 
 9 | # Those 2 should work the same
10 | # while using find_package for the installed Boost avoids the need to manually specify dependencies
11 | if(BOOST_CI_INSTALL_TEST)
12 |     find_package(boost_concept_check REQUIRED)
13 | else()
14 |     set(BOOST_INCLUDE_LIBRARIES concept_check)
15 |     add_subdirectory(../../../.. deps/boost EXCLUDE_FROM_ALL)
16 | endif()
17 | 
18 | add_executable(main main.cpp)
19 | target_link_libraries(main Boost::concept_check)
20 | 
21 | enable_testing()
22 | add_test(NAME main COMMAND main)
23 | 


--------------------------------------------------------------------------------
/test/cmake_test/main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
 5 | # define BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
 6 | 
 7 | # include <iterator>
 8 | # include <boost/concept/requires.hpp>
 9 | # include <boost/concept_check.hpp>
10 | 
11 | namespace fake
12 | {
13 |   using namespace boost;
14 |   
15 |   template<typename RanIter>
16 |   BOOST_CONCEPT_REQUIRES(
17 |       ((Mutable_RandomAccessIterator<RanIter>))
18 |       ((LessThanComparable<typename Mutable_RandomAccessIterator<RanIter>::value_type>))
19 |     
20 |     , (void))
21 |       sort(RanIter,RanIter)
22 |   {
23 |  
24 |   }
25 | }
26 | 
27 | #endif // BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
28 | // Copyright David Abrahams 2006. Distributed under the Boost
29 | // Software License, Version 1.0. (See accompanying
30 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
31 | #include <vector>
32 | #undef NDEBUG
33 | 
34 | int main()
35 | {
36 |   std::vector<int> v;
37 |   fake::sort(v.begin(), v.end());
38 |   return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/test/concept_check_fail_expected.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifdef NDEBUG
 7 | #  undef NDEBUG
 8 | #endif
 9 | 
10 | #include <boost/concept_check.hpp>
11 | 
12 | /*
13 | 
14 |   This file verifies that BOOST_CONCEPT_ASSERT catches errors in
15 |   function context.
16 | 
17 | */
18 | 
19 | struct foo { };
20 | 
21 | int
22 | main()
23 | {
24 |     BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/test/concept_check_test.cpp:
--------------------------------------------------------------------------------
  1 | // (C) Copyright Jeremy Siek 2000.
  2 | // Distributed under the Boost Software License, Version 1.0. (See
  3 | // accompanying file LICENSE_1_0.txt or copy at
  4 | // http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #include <boost/concept_check.hpp>
  7 | #include <boost/concept_archetype.hpp>
  8 | 
  9 | /*
 10 | 
 11 |   This file verifies that function_requires() of the Boost Concept
 12 |   Checking Library does not cause errors when it is not suppose to
 13 |   and verifies that the concept archetypes meet the requirements of
 14 |   their matching concepts.
 15 | 
 16 | */
 17 | 
 18 | 
 19 | int
 20 | main()
 21 | {
 22 |   using namespace boost;
 23 | 
 24 |   //===========================================================================
 25 |   // Basic Concepts
 26 |   {
 27 |     typedef default_constructible_archetype<> foo;
 28 |     function_requires< DefaultConstructible<foo> >();
 29 |   }
 30 |   {
 31 |     typedef assignable_archetype<> foo;
 32 |     function_requires< Assignable<foo> >();
 33 |   }
 34 |   {
 35 |     typedef copy_constructible_archetype<> foo;
 36 |     function_requires< CopyConstructible<foo> >();
 37 |   }
 38 |   {
 39 |     typedef sgi_assignable_archetype<> foo;
 40 |     function_requires< SGIAssignable<foo> >();
 41 |   }
 42 |   {
 43 |     typedef copy_constructible_archetype<> foo;
 44 |     typedef convertible_to_archetype<foo> convertible_to_foo;
 45 |     function_requires< Convertible<convertible_to_foo, foo> >();
 46 |   }
 47 |   {
 48 |     function_requires< Convertible<boolean_archetype, bool> >();
 49 |   }
 50 |   {
 51 |     typedef equality_comparable_archetype<> foo;
 52 |     function_requires< EqualityComparable<foo> >();
 53 |   }
 54 |   {
 55 |     typedef less_than_comparable_archetype<> foo;
 56 |     function_requires< LessThanComparable<foo> >();
 57 |   }
 58 |   {
 59 |     typedef comparable_archetype<> foo;
 60 |     function_requires< Comparable<foo> >();
 61 |   }
 62 |   {
 63 |     typedef equal_op_first_archetype<> First;
 64 |     typedef equal_op_second_archetype<> Second;
 65 |     function_requires< EqualOp<First, Second> >();
 66 |   }
 67 |   {
 68 |     typedef not_equal_op_first_archetype<> First;
 69 |     typedef not_equal_op_second_archetype<> Second;
 70 |     function_requires< NotEqualOp<First, Second> >();
 71 |   }
 72 |   {
 73 |     typedef less_than_op_first_archetype<> First;
 74 |     typedef less_than_op_second_archetype<> Second;
 75 |     function_requires< LessThanOp<First, Second> >();
 76 |   }
 77 |   {
 78 |     typedef less_equal_op_first_archetype<> First;
 79 |     typedef less_equal_op_second_archetype<> Second;
 80 |     function_requires< LessEqualOp<First, Second> >();
 81 |   }
 82 |   {
 83 |     typedef greater_than_op_first_archetype<> First;
 84 |     typedef greater_than_op_second_archetype<> Second;
 85 |     function_requires< GreaterThanOp<First, Second> >();
 86 |   }
 87 |   {
 88 |     typedef greater_equal_op_first_archetype<> First;
 89 |     typedef greater_equal_op_second_archetype<> Second;
 90 |     function_requires< GreaterEqualOp<First, Second> >();
 91 |   }
 92 | 
 93 |   {
 94 |     typedef copy_constructible_archetype<> Return;
 95 |     typedef plus_op_first_archetype<Return> First;
 96 |     typedef plus_op_second_archetype<Return> Second;
 97 |     function_requires< PlusOp<Return, First, Second> >();
 98 |   }
 99 | 
100 |   //===========================================================================
101 |   // Function Object Concepts
102 | 
103 |   {
104 |     typedef generator_archetype<null_archetype<> > foo;
105 |     function_requires< Generator<foo, null_archetype<> > >();
106 |   }
107 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
108 |   {
109 |     function_requires< Generator< void_generator_archetype, void > >();
110 |   }
111 | #endif
112 |   {
113 |     typedef unary_function_archetype<int, int> F;
114 |     function_requires< UnaryFunction<F, int, int> >();
115 |   }
116 |   {
117 |     typedef binary_function_archetype<int, int, int> F;
118 |     function_requires< BinaryFunction<F, int, int, int> >();
119 |   }
120 |   {
121 |     typedef unary_predicate_archetype<int> F;
122 |     function_requires< UnaryPredicate<F, int> >();
123 |   }
124 |   {
125 |     typedef binary_predicate_archetype<int, int> F;
126 |     function_requires< BinaryPredicate<F, int, int> >();
127 |   }
128 | 
129 |   //===========================================================================
130 |   // Iterator Concepts
131 |   {
132 |     typedef input_iterator_archetype<null_archetype<> > Iter;
133 |     function_requires< InputIterator<Iter> >();
134 |   }
135 |   {
136 |     typedef output_iterator_archetype<int> Iter;
137 |     function_requires< OutputIterator<Iter, int> >();
138 |   }
139 |   {
140 |     typedef input_output_iterator_archetype<int> Iter;
141 |     function_requires< InputIterator<Iter> >();
142 |     function_requires< OutputIterator<Iter, int> >();
143 |   }
144 |   {
145 |     typedef forward_iterator_archetype<null_archetype<> > Iter;
146 |     function_requires< ForwardIterator<Iter> >();
147 |   }
148 |   {
149 |     typedef mutable_forward_iterator_archetype<assignable_archetype<> > Iter;
150 |     function_requires< Mutable_ForwardIterator<Iter> >();
151 |   }
152 |   {
153 |     typedef bidirectional_iterator_archetype<null_archetype<> > Iter;
154 |     function_requires< BidirectionalIterator<Iter> >();
155 |   }
156 |   {
157 |     typedef mutable_bidirectional_iterator_archetype<assignable_archetype<> > 
158 |       Iter;
159 |     function_requires< Mutable_BidirectionalIterator<Iter> >();
160 |   }
161 |   {
162 |     typedef random_access_iterator_archetype<null_archetype<> > Iter;
163 |     function_requires< RandomAccessIterator<Iter> >();
164 |   }
165 |   {
166 |     typedef mutable_random_access_iterator_archetype<assignable_archetype<> > 
167 |       Iter;
168 |     function_requires< Mutable_RandomAccessIterator<Iter> >();
169 |   }
170 | 
171 |   //===========================================================================
172 |   // Container Concepts
173 | 
174 |   // UNDER CONSTRUCTION
175 | 
176 |   return 0;
177 | }
178 | 


--------------------------------------------------------------------------------
/test/fake_sort.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
 5 | # define BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
 6 | 
 7 | # include <iterator>
 8 | # include <boost/concept/requires.hpp>
 9 | # include <boost/concept_check.hpp>
10 | 
11 | namespace fake
12 | {
13 |   using namespace boost;
14 |   
15 |   template<typename RanIter>
16 |   BOOST_CONCEPT_REQUIRES(
17 |       ((Mutable_RandomAccessIterator<RanIter>))
18 |       ((LessThanComparable<typename Mutable_RandomAccessIterator<RanIter>::value_type>))
19 |     
20 |     , (void))
21 |       sort(RanIter,RanIter)
22 |   {
23 |  
24 |   }
25 | }
26 | 
27 | #endif // BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
28 | 


--------------------------------------------------------------------------------
/test/function_requires_fail.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek 2000.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifdef NDEBUG
 7 | #  undef NDEBUG
 8 | #endif
 9 | 
10 | #include <boost/concept_check.hpp>
11 | 
12 | /*
13 | 
14 |   This file verifies that function_requires() of the Boost Concept
15 |   Checking Library catches errors when it is suppose to.
16 | 
17 | */
18 | 
19 | struct foo { };
20 | 
21 | int
22 | main()
23 | {
24 |     boost::function_requires< boost::EqualityComparable<foo> >();
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/test/old_concept_class_fail.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | //
 6 | // Change Log:
 7 | // 20 Jan 2001 - Added warning suppression (David Abrahams)
 8 | 
 9 | #include "old_concepts.hpp"
10 | 
11 | // This file verifies that concepts written the old way still catch
12 | // errors in class context.  This is not expected to work on compilers
13 | // without SFINAE support.
14 | 
15 | struct foo { };
16 | 
17 | class class_requires_test
18 | {
19 |   BOOST_CLASS_REQUIRE(foo, old, EqualityComparableConcept);
20 | };
21 | 
22 | int
23 | main()
24 | {
25 |   class_requires_test x;
26 |   (void)x; // suppress unused variable warning
27 |   return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/test/old_concept_function_fail.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek 2000.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifdef NDEBUG
 7 | #  undef NDEBUG
 8 | #endif
 9 | 
10 | #include "old_concepts.hpp"
11 | 
12 | // This file verifies that concepts written the old way still catch
13 | // errors in function context.  This is not expected to work on
14 | // compilers without SFINAE support.
15 | 
16 | struct foo { };
17 | 
18 | int
19 | main()
20 | {
21 |     boost::function_requires< old::EqualityComparableConcept<foo> >();
22 |     return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/test/old_concept_pass.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include <boost/concept_check.hpp>
 7 | #include "old_concepts.hpp"
 8 | 
 9 | // This test verifies that use of the old-style concept checking
10 | // classes still compiles (but not that it detects constraint
11 | // violations).  We check them with the old-style macros just for
12 | // completeness, since those macros stranslate into
13 | // BOOST_CONCEPT_ASSERTs.
14 | 
15 | struct foo { bool operator()(int) { return true; } };
16 | struct bar { bool operator()(int, char) { return true; } };
17 | 
18 | 
19 | class class_requires_test
20 | {
21 |   BOOST_CLASS_REQUIRE(int, old, EqualityComparableConcept);
22 |   typedef int* int_ptr; typedef const int* const_int_ptr;
23 |   BOOST_CLASS_REQUIRE2(int_ptr, const_int_ptr, old, EqualOpConcept);
24 |   BOOST_CLASS_REQUIRE3(foo, bool, int, old, UnaryFunctionConcept);
25 |   BOOST_CLASS_REQUIRE4(bar, bool, int, char, old, BinaryFunctionConcept);
26 | };
27 | 
28 | int
29 | main()
30 | {
31 |     class_requires_test x;
32 |     boost::ignore_unused_variable_warning(x);
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/test/old_concepts.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Jeremy Siek, David Abrahams 2000-2006. Distributed under
 2 | // the Boost Software License, Version 1.0. (See accompanying file
 3 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #ifndef BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
 5 | # define BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
 6 | 
 7 | #include <boost/concept_check.hpp>
 8 | 
 9 | namespace old
10 | {
11 |   template <class TT>
12 |   void require_boolean_expr(const TT& t) {
13 |     bool x = t;
14 |     boost::ignore_unused_variable_warning(x);
15 |   }
16 |   
17 |   template <class TT>
18 |   struct EqualityComparableConcept
19 |   {
20 |     void constraints() {
21 |         boost::require_boolean_expr(a == b);
22 |         boost::require_boolean_expr(a != b);
23 |     }
24 |     TT a, b;
25 |   };
26 | 
27 |   template <class Func, class Return, class Arg>
28 |   struct UnaryFunctionConcept
29 |   {
30 |     // required in case any of our template args are const-qualified:
31 |     UnaryFunctionConcept();
32 |     
33 |     void constraints() {
34 |       r = f(arg); // require operator()
35 |     }
36 |     Func f;
37 |     Arg arg;
38 |     Return r;
39 |   };
40 | 
41 |   template <class Func, class Return, class First, class Second>
42 |   struct BinaryFunctionConcept
43 |   {
44 |     void constraints() { 
45 |       r = f(first, second); // require operator()
46 |     }
47 |     Func f;
48 |     First first;
49 |     Second second;
50 |     Return r;
51 |   };
52 | 
53 | #define DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
54 |   template <class First, class Second> \
55 |   struct NAME { \
56 |     void constraints() { (void)constraints_(); } \
57 |     bool constraints_() {  \
58 |       return  a OP b; \
59 |     } \
60 |     First a; \
61 |     Second b; \
62 |   }
63 | 
64 |   DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept);
65 | }
66 | 
67 | #endif // BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
68 | 


--------------------------------------------------------------------------------
/test/stl_concept_check.cpp:
--------------------------------------------------------------------------------
 1 | // (C) Copyright Jeremy Siek 2000.
 2 | // Distributed under the Boost Software License, Version 1.0. (See
 3 | // accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | //
 7 | // This file checks to see if various standard container
 8 | // implementations live up to requirements specified in the C++
 9 | // standard. As many implementations do not live to the requirements,
10 | // it is not uncommon for this file to fail to compile. The
11 | // BOOST_HIDE_EXPECTED_ERRORS macro is provided here if you want to
12 | // see as much of this file compile as possible.
13 | //
14 | 
15 | #include <boost/concept_check.hpp>
16 | 
17 | #include <iterator>
18 | #include <set>
19 | #include <map>
20 | #include <vector>
21 | #include <list>
22 | #include <deque>
23 | #if 0
24 | #include <slist>
25 | #endif
26 | 
27 | // Define this macro if you want to hide the expected error, that is,
28 | // error in the various C++ standard library implementations.
29 | //
30 | //#define BOOST_HIDE_EXPECTED_ERRORS
31 | 
32 | int
33 | main()
34 | {
35 |   using namespace boost;
36 | 
37 | #if defined(_ITERATOR_) && defined(BOOST_HIDE_EXPECTED_ERRORS)
38 |   // VC++ STL implementation is not standard conformant and
39 |   // fails to pass these concept checks
40 | #else
41 |   typedef std::vector<int> Vector;
42 |   typedef std::deque<int> Deque;
43 |   typedef std::list<int> List;
44 | 
45 |   // VC++ missing pointer and const_pointer typedefs
46 |   function_requires< Mutable_RandomAccessContainer<Vector> >();
47 |   function_requires< BackInsertionSequence<Vector> >();
48 | 
49 | #if !(defined(__GNUC__) && defined(BOOST_HIDE_EXPECTED_ERRORS))
50 | #if !((defined(__sgi) || (defined(__DECCXX) && defined(_RWSTD_VER) && _RWSTD_VER <= 0x0203)) \
51 |   && defined(BOOST_HIDE_EXPECTED_ERRORS))
52 |   // old deque iterator missing n + iter operation
53 |   function_requires< Mutable_RandomAccessContainer<Deque> >();
54 | #endif
55 |   // warnings about signed and unsigned in old deque version
56 |   function_requires< FrontInsertionSequence<Deque> >();
57 |   function_requires< BackInsertionSequence<Deque> >();
58 | #endif
59 | 
60 |   // VC++ missing pointer and const_pointer typedefs
61 |   function_requires< Mutable_ReversibleContainer<List> >();
62 |   function_requires< FrontInsertionSequence<List> >();
63 |   function_requires< BackInsertionSequence<List> >();
64 | 
65 | #if 0
66 |   typedef BOOST_STD_EXTENSION_NAMESPACE::slist<int> SList;
67 |   function_requires< FrontInsertionSequence<SList> >();
68 | #endif
69 | 
70 |   typedef std::set<int> Set;
71 |   typedef std::multiset<int> MultiSet;
72 |   typedef std::map<int,int> Map;
73 |   typedef std::multimap<int,int> MultiMap;
74 | 
75 |   function_requires< SortedAssociativeContainer<Set> >();
76 |   function_requires< SimpleAssociativeContainer<Set> >();
77 |   function_requires< UniqueAssociativeContainer<Set> >();
78 | 
79 |   function_requires< SortedAssociativeContainer<MultiSet> >();
80 |   function_requires< SimpleAssociativeContainer<MultiSet> >();
81 |   function_requires< MultipleAssociativeContainer<MultiSet> >();
82 | 
83 |   function_requires< SortedAssociativeContainer<Map> >();
84 |   function_requires< UniqueAssociativeContainer<Map> >();
85 |   function_requires< PairAssociativeContainer<Map> >();
86 | 
87 |   function_requires< SortedAssociativeContainer<MultiMap> >();
88 |   function_requires< MultipleAssociativeContainer<MultiMap> >();
89 |   function_requires< PairAssociativeContainer<MultiMap> >();
90 | #endif
91 | 
92 |   return 0;
93 | }
94 | 


--------------------------------------------------------------------------------
/test/usage_fail.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | 
 5 | #include <boost/concept/usage.hpp>
 6 | #include <boost/core/ignore_unused.hpp>
 7 | 
 8 | template <class T>
 9 | struct StringInitializable
10 | {
11 |     typedef int associated;
12 |     BOOST_CONCEPT_USAGE(StringInitializable)
13 |     {
14 |         T x = "foo";
15 |         boost::ignore_unused(x);
16 |     }
17 | };
18 | 
19 | // Test that accessing an associated type will actually exercise usage
20 | // requirements
21 | typedef StringInitializable<int>::associated tee;
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/test/where.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #include <vector>
 5 | #undef NDEBUG
 6 | #include "fake_sort.hpp"
 7 | 
 8 | int main()
 9 | {
10 |   std::vector<int> v;
11 |   fake::sort(v.begin(), v.end());
12 |   return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/test/where_fail.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright David Abrahams 2006. Distributed under the Boost
 2 | // Software License, Version 1.0. (See accompanying
 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 4 | #include <list>
 5 | #undef NDEBUG
 6 | #include "fake_sort.hpp"
 7 | 
 8 | int main()
 9 | {
10 |   std::list<int> v;
11 |   fake::sort(v.begin(), v.end());
12 |   return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/using_concept_check.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | 
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <!-- Copyright (c) Jeremy Siek and Andrew Lumsdaine 2000 -->
  6 | <!-- Distributed under the Boost -->
  7 | <!-- Software License, Version 1.0. (See accompanying -->
  8 | <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
  9 | 
 10 | <head>
 11 |   <meta name="generator" content=
 12 |   "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />
 13 |   <meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
 14 | 
 15 |   <title>Using Concept Checks</title>
 16 |   <link rel="stylesheet" href="../../rst.css" type="text/css" />
 17 | </head>
 18 | 
 19 | <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 20 | "#FF0000">
 21 |   <img src="../../boost.png" alt="C++ Boost" width="277" height=
 22 |   "86" /><br clear="none" />
 23 | 
 24 |   <h2><a name="using-concept-checks" id="using-concept-checks">Using Concept
 25 |   Checks</a></h2>
 26 | 
 27 |   <p>For each concept there is a concept checking class template that can be
 28 |   used to make sure that a given type (or set of types) models the concept.
 29 |   The Boost Concept Checking Library (BCCL) includes concept checking class
 30 |   templates for all of the concepts used in the C++ standard library and a
 31 |   few more. See the <a href="./reference.htm">Reference</a> section for a
 32 |   complete list. In addition, other boost libraries come with concept
 33 |   checking classes for the concepts that are particular to those libraries.
 34 |   For example, there are <a href="../graph/doc/graph_concepts.html">graph
 35 |   concepts</a> and <a href="../property_map/doc/property_map.html">property map
 36 |   concepts</a>. Also, whenever <b>anyone</b> writing function templates needs
 37 |   to express requirements that are not yet stated by an existing concept, a
 38 |   new concept checking class should be created. How to do this is explained
 39 |   in <a href="./creating_concepts.htm">Creating Concept Checking
 40 |   Classes</a>.</p>
 41 | 
 42 |   <p>An example of a concept checking class from the BCCL is the
 43 |   <tt>EqualityComparableConcept</tt> class. The class corresponds to the
 44 |   EqualityComparable requirements described in 20.1.1 of the C++ Standard,
 45 |   and to the <a href=
 46 |   "http://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a>
 47 |   concept documented in the SGI STL.</p>
 48 |   <pre>
 49 | template &lt;class T&gt;
 50 | struct EqualityComparable;
 51 | </pre>
 52 | 
 53 |   <p>The template argument is the type to be checked. That is, the purpose of
 54 |   <tt>EqualityComparable&lt;<em>T</em>&gt;</tt> is to make sure that
 55 |   <tt><em>T</em></tt> models the EqualityComparable concept.</p>
 56 | 
 57 |   <h4><tt>BOOST_CONCEPT_ASSERT()</tt></h4>
 58 | 
 59 |   <p>The most versatile way of checking concept requirements is to use the
 60 |   <code>BOOST_CONCEPT_ASSERT()</code> macro. You can use this macro at any
 61 |   scope, by passing a concept checking template specialization enclosed in
 62 |   parentheses. <strong>Note:</strong> that means invocations of
 63 |   <code>BOOST_CONCEPT_ASSERT</code> will appear to use <strong>double
 64 |   parentheses</strong>.</p>
 65 |   <pre>
 66 | <font color="green">// In my library:</font>
 67 | template &lt;class T&gt;
 68 | void generic_library_function(T x)
 69 | {
 70 |   BOOST_CONCEPT_ASSERT<strong>((</strong>EqualityComparable&lt;T&gt;<strong>))</strong>;
 71 |   <font color="green">// ...</font>
 72 | };
 73 | 
 74 | template &lt;class It&gt;
 75 | class generic_library_class
 76 | {
 77 |   BOOST_CONCEPT_ASSERT<strong>((</strong>RandomAccessIterator&lt;It&gt;<strong>))</strong>;
 78 |   <font color="green">// ...</font>
 79 | };
 80 | 
 81 | <font color="green">// In the user's code:</font>  
 82 | class foo {
 83 |   <font color="green">//... </font>
 84 | };
 85 | 
 86 | int main() {
 87 |   foo x;
 88 |   generic_library_function(x);
 89 |   generic_library_class&lt;std::vector&lt;char&gt;::iterator&gt; y;
 90 |   <font color="green">//...</font> 
 91 | }
 92 | </pre>
 93 | 
 94 |   <h4><tt>BOOST_CONCEPT_REQUIRES</tt></h4>
 95 | 
 96 |   <p>One of the nice things about the proposed C++0x <a href=
 97 |   "http://www.generic-programming.org/languages/conceptcpp/tutorial">syntax
 98 |   for declaring concept constrained function templates</a> is the way that
 99 |   constraints are part of the function <em>declaration</em>, so clients will
100 |   see them. <code>BOOST_CONCEPT_ASSERT</code> can only express constraints
101 |   within the function template definition, which hides the constraint in the
102 |   function body. Aside from the loss of a self-documenting interface,
103 |   asserting conformance only in the function body can undesirably delay
104 |   checking if the function is explicitly instantiated in a different
105 |   translation unit from the one in which it is called, or if the compiler
106 |   does link-time instantiation.</p>
107 | 
108 |   <p>The <tt>BOOST_CONCEPT_REQUIRES</tt> macro can be used in a function
109 |   template declaration to check whether some type models a concept. It
110 |   accepts two arguments, a <strong>list of constraints</strong>, and the
111 |   function template's return type. The list of constraints takes the form of
112 |   a sequence of adjacent concept checking template specializations,
113 |   <strong>in double parentheses</strong>, and the function's return type must
114 |   also be parenthesized. For example, the standard <code>stable_sort</code>
115 |   algorithm might be declared as follows: </p>
116 |   <pre>
117 | template &lt;class RanIter&gt;
118 | BOOST_CONCEPT_REQUIRES(
119 |     ((Mutable_RandomAccessIterator&lt;RanIter&gt;))
120 |     ((LessThanComparable&lt;typename Mutable_RandomAccessIterator&lt;RanIter&gt;::value_type&gt;)),
121 |     (void)) <font color="green">// return type</font>
122 |     stable_sort(RanIter,RanIter);
123 | </pre>
124 | 
125 |   <p>Note that the algorithm requires that the value type of the iterator be
126 |   LessThanComparable, and it accesses that value type through the
127 |   <code>Mutable_RandomAccessIterator</code> concept checking template. In
128 |   general, the Boost concept checking classes expose associated types as
129 |   nested member typedefs so that you can use this syntax, which mimics the
130 |   approach used in the concept support proposed for the next version of
131 |   C++.</p>
132 | 
133 |   <h4>Multi-Type Concepts</h4>
134 | 
135 |   <p>Some concepts deal with more than one type. In this case the
136 |   corresponding concept checking class will have multiple template
137 |   parameters. The following example shows how <tt>BOOST_CONCEPT_REQUIRES</tt>
138 |   is used with the <a href=
139 |   "../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>
140 |   concept, which takes two type parameters: a property map and the key type
141 |   for the map.</p>
142 |   <pre>
143 | template &lt;class G, class Buffer, class BFSVisitor, 
144 |           class ColorMap&gt;
145 | BOOST_CONCEPT_REQUIRES(
146 |   ((ReadWritePropertyMap&lt;ColorMap, typename IncidenceGraph&lt;G&gt;::vertex_descriptor&gt;)),
147 |   (void)) <font color="green">// return type</font>
148 | breadth_first_search(G&amp; g, 
149 |   typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
150 |   Buffer&amp; Q, BFSVisitor vis, ColorMap color)
151 | {
152 |   typedef typename IncidenceGraph&lt;G&gt;::vertex_descriptor Vertex;
153 |   ...
154 | }
155 | </pre>
156 | 
157 |   <p>Although concept checks are designed for use by generic library
158 |   implementors, they can also be useful to end users. Sometimes one may not
159 |   be sure whether some type models a particular concept. The syntactic
160 |   requirements, at least, can easily be checked by creating a small program
161 |   and using <tt>BOOST_CONCEPT_ASSERT</tt> with the type and concept in
162 |   question. For example:</p>
163 |   <pre>
164 | <font color=
165 | "green">// Make sure list&lt;int&gt; has bidirectional iterators.</font>
166 | BOOST_CONCEPT_ASSERT((BidirectionalIterator&lt;std::list&lt;int&gt;::iterator&gt;));
167 | </pre>
168 | 
169 |   <p><a href="./concept_check.htm">Prev: Concept Checking
170 |   Introduction</a><br />
171 |   <a href="./creating_concepts.htm">Next: Creating Concept Checking
172 |   Classes</a><br /></p>
173 |   <hr />
174 | 
175 |   <table>
176 |     <tr valign="top">
177 |       <td nowrap="nowrap">Copyright &copy; 2000</td>
178 | 
179 |       <td><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>(<a href=
180 |       "mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a>) Andrew
181 |       Lumsdaine(<a href="mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>), 2007
182 |       <a href="mailto:dave@boost-consulting.com">David Abrahams</a>.</td>
183 |     </tr>
184 |   </table>
185 | </body>
186 | </html>
187 | 


--------------------------------------------------------------------------------