cleaning master to prep for release tags
This commit is contained in:
Lorenzo Caminiti
parent
7c48d78c92
commit
914e7bdcec
@ -1,4 +0,0 @@
|
||||
Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
See: https://lcaminiti.github.io/boost-contract
|
||||
110
Jamroot
110
Jamroot
@ -1,110 +0,0 @@
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
|
||||
|
||||
import build/boost_contract_no ;
|
||||
import testing ;
|
||||
import os ;
|
||||
import feature ;
|
||||
|
||||
BOOST_ROOT = [ os.environ BOOST_ROOT ] ;
|
||||
if ! $(BOOST_ROOT) {
|
||||
exit "Error: set BOOST_ROOT environment variable to Boost root directory" ;
|
||||
}
|
||||
|
||||
rule help_exit ( targets * : sources * : properties * ) {
|
||||
all_nos = "" ;
|
||||
sep = "" ;
|
||||
for local cond in [ boost_contract_no.conds ] {
|
||||
all_nos = "$(all_nos)$(sep)$(cond)" ;
|
||||
sep = "," ;
|
||||
}
|
||||
echo "
|
||||
Usage: bjam [OPTION]... DIR[-CPP_FILE_NAME]
|
||||
Build and run Boost.Contract tests and examples.
|
||||
Using Boost libraries from environment variable: $BOOST_ROOT = $(BOOST_ROOT)
|
||||
|
||||
Options:
|
||||
boost_contract_link=shared, build Boost.Contract library as shared,
|
||||
static,header static, or header-only (shared by default)
|
||||
boost_contract_no=all_yes, contract checking off (all_yea by default)
|
||||
$(all_nos)
|
||||
|
||||
Examples (on Linux-based bash):
|
||||
Build just \"test/public_function/body_throw.cpp\":
|
||||
[test]$ bjam public_function-body_throw
|
||||
Build all targets using MSVC, GCC, and CLang compilers:
|
||||
$ time bjam -q toolset=msvc,gcc,clang ; echo $?
|
||||
Build with all linkages on multiple compilers:
|
||||
$ time bjam -q toolset=msvc,gcc,clang boost_contract_link=static,header ; echo $?
|
||||
Build with all contract checking combinations on multiple compilers:
|
||||
$ time bjam -q toolset=msvc,gcc,clang boost_contract_no=$(all_nos) ; echo $?
|
||||
" ;
|
||||
exit ;
|
||||
}
|
||||
|
||||
project :
|
||||
requirements
|
||||
<toolset>gcc:<cxxflags>-std=c++11
|
||||
<toolset>clang:<cxxflags>-std=c++11
|
||||
|
||||
<include>"./include"
|
||||
|
||||
<include>$(BOOST_ROOT)
|
||||
<library-path>$(BOOST_ROOT)/stage/lib
|
||||
<toolset>gcc:<library>/boost/system//boost_system
|
||||
<toolset>clang:<library>/boost/system//boost_system
|
||||
;
|
||||
use-project boost : $(BOOST_ROOT) ;
|
||||
|
||||
rule subdir-compile-fail ( subdir : cpp_fname : requirements * ) {
|
||||
compile-fail $(subdir)/$(cpp_fname).cpp :
|
||||
<link>shared:<library>../build//boost_contract
|
||||
<link>static:<library>../build//boost_contract
|
||||
<include>$(subdir)
|
||||
$(requirements)
|
||||
:
|
||||
$(subdir)-$(cpp_fname)
|
||||
;
|
||||
}
|
||||
|
||||
rule subdir-run ( subdir : cpp_fname : requirements * ) {
|
||||
run $(subdir)/$(cpp_fname).cpp : : :
|
||||
<link>shared:<library>../build//boost_contract
|
||||
<link>static:<library>../build//boost_contract
|
||||
<include>$(subdir)
|
||||
$(requirements)
|
||||
:
|
||||
$(subdir)-$(cpp_fname)
|
||||
;
|
||||
}
|
||||
|
||||
rule subdir-lib ( subdir : cpp_fname : requirements * ) {
|
||||
lib $(subdir)-$(cpp_fname) : $(subdir)/$(cpp_fname).cpp :
|
||||
<link>shared:<library>../build//boost_contract
|
||||
<link>static:<library>../build//boost_contract
|
||||
<include>$(subdir)
|
||||
$(requirements)
|
||||
;
|
||||
}
|
||||
|
||||
feature.feature boost_contract_link : shared static header :
|
||||
composite propagated link-incompatible ;
|
||||
feature.compose <boost_contract_link>shared : <link>shared ;
|
||||
feature.compose <boost_contract_link>static :
|
||||
<link>static
|
||||
<define>BOOST_CONTRACT_STATIC_LINK
|
||||
;
|
||||
feature.compose <boost_contract_link>header :
|
||||
<define>BOOST_CONTRACT_HEADER_ONLY
|
||||
;
|
||||
|
||||
feature.feature boost_contract_no : all_yes [ boost_contract_no.conds ] :
|
||||
composite propagated link-incompatible ;
|
||||
for local cond in [ boost_contract_no.conds ] {
|
||||
feature.compose <boost_contract_no>$(cond) :
|
||||
[ boost_contract_no.defs_$(cond) ] ;
|
||||
}
|
||||
|
||||
@ -1,23 +0,0 @@
|
||||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
Permission is hereby granted, free of charge, to any person or organization
|
||||
obtaining a copy of the software and accompanying documentation covered by
|
||||
this license (the "Software") to use, reproduce, display, distribute,
|
||||
execute, and transmit the Software, and to prepare derivative works of the
|
||||
Software, and to permit third-parties to whom the Software is furnished to
|
||||
do so, all subject to the following:
|
||||
|
||||
The copyright notices in the Software and this entire statement, including
|
||||
the above license grant, this restriction and the following disclaimer,
|
||||
must be included in all copies of the Software, in whole or in part, and
|
||||
all derivative works of the Software, unless such copies or derivative
|
||||
works are solely in the form of machine-executable object code generated by
|
||||
a source language processor.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
19
README.txt
19
README.txt
@ -1,19 +0,0 @@
|
||||
Boost.Contract (see: https://lcaminiti.github.io/boost-contract)
|
||||
|
||||
A library implementing Contract Programming (a.k.a., Design by Contract or DbC)
|
||||
for the C++ programming language.
|
||||
|
||||
All Contract Programming features are supported by this library: subcontracting,
|
||||
class invariants (also static and volatile), postconditions (with old and return
|
||||
values), preconditions, customizable actions on assertion failure (terminate,
|
||||
throw, etc.), optional compilation of assertion and checking, disable assertions
|
||||
while already checking other assertions (to avoid infinite recursion), etc.
|
||||
|
||||
NOTE: In one of its previous versions, this library passed Boost formal review
|
||||
and it was accepted into the Boost libraries. However, the authors have not had
|
||||
time yet to add this library to an official Boost release (see:
|
||||
https://groups.google.com/forum/?fromgroups=#!topic/boost-list/jQ7OjAmos_Y).
|
||||
|
||||
Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
@ -1,10 +0,0 @@
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
|
||||
|
||||
lib boost_contract : ../src/contract.cpp : <boost_contract_link>shared ;
|
||||
lib boost_contract : ../src/contract.cpp : <boost_contract_link>static ;
|
||||
# Build nothing for boost_contract_link=header (ignore errors Bjam gives).
|
||||
|
||||
@ -1,141 +0,0 @@
|
||||
|
||||
# Generated file `python boost_contract_no.jam-gen.py > boost_contract_no.jam`.
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: https://lcaminiti.github.io/boost-contract
|
||||
|
||||
module boost_contract_no {
|
||||
|
||||
rule defs_entryinv { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS ; }
|
||||
|
||||
rule defs_pre { return <define>BOOST_CONTRACT_NO_PRECONDITIONS ; }
|
||||
|
||||
rule defs_exitinv { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS ; }
|
||||
|
||||
rule defs_post { return <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_except { return <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_check { return <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS ; }
|
||||
|
||||
rule defs_entryinv_exitinv { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS ; }
|
||||
|
||||
rule defs_entryinv_post { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_entryinv_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_exitinv { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS ; }
|
||||
|
||||
rule defs_pre_post { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_pre_except { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_pre_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_exitinv_post { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_exitinv_except { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_exitinv_check { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_post_except { return <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_post_check { return <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_except_check { return <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS ; }
|
||||
|
||||
rule defs_entryinv_pre_post { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_entryinv_pre_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_pre_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_post { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_post_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_post_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_exitinv_post { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_pre_exitinv_except { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_pre_exitinv_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_post_except { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_pre_post_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_except_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_exitinv_post_except { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_exitinv_post_check { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_exitinv_except_check { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_post_except_check { return <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_post { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_post_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_pre_post_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_post_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_post_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_post_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_exitinv_post_except { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_pre_exitinv_post_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_exitinv_except_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_post_except_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_exitinv_post_except_check { return <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_post_except { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_post_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_post_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_exitinv_post_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_pre_exitinv_post_except_check { return <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
rule defs_entryinv_pre_exitinv_post_except_check { return <define>BOOST_CONTRACT_NO_ENTRY_INVARIANTS <define>BOOST_CONTRACT_NO_PRECONDITIONS <define>BOOST_CONTRACT_NO_EXIT_INVARIANTS <define>BOOST_CONTRACT_NO_POSTCONDITIONS <define>BOOST_CONTRACT_NO_EXCEPTS <define>BOOST_CONTRACT_NO_CHECKS ; }
|
||||
|
||||
|
||||
rule conds { return entryinv pre exitinv post except check entryinv_pre entryinv_exitinv entryinv_post entryinv_except entryinv_check pre_exitinv pre_post pre_except pre_check exitinv_post exitinv_except exitinv_check post_except post_check except_check entryinv_pre_exitinv entryinv_pre_post entryinv_pre_except entryinv_pre_check entryinv_exitinv_post entryinv_exitinv_except entryinv_exitinv_check entryinv_post_except entryinv_post_check entryinv_except_check pre_exitinv_post pre_exitinv_except pre_exitinv_check pre_post_except pre_post_check pre_except_check exitinv_post_except exitinv_post_check exitinv_except_check post_except_check entryinv_pre_exitinv_post entryinv_pre_exitinv_except entryinv_pre_exitinv_check entryinv_pre_post_except entryinv_pre_post_check entryinv_pre_except_check entryinv_exitinv_post_except entryinv_exitinv_post_check entryinv_exitinv_except_check entryinv_post_except_check pre_exitinv_post_except pre_exitinv_post_check pre_exitinv_except_check pre_post_except_check exitinv_post_except_check entryinv_pre_exitinv_post_except entryinv_pre_exitinv_post_check entryinv_pre_exitinv_except_check entryinv_pre_post_except_check entryinv_exitinv_post_except_check pre_exitinv_post_except_check entryinv_pre_exitinv_post_except_check ; }
|
||||
|
||||
} # module
|
||||
|
||||
@ -1,41 +0,0 @@
|
||||
|
||||
print '''
|
||||
# Generated file `python boost_contract_no.jam-gen.py > boost_contract_no.jam`.
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: https://lcaminiti.github.io/boost-contract
|
||||
'''
|
||||
|
||||
# NOTE: Other macros symbols can be added here as needed.
|
||||
conds = ['entryinv', 'pre', 'exitinv', 'post', 'except', 'check']
|
||||
defs = {
|
||||
'entryinv': 'BOOST_CONTRACT_NO_ENTRY_INVARIANTS',
|
||||
'pre': 'BOOST_CONTRACT_NO_PRECONDITIONS',
|
||||
'exitinv': 'BOOST_CONTRACT_NO_EXIT_INVARIANTS',
|
||||
'post': 'BOOST_CONTRACT_NO_POSTCONDITIONS',
|
||||
'except': 'BOOST_CONTRACT_NO_EXCEPTS',
|
||||
'check': 'BOOST_CONTRACT_NO_CHECKS'
|
||||
}
|
||||
|
||||
import itertools
|
||||
print 'module boost_contract_no {\n'
|
||||
s = ''
|
||||
for r in range(len(conds)):
|
||||
for comb in itertools.combinations(conds, r + 1):
|
||||
c = ''
|
||||
d = ''
|
||||
sep = ''
|
||||
for cond in comb:
|
||||
c += sep + cond
|
||||
sep = '_'
|
||||
d += " <define>" + defs[cond]
|
||||
s += ' ' + c
|
||||
print 'rule defs_{0} {{ return {1} ; }}\n'.format(c, d)
|
||||
print '''
|
||||
rule conds {{ return {0} ; }}
|
||||
|
||||
}} # module
|
||||
'''.format(s)
|
||||
|
||||
@ -1,63 +0,0 @@
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
|
||||
|
||||
import quickbook ;
|
||||
using boostbook ;
|
||||
|
||||
doxygen reference
|
||||
:
|
||||
../include/boost/contract.hpp
|
||||
../include/boost/contract_macro.hpp
|
||||
|
||||
../include/boost/contract/assert.hpp
|
||||
../include/boost/contract/base_types.hpp
|
||||
../include/boost/contract/call_if.hpp
|
||||
../include/boost/contract/check.hpp
|
||||
../include/boost/contract/constructor.hpp
|
||||
../include/boost/contract/destructor.hpp
|
||||
../include/boost/contract/function.hpp
|
||||
../include/boost/contract/old.hpp
|
||||
../include/boost/contract/override.hpp
|
||||
../include/boost/contract/public_function.hpp
|
||||
|
||||
../include/boost/contract/core/access.hpp
|
||||
../include/boost/contract/core/check_macro.hpp
|
||||
../include/boost/contract/core/config.hpp
|
||||
../include/boost/contract/core/constructor_precondition.hpp
|
||||
../include/boost/contract/core/exception.hpp
|
||||
../include/boost/contract/core/specify.hpp
|
||||
../include/boost/contract/core/virtual.hpp
|
||||
:
|
||||
<reftitle>"Reference"
|
||||
# Quickbook's Doxygen does not show destructor exception specs.
|
||||
<doxygen:param>PREDEFINED="BOOST_CONTRACT_DETAIL_DOXYGEN BOOST_PP_VARIADICS"
|
||||
<doxygen:param>MACRO_EXPANSION=YES
|
||||
<doxygen:param>INCLUDE_PATH="../include"
|
||||
<doxygen:param>QUIET=YES
|
||||
<doxygen:param>JAVADOC_AUTOBRIEF=YES
|
||||
<doxygen:param>WARN_IF_UNDOCUMENTED=NO
|
||||
<doxygen:param>EXCLUDE_SYMBOLS=std
|
||||
# Following does not work for XML output... use @cond and/or
|
||||
# #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN in code instead.
|
||||
<doxygen:param>EXTRACT_PRIVATE=NO
|
||||
<doxygen:param>HIDE_UNDOC_MEMBERS=YES
|
||||
<doxygen:param>HIDE_UNDOC_CLASSES=YES
|
||||
<doxygen:param>SHORT_NAMES=NO
|
||||
<doxygen:param>ALIASES=" RefSect{2}=\"\\xmlonly<link linkend='boost_contract.\\1'>\\2</link>\\endxmlonly\" RefClass{1}=\"\\xmlonly<computeroutput><classname alt='\\1'>\\1</classname></computeroutput>\\endxmlonly\" RefFunc{1}=\"\\xmlonly<computeroutput><functionname alt='\\1'>\\1</functionname></computeroutput>\\endxmlonly\" RefMacro{1}=\"\\xmlonly<computeroutput><macroname alt='\\1'>\\1</macroname></computeroutput>\\endxmlonly\" RefEnum{1}=\"\\xmlonly<computeroutput><enumname alt='\\1'>\\1</enumname></computeroutput>\\endxmlonly\" "
|
||||
;
|
||||
|
||||
xml contract : main.qbk : <dependency>reference ;
|
||||
|
||||
boostbook doc : contract
|
||||
:
|
||||
<location>html
|
||||
<xsl:param>boost.defaults=Boost
|
||||
<xsl:param>boost.root=../../
|
||||
<xsl:param>admon.graphics.path=../../doc/src/images/
|
||||
<xsl:param>html.stylesheet=../../doc/src/boostbook.css
|
||||
<xsl:param>toc.max.depth=1
|
||||
;
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Acknowledgments]
|
||||
|
||||
This section aims to recognize the contributions of all the different people that participated directly or indirectly to the design and development of this library.
|
||||
|
||||
Sincere thanks to my parents for their support with my education and my studies in computer science.
|
||||
|
||||
Many thanks to Andrzej Krzemienski for reviewing early versions of this library providing valuable insights and exchanging early ideas on assertion requirements.
|
||||
|
||||
Many thanks to Vicente J. Botet Escriba for reviewing earlier versions of this library providing valuable insights and for suggesting to use a dedicated trait to copy old values.
|
||||
|
||||
Thanks to Steven Watanabe for providing valuable insights on C++, SFINAE, and introspection.
|
||||
|
||||
Thanks to Dave Abrahams for moderating the Boost review of this library.
|
||||
|
||||
Thanks to David Maley for sharing source code form his inspiring work on emulating Contract Programming and subcontracting in C++ in __Maley99__.
|
||||
|
||||
Many thanks to Thorsten Ottosen for his work on the __N1962__ proposal (and its previous revisions) and for clarifying the proposal requirements directly with the library authors when needed.
|
||||
|
||||
Many thanks to Bertrand Meyer for his pioneering and thorough work on Contract Programming in __Meyer97__.
|
||||
|
||||
Finally, many thanks to the entire Boost community and [@http://lists.boost.org mailing list] for providing valuable comments on this library and great insights on the C++ programming language.
|
||||
|
||||
[endsect]
|
||||
|
||||
484
doc/advanced.qbk
484
doc/advanced.qbk
@ -1,484 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Advanced]
|
||||
|
||||
This section is a guide to advanced usages of this library.
|
||||
|
||||
[section Pure Virtual Public Functions]
|
||||
|
||||
In C++, pure virtual functions are allowed to have a /default implementation/ as long as such implementation is programmed out-of-line so defined outside the class declaring the pure virtual function `virtual ... = 0;`.
|
||||
|
||||
Contracts for pure virtual public functions are programmed using the [funcref boost::contract::public_function] function like for (non-pure) virtual public functions (all consideration made in __Virtual_Public_Functions__ apply).
|
||||
However, contracts have to be programmed out-of-line, in the default implementation of the pure virtual function.
|
||||
For example (see [@../../example/features/pure_virtual_public.cpp =pure_virtual_public.cpp=]):
|
||||
|
||||
[import ../example/features/pure_virtual_public.cpp]
|
||||
[pure_virtual_public_base_begin]
|
||||
[pure_virtual_public_base_end]
|
||||
[pure_virtual_public_base_impl]
|
||||
|
||||
This library will never actually execute the pure virtual function body while it is calling the pure virtual function default implementation to check contracts for subcontracting.
|
||||
Therefore, programmers can safely `assert(false)` at the beginning of the body if they intend for that body to never be executed (or they can program a working body in case they need to use C++ pure virtual function default implementation as usual with C++).
|
||||
|
||||
[heading Subcontracting Preconditions Always True/False]
|
||||
|
||||
As seen in __Public_Function_Overrides__, preconditions of overriding public functions are checked in __OR__ with preconditions of overridden virtual public functions.
|
||||
Therefore, if a virtual public function in a base class specifies no precondition then preconditions specified by all its overriding functions in derived classes will have no effect (because when checked in __OR__ with the overridden function from the base class that has no preconditions, they will always pass).
|
||||
This correctly reflects the fact that the overridden function in the base class can be called from any context (because it has no precondition) and so must all its overriding functions in all derived classes in accordance to the __substitution_principle__.
|
||||
This is equivalent to declare the virtual public function in a base class with a single precondition `BOOST_CONTRACT_ASSERT(true)` that will always pass:
|
||||
|
||||
// In a virtual public function of a base class.
|
||||
boost::contract::check c = boost::contract::public_function(v, this)
|
||||
.precondition([&] {
|
||||
BOOST_CONTRACT_ASSERT(true); // Prevent preconditions of overrides.
|
||||
})
|
||||
...
|
||||
;
|
||||
|
||||
On the flip side, programmers might sometimes consider to declare a pure virtual public function in a base class with a single precondition `BOOST_CONTRACT_ASSERT(false)` that will always fail.
|
||||
This indicates that the pure virtual public function can never be called unless it is redefined by a derived class (which is actually the case with C++ pure virtual functions) and also that the base class designers have intentionally left it up to derived classes to specify preconditions for the pure virtual function in question.
|
||||
This technique might make sense only for preconditions of pure virtual public functions (otherwise `BOOST_CONTRACT_ASSERT(false)` will prevent calling virtual public functions in concrete bases).
|
||||
For example (see [@../../example/features/named_override.cpp =named_override.cpp=]):
|
||||
|
||||
[import ../example/features/named_override.cpp]
|
||||
[named_override_pure_virtual_assert_false]
|
||||
|
||||
That said, the need to declare such a precondition `BOOST_CONTRACT_ASSERT(false)` that will always fail might be an indication that the base class interface is not correctly designed.
|
||||
In general, the base class interface should still contain all functions (eventually as pure virtual) that are necessary to program its contracts.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Optional Return Value]
|
||||
|
||||
It is possible to use `boost::optional` to handle return values when programmers cannot construct the result variable at its point of declaration before the contract (e.g., because an appropriate constructor for the return type is not available at that point, or just because it would be too expensive to execute an extra initialization of the return value at run-time).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
`boost::optional` is used instead of `std::optional` because `std::optional` is not part of C++ standards prior to C++17.
|
||||
]
|
||||
For example (see [@../../example/features/optional_result.cpp =optional_result.cpp=]):
|
||||
|
||||
[import ../example/features/optional_result.cpp]
|
||||
[optional_result]
|
||||
|
||||
In this example the return type is a reference so it does not have default constructor that can be used to initialize `result` when it is declared before the contract declaration.
|
||||
In addition, `Index` needs to be validated to be smaller than `size()` by the precondition before it can be used to retrieve the reference to be assigned to `result` so `vect[Index]` cannot be used to initialize `result` when it is declared before the contract declaration.
|
||||
Therefore, `boost::optional` is used to defer `result` proper initialization until the execution of the function body after the contract declaration when `Index` has been validated by the precondition and `vect[Index]` can be safely evaluated to initialize `result`.
|
||||
|
||||
As seen in __Return_Value__, it is the responsibility of the programmers to ensure that `result` is always set to the return value (when the function exits without trowing an exception).
|
||||
This also ensures that `result` is always set before the postconditions are checked so programmers can always dereference `result` in postconditions to access the return value (using `operator*` and `operator->` as usual with `boost::optional`, and without having to explicitly check if `result` is an empty `boost::optional` object or not).
|
||||
This can be easily done by making sure that /all/ return statements in the function are of the form:
|
||||
|
||||
boost::optional<...> result;
|
||||
...
|
||||
return *(result = ...); // Assign `result` at each return.
|
||||
|
||||
[heading Optional Results in Virtual Public Functions]
|
||||
|
||||
Similarly, `boost::optional` can be used to handle the return value passed to contracts of virtual public functions (pure or not) and of public function overrides.
|
||||
As seen in __Pure_Virtual_Public_Functions__, __Virtual_Public_Functions__, and __Public_Function_Overrides__, in these cases the return value `result` must be passed as a parameter to [funcref boost::contract::public_function] right after the parameter `v` of type [classref boost::contract::virtual_]`*`.
|
||||
Then the functor passed to `.postcondition(...)` takes one single parameter of type `boost::optional<`[^['result-type]]` const&> const&`.
|
||||
For example (see [@../../example/features/optional_result_virtual.cpp =optional_result_virtual.cpp=]):
|
||||
|
||||
[import ../example/features/optional_result_virtual.cpp]
|
||||
[optional_result_virtual]
|
||||
|
||||
The inner `const&` in the postcondition functor parameter type `boost::optional<... const&> ...` is mandatory (while the outer `const&` in the postcondition functor parameter type `boost::optional<...> const&` is not).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
This library requires the postcondition functor parameter to be of type `boost::optional<... const&>` so the return value does not have to be copied (because of `&`) while postconditions are still not allowed to change its value (because of `const`, see __Constant_Correctness__).
|
||||
In addition, programmers are encouraged to declare the postcondition functor to take its argument also as a constant reference `boost::optional<... const&> const&` to avoid possibly expensive copies of the `boost::optional` type.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Private and Protected Functions]
|
||||
|
||||
Private and protected functions do not check class invariants (because they are not part of the public class interface) and they do not subcontract (because they are not accessible at the calling site where the __substitution_principle__ applies, see __Function_Calls__).
|
||||
However, programmers may still want to specify preconditions and postconditions for private and protected functions when they want to check correctness of their implementation and usage from within the class, base classes, and friend classes or functions.
|
||||
When programmers decide to specify contracts for private and protected functions, they shall use [funcref boost::contract::function] (like for non-member functions).
|
||||
For example (see [@../../example/features/private_protected.cpp =private_protected.cpp=]):
|
||||
|
||||
[import ../example/features/private_protected.cpp]
|
||||
[private_protected]
|
||||
|
||||
Considerations made in __Non_Member_Functions__ apply to private and protected functions as well.
|
||||
|
||||
See __Constructors__ and __Destructors__ on how to program contracts for private and protected constructors and destructors instead.
|
||||
|
||||
[heading Virtual Private and Protected Functions]
|
||||
|
||||
When private and protected functions are virtual they should still declare the extra virtual parameter of type [classref boost::contract::virtual_]`*` with default value `0` (see __Virtual_Public_Functions__) even if that parameter does not have to be passed to [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::function] takes no argument (so the extra virtual parameter will remain unused and it does not need a name).
|
||||
[footnote
|
||||
Technically, the extra virtual parameter can still be passed to [macroref BOOST_CONTRACT_OLDOF] but that is not necessary and it has no effect so it is not done in this documentation.
|
||||
]
|
||||
That is necessary otherwise the private and protected virtual functions cannot be overridden by public functions in derived classes that specify contracts (because the [classref boost::contract::virtual_]`* = 0` parameter has to be part of signatures for public function overrides).
|
||||
For example (see [@../../example/features/private_protected_virtual.cpp =private_protected_virtual.cpp=]):
|
||||
|
||||
[import ../example/features/private_protected_virtual.cpp]
|
||||
[private_protected_virtual_counter]
|
||||
|
||||
However, public functions in derived classes overriding private or protected virtual functions from base classes shall not specify the extra `override_...` template parameter to [funcref boost::contract::public_function] because the overridden functions are private or protected and, not being public, they do not participate to subcontracting (this library will generate a compile-time error if `override_...` is specified because there will be no virtual public function to override from the base class).
|
||||
For example (see [@../../example/features/private_protected_virtual.cpp =private_protected_virtual.cpp=]):
|
||||
|
||||
[private_protected_virtual_counter10]
|
||||
|
||||
Furthermore, using multiple inheritance it is possible to override functions that are private or protected from one base but public from another base.
|
||||
In this case, public function overrides in derived classes will specify the extra `override_...` template parameter to [funcref boost::contract::public_function] (because the overridden functions are private or protected in one base and those do not participate to subcontracting, but public in another base and these participate to subcontracting instead).
|
||||
For example (see [@../../example/features/private_protected_virtual_multi.cpp =private_protected_virtual_multi.cpp=]):
|
||||
|
||||
[import ../example/features/private_protected_virtual_multi.cpp]
|
||||
[private_protected_virtual_multi_countable]
|
||||
[private_protected_virtual_multi_counter10]
|
||||
|
||||
[warning
|
||||
Unfortunately, the code above does not compile on MSVC (at least up to Visual Studio 2015) because MSVC incorrectly gives a compile-time error when SFINAE fails due to private or protected access levels.
|
||||
Instead, GCC and Clang correctly implement SFINAE failures due to private and protected functions so the code above correctly complies on GCC and Clang.
|
||||
Therefore, currently it is not possible to override a function that is public in one base but private or protected in other base using this library on MSVC, but that can be done on GCC or CLang instead.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Friend Functions]
|
||||
|
||||
Friend functions are not member functions so [funcref boost::contract::function] can used to program contracts for them and all considerations made in __Non_Member_Functions__ apply.
|
||||
For example (see [@../../example/features/friend.cpp =friend.cpp=]):
|
||||
|
||||
[import ../example/features/friend.cpp]
|
||||
[friend_byte]
|
||||
[friend_bytes]
|
||||
|
||||
However, in some cases a friend function might take an object as parameter and it can be logically considered an extension of that object's public interface (essentially at the same level as the object's public functions).
|
||||
In these cases, programmers might chose to program the friend function contracts using [funcref boost::contract::public_function] (instead of [funcref boost::contract::function]) so to also check the class invariants of the object passed as parameter (and not just the pre- and postconditions of the friend function).
|
||||
For example (see [@../../example/features/friend_invariant.cpp =friend_invariant.cpp=]):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Contract programming proposals for C++ like __N1962__ do not provide a mechanism for friend functions to check class invariants of objects passed as parameters.
|
||||
In other words, these proposals do not enable contracts to recognize that in C++ some friend functions logically act as if they were part of the public interface of the objects they take as parameters.
|
||||
This is actually reasonable for proposals that add contracts to the core language because friend functions are not always meant to extend an object public interface and C++ does not provide a mechanism to programmatically specify when they do and when they do not.
|
||||
However, this library adds the flexibility to let programmers manually specify when friend functions should also check class invariants of the objects they take as parameters (using [funcref boost::contract::public_function]) and when they should not (using [funcref boost::contract::function] instead).
|
||||
]
|
||||
|
||||
[import ../example/features/friend_invariant.cpp]
|
||||
[friend_invariant]
|
||||
|
||||
This technique can also be extended to friend functions that take multiple objects as parameters and can be logically considered extensions to the public interfaces of each of these objects.
|
||||
For example:
|
||||
|
||||
// Can be considered an extension of multiple objects' public interfaces.
|
||||
friend void f(class1& object1, class2* object2, type3& value3) {
|
||||
// Check preconditions.
|
||||
boost::contract::check pre = boost::contract::function()
|
||||
.precondition([&] {
|
||||
BOOST_CONTRACT_ASSERT(object2 != nullptr);
|
||||
...
|
||||
})
|
||||
;
|
||||
// Check class invariants for each object (programmers chose the order).
|
||||
boost::contract::check inv1 = boost::contract::public_function(&object1);
|
||||
boost::contract::check inv2 = boost::contract::public_function(object2);
|
||||
// Check postconditions and exception guarantees.
|
||||
boost::contract::check post_except = boost::contract::function()
|
||||
.postcondition(...)
|
||||
.except(...)
|
||||
;
|
||||
|
||||
... // Function body.
|
||||
}
|
||||
|
||||
Changing the order of the [classref boost::contract::check] declarations above, programmers can chose the order for checking class invariants among the different objects passed to the friend function and also whether to check these invariants before or after preconditions, postconditions, and exception guarantees at function entry and exit respectively (see __Non_Member_Functions__ and __Public_Functions__ for information on how the RAII objects returned by [funcref boost::contract::function] and [funcref boost::contract::public_function] check contract conditions).
|
||||
The example above is programmed to check `class1` invariants before `class2` invariants (but the order could have been inverted if programmers so chose).
|
||||
|
||||
[note
|
||||
In the example above, preconditions are intentionally programmed to be checked before class invariants so the objects passed to the friend function can be validated by the preconditions before they are passed as pointers to [funcref boost::contract::public_function] (e.g., check `object2` is not null).
|
||||
(Within member functions instead, the object pointer `this` is always well-formed, its validation is never needed, and [funcref boost::contract::public_function] checks class invariants before checking preconditions so programming preconditions can be simplified assuming the class invariants are satisfied already, see __Public_Function_Calls__.)
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Function Overloads]
|
||||
|
||||
As seen in __Public_Function_Overrides__, [funcref boost::contract::public_function] takes a pointer to the enclosing function as a parameter when used in public function overrides.
|
||||
When names of public function overrides are overloaded, the function pointer cannot be automatically deduced by the compiler so programmers have to use `static_cast` to resolve ambiguities (as usual with pointers to overloaded functions in C++).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
In order to avoid copies, this library takes all function arguments and the return value passed to [funcref boost::contract::public_function] as references when used within public function overrides.
|
||||
Therefore, the library cannot differentiate when the actual function argument and return types are passed by reference and when they are not.
|
||||
As a result, the library cannot automatically reconstruct the type of the enclosing public function so this type must be deduced from the function pointer passed by programmers to [funcref boost::contract::public_function].
|
||||
When this automatic deduction is not possible due to overloaded function names, programmers must explicitly use `static_cast` to resolve ambiguities as usual in C++ with pointers to overloaded functions.
|
||||
]
|
||||
For example, note how `static_cast` is used in the following calls to [funcref boost::contract::public_function] (see [@../../example/features/overload.cpp =overload.cpp=]):
|
||||
|
||||
[import ../example/features/overload.cpp]
|
||||
[overload]
|
||||
|
||||
Overloaded functions have the same function name so the same [^override_['function-name]] type can be reused as template parameter for all [funcref boost::contract::public_function] calls.
|
||||
Therefore, [macroref BOOST_CONTRACT_OVERRIDE] only needs to be invoked once for any given function name even when that function name is overloaded.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Lambdas, Loops, Code Blocks (and `constexpr`)]
|
||||
|
||||
While contracts are usually most useful to program specifications of functions and class interfaces, this library also allows to check contract conditions for implementation code (lambda functions, loops, code blocks, etc.).
|
||||
|
||||
Lambda functions are not member functions, they are not part of class public interfaces so they do not check class invariants or participate int subcontracting.
|
||||
They can use [funcref boost::contract::function] to specify preconditions, postconditions, and exception guarantees (considerations made in __Non_Member_Functions__ apply).
|
||||
For example (see [@../../example/features/lambda.cpp =lambda.cpp=]):
|
||||
|
||||
[import ../example/features/lambda.cpp]
|
||||
[lambda]
|
||||
|
||||
Similarly, [funcref boost::contract::function] can be used to program preconditions, postconditions, and exception guarantees for loops.
|
||||
For example, for a for-loop but same for while- and all other loops (see [@../../example/features/loop.cpp =loop.cpp=]):
|
||||
|
||||
[import ../example/features/loop.cpp]
|
||||
[loop]
|
||||
|
||||
More in general, [funcref boost::contract::function] can be used to program preconditions, postconditions, and exception guarantees of any block of code in a given function.
|
||||
For example (see [@../../example/features/code_block.cpp =code_block.cpp=]):
|
||||
|
||||
[import ../example/features/code_block.cpp]
|
||||
[code_block]
|
||||
|
||||
Finally, at the moment this library does not support contracts for functions and classes declared `constexpr`.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
In general, it might be useful to specify contracts for `constexpr` functions and literal classes.
|
||||
However, the implementation of this library cannot support contracts for these functions and classes because C++ does not currently allow `constexpr` functions to do the following:
|
||||
Declare local variables of (literal) types with non-trivial `constexpr` destructors (this RAII technique is used by this library to check invariants, postconditions, and exceptions guarantees at exit);
|
||||
Call other `constexpr` functions using try-catch statements (used by this library to report contract assertion failures and catch any other exception that might be thrown when evaluating the asserted conditions);
|
||||
Use lambda functions (used by this library for convenience to program functors that that check preconditions, postconditions, and exception guarantees).
|
||||
Also note that even if supported, contracts for `constexpr` functions probably would not use old values (because `constexpr` prevents functions from having any side effect visible to the caller and variables recording such side-effects are usually the candidates for old value copies) and subcontracting (because `constexpr` functions cannot be virtual).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Implementation Checks]
|
||||
|
||||
This library provides a mechanism to check assertions within implementation code outside of preconditions, postconditions, exceptions guarantees, and class invariants.
|
||||
These implementation checks can be programmed using [macroref BOOST_CONTRACT_ASSERT] in a nullary functor that is directly assigned to [classref boost::contract::check] at the place within the code where the checks have to be executed (so without using [funcref boost::contract::function], [funcref boost::contract::public_function], etc.).
|
||||
For example (see [@ ../../example/features/check.cpp =check.cpp=]):
|
||||
|
||||
[import ../example/features/check.cpp]
|
||||
[check_class]
|
||||
|
||||
Alternatively, this library provides the [macroref BOOST_CONTRACT_CHECK] macro that allows to completely remove run- and compile-time overhead of implementation checks when [macroref BOOST_CONTRACT_NO_CHECKS] is defined.
|
||||
For example (see [@ ../../example/features/check.cpp =check.cpp=]):
|
||||
|
||||
[check_macro]
|
||||
|
||||
(See __Disable_Contract_Checking__ and __Disable_Contract_Compilation__ for macros to completely remove run- and compile-time overhead of preconditions, postconditions, exception guarantees, and class invariants.)
|
||||
|
||||
These implementation checks are essentially equivalent to using the C-style `assert` macro a part from the following:
|
||||
|
||||
* A failure of the implementation checks will call [funcref boost::contract::check_failure] (see [funcref boost::contract::set_check_failure] and [funcref boost::contract::get_check_failure]).
|
||||
* Implementation checks are automatically disabled when other contract conditions specified using this libraries are already being checked (to avoid infinite recursion, see [macroref BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION]).
|
||||
* Implementation checks are disabled defining [macroref BOOST_CONTRACT_NO_CHECKS] (instead of `NDEBUG` for disabling `assert`).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Old Copies at Body]
|
||||
|
||||
In the examples seen so far, old value variables of type [classref boost::contract::old_ptr] are initialized to a copy of the expression passed to [macroref BOOST_CONTRACT_OLDOF] at the point of their declaration.
|
||||
This is correctly done before the function body is executed but it is also done before the contract is declared, therefore even before class invariants (for public functions) and preconditions are checked at function entry.
|
||||
|
||||
This might work well in most cases, however in general old values should be copied before executing the function body but after checking entry class invariants and preconditions (see __Assertions__).
|
||||
Specifically, there could be cases in which it makes sense to evaluate the expressions passed to [macroref BOOST_CONTRACT_OLDOF] only assuming that the assertions programmed in the class invariants and preconditions are first checked to be true.
|
||||
|
||||
This library allows to construct [classref boost::contract::old_ptr] variables using their default constructor (equivalent to a null pointer) and then to assign them later to a copy of the expression passed to [macroref BOOST_CONTRACT_OLDOF] in a nullary functor [^['d]]`()` passed to `.old(`[^['d]]`)`.
|
||||
The functor [^['d]]`()` is called by this library before the function body is executed but only after class invariants and preconditions are checked:
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Functors for preconditions, old value assignments, postconditions, and exception guarantees are all optional but when specified, they must be specified in that order.
|
||||
Such order is enforced by the fact that [classref boost::contract::specify_precondition_old_postcondition_except], [classref boost::contract::specify_old_postcondition_except], [classref boost::contract::specify_postcondition_except], [classref boost::contract::specify_except], and [classref boost::contract::specify_nothing] provide a progressively decreasing subset of the `.precondition(...)`, `.old(...)`, `.postcondition(...)`, and `.except(...)` member functions.
|
||||
The enforced order for specifying preconditions, old value assignments, postconditions, and exception guarantees makes logical sense because it follows the order at which these are executed at run-time.
|
||||
Other contract programming frameworks allow to mix this order, that could have been implemented for this library as well but it would have complicated somewhat the library implementation while adding no real value (arguably creating confusion in user code by not enforcing a consistent order for specifying contract conditions).
|
||||
]
|
||||
|
||||
boost::contract::old_ptr<...> old_``[^['name]]``; // Default constructor (i.e., null pointer).
|
||||
...
|
||||
boost::contract::guard c = boost::contract::function() // Same for all other contracts.
|
||||
...
|
||||
.old([&] { // Capture by reference...
|
||||
old_``[^['name]]`` = BOOST_CONTRACT_OLDOF(``[^['expression]]``); // ...but modify only old values.
|
||||
...
|
||||
})
|
||||
.postcondition([&] {
|
||||
BOOST_CONTRACT_ASSERT(*old_``[^['name]]`` ...); // Never null here.
|
||||
...
|
||||
})
|
||||
.except([&] {
|
||||
BOOST_CONTRACT_ASSERT(*old_``[^['name]]`` ...); // Never null here.
|
||||
...
|
||||
})
|
||||
;
|
||||
|
||||
For example, the following old value expression `s[index]` passed to [macroref BOOST_CONTRACT_OLDOF] is valid only after the precondition has checked that `index` is within valid range `index < s.size()`.
|
||||
Therefore, `old_y` is first declared using its default constructor (i.e., initialized to a null pointer) and later assigned to a copy of `s[index]` in `.old(...)` after the precondition has checked `index` (see [@../../example/features/old.cpp =old.cpp=]):
|
||||
|
||||
[import ../example/features/old.cpp]
|
||||
[old]
|
||||
|
||||
The functor passed to `.old(...)` should capture all variables it needs to evaluate to copy the old value expressions passed to [macroref BOOST_CONTRACT_OLDOF].
|
||||
In general, these variables should be captured by reference and not by value (because old values need to make copies of the values the captured variables will have just before executing the function body, and not copy the values these variables had when the functor passed to `.old(...)` was first declared).
|
||||
In any case, the functor passed to `.old(...)` should modify only old values and not the values of other captured variables (see __Constant_Correctness__).
|
||||
|
||||
This library will automatically call the failure handler [funcref boost::contract::old_failure] if calling the functor specified via `.old(...)` throws an exception (by default, this handler prints an error message to `std::cerr` and terminates the program calling `std::terminate`, but see __Throw_on_Failure__ to throw exceptions, exit the program with an error code, etc.).
|
||||
|
||||
[note
|
||||
If old value pointers are initialized at the point of their construction instead of using `.old(...)` then an exception thrown by the old value expression passed to [macroref BOOST_CONTRACT_OLDOF], or more in general any exception thrown by the old value pointer initialization, will result in that exception being thrown up the stack by the enclosing function.
|
||||
This is arguably less correct than calling [funcref boost::contract::old_failure] because an exception thrown by an old value copy causes the program to fail checking its postconditions and exception guarantees but should not automatically causes the enclosing function to thrown an exception (this might not be a significant difference in practice, but it could be an additional reason to use `.old(...)` instead of copying old values when they are declared before the contract).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
It would be possible to wrap all old value operations ([classref boost::contract::old_ptr] copy constructor, [funcref boost::contract::make_old], etc.) in try-catch statements so this library will call [funcref boost::contract::old_failure] also when old values are copied when they are constructed outside `.old(...)`.
|
||||
However, that will prevent this library from knowing the [enumref boost::contract::from] parameter and that would be problematic (specifically because destructors can have postconditions so that parameter is necessary to make sure user-defined failure handlers can be programmed to never throw from destructors as C++ usually requires).
|
||||
]
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Named Overrides]
|
||||
|
||||
The function names passed to [macroref BOOST_CONTRACT_OVERRIDE] and [macroref BOOST_CONTRACT_OVERRIDES] should never start with an underscore to avoid generating names containing double underscores `override__...` (which are reserved by the C++ standard).
|
||||
There is a separate macro [macroref BOOST_CONTRACT_NAMED_OVERRIDE] that can be used to explicitly specify the name of the type that will be passed to [funcref boost::contract::public_function] as a template argument:
|
||||
[footnote
|
||||
*Rationale:*
|
||||
A different macro [macroref BOOST_CONTRACT_NAMED_OVERRIDE] is used instead of overloading [macroref BOOST_CONTRACT_OVERRIDE] using variadic macros because the override macros cannot be programmed manually by users so making it a variadic would prevent to use this library on compilers that do not support variadic macros (see __No_Macros__).
|
||||
]
|
||||
|
||||
BOOST_CONTRACT_OVERRIDE(``[^['function-name]]``) // Generate `override_...`.
|
||||
BOOST_CONTRACT_NAMED_OVERRIDE(``[^['type-name]]``, ``[^['function-name]]``) // Generate `type-name`.
|
||||
|
||||
For example, the following public function override is named `_1` so `BOOST_CONTRACT_OVERRIDE(_1)` would generate a type named `override__1` (which is reserved in C++ because it contains double underscores `__`), `BOOST_CONTRACT_NAMED_OVERRIDE(override1, _1)` is used to name the type `override1` instead (see [@../../example/features/named_override.cpp =named_override.cpp=]):
|
||||
|
||||
[named_override]
|
||||
|
||||
The [macroref BOOST_CONTRACT_NAMED_OVERRIDE] macro can also be used when the name `override_`[^['function-name]] generated by [macroref BOOST_CONTRACT_OVERRIDE] would clash with other names in user code, to generate names in CamelCase or in any other preferred style, and in any other case when programmers need or prefer to generate names different from `override_...`.
|
||||
|
||||
Note that there is not a `BOOST_CONTRACT_NAMED_OVERRIDES` macro so [macroref BOOST_CONTRACT_NAMED_OVERRIDE] needs to be invoked separately on each function name (there is instead a [macroref BOOST_CONTRACT_OVERRIDES] macro as seen in __Public_Function_Overrides__).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The syntax for invoking a possible `BOOST_CONTRACT_NAMED_OVERRIDES` macro would need to be something like `BOOST_CONTRACT_NAMED_OVERRIDES(`[^['type-name1]]`, `[^['function-name1]]`, `[^['type-name2]]`, `[^['function-name2]]`, ...)`.
|
||||
The authors felt this syntax is less readable than repeating single `BOOST_CONTRACT_NAMED_OVERRIDE` invocations `BOOST_CONTRACT_NAMED_OVERRIDE(`[^['type-name1]]`, `[^['function-name1]]`) BOOST_CONTRACT_NAMED_OVERRIDE(`[^['type-name2]]`, `[^['function-name2]]`) ...` so decided not to provide the `BOOST_CONTRACT_NAMED_OVERRIDES` macro.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Access Specifiers]
|
||||
|
||||
As we have seen so far, programmers are required to decorate their classes declaring extra members that are internally used by this library to check contracts:
|
||||
|
||||
* The `invariant` and `static_invariant` member functions (used to check class invariants, see __Class_Invariants__).
|
||||
* The `base_types` member type declared via [macroref BOOST_CONTRACT_BASE_TYPES] (used to implement subcontracting, see __Public_Function_Overrides__).
|
||||
* The `override_...` member types declared via [macroref BOOST_CONTRACT_OVERRIDE], [macroref BOOST_CONTRACT_NAMED_OVERRIDE], and [macroref BOOST_CONTRACT_OVERRIDES] (used to implement subcontracting for overriding functions, see __Public_Function_Overrides__).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The internals of the `override_...` type generated by [macroref BOOST_CONTRACT_OVERRIDE] use names reserved by this library so programmers should not actually use such a type even when it is declared `public`.
|
||||
]
|
||||
|
||||
In general, these members must be declared `public` in the user class in order for this library to be able to access them.
|
||||
[footnote
|
||||
There is some variability among compiler implementations:
|
||||
The `base_types` member type needs to be declared `public` on MSVC, GCC, ang CLang;
|
||||
The `invariant` and `static_invariant` member functions need to be declared `public` on MSVC, but not on GCC and CLang;
|
||||
The `override_...` member types do not have to be declared `public` on any compiler.
|
||||
In any case, declaring the [classref boost::contract::access] class `friend` allows to always declare all these extra members `private` on all compilers.
|
||||
]
|
||||
However, programmers might need to more precisely control the public members of their classes to prevent incorrect access of encapsulated members.
|
||||
All these members can be declared `private` as long as the [classref boost::contract::access] class is declared as `friend` of the user class.
|
||||
For example (see [@../../example/features/access.cpp =access.cpp=]):
|
||||
|
||||
[import ../example/features/access.cpp]
|
||||
[access]
|
||||
|
||||
This technique is not used in most examples of this documentation only for brevity, but programmers are encouraged to use it in real code.
|
||||
|
||||
[warning
|
||||
Not declaring this class friend of user classes might cause compiler errors on some compilers (e.g., MSVC) because the private members needed to check the contracts will not be accessible.
|
||||
On other compilers (e.g., GCC and CLang), the private access will instead fail SFINAE and no compiler error will be reported while invariants and subcontracting will be silently skipped at run-time.
|
||||
Therefore, programmers should always make sure to either declare invariant functions and base types `typedef` as public members or to declare the [classref boost::contract::access] class as friend.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Throw on Failure (and `noexcept`)]
|
||||
|
||||
If a conditions checked using [macroref BOOST_CONTRACT_ASSERT] is evaluated to be `false` or more in general if any of the specified contract code throws an exception ([macroref BOOST_CONTRACT_ASSERT] simply expands to code that throws a [classref boost::contract::assertion_failure] exception, see __No_Macros__), this library will call an appropriate /contract failure handler/ function as follow:
|
||||
|
||||
* Preconditions: False [macroref BOOST_CONTRACT_ASSERT] assertions and exceptions thrown from within `.precondition(...)` call [funcref boost::contract::precondition_failure].
|
||||
* Postconditions: False [macroref BOOST_CONTRACT_ASSERT] assertions and exceptions thrown from within `.postcondition(...)` call [funcref boost::contract::postcondition_failure].
|
||||
* Exceptions guarantees: False [macroref BOOST_CONTRACT_ASSERT] assertions and exceptions thrown from within `.except(...)` call [funcref boost::contract::except_failure].
|
||||
* Class invariants: False [macroref BOOST_CONTRACT_ASSERT] assertions and exceptions thrown from `invariant()` and `static_invariant()` call [funcref boost::contract::entry_invariant_failure] when checked at function entry and [funcref boost::contract::exit_invariant_failure] when checked at function exit.
|
||||
* Old copies at body: Exceptions thrown from old value copies at body within `.old(...)` call [funcref boost::contract::old_failure].
|
||||
* Implementation checks: False [macroref BOOST_CONTRACT_ASSERT] assertions and exceptions thrown from implementation checks `boost::contract::check c = `[^['nullary-functor]] and [macroref BOOST_CONTRACT_CHECK] calls [funcref boost::contract::check_failure].
|
||||
|
||||
By default, these contract failure handlers print a message to the standard error `std::cerr` and then terminate the program calling `std::terminate`.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
In general, when a contract fails the only safe thing to do is to terminate program execution (because the contract failure indicates a bug in the program, and in general the program is in a state for which no operation can be successfully performed, so the program should be stopped).
|
||||
Therefore, this library terminates the program by default.
|
||||
However, for specific applications, programmers could implement some fail-safe mechanism for which some mission-critical operation could always be performed upon handling failures so this library allows programmers to override the default contract failure handlers to fully customize how to handle contract failures.
|
||||
]
|
||||
However, programmers can override the default contract failure handlers to perform any custom action on contract failure using the following functions respectively:
|
||||
|
||||
* Preconditions: [funcref boost::contract::set_precondition_failure].
|
||||
* Postconditions: [funcref boost::contract::set_postcondition_failure].
|
||||
* Exception guarantees: [funcref boost::contract::set_except_failure].
|
||||
* Class invariants: [funcref boost::contract::set_entry_invariant_failure] and [funcref boost::contract::set_exit_invariant_failure], or [funcref boost::contract::set_invariant_failure] (to set both entry and exit invariant failure handlers at once for convenience).
|
||||
* Old copies at body: [funcref boost::contract::set_old_failure].
|
||||
* Implementation checks: [funcref boost::contract::set_check_failure].
|
||||
|
||||
These `set_..._failure(`[^['f]]`)` function calls return the contract failure handler functor [^['f]] that they take as input parameter.
|
||||
For example (see [@../../example/features/throw_on_failure.cpp =throw_on_failure.cpp=]):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Even if somewhat different from `std::set_terminate`, the `set_..._failure` functions take a functor as parameter (so to handle not just function pointers, but also lambdas, binds, etc.) and return this same functor as result (so they can be concatenated).
|
||||
The related `get_..._failure` functions can be used to query the functors currently set as failure handlers.
|
||||
]
|
||||
|
||||
[import ../example/features/throw_on_failure.cpp]
|
||||
[throw_on_failure_handlers]
|
||||
|
||||
When programming custom failure handlers that trow exceptions instead of terminating the program, programmers should be wary of the following:
|
||||
|
||||
* In order to comply with C++ and STL exception safety, destructors should never throw.
|
||||
This library passes a [enumref boost::contract::from] parameter to the contract failure handlers for preconditions ([funcref boost::contract::precondition_failure]), postconditions ([funcref boost::contract::postcondition_failure]), class invariants ([funcref boost::contract::entry_invariant_failure] and [funcref boost::contract::exit_invariant_failure]), and old value copies at body ([funcref boost::contract::old_failure]).
|
||||
This [enumref boost::contract::from] parameter indicates if the contract failure occurred in a destructor, constructor, or function call so programmers can use it to code custom contract failure hander functions that never throw from destructors.
|
||||
(In the example above, contract failures from destructors are simply ignored even if that is probably never a safe thing to do in real code.)
|
||||
* C++ stack-unwinding will execute base class destructors even when the derived class destructor trows an exception.
|
||||
Therefore, the contracts of base class destructors will continue to be checked when contract failure handlers are programmed to throw exceptions on contract failures from destructors (yet another reason to not throw exception from destructors, not even for contract failures).
|
||||
* Implementation checks can appear in any code, including destructor implementation code, so [funcref boost::contract::check_failure] should also never throw, or implementation checks should never be used in destructors (note that [funcref boost::contract::check_failure] does not provide the [enumref boost::contract::from] parameter so it is not possible to differentiate from implementation checks failing from destructors instead than from other parts of the code).
|
||||
* The contract failure handler for exception guarantees [funcref boost::contract::except_failure] should also never throw (regardless of the value of its [enumref boost::contract::from] parameter) because when [funcref boost::contract::except_failure] is called there is already an active exception on the stack, the exception that triggered the exception guarantees to be checked in the first place (and throwing an exception while there is already an active exception will force C++ to terminate the program or lead to undefined behaviour).
|
||||
|
||||
[note
|
||||
It is the responsibility of the programmers to decide how to handle contract failures from destructors when they program custom contract failure handlers that throw exceptions instead of terminating the program (given that C++ and STL exception safety rules requires destructors to never throw).
|
||||
This is not a simple dilemma and it might be a good reason to terminate the program instead of throwing exceptions when assertions fail in C++ (as this library and also C-style `assert` do by default).
|
||||
]
|
||||
|
||||
Contract assertions can be programmed to throw [classref boost::contract::assertion_failure] using [macroref BOOST_CONTRACT_ASSERT]`(`[^['condition]]`)` as we have seen so far (see __No_Macros__).
|
||||
Alternatively, contract assertions can be programmed to throw any other exception (including user-defined exceptions) using code similar to the following:
|
||||
|
||||
if(!``[^['condition]]``) throw ``[^['exception-object]]``;
|
||||
|
||||
For example, if the following precondition functor throws the user-defined exception `too_large_error` then the contract failure handler [funcref boost::contract::precondition_failure] will be called (same as when preconditions programmed using [macroref BOOST_CONTRACT_ASSERT] fail, see [@../../example/features/throw_on_failure.cpp =throw_on_failure.cpp=]):
|
||||
|
||||
[throw_on_failure_class_begin]
|
||||
[throw_on_failure_ctor]
|
||||
[throw_on_failure_class_end]
|
||||
|
||||
Finally, note that the exception specifiers `noexcept` (since C++11) and `throw` (deprecated in C++11) of the enclosing operation declaring the contract correctly apply to the contract code as well.
|
||||
Therefore, even if the contract failure handlers are reprogrammed to throw exceptions in case of contract failures, those exceptions will never be thrown outside the context of the enclosing operation if that is not in accordance with the exception specifiers of that operation (e.g., note that all destructors are implicitly declared `noexcept` in C++11).
|
||||
For example, the following code will correctly never throw from the `noexcept` destructor, not even if the class invariants checked at destructor entry throw `too_large_error` and the contract failure handlers for invariants are programmed to throw from destructors (the program will always terminate in this case instead, see [@../../example/features/throw_on_failure.cpp =throw_on_failure.cpp=]):
|
||||
|
||||
[throw_on_failure_class_begin]
|
||||
[throw_on_failure_dtor]
|
||||
[throw_on_failure_class_end]
|
||||
[throw_on_failure_bad_handler]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,112 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Bibliography]
|
||||
|
||||
This section lists all references consulted while designing and developing this library.
|
||||
|
||||
[#Andrzej13_anchor] [Andrzej13] A. Krzemienski. [@https://akrzemi1.wordpress.com/2013/01/04/preconditions-part-i/ /Andrzej's C++ blog: Preconditions/]. 2013.
|
||||
|
||||
[#Bright04_anchor] [Bright04] W. Bright. [@http://www.digitalmars.com/d/2.0/dbc.html /Contract Programming for the D Programming Language/]. 2004.
|
||||
|
||||
[#Bright04b_anchor] [Bright04b] W. Bright. [@http://www.digitalmars.com/ctg/contract.html /Contract Programming for the Digital Mars C++ Compiler/]. 2004.
|
||||
|
||||
[#C2_anchor] [C2] Aechmea. [@http://www.programmersheaven.com/app/news/DisplayNews.aspx?NewsID=3843 /C^2 Contract Programming add-on for C++/]. 2005.
|
||||
|
||||
[#Chrome_anchor] [Chrome] RemObjects. [@http://blogs.remobjects.com/blogs/mh/2008/05/01/p216 /Chrome: Contract Programming for Object Pascal in .NET/]. 2002.
|
||||
|
||||
[#Clarke06_anchor] [Clarke06] L. A. Clarke and D. S. Rosenblum. [@http://discovery.ucl.ac.uk/4991/1/4991.pdf /A Historical Perspective on Runtime Assertion Checking in Software Development/]. Newsletter ACM SIGSOFT Software Engineering Notes, 2006.
|
||||
|
||||
[#Cline90_anchor] [Cline90] M. Cline and D. Lea. /The Behaviour of C++ Classes/ and [@http://surface.syr.edu/cgi/viewcontent.cgi?article=1116&context=eecs /Using Annotated C++/]. Proc. of the Symposium on Object Oriented Programming Emphasizing Practical Applications, Maris College, 1990.
|
||||
|
||||
[#Ellis90_anchor] [Ellis90] M. A. Ellis and B. Stroustrup. /The Annotated C++ Reference Manual/. ANSI Base Document, Addison Wesley, 1990.
|
||||
|
||||
[#Gautron92_anchor] [Gautron92] P. Gautron. /An Assertion Mechanism Based on Exceptions/. Fourth C++ Technical Conference, 1992.
|
||||
|
||||
[#Hoare73_anchor] [Hoare73] C. A. R. Hoare. /Hints on Programming Language Design/. Stanford University Artificial Intelligence memo AIM-224/STAN-CS-73-403, pages 193-216, 1973.
|
||||
|
||||
[#CodeContracts_anchor] [CodeContracts] Microsoft Research. [@http://research.microsoft.com/en-us/projects/contracts/ /Code Contracts: Design-By-Contract Programming for All .NET Programming Languages/]. 2012.
|
||||
|
||||
[#iContract_anchor] [iContract] O. Enseling. [@http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html /iContract: Contract Programming for Java/]. 2001.
|
||||
|
||||
[#Jcontract_anchor] [Jcontract] Parasoft. [@http://www.parasoft.com/jsp/products/article.jsp?label=product_info_Jcontract /Jcontract: Contract Programming for Java/].
|
||||
|
||||
[#Lindrud04_anchor] [Lindrud04] J. Lindrud. [@http://www.codeproject.com/Articles/8293/Design-by-Contract-in-C /Design by Contract in C++/]. 2004.
|
||||
|
||||
[#Maley99_anchor] [Maley99] D. Maley and I. Spence. [@http://www.computer.org/portal/web/csdl/doi/10.1109/TOOLS.1999.779000 /Emulating Design by Contract in C++/]. Proceedings of TOOLS, IEEE Computer Society, 1999.
|
||||
|
||||
[#Meyer97_anchor] [Meyer97] B. Meyer. /Object Oriented Software Construction/. Prentice-Hall, 2nd edition, 1997.
|
||||
|
||||
[#Mitchell02_anchor] [Mitchell02] R. Mitchell and J. McKim. /Design by Contract, by Example/. Addison-Wesley, 2002.
|
||||
|
||||
[#N1613_anchor] [N1613] T. Ottosen. [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2004/n1613.pdf /Proposal to add Design by Contract to C++/]. The C++ Standards Committee, N1613, 2004.
|
||||
|
||||
[#N1653_anchor] [N1653] C. Nelson. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm /Working draft changes for C99 preprocessor synchronization/]. C++ Standards Committee, N1653, 2004.
|
||||
|
||||
[#N1669_anchor] [N1669] T. Ottosen. [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2004/n1669.html /Proposal to add Contract Programming to C++ (revision 1)/]. The C++ Standards Committee, N1669, 2004.
|
||||
|
||||
[#N1773_anchor] [N1773] D. Abrahams, L. Crowl, T. Ottosen, and J. Widman. [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1773.html /Proposal to add Contract Programming to C++ (revision 2)/]. The C++ Standards Committee, N1773, 2005.
|
||||
|
||||
[#N1866_anchor] [N1866] L. Crowl and T. Ottosen. [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1866.html /Proposal to add Contract Programming to C++ (revision 3)/]. The C++ Standards Committee, N1866, 2005.
|
||||
|
||||
[#N1895_anchor] [N1895] H. Sutter and F. Glassborow. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1895.pdf /Delegating Constructors (revision 2)/]. C++ Standards Committee, N1895, 2005.
|
||||
|
||||
[#N1962_anchor] [N1962] L. Crowl and T. Ottosen. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1962.html /Proposal to add Contract Programming to C++ (revision 4)/]. The C++ Standards Committee, N1962, 2006.
|
||||
|
||||
[#N2081_anchor] [N2081] D. Gregor and B. Stroustrup. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2081.pdf /Concepts (revision 1)/]. The C++ Standards Committee, N2081, 2006.
|
||||
|
||||
[#N2887_anchor] [N2887] G. Dos Reis, B. Stroustrup, and A. Meredith. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2887.pdf /Axioms: Semantics Aspects of C++ Concepts/]. The C++ Standards Committee, N2887, 2009.
|
||||
|
||||
[#N2914_anchor] [N2914] P. Becker. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf /Working Draft, Standard for Programming Language C++/]. The C++ Standards Committee, N2914, 2009.
|
||||
|
||||
[#N2906_anchor] [N2906] B. Stroustrup. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2906.pdf /Simplifying the sue of concepts/]. The C++ Standards Committee, N2906, 2009.
|
||||
|
||||
[#N3248_anchor] [N3248] J. Lakos. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3248.pdf ['[^noexcept] Prevents Library Validation]]. The C++ Standards Committee, N3248, 2011.
|
||||
|
||||
[#N4154_anchor] [N4154] D. Krauss. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4154.pdf ['Operator [^assert]]]. The C++ Standards Committee, N4154, 2014.
|
||||
|
||||
[#N4160_anchor] [N4160] A. Krzemienski. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4160.html /Value constraints/]. The C++ Standards Committee, N4160, 2014.
|
||||
|
||||
[#N4248_anchor] [N4248] A. Meredith. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4248.html /Library Preconditions are a Language Feature/]. The C++ Standards Committee, N4248, 2014.
|
||||
|
||||
[#N4293_anchor] [N4293] J. D. Garcia. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4293.pdf /C++ language support for contract programming/]. The C++ Standards Committee, N4293, 2014.
|
||||
|
||||
[#N4378_anchor] [N4378] J. Lakos, N. Myers, A. Zakharov, and A. Beels. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4378.pdf /Language Support for Contract Assertions (Revision 10)/]. The C++ Standards Committee, N4378, 2015.
|
||||
|
||||
[#Nana_anchor] [Nana] P. J. Maker. [@https://github.com/pjmaker/nana /GNU Nana/]. 2014.
|
||||
|
||||
[#N4379_anchor] [N4378] J. Lakos and N. Myers. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4379.pdf /FAQ about Contract Assertions/]. The C++ Standards Committee, N4379, 2015.
|
||||
|
||||
[#N4435_anchor] [N4435] W. E. Brown. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4435.pdf /Proposing Contract Attributes/]. The C++ Standards Committee, N4435, 2015.
|
||||
|
||||
[#P0147_anchor] [P0147] L. Crowl. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0147r0.html /The Use and Implementation of Contracts/]. The C++ Standards Committee, P0147R0, 2015.
|
||||
|
||||
[#P0166_anchor] [P0166] J. D. Garcia. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0166r0.pdf /Three interesting questions about contracts/]. The C++ Standards Committee, P0166R0, 2015.
|
||||
|
||||
[#P0246_anchor] [P0246] N. Myers. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0246r0.pdf /Criteria for Contract Support Merged Proposal/]. The C++ Standards Committee, P0246R0, 2016.
|
||||
|
||||
[#P0287_anchor] [P0287] G. Dos Reis, J.D. Garcia, F. Logozzo, M. Fahndrich, S. Lahiri. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0287r0.pdf /Simple Contracts for C++ (R1)/]. The C++ Standards Committee, P0287R0, 2016.
|
||||
|
||||
[#P0380_anchor] [P0380] G. Dos Reis, J.D. Garcia, J. Lakos, A. Meredith, N. Myers, and B. Stroustrup. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf /A Contract Design/]. The C++ Standards Committee, P0380R1, 2016.
|
||||
|
||||
[#P0542_anchor] [P0542] G. Dos Reis, J.D. Garcia, J. Lakos, A. Meredith, N. Myers, and B. Stroustrup. [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0542r0.html /Support for contract based programming in C++/]. The C++ Standards Committee, P0542R0, 2017.
|
||||
|
||||
[#Rosenblum95_anchor] [Rosenblum95] D. S. Rosenblum. [@http://www.cs.toronto.edu/~chechik/courses06/csc410/rosenblum_assert95.pdf /A practical Approach to Programming With Assertions/]. IEEE Transactions on Software Engineering, 1995.
|
||||
|
||||
[#SPARKAda_anchor] [SPARKAda] Praxis. [@http://www.praxis-his.com/sparkada/language.asp /SPARKAda (Ada-like Language with Contract Programming)/].
|
||||
|
||||
[#SpecSharp_anchor] [SpecSharp] Microsoft. [@http:://research.microsoft.com/en-us/projects/specsharp/ /Spec# (C# Extension)/].
|
||||
|
||||
[#Stroustrup94_anchor] [Stroustrup94] B. Stroustrup. /The Design and Evolution of C++/. Addison Wesley, 1994.
|
||||
|
||||
[#Stroustrup13_anchor] [Stroustrup13] B. Stroustrup. /The C++ Programming Language/. Addison Wesley, 4th Edition, 2013.
|
||||
|
||||
[#Tandin04_anchor] [Tandin04] A. Tandin. [@http://www.codeproject.com/KB/macros/DbC_and_Doxygen.aspx /Design by Contract macros for C++ and link to Doxygen/]. 2004.
|
||||
|
||||
[#Wilson06_anchor] [Wilson06] M. Wilson. [@http://www.artima.com/cppsource/deepspace.html /Contract Programming 101 - The Nuclear Reactor and the Deep Space Probe/]. The C++ Source, 2006.
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,679 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Contract Programming Overview]
|
||||
|
||||
[:['["It is absurd to make elaborate security checks on debugging runs, when no trust is put in the results, and then remove them in production runs, when an erroneous result could be expensive or disastrous. What would we think of a sailing enthusiast who wears his life-jacket when training on dry land but takes it off as soon as he goes to sea?]]]
|
||||
[:['-- Charles Antony Richard Hoare (see __Hoare73__)]]
|
||||
|
||||
This section gives an overview of Contract Programming (see __Meyer97__, __Mitchell02__, and __N1613__ for more detailed introductions to Contract Programming).
|
||||
Readers that already have a basic understanding of Contract Programming can skip this section and maybe come back to it after reading the __Tutorial__.
|
||||
|
||||
[note
|
||||
The objective of this library is not to convince programmers to use Contract Programming.
|
||||
It is assumed that programmes understand the benefits and trade-offs associated with Contract Programming and they have already decided to use this methodology in their code.
|
||||
Then, this library aims to be the best and more complete Contract Programming library for C++ (that does not use preprocessors and other tools external to the C++ preprocessor and language itself).
|
||||
]
|
||||
|
||||
[section Assertions]
|
||||
|
||||
Contract Programming is characterized by the following assertion mechanisms:
|
||||
|
||||
* /Preconditions/: These are logical conditions that programmers expect to be true when a function is called (e.g., to check constraints on function arguments).
|
||||
Operations that logically have no preconditions (i.e., that are always well-defined for the entire domain of their inputs) are often referred to as having a /wide contract/.
|
||||
This is in contrast to operations that have preconditions which are often referred to as having a /narrow contract/ (note that operations with truly narrow contracts should not even throw exceptions).
|
||||
[footnote
|
||||
The nomenclature of wide and narrow contracts has gained some popularity in recent years in the C++ community (appearing in a number of more recent proposals to add contract programming to the C++ standard, see __Bibliography__).
|
||||
This nomenclature is perfectly reasonable but it is not often used in this document because the authors generally prefer to explicit mention "this operation has no preconditions..." or "this operation has preconditions...".
|
||||
]
|
||||
* /Postconditions/: These are logical conditions that programmers expect to be true when a function exits without throwing an exception (e.g., to check the result and any side effect that a function might have).
|
||||
Postconditions can access the function return value (for non-void functions) and /old values/ that expressions had before the function body was executed.
|
||||
* /Exception guarantees/: These are logical conditions that programmers except to be true when a function exits throwing an exception.
|
||||
Exceptions specifications can access old values (but not the function return value).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Contract assertions for exception guarantees were first introduced by this library (even if exception safety guarantees have long been part of C++ STL documentation).
|
||||
Contract assertions for exception safety guarantees are not part of __N1962__ or other references listed in the __Bibliography__.
|
||||
]
|
||||
* /Class invariants/: These are logical conditions that programmers expect to be true after a constructor exits without throwing an exception, before and after the execution of every non-static public non-static function (even if they throw exceptions), before the destructor is executed and if the destructor throws an exception (i.e., class invariants define valid states for all objects of a given class).
|
||||
It is possible to specify a different set of class invariants for volatile public functions, namely /volatile class invariants/.
|
||||
It is also possible to specify /static class invariants/ which are excepted to be true before and after the execution of any constructor, destructor (even if it does not throw an exception), and public function (even if static).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Static and volatile class invariants were first introduced by this library to reflect the fact that C++ supports both static and volatile public functions.
|
||||
Static and volatile class invariants are not part of __N1962__ or other references listed in the __Bibliography__.
|
||||
]
|
||||
* /Subcontracting/: This indicates that preconditions cannot be strengthen, while postconditions and class invariants cannot be weaken when a public function in a derived class overrides public functions in one or more of its base classes (this is formally defined according to the __substitution_principle__).
|
||||
|
||||
Class invariants can also be used to specify /basic/ exception safety guarantees for an object (because they are checked at exit of public functions even when those throw an exception), while contract assertions for exception guarantees can be used to specify /strong/ exception safety guarantees for given operations on the same object.
|
||||
|
||||
It is also a common requirement for Contract Programming to automatically disable contract checking while already checking assertions from another contract (in order to avoid infinite recursion while checking contract assertions).
|
||||
|
||||
[note
|
||||
This library implements this requirement but in order to globally disable assertions while checking another assertion some kind of global arbitrating variable needs to be used by this library implementation.
|
||||
This library will automatically protect such a global variable from race conditions in multi-threated programs, but this will effectively introduce a global lock in the program (the [macroref BOOST_CONTRACT_DISABLE_THREADS] macro can be defined to disable this global lock but at the risk of incurring in race conditions).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
[macroref BOOST_CONTRACT_DISABLE_THREADS] is named after `BOOST_DISABLE_THREADS`.
|
||||
]
|
||||
]
|
||||
|
||||
In general, it is recommended to specify different contract conditions using separate assertion statements and not to group them together into a single condition using logical operators (`&&`, `||`, etc.).
|
||||
This is because when contract conditions are programmed together in a single assertion using logical operators, it is not be clear which condition actually failed in case the entire assertion fails at run-time.
|
||||
|
||||
[heading C-Style Assertions]
|
||||
|
||||
A limited form of Contract Programming is the use of the C-style `assert` macro.
|
||||
Using `assert` is common practice for many programmers but it suffers of the following limitations:
|
||||
|
||||
* `assert` does not distinguish between preconditions and postconditions.
|
||||
In well-tested production code, postconditions can usually be disabled trusting the correctness of the implementation while preconditions might still need to remain enabled because of possible changes in the calling code (e.g., postconditions of a given library could be disabled after testing while its preconditions can be kept enabled given the library cannot predict the evolution of user code that will be calling it).
|
||||
Using `assert` it is not possible to selectively disable only postconditions and all assertions must be disabled at once.
|
||||
* `assert` requires to manually program extra code to check class invariants (extra member functions, try blocks, etc.).
|
||||
* `assert` does not support subcontracting.
|
||||
* `assert` calls are usually scattered within function implementations thus the asserted conditions are not immediately visible in their entirety by programmers (as they are instead when the assertions appear in the function declaration or at least at the very top of function definition).
|
||||
|
||||
Contract Programming does not suffers of these limitations.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Benefits and Costs]
|
||||
|
||||
[heading Benefits]
|
||||
|
||||
The main use of Contract Programming is to improve software quality.
|
||||
__Meyer97__ discusses how Contract Programming can be used as the basic tool to write ["correct] software.
|
||||
__Stroustrup94__ discusses the key importance of class invariants plus advantages and disadvantages of preconditions and postconditions.
|
||||
The following is a short summary of the benefits associated with Contract Programming inspired mainly by __N1613__:
|
||||
|
||||
* Preconditions and postconditions:
|
||||
Using function preconditions and postconditions, programmers can give a precise semantic description of what a function requires at its entry and what it ensures at its exit (if it does not throw an exception).
|
||||
In particular, using postcondition old values, Contract Programming provides a mechanism that allows programmers to compare values of an expression before and after the function body execution.
|
||||
This mechanism is powerful enough to enable programmers to express many correctness constraints within the code itself, constraints that would otherwise have to be captured at best only informally by documentation.
|
||||
* Class invariants:
|
||||
Using class invariants, programmers can describe what to expect from a class and the logic dependencies between the class members.
|
||||
It is the job of the constructor to ensure that the class invariants are satisfied when the object is first created.
|
||||
Then the implementation of the member functions can be largely simplified as they can be written knowing that the class invariants are satisfied because Contract Programing checks them before and after the execution of every public function.
|
||||
Finally, the destructor makes sure that the class invariants held for the entire life of the object checking the class invariants one last time before the object is destructed.
|
||||
Class invariants can also be used as a criterion for good abstraction: If it is not possible to specify an invariant, it might be an indication that the design abstraction maybe be poor and it should not have been made into a class.
|
||||
* Self-documenting code:
|
||||
Contracts are part of the source code, they are checked at run-time so they are always up-to-date with the code itself.
|
||||
Therefore program specifications, as documented by the contracts, can be trusted to always be up-to-date with the implementation.
|
||||
* Easier debugging:
|
||||
Contract Programming can provide a powerful debugging facility because, if contracts are well written, bugs will cause contract assertions to fail exactly where the problem first occurs instead than at some later stage of the program execution in an apparently unrelated (and often hard to debug) manner.
|
||||
Note that a precondition failure points to a bug in the function caller, a postcondition failure points instead to a bug in the function implementation.
|
||||
[footnote
|
||||
Of course, if contracts are ill-written then Contract Programming is of little use.
|
||||
However, it is less likely to have a bug in both the function body and the contract than in the function body only.
|
||||
For example, consider the validation of a result in postconditions.
|
||||
Validating the return value might seem redundant, but in this case we actually want that redundancy.
|
||||
When programmers write a function, there is a certain probability that they make a mistake in implementing the function body.
|
||||
When programmers specify the result of the function in the postconditions, there is also a certain probability that they make a mistake in writing the contract.
|
||||
However, the probability that programmers make a mistake twice (in both the body /and/ the contract) is in general lower than the probability that the mistake is made just once (in either the body or the contract).
|
||||
]
|
||||
* Easier testing:
|
||||
Contract Programming facilitates testing because a contract naturally specifies what a test should check.
|
||||
For example, preconditions of a function state which inputs cause the function to fail and postconditions state which outputs are produced by the function on successful exit (Contract Programming should be seen as a tool to complement, but obviously not to replace, testing).
|
||||
* Formal design:
|
||||
Contract Programming can serve to reduce the gap between designers and programmers by providing a precise and unambiguous specification language in terms of the contract assertions.
|
||||
Moreover, contracts can make code reviews easier by clarifying some of the semantics and usage of the code.
|
||||
* Formalized inheritance:
|
||||
Contract Programming formalizes the virtual function overriding mechanism using subcontracting as justified by the __substitution_principle__.
|
||||
This keeps the base class programmers in control as overriding functions always have to fully satisfy the contracts of their base classes.
|
||||
* Replace Defensive Programming:
|
||||
Contract Programming assertions can replace [@http://en.wikipedia.org/wiki/Defensive_programming Defensive Programming] checks localizing these checks within the contract and making the code more readable.
|
||||
|
||||
Of course, not all formal contract specifications can be asserted in C++.
|
||||
For example, in C++ is it not possible to assert the validity of an iterator range in the general case because the only way to check if two iterators form a valid range is to keep incrementing the first iterator until we reach the second iterator.
|
||||
However, in case the iterator range is invalid, such a code would render undefined behaviour or run forever instead of failing an assertion.
|
||||
Nevertheless, a large amount of contract assertions can be successfully programmed in C++ as illustrated by the numerous examples in this documentation and from the literature (for example see how much of STL [link N1962_vector_anchor `vector`] contract assertions can actually be programmed in C++ using this library).
|
||||
|
||||
[heading Costs]
|
||||
|
||||
In general, Contract Programming benefits come at the cost of performance as discussed in detail by both __Stroustrup94__ and __Meyer97__.
|
||||
While performance trade-offs should be carefully considered depending on the specific application domain, software quality cannot be sacrificed: It is difficult to see value in software that quickly and efficiently provides incorrect results.
|
||||
|
||||
The run-time performances are negatively impacted by Contract Programming mainly because of extra time require to:
|
||||
|
||||
* Check the asserted conditions.
|
||||
* Copy old values when these are used in postconditions and exception guarantees.
|
||||
* Call additional functors that check preconditions, postconditions, exception guarantees, class invariants, etc. (especially for subcontracting).
|
||||
|
||||
[note
|
||||
In general, contracts introduce at least three extra functor calls to check preconditions, postconditions, and exception guarantees for any given non-member function call.
|
||||
Public functions introduce also two more function calls to check class invariants (at entry and at exit).
|
||||
For subcontracting, these extra calls (some of which become virtual calls) are repeated for the number of functions being overridden from the base classes (possibly deep in the inheritance tree).
|
||||
In addition to that, this library introduces a number of function calls internal to its implementation in order to properly check the contracts.
|
||||
]
|
||||
|
||||
To mitigate the run-time performance impact, programmers can selectively disable run-time checking of some of the contract assertions.
|
||||
Programmers will have to decide based on the performance trade-offs required by their applications, but a reasonable approach often is to (see __Disable_Contract_Checking__):
|
||||
|
||||
* Always write contracts to clarify the semantics of the design embedding the specifications directly in the code and making the code self-documenting.
|
||||
* Check preconditions, postconditions, class invariants, and maybe even exception guarantees during initial testing.
|
||||
* Only check preconditions (and maybe class invariants, but not postconditions and exception guarantees) during release testing and for the final release.
|
||||
|
||||
This approach is usually reasonable because in well-tested production code, validating the function body implementation using postconditions is rarely needed since the function has shown itself to be ["correct] during testing.
|
||||
On the other hand, checking function arguments using preconditions is always needed because of changes that can be made to the calling code (without having to necessarily re-test and re-release the called code).
|
||||
Furthermore, postconditions and also exception guarantees, with related old value copies, are often computationally more expensive to check than preconditions and even class invariants.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Function Calls]
|
||||
|
||||
[heading Non-Member Functions]
|
||||
|
||||
A call to a non-member function with a contract executes the following steps (see [funcref boost::contract::function]):
|
||||
|
||||
# Check function preconditions.
|
||||
# Execute the function body.
|
||||
# If the body did not throw an exception, check function postconditions.
|
||||
# Else, check function exception guarantees.
|
||||
|
||||
[heading Private and Protected Functions]
|
||||
|
||||
In Contract Programming, private and protected functions do not have to satisfy the class invariants because these functions are part of the class implementation and not of the class public interface.
|
||||
Furthermore, the __substitution_principle__ does not apply to private and protected functions because these functions are not accessible to the user at the calling site where the __substitution_principle__ applies.
|
||||
|
||||
Therefore, calls to private and protected functions with contracts execute the same steps as the ones indicated above for non-member functions (checking only preconditions and postconditions, but without checking class invariants and without subcontracting).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Public Function Calls]
|
||||
|
||||
[heading Overriding Public Functions]
|
||||
|
||||
Let's consider a public function in a derived class that overrides public virtual functions declared in a number of its public base classes (because of C++ multiple inheritance, the function could override from more than one base class).
|
||||
We refer to the function in the derived class as the /overriding function/, and to the set of base classes containing all the /overridden functions/ as /overridden bases/.
|
||||
|
||||
When subcontracting, overridden functions are searched (at compile-time) deeply in the public branches of the inheritance tree (i.e., not just the derived class's direct public parents are inspected, but also all its public grandparents, etc.).
|
||||
In case of multiple inheritance this search also extends widely to all multiple public base classes following their order of declaration in the derived class inheritance list (as usual in C++, this search could result in multiple overridden functions and therefore in subcontracting from multiple public base classes).
|
||||
Note that only public base classes are considered for subcontracting because private and protected base classes are not accessible to the user at the calling site where the __substitution_principle__ applies.
|
||||
|
||||
A call to the overriding public function with a contract executes the following steps (see [funcref boost::contract::public_function]):
|
||||
|
||||
# Check static class invariants __AND__ non-static class invariants for all overridden bases, __AND__ then check the derived class static __AND__ non-static invariants.
|
||||
# Check preconditions of overridden public functions from all overridden bases in __OR__ with each other, __OR__ else check the overriding function preconditions in the derived class.
|
||||
# Execute the overriding function body.
|
||||
# Check static class invariants __AND__ non-static class invariants for all overridden bases, __AND__ then check the derived class static __AND__ non-static invariants (even if the body threw an exception).
|
||||
# If the body did not throw an exception, check postconditions of overridden public functions from all overridden bases in __AND__ with each other, __AND__ then check the overriding function postconditions in the derived class.
|
||||
# Else, check exception guarantees of overridden public functions from all overridden bases in __AND__ with each other, __AND__ then check the overriding function exception guarantees in the derived class.
|
||||
|
||||
Volatile public functions check static class invariants __AND__ /volatile/ class invariants instead.
|
||||
Preconditions and postconditions of volatile public functions and volatile class invariants access the object as `volatile`.
|
||||
|
||||
Class invariants are checked before preconditions and postconditions so programming precondition and postcondition assertions can be simplified assuming that class invariants are satisfied already (e.g., if class invariants assert that a pointer cannot be null then preconditions and postconditions can safety dereference that pointer without additional checking).
|
||||
Similarly, subcontracting checks contracts of public base classes before checking the derived class contracts so programming derived class contract assertions can be simplified by assuming that public base class contracts are satisfied already.
|
||||
|
||||
[note
|
||||
[#and_anchor] [#or_anchor]
|
||||
In this documentation __AND__ and __OR__ indicate the logic /and/ and /or/ operations evaluated in /short-circuit/.
|
||||
For example: `p` __AND__ `q` is true if and only if both `p` and `q` are true, but `q` is never evaluated when `p` is false; `p` __OR__ `q` is true if and only if either `p` or `q` are true, but `q` is never evaluated when `p` is true.
|
||||
|
||||
As indicated by the steps above and in accordance with the __substitution_principle__, subcontracting checks preconditions in __OR__ while class invariants, postconditions, and exceptions guarantees in __AND__ with preconditions, class invariants, postconditions, and exceptions guarantees of base classes.
|
||||
]
|
||||
|
||||
[heading Non-Overriding Public Functions]
|
||||
|
||||
A call to a non-static public function with a contract (that does not override functions from any of the public base classes) executes the following steps (see [funcref boost::contract::public_function]):
|
||||
|
||||
# Check class static __AND__ non-static invariants (but none of the invariants from base classes).
|
||||
# Check function preconditions (but none of the preconditions from functions in base classes).
|
||||
# Execute the function body.
|
||||
# Check the class static __AND__ non-static invariants (even if the body threw an exception, but none of the invariants from base classes).
|
||||
# If the body did not throw an exception, check function postconditions (but none of the postconditions from functions in base classes).
|
||||
# Else, check function exception guarantees (but none of the exception guarantees from functions in base classes).
|
||||
|
||||
Volatile public functions check static class invariants __AND__ /volatile/ class invariants instead.
|
||||
Preconditions and postconditions of volatile functions and volatile class invariants access the object as `volatile`.
|
||||
|
||||
Class invariants are checked because this function is part of the class public interface.
|
||||
However, none of the contracts of the base classes are checked because this function does not override any functions from any of the public base classes (so the __substitution_principle__ does not require to subcontract in this case).
|
||||
|
||||
[heading Static Public Functions]
|
||||
|
||||
A call to a static public function with a contract executes the following steps (see [funcref boost::contract::public_function]):
|
||||
|
||||
# Check static class invariants (but not the non-static invariants and none of the invariants from base classes).
|
||||
# Check function preconditions (but none of the preconditions from function in base classes).
|
||||
# Execute the function body.
|
||||
# Check static class invariants (even if the body threw an exception, but not the non-static invariants and none of the invariants from base classes).
|
||||
# If the body did not throw an exception, check function postconditions (but none of the postconditions from functions in base classes).
|
||||
# Else, check function exception guarantees (but none of the exception guarantees from functions in base classes).
|
||||
|
||||
Class invariants are checked because this function is part of the class public interface, but only static class invariants can be checked (because this is a static function so it cannot access the object that would instead be required to check non-static class invariants, volatile or not).
|
||||
Furthermore, static functions cannot override any function so the __substitution_principle__ does not apply and they do not subcontract.
|
||||
|
||||
Preconditions and postconditions of static functions and static class invariants cannot access the object (because they are checked from `static` member functions).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Constructor Calls]
|
||||
|
||||
A call to a constructor with a contract executes the following steps (see [classref boost::contract::constructor_precondition] and [funcref boost::contract::constructor]):
|
||||
|
||||
# Check constructor preconditions (but these cannot access the object because the object is not constructed yet).
|
||||
# Execute the constructor member initialization list (if present).
|
||||
# Construct any base class (public or not) according with C++ construction mechanism and also check the contracts of these base constructors (according with steps similar to the ones listed here).
|
||||
# Check static class invariants (but not the non-static or volatile class invariants, because the object is not constructed yet).
|
||||
# Execute the constructor body.
|
||||
# Check static class invariants (even if the body threw an exception).
|
||||
# If the body did not throw an exception:
|
||||
# Check non-static __AND__ volatile class invariants (because the object is now successfully constructed).
|
||||
# Check constructor postconditions (but these cannot access the object old value [^['oldof]]`(*this)` because there was no object before the execution of the constructor body).
|
||||
# Else, check constructor exception guarantees (but these cannot access the object old value [^['oldof]]`(*this)` because there was no object before the execution of the constructor body, plus they can only access class static members because the object was not successfully constructed upon the constructor body throwing an exception).
|
||||
|
||||
Constructor preconditions are checked before executing the member initialization list so programming these initializations can be simplified assuming the constructor preconditions are satisfied (e.g., constructor arguments can be validated by the constructor preconditions before they are used to initialize base classes and data members).
|
||||
|
||||
As indicated in step 2.a. above, C++ object construction mechanism will automatically check base class contracts when these bases are initialized (no explicit subcontracting behaviour is required here).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Destructor Calls]
|
||||
|
||||
A call to a destructor with a contract executes the following steps (see [funcref boost::contract::destructor]):
|
||||
|
||||
# Check static class invariants __AND__ non-static __AND__ volatile class invariants.
|
||||
# Execute the destructor body (destructors have no parameters and they can be called at any time after object construction so they have no preconditions).
|
||||
# Check static class invariants (even if the body threw an exception).
|
||||
# If the body did not throw an exception:
|
||||
# Check destructor postconditions (but these can only access class static members and the object old value [^['oldof]]`(*this)` because there is no object after successful execution of the destructor body).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Postconditions for destructors are not part of __N1962__ or other references listed in the __Bibliography__ (but with respect to __Meyer97__ it should be noted that Eiffel does not support static data members and that might by why destructors do not have postconditions in Eiffel).
|
||||
However, in principle there could be uses for destructor postconditions so this library supports postconditions for destructors (e.g., a class that counts object instances could use destructor postconditions to assert that an instance counter stored in a static data member is decreased by `1` because the object has been destructed).
|
||||
]
|
||||
# Destroy any base class (public or not) according with C++ destruction mechanism and also check the contracts of these base destructors (according with steps similar to the ones listed here).
|
||||
# Else (even if destructors should rarely, if ever, be allowed to throw exceptions in C++):
|
||||
# Check non-static class invariants (because the object was not successfully destructed so it still exists and should satisfy its invariants).
|
||||
# Check destructor exception guarantees.
|
||||
|
||||
As indicated in step 4.b. above, C++ object destruction mechanism will automatically check base class contracts when the destructor exits without throwing an exception (no explicit subcontracting behaviour is required here).
|
||||
|
||||
[note
|
||||
Given that C++ allows destructors to throw, this library handles the case when the destructor body throws an exception as indicated above.
|
||||
However, in order to comply with STL exception safety guarantees and good C++ programming practices, programmers should implement destructor bodies to rarely, if ever, throw exceptions (in fact destructors are declared `noexcept` by default in C++11).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Constant-Correctness]
|
||||
|
||||
Contracts should not be allowed to modify the program state because they are only responsible to check (and not to change) the program state in order to verify its compliance with the specifications.
|
||||
Therefore, contracts should only have access to the object, function arguments, function return value, old values, and all other program variables in `const` context (via `const&`, `const* const`, `const volatile`, etc.).
|
||||
|
||||
Whenever possible (e.g., class invariants and postcondition old values), this library automatically enforces this constant-correctness constraint at compile-time using `const`.
|
||||
However, this library cannot automatically enforce this constraint in all cases (for preconditions and postconditions of mutable member functions, for global variables, etc.).
|
||||
See __No_Lambda_Functions__ for ways of using this library that always and automatically enforce the constant-correctness constraint at compile-time (but these methods require a significant amount of boiler-plate code to be programmed manually so they are not recommended in general).
|
||||
|
||||
[important
|
||||
In general, it is the responsibility of the programmers to code assertions that only check, and do not change, program variables.
|
||||
[footnote
|
||||
Note that also when using C-style `assert` it is the responsibility of the programmers to code assertions that only check and do not change program variables.
|
||||
]
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Specification vs. Implementation]
|
||||
|
||||
Contracts are part of the program specification and not of its implementation.
|
||||
Therefore, contracts should ideally be programmed within C++ declarations, and not within definitions.
|
||||
|
||||
In general, this library cannot satisfy this requirement.
|
||||
However, even when the contracts are programmed together with the body in the function definition, it is still very easy for users to identify and read just the contract portion of the function definition (because the contract code must always be programmed at the very top of the function definition).
|
||||
See __Separate_Body_Implementation__ for ways of using this library to program contract specifications outside of the body implementation but at the cost of writing one extra function for any given function (for applications were this requirement is truly important).
|
||||
|
||||
Furthermore, contracts are most useful when they assert conditions only using public members (in most cases, the need for using non-public members to check contracts, especially in preconditions, indicates an error in the class design).
|
||||
For example, the caller of a public function cannot in general make sure that the function preconditions are satisfied if the precondition assertions use private members that are not callable by the caller (therefore, a failure in the preconditions will not necessarily indicate a bug in the caller given that the caller was made unable to fully check the preconditions in the first place).
|
||||
|
||||
However, given that C++ provides programmers ways around access level restrictions (`friend`, function pointers, etc.), this library leaves it up to the programmers to make sure that only public members are used in contract assertions (especially in preconditions). (__N1962__ follows the same approach not restricting contracts to only use public members, Eiffel instead generates a compile-time error if preconditions are asserted using non-public members.)
|
||||
[footnote
|
||||
*Rationale:*
|
||||
If C++ [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#45 defect 45] had not been fixed, this library could have been implemented so to generate a compile-time error when precondition assertions use non-public members more similarly to Eiffel's implementation (but not necessary the best approach for C++).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section On Contract Failure]
|
||||
|
||||
If precondition, postcondition, exception guarantee, or class invariant assertions are either checked to be false or their evaluation throws an exception at run-time then this library will call specific /failure handler functions/.
|
||||
|
||||
By default, these failure handler functions print a message to the standard error `std::cerr` (with detailed information about the failure) and then terminate the program calling `std::terminate`.
|
||||
However, using [funcref boost::contract::set_precondition_failure], [funcref boost::contract::set_postcondition_failure], [funcref boost::contract::set_except_failure], [funcref boost::contract::set_invariant_failure], etc. programmers can define their own failure handler functions that can take any user-specified action (throw an exception, exit the program with an error code, etc., see __Throw_on_Failure__).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
This customizable failure handling mechanism is similar to the one used by C++ `std::terminate` and also to the one proposed in __N1962__.
|
||||
]
|
||||
|
||||
[note
|
||||
In C++ there are a number of issues with programming contract failure handlers that throw exceptions instead of terminating the program.
|
||||
Specifically, destructors check class invariants so they will throw if programmers change class invariant failure handlers to throw instead of terminating the program, but in general destructors should not throw in C++ (to comply with STL exception safety, etc.).
|
||||
Furthermore, programming an exception guarantee failure handler to throw will throw an exception (the one reporting the contract failure) while there is already an active exception (the one that caused the exception guarantees to be checked in the first place), and this will force C++ to terminate the program anyway.
|
||||
]
|
||||
|
||||
Therefore, it is recommended to terminate the program at least for contract failures from destructors and exception guarantees (if not in all other cases of contract failures as it is done by default by this library).
|
||||
The contract failure handler functions programmed using this library have information about the failed contract (preconditions, postconditions, etc.) and the operation that was checking the contract (constructor, destructor, etc.) so programmers can granularly distinguish all cases and decide when it is appropriate to terminate, throw, or take some other user-specific action.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Feature Summary]
|
||||
|
||||
The Contract Programming features supported by this library are largely based on __N1962__ and on the Eiffel programming language.
|
||||
The following table compares Contract Programming features among this library, __N1962__ (unfortunately the C++ standard committee rejected this proposal commenting on a general lack of need for adding Contract Programming to C++ at the time, even if __N1962__ itself is sound), a more recent proposal __P0380__ (which unfortunately only supports preconditions and postconditions, but does not support class invariants, old values, and subcontracting), the Eiffel and D programming languages:
|
||||
|
||||
[table
|
||||
[
|
||||
[Feature]
|
||||
[This Library]
|
||||
[__N1962__ Proposal (not accepted in C++)]
|
||||
[__P0380__ Proposal (being considered for C++2x)]
|
||||
[ISE Eiffel 5.4 (see __Meyer97__)]
|
||||
[D (see __Bright04__)]
|
||||
][
|
||||
[['Keywords and specifiers]]
|
||||
[
|
||||
Specifiers: `precondition`, `postcondition`, `invariant`, `static_invariant`, and `base_types`.
|
||||
The last three specifiers appear in user code so their names can be referred to or changed using [macroref BOOST_CONTRACT_INVARIANT], [macroref BOOST_CONTRACT_STATIC_INVARIANT], and [macroref BOOST_CONTRACT_BASES_TYPEDEF] macros respectively to avoid name clashes.
|
||||
]
|
||||
[Keywords: `precondition`, `postcondition`, `oldof`, and `invariant`.]
|
||||
[Attributes: `[[expects]]` and `[[ensures]]`.]
|
||||
[Keywords: =require=, =require else=, =ensure=, =ensure then=, =old=, =result=, =do=, and =invariant=.]
|
||||
[Keywords: =in=, =out=, =assert=, and =invariant=.]
|
||||
][
|
||||
[['On contract failure]]
|
||||
[Print an error to `std::cerr` and call `std::terminate` (but can be customized to throw exceptions, exit with an error code, etc.).]
|
||||
[Call `std::terminate` (but can be customized to throw exceptions, exit with an error code, etc.).]
|
||||
[Call `std::abort` (but can be customized to throw exceptions, exit with an error code, etc.).]
|
||||
[Throw exceptions.]
|
||||
[Throw exceptions.]
|
||||
][
|
||||
[['Result value in postconditions]]
|
||||
[Yes, captured by or passed as a parameter to (for virtual functions) the postcondition functor.]
|
||||
[Yes, `postcondition(`[^['result-variable-name]]`)`.]
|
||||
[Yes, `[[ensures `[^['result-variable-name]]`: ...]]`.]
|
||||
[Yes, =result= keyword.]
|
||||
[No.]
|
||||
][
|
||||
[['Old values in postconditions]]
|
||||
[
|
||||
Yes, [macroref BOOST_CONTRACT_OLD] macro and [classref boost::contract::old_ptr] (but copied before preconditions unless `.old(...)` is used as shown in __Old_Copies_at_Body__).
|
||||
For templates, [classref boost::contract::old_ptr_if_copyable] skips old value copies for non-copyable types and [funcref boost::contract::condition_if] skips old value copies selectively based on old expression type requirements.
|
||||
]
|
||||
[
|
||||
Yes, `oldof` keyword (copied after preconditions and before body).
|
||||
(Never skipped, not even in templates for non-copyable types.)
|
||||
]
|
||||
[No.]
|
||||
[
|
||||
Yes, =old= keyword (copied after preconditions and before body).
|
||||
(Never skipped, but all types are copyable in Eiffel.)
|
||||
]
|
||||
[No.]
|
||||
][
|
||||
[['Class invariants]]
|
||||
[
|
||||
Checked at constructor exit, at destructor entry and throw, and at public function entry, exit, and throw.
|
||||
Same for volatile class invariants.
|
||||
Static class invariants checked at entry and exit of constructor, destructor, and any (also `static`) public function.
|
||||
]
|
||||
[
|
||||
Checked at constructor exit, at destructor entry and throw, and at public function entry, exit, and throw.
|
||||
(Volatile and static class invariants not supported.)
|
||||
]
|
||||
[No.]
|
||||
[
|
||||
Checked at constructor exit, and around public functions.
|
||||
(Volatile and static class invariants do not apply to Eiffel.)
|
||||
]
|
||||
[
|
||||
Checked at constructor exit, at destructor entry, and around public functions.
|
||||
(Volatile and static class invariants not supported, `volatile` was deprecated all together in D.)
|
||||
]
|
||||
][
|
||||
[['Subcontracting]]
|
||||
[
|
||||
Yes, also supports subcontracting for multiple inheritance ([macroref BOOST_CONTRACT_BASE_TYPES], [macroref BOOST_CONTRACT_OVERRIDE], and [classref boost::contract::virtual_] are used for declaring base classes, overriding and virtual public functions respectively).
|
||||
]
|
||||
[
|
||||
Yes, also supports subcontracting for multiple inheritance but only preconditions only in base classes.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The authors of __N1962__ decided to forbid derived classes from subcontracting preconditions because they found that such a feature was rarely, if evet, used (see [@http://lists.boost.org/Archives/boost/2010/04/164862.php Re: \[boost\] \[contract\] diff n1962]).
|
||||
Still, it should be noted that even in __N1962__ if a derived class overrides two functions with preconditions coming from two different base classes via multiple inheritance, the overriding function contract will check preconditions from its two base class functions in __OR__ (so even in __N1962__ preconditions can indirectly subcontract when multiple inheritance is used).
|
||||
The authors of this library found that confusing about __N1962__.
|
||||
Furthermore, subcontracting preconditions is soundly defined by the __substitution_principle__ so this library allows to subcontract preconditions as Eiffel does (users can always avoid using this feature if they have no need for it).
|
||||
(This is essentially the only feature for which this library deliberately differ from __N1962__.)
|
||||
]
|
||||
]
|
||||
[No.]
|
||||
[Yes.]
|
||||
[Yes.]
|
||||
][
|
||||
[['Contracts for pure virtual functions]]
|
||||
[Yes (but they must be programmed in out-of-line functions as always in C++ with pure virtual function definitions).]
|
||||
[Yes.]
|
||||
[No (because no subcontracting).]
|
||||
[Yes (contracts for abstract functions).]
|
||||
[No (but planned).]
|
||||
][
|
||||
[['Arbitrary code in contracts]]
|
||||
[Yes (but users are generally recommended to only program assertions using [macroref BOOST_CONTRACT_ASSERT] and if-guard statements within contracts to avoid introducing bugs and expensive code in contracts, and also to only use public functions to program preconditions).]
|
||||
[No, assertions only.]
|
||||
[No, assertions only. In addition only public members can be used in preconditions.]
|
||||
[No, assertions only. In addition only public members can be used in preconditions.]
|
||||
[Yes.]
|
||||
][
|
||||
[['Constant-correctness]]
|
||||
[Enforced only for class invariants and old values (making also preconditions and postconditions constant-correct is possible but requires users to program a fare amount of boiler-plate code).]
|
||||
[Yes.]
|
||||
[Yes.]
|
||||
[Yes.]
|
||||
[No.]
|
||||
][
|
||||
[['Contracts in specifications or implementation]]
|
||||
[Implementation (unless programmers manually write an extra function for any given function).]
|
||||
[Specification (function declaration).]
|
||||
[Specification (function declaration).]
|
||||
[Specification.]
|
||||
[Specification.]
|
||||
][
|
||||
[['Function code ordering]]
|
||||
[Preconditions, postconditions, exception guarantees, body.]
|
||||
[Preconditions, postconditions, body.]
|
||||
[Preconditions, postconditions, body.]
|
||||
[Preconditions, body, postconditions.]
|
||||
[Preconditions, postconditions, body.]
|
||||
][
|
||||
[['Disable assertion checking within assertions checking (to avoid infinite recursion when checking contracts)]]
|
||||
[
|
||||
Yes, but use [macroref BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTION] to disable no assertion while checking preconditions (see [macroref BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION]).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Theoretically, it can be shown that an incorrect argument might be passed to the function body when assertion checking is disabled while checking preconditions (see [@http://lists.boost.org/Archives/boost/2010/04/164862.php Re: \[boost\] \[contract\] diff n1962]).
|
||||
Therefore, __N1962__ does not disable any assertion while checking preconditions.
|
||||
However, that makes it possible to have infinite recursion while checking preconditions, plus Eiffel disables assertion checking also while checking preconditions.
|
||||
Therefore, this library by default disables assertion checking also while checking preconditions, but it also provides the [macroref BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTION] configuration macro so users can change this behaviour if needed.
|
||||
]
|
||||
(In multi-threaded programs this introduces a global lock, see [macroref BOOST_CONTRACT_DISABLE_THREADS].)
|
||||
]
|
||||
[Yes for class invariants and postconditions, but preconditions disable no assertion.]
|
||||
[No.]
|
||||
[Yes.]
|
||||
[No.]
|
||||
][
|
||||
[['Nested member function calls]]
|
||||
[
|
||||
Disable nothing.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Older versions of this library defined a data member in the user class that was automatically used to disable checking of class invariants within nested member function calls (similarly to Eiffel).
|
||||
This feature was also required by older revisions of __N1962__ but it is no longer required by __N1962__.
|
||||
Furthermore, in multi-threaded programs this feature would introduce a lock that synchronizes all member functions calls for a given object.
|
||||
Therefore, this feature was removed in the current revision of this library.
|
||||
]
|
||||
]
|
||||
[Disable nothing.]
|
||||
[Disable nothing.]
|
||||
[Disable all contract assertions.]
|
||||
[Disable nothing.]
|
||||
][
|
||||
[['Disable contract checking]]
|
||||
[Yes, contract checking can be skipped at run-time by defining combinations of the [macroref BOOST_CONTRACT_NO_PRECONDITIONS], [macroref BOOST_CONTRACT_NO_POSTCONDITIONS], [macroref BOOST_CONTRACT_NO_INVARIANTS], [macroref BOOST_CONTRACT_NO_ENTRY_INVARIANTS], and [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS] macros (completely removing contract code from compiled object code is possible but requires using macros shown in __Disable_Contract_Compilation__).]
|
||||
[Yes (contract code also removed from compiled object code, but details are compiler-implementation specific).]
|
||||
[Yes (contract code also removed from compiled object code, but details are compiler-implementation specific).]
|
||||
[Yes, but only predefined combinations of preconditions, postconditions, and class invariants can be disabled (contract code also removed from compiled object code).]
|
||||
[Yes.]
|
||||
][
|
||||
[['Assertion levels]]
|
||||
[Yes, predefined default, audit, and axiom plus programmers can define their own levels.]
|
||||
[No (but a previous revision of this proposal considered adding assertion levels called "assertion ordering").]
|
||||
[Yes, predefined default, audit, and axiom.]
|
||||
[No.]
|
||||
[No.]
|
||||
]
|
||||
]
|
||||
|
||||
The authors of this library also consulted the following references that implemented Contract Programming for C++ (but usually for only a limited set of features, or using preprocessing tools other than the C++ preprocessor and external to the language itself) or for languages other than C++ (see __Bibliography__ for a complete list of all the references consulted in the design and development of this library):
|
||||
|
||||
[table
|
||||
[ [Reference] [Language] [Notes] ]
|
||||
[ [__Bright04b__] [C++] [
|
||||
The Digital Mars C++ compiler extends C++ adding Contract Programming language support (among many other features).
|
||||
] ]
|
||||
[ [__Lindrud04__] [C++] [
|
||||
This supports class invariants and old values but it does not support subcontracting (contracts are specified within definitions instead of declarations and assertions are not constant-correct).
|
||||
] ]
|
||||
[ [__Tandin04__] [C++] [
|
||||
Interestingly, these contract macros automatically generate Doxygen documentation
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Older versions of this library also automatically generated Doxygen documentation from contract definition macros.
|
||||
This functionality was abandoned for a number of reasons: this library no longer uses macros to program contracts; even before that, the implementation of this library macros became too complex and the Doxygen preprocessor was no longer able to expand them; the Doxygen documentation was just a repeat of the contract code (so programmers could directly look at contracts in the source code); Doxygen might not necessarily be the documentation tool used by all C++ programmers.
|
||||
]
|
||||
but old values, class invariants, and subcontracting are not supported (plus contracts are specified within definitions instead of declarations and assertions are not constant-correct).
|
||||
] ]
|
||||
[ [__Maley99__] [C++] [
|
||||
This supports Contract Programming including subcontracting but with limitations (e.g., programmers need to manually build an inheritance tree using artificial template parameters), it does not use macros but programmers are required to write by hand a significant amount of boiler-plate code.
|
||||
(The authors have found this work very inspiring when developing initial revisions of this library especially for its attempt to support subcontracting.)
|
||||
] ]
|
||||
[ [__Nana__] [C++] [
|
||||
This uses macros but it only works on GCC (and maybe Clang, but it does not work on MSVC, etc.).
|
||||
It does not support subcontracting.
|
||||
It requires extra care to program postconditions for functions with multiple return statements.
|
||||
It seems that it might not check class invariants when functions throw exceptions (unless the `END` macro does that...).
|
||||
(In addition, it provides tools for logging and integration with GDB.)
|
||||
] ]
|
||||
[ [__C2__] [C++] [
|
||||
This uses an external preprocessing tool (the authors could no longer find this project's code to evaluate it).
|
||||
] ]
|
||||
[ [__iContract__] [Java] [
|
||||
This uses an external preprocessing tool.
|
||||
] ]
|
||||
[ [__Jcontract__] [Java] [
|
||||
This uses an external preprocessing tool.
|
||||
] ]
|
||||
[ [__CodeContracts__] [.NET] [
|
||||
Microsoft Contract Programming for .NET programming languages.
|
||||
] ]
|
||||
[ [__SpecSharp__] [C#] [
|
||||
This is a C# extension with Contract Programming language support.
|
||||
] ]
|
||||
[ [__Chrome__] [Object Pascal] [
|
||||
This is the .NET version of Object Pascal and it has language support for Contract Programming.
|
||||
] ]
|
||||
[ [__SPARKAda__] [Ada] [
|
||||
This is an Ada-like programming language with support for Contract Programming.
|
||||
] ]
|
||||
]
|
||||
|
||||
To the best knowledge of the authors, this the only library that fully supports all Contract Programming features for C++.
|
||||
Generally speaking:
|
||||
|
||||
* Implementing preconditions and postconditions in C++ is not difficult (e.g., using some kind of RAII object).
|
||||
* Implementing postcondition old values is also not too difficult usually requiring programmers to copy old values into local variables, but it is already somewhat more difficult to ensure such copies are not performed when postconditions are disabled.
|
||||
[footnote
|
||||
For example, the following emulation of old values based on __P0380__ never disables old value copies plus requires boiler-plate code to make sure postconditions are correctly checked in a `scope_exit` RAII object after all other local objects have been destroyed (because some of these destructors contribute to establishing the postconditions) and only if the function did not throw an exception:
|
||||
``
|
||||
void fswap(file& x, file& y)
|
||||
[[expects: x.closed()]]
|
||||
[[excepts: y.closed()]]
|
||||
// Postconditions in function definition below to emulate old values.
|
||||
{
|
||||
file old_x = x; // Emulate old values with local copies (not disabled).
|
||||
file old_y = y;
|
||||
scope_exit ensures([&] { // Check after local objects destroyed.
|
||||
if(!std::uncaught_exception()) { // Check only if no throw.
|
||||
[[assert: x.closed()]]
|
||||
[[assert: y.closed()]]
|
||||
[[assert: x == old_y]]
|
||||
[[assert: y == old_x]]
|
||||
}
|
||||
});
|
||||
|
||||
x.open();
|
||||
scope_exit close_x([&] { x.close(); });
|
||||
y.open();
|
||||
scope_exit close_y([&] { y.close(); });
|
||||
file t = file::temp();
|
||||
t.open;
|
||||
scope_exit close_t([&] { t.close(); });
|
||||
|
||||
x.mv(t);
|
||||
y.mv(x);
|
||||
t.mv(y);
|
||||
}
|
||||
``
|
||||
Here `scope_exit` is an RAII object that executes the nullary functor passed to its constructor when it is destroyed.
|
||||
]
|
||||
|
||||
* Implementing class invariants is more involved (especially if done automatically, without requiring programmers to manually invoke extra functions to check the invariants).
|
||||
[footnote
|
||||
For example, the following possible emulation of class invariants based on __P0380__ requires boiler-plate code to manually invoke the function that checks the invariants (note that invariants are checked at public function exit regardless of exceptions being thrown while postconditions are not):
|
||||
``
|
||||
template<typename T>
|
||||
class vector {
|
||||
bool invariant() const { // Check invariants at...
|
||||
[[assert: empty() == (size() == 0)]]
|
||||
[[assert: size() <= capacity()]]
|
||||
return true;
|
||||
}
|
||||
|
||||
public:
|
||||
vector()
|
||||
[[ensures: invariant()]] // ...constructor exit (only if no throw).
|
||||
{ ... }
|
||||
|
||||
~vector() noexcept
|
||||
[[expects: invariant()]] // ...destructor entry.
|
||||
{ ... }
|
||||
|
||||
void push_back(T const& value)
|
||||
[[expects: invariant()]] // ...public function entry.
|
||||
[[ensures: invariant()]] // ...public function exit (if no throw).
|
||||
try {
|
||||
... // Function body.
|
||||
} catch(...) {
|
||||
invariant(); // ...public function exit (if throw).
|
||||
throw;
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
``
|
||||
In case the destructor can throw (e.g., it is declared `noexcept(false)`), the destructor also requires a `try-catch` statement similar to the one programmed for `push_back` to check class invariants at destructor exit when it throws exceptions.
|
||||
]
|
||||
All references reviewed by the authors seem to not consider static and volatile functions not supporting static and volatile invariants respectively.
|
||||
|
||||
* Implementing subcontracting involves a significant amount of complexity and it seems to not be properly supported by any C++ library other than this one (especially when handling multiple inheritance, correctly copying postcondition old values across all overridden contracts deep in the inheritance tree, and correctly reporting the return value to the postconditions of overridden virtual functions in base classes).
|
||||
[footnote
|
||||
For example, it is not really possible to sketch pseudocode based on __P0380__ that emulates subcontracting in the general case.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
172
doc/examples.qbk
172
doc/examples.qbk
@ -1,172 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Examples]
|
||||
|
||||
This section lists some examples taken from different sources discussing Contract Programming and implemented here using this library.
|
||||
|
||||
[note
|
||||
Some of these examples might be from old code, containing obsolete coding practices, not optimized for execution speed, not complete, and they might be more relevant in the context of programming languages different from C++.
|
||||
Nevertheless, programmers are encouraged to review these examples to see a few diverse usages of this library that might be relevant to their needs.
|
||||
]
|
||||
|
||||
Sources of the listed examples:
|
||||
|
||||
* __N1962__: Examples from the proposal to add Contract Programming to C++11 (unfortunately, this proposal was never accepted into the standard).
|
||||
* __Meyer97__: Examples using the Eiffel programming language and reprogrammed using this library for C++.
|
||||
* __Mitchell02__: Additional examples using the Eiffel programming language and reprogrammed using this library for C++.
|
||||
* __Cline90__: Examples from a very early proposal called Annotated C++ (A++) to add Contract Programming to C++ (A++ was never implemented or proposed for addition to the standard).
|
||||
|
||||
A few notable examples:
|
||||
|
||||
* [link N1962_vector_anchor \[N1962\] Vector]: Complete contracts for `std::vector` and a comparison with __N1962__ syntax.
|
||||
* [link N1962_square_root_anchor \[N1962\] Square Root]: Comparison with D syntax.
|
||||
* [link Mitchell02_counter_anchor \[Mitchell02\] Counter]: Subcontracting.
|
||||
* [link Meyer97_stack4_anchor \[Meyer97\] Stack4]: Comparison with Eiffel syntax.
|
||||
* [link Cline90_vector_anchor \[Cline90\] Vector]: Comparison with A++ syntax.
|
||||
|
||||
[#N1962_vector_anchor]
|
||||
[section \[N1962\] Vector: Contracts for STL vector and comparison with C++11 proposal syntax]
|
||||
|
||||
On compilers that support C++17 `if constexpr`, the following example using this library can be simplified removing [funcref boost::contract::condition_if] and related functor templates such as `all_of_equal_to`, etc. (making it more similar to the pseudo-code on the right-hand side).
|
||||
|
||||
[import ../example/n1962/vector.cpp]
|
||||
[import ../example/n1962/vector_n1962.hpp]
|
||||
[table
|
||||
[ [This library] [\[N1962\] proposal (not accepted in C++) plus C++17 [^if constexpr]] ]
|
||||
[ [[n1962_vector]] [[n1962_vector_n1962]] ]
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section \[N1962\] Circle: Subcontracting]
|
||||
[import ../example/n1962/circle.cpp]
|
||||
[n1962_circle]
|
||||
[endsect]
|
||||
|
||||
[#N1962_factorial_anchor]
|
||||
[section \[N1962\] Factorial: Recursion]
|
||||
[import ../example/n1962/factorial.cpp]
|
||||
[n1962_factorial]
|
||||
[endsect]
|
||||
|
||||
[section \[N1962\] Equal: Operators]
|
||||
[import ../example/n1962/equal.cpp]
|
||||
[n1962_equal]
|
||||
[endsect]
|
||||
|
||||
[section \[N1962\] Sum: Array parameter]
|
||||
[import ../example/n1962/sum.cpp]
|
||||
[n1962_sum]
|
||||
[endsect]
|
||||
|
||||
[#N1962_square_root_anchor]
|
||||
[section \[N1962\] Square Root: Default parameters and comparison with D syntax]
|
||||
[import ../example/n1962/sqrt.cpp]
|
||||
[import ../example/n1962/sqrt.d]
|
||||
[table
|
||||
[ [This Library] [The D Programming Language] ]
|
||||
[ [[n1962_sqrt]] [[n1962_sqrt_d]] ]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[#Meyer97_stack4_anchor]
|
||||
[section \[Meyer97\] Stack4: Comparison with Eiffel syntax]
|
||||
[import ../example/meyer97/stack4.hpp]
|
||||
[import ../example/meyer97/stack4_main.cpp]
|
||||
[import ../example/meyer97/stack4.e]
|
||||
[table
|
||||
[ [This Library] [The Eiffel Programming Language] ]
|
||||
[ [[meyer97_stack4]] [[meyer97_stack4_e]] ]
|
||||
[ [[meyer97_stack4_main]] [] ]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[section \[Meyer97\] Stack3: Error codes instead of preconditions]
|
||||
[import ../example/meyer97/stack3.cpp]
|
||||
[meyer97_stack3]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Name List: Relaxed subcontracts]
|
||||
[import ../example/mitchell02/name_list.cpp]
|
||||
[mitchell02_name_list]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Dictionary: Key-value map]
|
||||
[import ../example/mitchell02/dictionary.cpp]
|
||||
[mitchell02_dictionary]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Courier: Subcontracting and static class invariants]
|
||||
[import ../example/mitchell02/courier.cpp]
|
||||
[mitchell02_courier]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Stack: Stack-like container]
|
||||
[import ../example/mitchell02/stack.cpp]
|
||||
[mitchell02_stack]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Simple Queue: Queue-like container and disable old value copies for audit assertions]
|
||||
[import ../example/mitchell02/simple_queue.cpp]
|
||||
[mitchell02_simple_queue]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Customer Manager: Contracts instead of Defensive Programming]
|
||||
[import ../example/mitchell02/customer_manager.cpp]
|
||||
[mitchell02_customer_manager]
|
||||
[endsect]
|
||||
|
||||
[section \[Mitchell02\] Observer: Pure virtual functions]
|
||||
[import ../example/mitchell02/observer/observer.hpp]
|
||||
[mitchell02_observer]
|
||||
[import ../example/mitchell02/observer/subject.hpp]
|
||||
[mitchell02_subject]
|
||||
[import ../example/mitchell02/observer_main.cpp]
|
||||
[mitchell02_observer_main]
|
||||
[endsect]
|
||||
|
||||
[#Mitchell02_counter_anchor]
|
||||
[section \[Mitchell02\] Counter: Subcontracting]
|
||||
[import ../example/mitchell02/counter/push_button.hpp]
|
||||
[mitchell02_push_button]
|
||||
[import ../example/mitchell02/counter/decrement_button.hpp]
|
||||
[mitchell02_decrement_button]
|
||||
[import ../example/mitchell02/counter/counter.hpp]
|
||||
[mitchell02_counter]
|
||||
[import ../example/mitchell02/counter_main.cpp]
|
||||
[mitchell02_counter_main]
|
||||
[endsect]
|
||||
|
||||
[#Cline90_vector_anchor]
|
||||
[section \[Cline90\] Vector: Comparison with A++ proposal syntax]
|
||||
[import ../example/cline90/vector.hpp]
|
||||
[import ../example/cline90/vector_main.cpp]
|
||||
[import ../example/cline90/vector_axx.hpp]
|
||||
[table
|
||||
[ [This Library] [A++ Proposal (never actually implemented)] ]
|
||||
[ [[cline90_vector]] [[cline90_vector_axx]] ]
|
||||
[ [[cline90_vector_main]] [] ]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[section \[Cline90\] Stack: Stack-like container]
|
||||
[import ../example/cline90/stack.cpp]
|
||||
[cline90_stack]
|
||||
[endsect]
|
||||
|
||||
[section \[Cline90\] Vector-Stack: Subcontracting]
|
||||
[import ../example/cline90/vstack.cpp]
|
||||
[cline90_vstack]
|
||||
[endsect]
|
||||
|
||||
[section \[Cline90\] Calendar: A very simple calendar]
|
||||
[import ../example/cline90/calendar.cpp]
|
||||
[cline90_calendar]
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
612
doc/extras.qbk
612
doc/extras.qbk
@ -1,612 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Extras]
|
||||
|
||||
This section can be consulted selectively for specific topics of interest.
|
||||
|
||||
[section Old Value Requirements (Templates)]
|
||||
|
||||
Old values require to copy the expression passed to [macroref BOOST_CONTRACT_OLDOF] thus the type of that expression must be copyable.
|
||||
More precisely, dereferencing an old value pointer of type [classref boost::contract::old_ptr]`<T>` requires [classref boost::contract::is_old_value_copyable]`<T>::value` to be `true` (otherwise this library will generate a compile-time error).
|
||||
|
||||
In some cases it might be acceptable, or even desirable, to cause a compile-time error when a program uses old value types that are not copyable (because it is not possible to fully check the correctness of the program as stated by the contract assertions that use these old values).
|
||||
In these cases, programmers can declare old values using [classref boost::contract::old_ptr] as seen so far.
|
||||
|
||||
However, in some other cases it might be desirable to skip assertions that use old values when the respective old value types are not copyable.
|
||||
Programmers can do this by using [classref boost::contract::old_ptr_if_copyable] instead of [classref boost::contract::old_ptr] to program these old values and by checking if the old value pointer is not null before dereferencing it in postconditions.
|
||||
For example, consider the following function template that could in general be instantiated for types `T` that are not copy constructible (that is for which [classref boost::contract::is_old_value_copyable]`<T>::value` is `false`, see [@../../example/features/old_if_copyable.cpp =old_if_copyable.cpp=]):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
__N1962__ and other proposals to add contracts to C++ do not provide a mechanism to selectively disable copies for only old value types that are not copy constructible.
|
||||
However, this library provides such a mechanism to allow to program contracts for template code without necessarily adding extra copy constructible type requirements that would not be present if it were not for copying the old values (so compiling the code with and without contracts will not necessarily alter the type requirements of the program).
|
||||
Something similar could be achieved combing C++17 `if constexpr` with __N1962__ or __P0380__ so that old value expressions within template code could be guarded by `if constexpr` statements checking if the old value types are copyable or not.
|
||||
For example, assuming old values are added to __P0380__ (e.g., via `oldof`) and that C++17 `if constexpr` can be used within __P0380__ contracts:
|
||||
``
|
||||
template<typename T>
|
||||
void offset(T& x, int count)
|
||||
[[ensures: if constexpr(std::is_copy_constructible<T>::value) x == oldof(x) + count]]
|
||||
...
|
||||
``
|
||||
]
|
||||
|
||||
[import ../example/features/old_if_copyable.cpp]
|
||||
[old_if_copyable_offset]
|
||||
|
||||
The old value pointer `old_x` is programmed using [classref boost::contract::old_ptr_if_copyable] so if `T` is not copyable then `x` will simply not be copied and `old_x` will be left as a null pointer (here `old_x` must be checked to be not null `if(old_x) ...` before it is dereferenced in postconditions and exception guarantees).
|
||||
If the above example used [classref boost::contract::old_ptr] instead then the library would have generated a compile-time error when `offset` is instantiated with types `T` that are not copy constructible (but only if `old_x` is actually dereferenced somewhere in the contract assertions using `*old_x ...`, `old_x->...`, etc.).
|
||||
|
||||
When C++11 `auto` declarations are used with [macroref BOOST_CONTRACT_OLDOF], this library always defaults to using the [classref boost::contract::old_ptr] type (because this type requirements are more stringent, if programmers want to relax the copyable type requirement they must do so explicitly by using [classref boost::contract::old_ptr_if_copyable] instead of using `auto`).
|
||||
For example, the following will use [classref boost::contract::old_ptr] and not [classref boost::contract::old_ptr_if_copyable] to declare `old_x`:
|
||||
|
||||
auto old_x = BOOST_CONTRACT_OLDOF(x); // C++11 auto declarations always use `old_ptr` (never `old_ptr_if_copyable`).
|
||||
|
||||
This library internally uses [classref boost::contract::is_old_value_copyable] to determine if an old value type is copyable or not, and then [classref boost::contract::old_value_copy] to actually copy the old value.
|
||||
By default, [classref boost::contract::is_old_value_copyable]`<T>` is equivalent to `boost::is_copy_constructible<T>` and [classref boost::contract::old_value_copy]`<T>` is implemented using `T`'s copy constructor.
|
||||
However, these type traits can be specialized by programmers for example to avoid making old value copies of types even when they have a copy constructor (maybe because these copy constructors are too expensive), or to make old value copies for types that do not have a copy constructor, or for any other specific need programmers might have for the types in question.
|
||||
For example, the following specialization of [classref boost::contract::is_old_value_copyable] intentionally avoids making old value copies for all expressions of type `w` even if that type has a copy constructor (see [@../../example/features/old_if_copyable.cpp =old_if_copyable.cpp=]):
|
||||
|
||||
[old_if_copyable_w_decl]
|
||||
[old_if_copyable_w_spec]
|
||||
|
||||
On the flit side, the following specializations of [classref boost::contract::is_old_value_copyable] and [classref boost::contract::old_value_copy] make old value copies of expressions of type `p` even if that type does not actually have a copy constructor (see [@../../example/features/old_if_copyable.cpp =old_if_copyable.cpp=]):
|
||||
|
||||
[old_if_copyable_p_decl]
|
||||
[old_if_copyable_p_spec]
|
||||
|
||||
[heading No C++11]
|
||||
|
||||
In general, `boost::contract::is_copy_constructible` and therefore [classref boost::contract::is_old_value_copyable] require C++11 `decltype` and SFINAE to automatically detect if a given type is not copyable.
|
||||
On non-C++11 compilers, it is possible to inherit the old value type from `boost::noncopyable`, or use `BOOST_MOVABLE_BUT_NOT_COPYABLE`, or specialize `boost::is_copy_constructible` (see [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/boost_typetraits/reference/is_copy_constructible.html `boost::is_copy_constructible`] documentation for more information).
|
||||
Alternatively, it is possible to just specialize [classref boost::contract::is_old_value_copyable].
|
||||
For example, for a non-copyable type `n` (see [@../../example/features/old_if_copyable.cpp =old_if_copyable.cpp=]):
|
||||
|
||||
[old_if_copyable_n_decl]
|
||||
[old_if_copyable_n_spec]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Assertion Requirements (Templates)]
|
||||
|
||||
In general, assertions can introduce a new set of requirements on the types used by a program.
|
||||
Some of these type requirements might be necessary only to check the assertions and they would not be required by the program otherwise.
|
||||
|
||||
In some cases it might be acceptable, or even desirable, to cause a compile-time error when a program uses types that do not provide all the operations needed to check contract assertions (because it is not possible to fully check the correctness of the program as specified by its contracts).
|
||||
In these cases, programmers can specify contract assertions as we have seen so far, compilation will fail if user types do not provide all operations necessary to check the contracts.
|
||||
|
||||
However, in some other cases it might be desirable to not augment the type requirements of a program because of contract assertions and to skip these assertions when user types do not provide all the operations necessary to check them.
|
||||
Programmers can do this by using [funcref boost::contract::condition_if] (or [funcref boost::contract::condition_if_c]).
|
||||
|
||||
For example, let's consider the following `vector<T>` class template.
|
||||
This class template does not usually require that its type parameter `T` has an equality operator `==` (it only requires `T` to be copy constructible, see `std::vector` documentation).
|
||||
However, the contracts for the `vector<T>::push_back(value)` public function include a postcondition `back() == value` that introduces the new requirement that `T` must also have an equality operator `==`.
|
||||
Programmers can specify this postcondition as usual with `BOOST_CONTRACT_ASSERT(back() == value)` an let the program fail to compile when users instantiate `vector<T>` with a type `T` that does not provide an equality operator `==`.
|
||||
Otherwise, programmers can specify this postcondition using [funcref boost::contract::condition_if] to evaluate the asserted condition only for types `T` that have an equality operator `==` (and trivially evaluate to `true` otherwise).
|
||||
On C++17 compilers, the same can be achieved using `if constexpr` instead of [funcref boost::contract::condition_if] resulting in a more concise and readable syntax.
|
||||
For example (see [@../../example/features/condition_if.cpp =condition_if.cpp=]):
|
||||
|
||||
[import ../example/features/condition_if.cpp]
|
||||
[table
|
||||
[[Until C++17 (without `if constexpr`)][Since C++17 (with `if constexpr`)]]
|
||||
[[[condition_if]] [``
|
||||
template<typename T>
|
||||
class vector {
|
||||
public:
|
||||
void push_back(T const& value) {
|
||||
boost::contract::check c = boot::contract::public_function(this)
|
||||
.postcondition([&] {
|
||||
// Guard with `if constexpr` for T without `==`.
|
||||
if constexpr(boost::has_equal_to<T>::value)
|
||||
BOOST_CONTRACT_ASSERT(back() == value);
|
||||
})
|
||||
;
|
||||
|
||||
vect_.push_back(value);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/* ... */
|
||||
``]]
|
||||
]
|
||||
|
||||
The [funcref boost::contract::condition_if] function template is a special case of the more general facility [funcref boost::contract::call_if]:
|
||||
Specifically, [funcref boost::contract::condition_if]`<`[^['Predicate]]`>(`[^['condition]]`)` is equivalent to:
|
||||
[footnote
|
||||
For optimization reasons, the internal implementation of [funcref boost::contract::condition_if] does not actually uses [funcref boost::contract::call_if] (but in principle [funcref boost::contract::condition_if] could be implemented using [funcref boost::contract::call_if] as shown in this documentation).
|
||||
]
|
||||
|
||||
boost::contract::call_if<``[^['Predicate]]``>(
|
||||
``[^['condition]]``
|
||||
).else_(
|
||||
[] { return true; }
|
||||
)
|
||||
|
||||
Where [^['Predicate]] is a nullary boolean meta-function and [^['condition]] is a nullary boolean functor.
|
||||
If [^['Predicate]]`::value` is statically evaluated to be `true` at compile-time then [^['condition]]`()` is called at run-time and its boolean result is returned by the enclosing `call_if`.
|
||||
Otherwise, if [^['Predicate]]`::value` is statically evaluated to be `false` at compile-time then the lambda function `[] { return true; }()` is called at run-time and `true` is trivially returned by the enclosing `call_if`.
|
||||
Therefore, if [^['condition]] is a functor template (and not just a functor) then its code that contains the assertion operations with the extra type requirements (e.g., the equality operator `==`) will not be instantiated and compiled for specific types unless the compiler determines at compile-time that [^['Predicate]]`::value` is `true` (functor templates like `std::equal_to` and C++14 generic lambdas can be used to program [^['condition]], but C++11 lambdas cannot).
|
||||
|
||||
More in general, [funcref boost::contract::call_if] accepts a number of optional /else-if/ statements and one optional /else/ statement:
|
||||
|
||||
boost::contract::call_if<``[^['Predicate1]]``>(
|
||||
``[^['then1]]``
|
||||
).template else_if<``[^['Predicate2]]``>( // Optional.
|
||||
``[^['then2]]``
|
||||
)
|
||||
... // Optionally, other `else_if` statements.
|
||||
.else_( // Optional for `void` functors, otherwise required.
|
||||
``[^['else]]``
|
||||
)
|
||||
|
||||
Where [^['Predicate1]], [^['Predicate2]], ... are nullary boolean meta-functions and [^['then1]], [^['then2]], ..., [^['else]] are nullary functors.
|
||||
The return types of the functor calls [^['then1]]`()`, [^['then2]]`()`, ..., [^['else]]`()` must either be all the same (including all `void`) or be of types implicitly convertible into one another.
|
||||
At run-time [funcref boost::contract::call_if] will call the functor [^['then1]]`()`, or [^['then2]]`()`, ..., or [^['else]]`()` depending on which meta-function [^['Predicate1]]`::value`, [^['Predicate2]]`::value`, ... is statically evaluated to be `true` or `false` at compile-time, and it will return the value returned by the functor being called.
|
||||
If [^['then1]], [^['then2]], ..., [^['else]] are nullary functor templates (not just nullary functors) then their code will only be compiled if the compiler determines they need to be actually called at run-time (so only if the related [^['Predicate1]]`::value`, [^['Predicate2]]`::value`, ... are evaluated to be `true` or `false` at compile-time).
|
||||
All the `else_if<...>(...)` statements are optional, the `else_(...)` statement is optional if the functor calls return `void` but it is required otherwise.
|
||||
|
||||
In general, [funcref boost::contract::call_if] can be used to program contract assertions that compile and check different functor templates depending on related predicates being statically evaluated to be `true` or `false` at compile-time (but in most cases [funcref boost::contract::condition_if] should be sufficient and less verbose to use).
|
||||
The [funcref boost::contract::condition_if_c], [funcref boost::contract::call_if_c], and `.else_if_c` function templates work similarly to their counterparts without the `..._c` postfix above, but they take their predicate template parameters as static boolean values instead of nullary boolean meta-functions.
|
||||
|
||||
Another example where assertion requirements might be useful is to disable assertions that might be constant-correct only for specific template types.
|
||||
For example, `std::distance` does not alter its iterator arguments but only for forward iterators so the follow template function evaluates its preconditions only for for those types (for convenience this example uses C++17 `if constexpr` but it could have been implemented using [funcref boost::contract::condition_if] together with C++14 generic lambdas or binding to a C++11 functor template that calls `std::distance` in its `operator()`):
|
||||
|
||||
template<typename InputIter>
|
||||
void display_first_second_next(InputIter begin, InputIter end) {
|
||||
boost::contract::check c = boost::contract::function()
|
||||
.precondition([&] {
|
||||
if constexpr(is_forward_iterator<InputIter>::value) {
|
||||
BOOST_CONTRACT_ASSERT(std::distance(begin, end) >= 2);
|
||||
} // Otherwise, std::distance would change begin and end.
|
||||
})
|
||||
;
|
||||
...
|
||||
}
|
||||
|
||||
|
||||
[heading If-Constexpr Emulation (C++14)]
|
||||
|
||||
The [funcref boost::contract::call_if] function template is a general facility and its use is not limited to programming contracts.
|
||||
In fact, [funcref boost::contract::call_if] can be used together with C++14 generic lambdas to emulate statements similar to C++17 `if constexpr`
|
||||
For example (see [@../../example/features/call_if_cxx14.cpp =call_if_cxx14.cpp=]):
|
||||
[footnote
|
||||
Boost.Hana (`boost::hana::if_`) can also be used together with C++14 generic lambdas to emulate statements similar to C++17 `if constexpr`.
|
||||
]
|
||||
|
||||
[import ../example/features/call_if_cxx14.cpp]
|
||||
[table
|
||||
[[Until C++17 (without `if constexpr`)][Since C++17 (with `if constexpr`)]]
|
||||
[[[call_if_cxx14]] [``
|
||||
template<typename Iter, typename Dist>
|
||||
void myadvance(Iter& i, Dist n) {
|
||||
if constexpr(is_random_access_iterator<Iter>::value) {
|
||||
i += n;
|
||||
} else if constexpr(is_bidirectional_iterator<Iter>::value) {
|
||||
if(n >= 0) while(n--) ++i;
|
||||
else while(n++) --i;
|
||||
} else if constexpr(is_input_iterator<Iter>::value) {
|
||||
while(n--) ++p;
|
||||
} else {
|
||||
static_assert(false, "requires at least input iterator");
|
||||
}
|
||||
}
|
||||
``]]
|
||||
]
|
||||
|
||||
This implementation is more concise, easier to read and maintain than the usual implementation of `std::advance` that uses tag dispatching.
|
||||
Of course the implementation that uses C++17 `if constexpr` is even more readable and concise.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Volatile Public Functions]
|
||||
|
||||
This library allows to specify a different set of class invariants to check for volatile public functions.
|
||||
These /volatile class invariants/ are programmed in a public `const volatile` function, named `invariant`, taking no argument, and returning `void` (see [macroref BOOST_CONTRACT_INVARIANT_FUNC] to name the invariant function differently from `invariant` and __Access_Specifiers__ to not have to declare it `public`).
|
||||
Classes that do no have invariants for their volatile public functions, simply do not declare the `void invariant() const volatile` function.
|
||||
|
||||
In general, `const volatile` invariants work the same as `const` invariants (see __Class_Invariants__) with the only difference that `volatile` and `const volatile` functions check `const volatile` invariants while non-`const` (i.e., neither `const` nor `volatile`) and `const` functions check `const` invariants.
|
||||
A given class can specify any combination of `static`, `const volatile`, and `const` invariant functions (see __Class_Invariants__):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Constructors and destructors check `const volatile` and `const` invariants in that order because the qualifier that can be applied to more calls is checked first (note that `const volatile` calls can be made on any object while `const` calls cannot be made on `volatile` objects, in that sense the `const volatile` qualifier can be applied to more calls than `const` alone can).
|
||||
This is consistent with `static` class invariants that are checked even before `const volatile` invariants (the `static` classifier can be applied to even more calls than `const volatile`, in fact an object is not even needed to make static calls).
|
||||
]
|
||||
|
||||
* Constructors check `static` invariants at entry and exit (even if an exception is thrown), plus `const volatile` and `const` invariants in that order at exit but only if no exception is thrown.
|
||||
* Destructors check `static` invariants at entry and exit (even if an exception is thrown), plus `const volatile` and `const` invariants in that order at entry (and at exit but only if an exception is thrown, even is destructors should in general never throw in C++).
|
||||
* Both non-`const` and `const` public functions check `static` and `const` invariants at entry and at exit (even if an exception is thrown).
|
||||
* Both `volatile` and `const volatile` public functions check `static` and `const volatile` invariants at entry and at exit (even if an exception is thrown).
|
||||
|
||||
These rules ensure that volatile class invariants are correctly checked (see __Constructor_Calls__, __Destructor_Calls__, and __Public_Function_Calls__).
|
||||
For example (see [@../../example/features/volatile.cpp =volatile.cpp=]):
|
||||
|
||||
[import ../example/features/volatile.cpp]
|
||||
[volatile]
|
||||
|
||||
This library does not automatically check `const volatile` invariants for non-`volatile` functions.
|
||||
However, if the contract specifications require it, programmers can explicitly call the `const volatile` invariant function from the `const` invariant function (preferably in that order to be consistent with the order `const volatile` and `const` invariants are checked for constructors and destructors).
|
||||
That way all public functions, `volatile` or not, will check `const volatile` invariants (while only `const` and non-`const` public functions will check only `const` invariants, correctly so because the `volatile` qualifier shall not be stripped away):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Note that while all public functions can be made to check `const volatile` invariants, it is never possible to make volatile public functions check `const` non-volatile invariants.
|
||||
That is because both `const` and `volatile` can always be added but never stripped in C++ (a part from forcefully via `const_cast`) but `const` is always automatically added by this library in order to enforce contract constant-correctness (see __Constant_Correctness__).
|
||||
That said, it would be incorrect for this library to also automatically add `volatile` and require all functions to check `const volatile` (not just `const`) invariants because only `volatile` members can be accessed from `const volatile` invariants so there could be many `const` (but not `const volatile`) members that are accessible from `const` invariants but not from `const volatile` invariants.
|
||||
To avoid this confusion, this library has chosen to draw a clear dichotomy between `const` and `const volatile` invariants so that only volatile public functions check `const volatile` invariants and only non-volatile public functions check `const` (but not `const volatile`) invariants.
|
||||
This is simple and should serve most cases.
|
||||
If programmers need non-volatile public functions to also check `const volatile` invariants, they can explicitly do so by calling the `const volatile` invariant function from the `const` invariant function as shown in this documentation.
|
||||
]
|
||||
|
||||
class a {
|
||||
public:
|
||||
void invariant() const volatile { ... } // Volatile invariants.
|
||||
|
||||
void invariant() const {
|
||||
const_cast<a const volatile*>(this)->invariant(); // Call `const volatile` invariant function above.
|
||||
... // Other non-volatile invariants.
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
|
||||
(As usual, private and protected functions do not check any invariant, not even when they are `volatile` or `const volatile`, see __Private_and_Protected_Functions__).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Move Operations]
|
||||
|
||||
As with all public operations of a class, also move operations should maintain class invariants (see __Stroustrup13__, p. 520).
|
||||
Specifically, C++ requires the following:
|
||||
|
||||
* The moved-from object can be copy assigned.
|
||||
* The moved-from object can be move assigned.
|
||||
* The moved-from object can be destroyed (if not for anything else, this requires that class invariants are maintained by move operations because the destructor of the moved-from object requires class invariants to be satisfied at its entry, as always with destructors see __Destructor_Calls__).
|
||||
|
||||
Therefore, both the move constructor and the move assignment operator need to maintain the class invariants of the moved-from object so their contracts can be programmed using [funcref boost::contract::constructor] and [funcref boost::contract::public_function] as always for constructors and public functions.
|
||||
For example (see [@../../example/features/move.cpp =move.cpp=]):
|
||||
|
||||
[import ../example/features/move.cpp]
|
||||
[move]
|
||||
|
||||
This example assumes that it is possible to call the public function `moved()` on the moved-from object.
|
||||
This allows to make explicit the precondition that except for destructor, copy and move assignments all other public functions cannot be called on a moved-from object.
|
||||
This precondition is usually implicit in C++ (i.e., documented by the standard but not checked by the language at run-time).
|
||||
If it is is not possible (e.g., due to some optimized implementation of the move operations) to have such a `moved()` public function, the private `moved_` member (or similar) can be used to program class invariants and preconditions (and that will just relay on the usual implicit C++ assumption on moved-from object because users will not be able to fully check preconditions and class invariants before calling functions of a moved-from object).
|
||||
|
||||
[note
|
||||
The default move constructor and move assignment operator generated by C++ will not automatically check contracts.
|
||||
Therefore, unless the move operations are not public or they have no preconditions, no postconditions, and their class has no invariants, programmers should manually define them using [funcref boost::contract::constructor], [classref boost::contract::constructor_precondition], and [funcref boost::contract::public_function] instead of relying on their default implementations generated by C++.
|
||||
(Same as for all other operations automatically implemented by C++.)
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Unions]
|
||||
|
||||
In C++, a `union` cannot have virtual functions, bases classes, and cannot be used as a base class thus subcontracting ([classref boost::contract::virtual_], [macroref BOOST_CONTRACT_OVERRIDE], etc.) do not apply to unions.
|
||||
Also a `union` cannot inherit from [classref boost::contract::constructor_precondition] (because it cannot have base classes) so such a class is used to declare a local object that checks constructor preconditions (at the very beginning of the constructor before old value copies and other contracts, see declaration of `pre` in the example below).
|
||||
A part from that, this library is used as usual to program contracts for unions.
|
||||
For example (see [@../../example/features/union.cpp =union.cpp=]):
|
||||
|
||||
[import ../example/features/union.cpp]
|
||||
[union]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Disable Contract Checking]
|
||||
|
||||
Checking contracts adds run-time overhead and can slow down program execution (see __Benefits_and_Costs__).
|
||||
Therefore, programmers can define any combination of the following macros (`-D` option in Clang and GCC, `/D` option in MSVC, etc.) to instruct this library to not check specific kind of contract conditions at run-time:
|
||||
|
||||
* Define [macroref BOOST_CONTRACT_NO_PRECONDITIONS] to not check preconditions.
|
||||
* Define [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] to not check postconditions.
|
||||
* Define [macroref BOOST_CONTRACT_NO_EXCEPTS] to not check exception guarantees.
|
||||
* Define [macroref BOOST_CONTRACT_NO_ENTRY_INVARIANTS] to not check class invariants at call entry.
|
||||
* Define [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS] to not check class invariants at call exit.
|
||||
* Or, define [macroref BOOST_CONTRACT_NO_INVARIANTS] to not check class invariants at both call entry and exit. (This is provided for convenience, it is equivalent to define both [macroref BOOST_CONTRACT_NO_ENTRY_INVARIANTS] and [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS].)
|
||||
* Define [macroref BOOST_CONTRACT_NO_CHECKS] to not run implementation checks (programmed using [macroref BOOST_CONTRACT_CHECK], etc.).
|
||||
|
||||
[note
|
||||
In general, old values are used by both postconditions and exception guarantees so it is necessary to define both [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] and [macroref BOOST_CONTRACT_NO_EXCEPTS] to disable old value copies.
|
||||
]
|
||||
|
||||
By default, none of these macros are defined so this library checks all contracts.
|
||||
When these macros are defined by the user, the implementation code of this library is internally optimized to minimize as much as possible any run-time and compile-time overhead associated with checking and compiling contracts (see __Disable_Contract_Compilation__ for techniques to completely remove any run-time and compile-time overhead associated with contract code).
|
||||
|
||||
For example, programmers could decide to check all contracts during early development builds, but later check only preconditions and maybe entry invariants for release builds by defining [macroref BOOST_CONTRACT_NO_POSTCONDITIONS], [macroref BOOST_CONTRACT_NO_EXCEPTS], [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS], and [macroref BOOST_CONTRACT_NO_CHECKS].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Assertion Levels]
|
||||
|
||||
This library provides three predefined /assertion levels/ that can be used depending on the computational complexity of the asserted conditions:
|
||||
[footnote
|
||||
The assertion levels predefined by this library are similar to the default, audit, and axiom levels proposed in __P0380__.
|
||||
]
|
||||
|
||||
* [macroref BOOST_CONTRACT_ASSERT] is used to assert conditions that are not computationally expensive, at least compared to the cost of executing the function body.
|
||||
These assertions are always checked at run-time and cannot be disabled.
|
||||
* [macroref BOOST_CONTRACT_ASSERT_AUDIT] is used to assert conditions that are computationally expensive compared to the cost of executing the function body.
|
||||
These assertions are not checked at run-time unless programmers explicitly define [macroref BOOST_CONTRACT_AUDITS] (undefined by default), but the conditions are always compiled and validated syntactically (even when they are not actually evaluated and checked at run-time).
|
||||
* [macroref BOOST_CONTRACT_ASSERT_AXIOM] is used to assert conditions that are computationally prohibitive, at least compared to the cost of executing the function body.
|
||||
These assertions are never evaluated or checked at run-time, but the asserted conditions are always compiled and validated syntactically so these assertions can serve as formal comments in the code.
|
||||
|
||||
In addition, [macroref BOOST_CONTRACT_CHECK_AUDIT] and [macroref BOOST_CONTRACT_CHECK_AXIOM] are similar to [macroref BOOST_CONTRACT_ASSERT_AUDIT] and [macroref BOOST_CONTRACT_ASSERT_AXIOM] but they are used to program audit and axiom levels for implementation checks instead of assertions (see __Implementation_Checks__).
|
||||
|
||||
For example, [macroref BOOST_CONTRACT_ASSERT_AUDIT] can be used to program computationally expensive assertions (see [@../../example/features/assertion_level.cpp =assertion_level.cpp=]):
|
||||
|
||||
[import ../example/features/assertion_level.cpp]
|
||||
[assertion_level_audit]
|
||||
|
||||
Also [macroref BOOST_CONTRACT_AUDITS] can be used to disable expensive old value copies and related assertions that use them (see [@../../example/features/assertion_level.cpp =assertion_level.cpp=]):
|
||||
|
||||
[assertion_level_class_begin]
|
||||
[assertion_level_audit_old]
|
||||
[assertion_level_class_end]
|
||||
|
||||
The condition passed to [macroref BOOST_CONTRACT_ASSERT_AXIOM] is compiled but not actually evaluated at run-time so this macro can be used to program computationally prohibitive assertions but also assertions that cannot actually be programmed in C++ using functions that are declared but left undefined.
|
||||
For example, (see [@../../example/features/assertion_level.cpp =assertion_level.cpp=]):
|
||||
|
||||
[assertion_level_no_impl]
|
||||
[assertion_level_class_begin]
|
||||
[assertion_level_axiom]
|
||||
[assertion_level_class_end]
|
||||
|
||||
In addition to the assertion levels predefined by this library, programmers are free to define their own.
|
||||
For example, the following macro could be used to program and selectively disable assertions that have exponential computational complexity `O(e^n)`:
|
||||
|
||||
#ifdef NO_EXPONENTIALLY_COMPLEX_ASSERTIONS
|
||||
// Following will compile but never actually evaluate `cond`.
|
||||
#define EXP_ASSERTION(cond) BOOST_CONTRACT_ASSERT(true || (cond))
|
||||
#else
|
||||
// Following will compile and also evaluate `cond`.
|
||||
#define EXP_ASSERTION(cond) BOOST_CONTRACT_ASSERT(cond)
|
||||
#endif
|
||||
|
||||
...
|
||||
|
||||
EXP_ASSERTION(``[^['some-exponentially-complex-boolean-condition]]``);
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Disable Contract Compilation (Macro Interface)]
|
||||
|
||||
This library provides macros that can be used to completely disable compile-time and run-time overhead introduced by contracts but at the cost of manually programming `#ifndef` statements around contract code:
|
||||
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_CONSTRUCTORS] when contract checking is disabled for constructors.
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_DESTRUCTORS] when contract checking is disabled for destructors.
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS] when contract checking is disabled for public functions.
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_FUNCTIONS] when contract checking is disabled for (non-public) functions.
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_OLDS] when old value copies are disabled.
|
||||
* This library defines [macroref BOOST_CONTRACT_NO_ALL] when checks are disabled for all contracts above.
|
||||
|
||||
These macros are not configuration macros and they should not be defined directly by the users (otherwise this library will generate a compile-time error).
|
||||
Instead, these macros are automatically defined by this library when users define [macroref BOOST_CONTRACT_NO_PRECONDITIONS], [macroref BOOST_CONTRACT_NO_POSTCONDITIONS], [macroref BOOST_CONTRACT_NO_EXCEPTS], [macroref BOOST_CONTRACT_NO_INVARIANTS] (or [macroref BOOST_CONTRACT_NO_ENTRY_INVARIANTS] and [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS]), and [macroref BOOST_CONTRACT_NO_CHECKS] (see __Disable_Contract_Checking__).
|
||||
|
||||
Alternatively, this library provides a macro-based interface [headerref boost/contract_macro.hpp] that can be used to completely disable compile-time and run-time overhead introduced by contracts.
|
||||
This macro interface is usually preferred because more concise and easier to use than programming `#ifdef` statements by hand, but it can make compiler errors more cryptic (because all macro code expands on a single line in C++ so line numbers in compiler errors are less useful than usual) and it leave a bit of contract decorations in the code but at no measurable overhead (extra [classref boost::contract::virtual_]`*` parameter, call to [classref boost::contract::constructor_precondition] default constructor which does nothing, [macroref BOOST_CONTRACT_BASE_TYPES] `typedef`, and [classref boost::contract::access] friendship, see example below).
|
||||
|
||||
The following examples show how to use both the macro interface and alternatively the `#ifdef` statements to completely disable compile-time and run-time overhead introduced by contracts (see [@../../example/features/ifdef_macro.cpp =ifdef_macro.cpp=] and [@../../example/features/ifdef.cpp =ifdef.cpp=]):
|
||||
|
||||
[import ../example/features/ifdef_macro.cpp]
|
||||
[import ../example/features/ifdef.cpp]
|
||||
[table
|
||||
[ [Macro Interface] [`#ifdef` Statements] ]
|
||||
[ [[ifdef_macro_function]] [[ifdef_function]] ]
|
||||
]
|
||||
|
||||
The same can be used to disable contract code complication for private and protected functions.
|
||||
The [macroref BOOST_CONTRACT_OLD_PTR_IF_COPYABLE] macro is provided to handle non-copyable old value types (equivalently to [classref boost::contract::old_ptr_if_copyable]).
|
||||
For constructors, destructors, and public functions instead (see [@../../example/features/ifdef_macro.cpp =ifdef_macro.cpp=] and [@../../example/features/ifdef.cpp =ifdef.cpp=]):
|
||||
|
||||
[table
|
||||
[ [Macro Interface] [`#ifdef` Statements] ]
|
||||
[ [[ifdef_macro_class]] [[ifdef_class]] ]
|
||||
]
|
||||
|
||||
Static class invariants can be programmed using [macroref BOOST_CONTRACT_STATIC_INVARIANT] and volatile class invariants using [macroref BOOST_CONTRACT_INVARIANT_VOLATILE] (these macros expand code equivalent to the `static void `[macroref BOOST_CONTRACT_STATIC_INVARIANT_FUNC]`()` and `void `[macroref BOOST_CONTRACT_INVARIANT_FUNC]`() const volatile` functions respectively).
|
||||
|
||||
Macro code expands on a single line so using the macro interface will cause all assertions within a given set of preconditions, postconditions, exception guarantees, and class invariants to list the same line number in their error messages if they fail at run-time (but the assertion code will be listed as well and it should allow programmers to identify the specific assertion that failed).
|
||||
In general, the authors do not recommend to use the macro interface and the `#ifdef` statements unless strictly necessary because they both make the contract code more verbose, less readable, and can cause cryptic error messages.
|
||||
|
||||
That said, disabling contract as shown in __Disable_Contract_Checking__ will still leave the overhead of compiling contract code plus some small run-time overhead due to the initialization of old value pointers (even if those will be all null and no old value will be actually copied), the calls to the contract functions used to initialize [classref boost::contract::check] and [classref boost::contract::constructor_precondition] (even if those calls will be internally optimized by this library to essentially do nothing), etc.
|
||||
For truly performance critical code for which even such small run-time overhead might not be acceptable, the macro interface (or the `#ifdef` statements) shown here can be used to completely disable compile-time and run-time overheads of contracts.
|
||||
However, for such performance-critical code even the overhead of checking simple preconditions might be too much so it might be best to not program contracts for such performance-critical code all together.
|
||||
|
||||
Therefore, in most cases the compile-time overhead of contracts should not represent an issue and it should be sufficient to disable contract checking at run-time as indicated in __Disable_Contract_Checking__.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Separate Body Implementation]
|
||||
|
||||
Contracts are part of the program specification and not of its implementation (see __Specification_vs_Implementation__).
|
||||
However, this library uses function definitions to program contracts so contract code appears together with the function implementation code.
|
||||
This is not ideal (even if contracts programmed using this library will always appear at the very beginning of the function definition so programmers will easily be able to distinguish contract code from the rest of the function implementation code and this might not be real problem in practise).
|
||||
|
||||
In some cases, it might be desirable to completely separate the contract code from the function implementation code.
|
||||
For example, this could be necessary for software that ships only header files and compiled object files to its users.
|
||||
If contracts are programmed in function definitions that are compiled in the object files, users will not be able to see the contract code to understand semantics and usage of the functions (again, this might not be a real problem in practice for example if contracts are already somehow extracted from the source code and presented as part of the documentation of the shipped software).
|
||||
|
||||
In any case, when it is truly important to separate contracts from function implementation code, function implementations can be programmed in extra /body functions/ (e.g., named `..._body`) that are compiled in object files.
|
||||
Function definitions that remain in header files instead will contain just contract code followed by calls the extra body functions.
|
||||
This technique allows to keep the contract code in header files while separating the implementation code to object files but at the cost of manually programming an extra function declaration for the body function (and with the limitation that constructor member initialization lists must be programmed in header files because that is where constructors need to be defined to list the constructor contract code).
|
||||
|
||||
For example, the following header file only contains function declarations, contract code, and constructor member initializations, but it does not contain the code implementing the function bodies (see [@../../example/features/separate_body.hpp =separate_body.hpp=]):
|
||||
|
||||
[import ../example/features/separate_body.hpp]
|
||||
[separate_body_hpp]
|
||||
|
||||
Instead, the function bodies are implemented in a separate source file (see [@../../example/features/separate_body.cpp =separate_body.cpp=]):
|
||||
|
||||
[import ../example/features/separate_body.cpp]
|
||||
[separate_body_cpp]
|
||||
|
||||
The same technique can be used for non-member, private, and protected functions, etc.
|
||||
|
||||
[note
|
||||
When contracts are programmed only in =.cpp= files and also all this library headers are `#include`d only from the =.cpp= files, then these =.cpp= files can be compiled disabling specific contract checking (for example, [macroref BOOST_CONTRACT_NO_POSTCONDITIONS], [macroref BOOST_CONTRACT_NO_EXCEPTS], and [macroref BOOST_CONTRACT_NO_EXIT_INVARIANTS], see __Disable_Contract_Checking__).
|
||||
Then the code in these =.cpp= files will always have such contract checking disabled even when linked to some other user code that might have been compiled with a different set of contracts disabled (i.e., a different set of `BOOST_CONTRACT_NO_...` macros defined).
|
||||
This technique might be useful to ship compiled object files (e.g., for a library) that will never check some contracts (e.g., postconditions, exception guarantees, and exit invariants) regardless of the definition of the `BOOST_CONTRACT_NO_...` macros used to compile code that links against the shipped object files.
|
||||
|
||||
On the contrary, if contracts are programmed only in header files (e.g., using extra `..._body` functions as shown in this section) and this library headers are `#include`d only in these header files that are being shipped, then end users can enable or disables contract checking of the shipped code by defining the `BOOST_CONTRACT_NO_...` macros when they compile the shipped header files as part of their code.
|
||||
This technique might be useful in other situations when programmers that ship code want to leave it up the their end users to decide which contracts of the shipped code should be checked at run-time.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section No Lambda Functions (No C++11)]
|
||||
|
||||
This section shows how to use this library without C++11 lambda functions.
|
||||
This has some advantages:
|
||||
|
||||
* It allows to use this library on compilers that do not support C++11 lambda functions (essentially most C++03 compilers can be used in that case, see __No_Macros__ to also avoid using variadic macros).
|
||||
* Contract functions (i.e., the `..._precondition`, `..._old`, and `..._postcondition` functions in the example below) can be programmed to fully enforce constant-correctness and other contract requirements at compile-time (see __Constant_Correctness__).
|
||||
[footnote
|
||||
If C++ allowed lambda functions to capture variables by constant reference (for example using the syntax `[const&] { ... }` and `[const& `[^['variable-name]]`] { ... }`, see [@https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/0UKQw9eo3N0]) also lambdas could be used to program contract functors that fully enforce __Constant_Correctness__ at compile-time.
|
||||
Note that C++11 lambdas allow to capture variables by value (`[=] { ... }` and `[`[^['variable-name]]`] { ... }`), these value captures are `const` (unless the lambda is explicitly declared `mutable`) but they are not suitable to program postconditions and exception guarantees using this library (because those require capturing by reference, see __Postconditions__ and __Exception_Guarantees__), plus they introduce a copy of the captured value that might be too expensive in general and therefore not suitable for preconditions either.
|
||||
]
|
||||
* Code of the contract functions is separated from function body implementations (see __Separate_Body_Implementation__).
|
||||
[footnote
|
||||
Alternatively, on compilers that do not support C++11 lambda functions, [@http://www.boost.org/doc/libs/release/libs/local_function/doc/html/index.html Boost.LocalFunction] could be used to program the contract functors still within the function definitions (for example, see [@../../example/features/no_lambdas_local_func.cpp =no_lambda_local_func.cpp=]).
|
||||
In general, such a code is less verbose than the example shown in this section that uses contract functions programmed outside of the original function definitions (about 30% less lines of code) but the contract code is hard to ready.
|
||||
Other libraries could also be used to program the contract functors without C++11 lambda functions (Boost.Lambda, Boost.Fusion, etc.) but again all these techniques will result in contract code either more verbose, or harder to read and maintain than the code that uses C++11 lambda functions.
|
||||
]
|
||||
|
||||
However, not using C++11 lambda functions comes to the significant cost of having to manually program the extra contract function and related boiler-plate code.
|
||||
For example (see [@../../example/features/no_lambdas.hpp =no_lambdas.hpp=] and [@../../example/features/no_lambdas.cpp =no_lambdas.cpp=]):
|
||||
|
||||
[import ../example/features/no_lambdas.hpp]
|
||||
[no_lambdas_hpp]
|
||||
|
||||
[import ../example/features/no_lambdas.cpp]
|
||||
[no_lambdas_cpp]
|
||||
|
||||
If programmers also want to fully enforce all contract programming constant-correctness requirements at compile-time, they should follow these rules when programming the contract functions (see __Constant_Correctness__):
|
||||
|
||||
* Precondition functions (i.e., the `..._precondition` functions in the example above) can take their arguments either by `const` value or by `const&`, and when they are member functions they should be either `static` or `const` functions.
|
||||
* Postcondition functions (i.e., the `..._postcondition` functions in the example above) should take their arguments by `const&`, and when they are member functions they should be either `static` or `const` functions.
|
||||
* Similarly, exception guarantee functions (not shown in the example above) should take their arguments by `const&`, and when they are member functions they should be either `static` or `const` functions.
|
||||
* Old value functions (i.e., the `..._old` functions in the example above) should take their arguments by `const&` a part from old value pointers that should be taken by `&` (so only old value pointers can be modified), and when they are member functions they should be either `static` or `const` functions.
|
||||
* Constructor precondition, old value, and exception guarantee functions should be `static` (because there is no valid object `this` if the constructor body does not run successfully, see __Constructor_Calls__).
|
||||
* Destructor postcondition functions should be `static` (because there is no valid object `this` after the destructor body runs successfully, but exception guarantee functions do not have to be `static` since the object `this` is still valid because the destructor body did not run successfully, see __Destructor_Calls__).
|
||||
|
||||
Note that the extra contract functions also allow to keep the contract code in the header file while all function bodies are implemented in a separate source file (including the constructor member initialization list, that could not be done with the techniques shown in __Separate_Body_Implementation__).
|
||||
[footnote
|
||||
In this example, `bind` was used to generate nullary functors from the contract functions.
|
||||
As always with `bind`, `cref` and `ref` must be used to bind arguments by `const&` and `&` respectively, plus it might be necessary to explicitly `static_cast` the function pointer passed to `bind` for overloaded functions.
|
||||
]
|
||||
Also note that the contract functions can always be declared `private` if programmers need to exactly control the public members of the class (this was not done in this example only for brevity).
|
||||
|
||||
The authors think this library is most useful when used together with C++11 lambda functions.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section No Macros (and No Variadic Macros)]
|
||||
|
||||
It is possible to specify contracts without using most of the macros provided by this library and programming the related code manually instead (the only macros that cannot be programmed manually are [macroref BOOST_CONTRACT_OVERRIDE], [macroref BOOST_CONTRACT_OVERRIDES], and [macroref BOOST_CONTRACT_NAMED_OVERRIDE]).
|
||||
|
||||
[note
|
||||
Some of this library macros are variadic macros, others are not (see below).
|
||||
Variadic macros were officially added to the language in C++11 but most compilers have been supporting them as an extension for a long time, plus essentially all compilers that support C++11 lambda functions also support C++11 variadic macros (and this library might rarely be used without the convenience of C++11 lambda functions, see __No_Lambda_Functions__).
|
||||
[footnote
|
||||
Compilation times of this library were measured to be comparable between compilers that support variadic macros and compilers that do not.
|
||||
(See also [macroref BOOST_CONTRACT_MAX_ARGS] on compilers that do not support variadic macros.
|
||||
*Rationale:* [macroref BOOST_CONTRACT_MAX_ARGS] is named after `BOOST_FUNCTION_MAX_ARGS`.)
|
||||
]
|
||||
Therefore, the rest of this section can be considered mainly a curiosity because programmers should seldom need to use this library without using its macros.
|
||||
]
|
||||
|
||||
[heading Overrides]
|
||||
|
||||
As shown in __Public_Function_Overrides__ and __Named_Overrides__, this library provides the [macroref BOOST_CONTRACT_OVERRIDE] and [macroref BOOST_CONTRACT_NAMED_OVERRIDE] macros to program contracts for overriding public functions.
|
||||
These macros cannot be programmed manually but they are not variadic macros so programmers should be able to use them on all C++ compilers.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
These macros expand SFINAE-based introspection templates that are too complex to be programmed manually by users (that remains the case even if C++14 generic lambdas were to be used here).
|
||||
On a related note, in theory using C++14 generic lambdas, the [macroref BOOST_CONTRACT_OVERRIDE] macro could be re-implemented in a way that can be expanded at function scope, instead of class scope (but there is not really a need for that).
|
||||
]
|
||||
The [macroref BOOST_CONTRACT_OVERRIDES] macro is a variadic macro instead but programmes can manually repeat the non-variadic macro [macroref BOOST_CONTRACT_OVERRIDE] for each overriding public function name on compilers that do not support variadic macros.
|
||||
|
||||
[heading Assertions (Not Variadic)]
|
||||
|
||||
As shown in __Preconditions__, __Postconditions__, __Exception_Guarantees__, __Class_Invariants__, etc. this library provides the [macroref BOOST_CONTRACT_ASSERT] macro to assert contract conditions.
|
||||
This is not a variadic macro and programmers should be able to use it on all C++ compilers.
|
||||
In any case, the invocation `BOOST_CONTRACT_ASSERT(`[^['condition]]`)` expands to code equivalent to the following:
|
||||
[footnote
|
||||
*Rationale:*
|
||||
No need to also support C++11 `__func__` because this will always expand to the name of `operator()` of the functor used to program the contract assertions (e.g., of the lambda function) and it will not expand to the name of the actual function specifying the contract.
|
||||
]
|
||||
|
||||
if(!(``[^['condition]]``)) {
|
||||
throw boost::contract::assertion_failure(__FILE__, __LINE__,
|
||||
BOOST_PP_STRINGIZE(``[^['condition]]``));
|
||||
}
|
||||
|
||||
In fact, this library considers any exception thrown from within preconditions, postconditions, exception guarantees, and class invariants as a contract failure and reports it calling the related contract failure handler ([funcref boost::contract::precondition_failure], etc.).
|
||||
If there is a need for it, programmers can always program contract assertions that throw specific user-defined exceptions as follow (see __Throw_on_Failure__):
|
||||
|
||||
if(!``[^['condition]]``) throw ``[^['exception-object]]``;
|
||||
|
||||
However, using [macroref BOOST_CONTRACT_ASSERT] is convenient because it always allows this library to show an informative message in case of assertion failure containing the assertion code, file name and line number, etc.
|
||||
|
||||
The [macroref BOOST_CONTRACT_ASSERT_AUDIT] and [macroref BOOST_CONTRACT_ASSERT_AXIOM] macros are not a variadic macros and programmers should be able to use them on all C++ compilers.
|
||||
Their implements are equivalent to the following:
|
||||
|
||||
#ifdef BOOST_CONTRACT_AUDITS
|
||||
#define BOOST_CONTRACT_ASSERT_AUDIT(condition) \
|
||||
BOOST_CONTRACT_ASSERT(condition)
|
||||
#else
|
||||
#define BOOST_CONTRACT_ASSERT_AUDIT(condition) \
|
||||
BOOST_CONTRACT_ASSERT(true || (condition))
|
||||
#endif
|
||||
|
||||
#define BOOST_CONTRACT_ASSERT_AXIOM(condition) \
|
||||
BOOST_CONTRACT_ASSERT(true || (condition))
|
||||
|
||||
[heading Base Types (Variadic)]
|
||||
|
||||
As shown in __Base_Classes__, this library provides the [macroref BOOST_CONTRACT_BASE_TYPES] variadic macro to declare the `base_types` member type that will expand to the list of all public bases of a derived class.
|
||||
Programmers can also declare `base_types` without using [macroref BOOST_CONTRACT_BASE_TYPES] at the cost of writing a bit more code manually and increased maintenance.
|
||||
For example (see [@../../example/features/base_types_no_macro.cpp =base_types_no_macro.cpp=]):
|
||||
|
||||
[import ../example/features/base_types_no_macro.cpp]
|
||||
[base_types_no_macro]
|
||||
|
||||
The `base_types` member type must be a `boost::mpl::vector` which must list /all and only/ `public` base classes (because only public bases subcontract, see __Function_Calls__), and in the same order these public base classes appear in the derived class inheritance list.
|
||||
If the [macroref BOOST_CONTRACT_BASE_TYPES] macro is not used, it is the responsibility of the programmers to maintain the correct list of bases in the `boost::mpl::vector` each time the derived class inheritance list changes (this might significantly complicate maintenance).
|
||||
|
||||
In general, it is recommended to use the [macroref BOOST_CONTRACT_BASE_TYPES] macro whenever possible.
|
||||
|
||||
[heading Old Values (Variadic)]
|
||||
|
||||
As shown in __Old_Values__, this library provides the [macroref BOOST_CONTRACT_OLDOF] variadic macro to assign old value copies.
|
||||
Programmers can also assign old values without using [macroref BOOST_CONTRACT_OLDOF] at the cost of writing a bit more code manually.
|
||||
For example (see [@../../example/features/old_no_macro.cpp =old_no_macro.cpp=]):
|
||||
|
||||
[import ../example/features/old_no_macro.cpp]
|
||||
[old_no_macro]
|
||||
|
||||
The ternary operator `boost::contract::copy_old(v) ? size() : boost::contract::null_old()` must be used here to avoid evaluating and copying the old value expression `size()` when [funcref boost::contract::copy_old] returns `false` (because old values are not being copied when postcondition and exception guarantees checking is disabled at run-time, an overridden virtual function call is not checking postconditions or exception guarantees yet, etc.).
|
||||
The enclosing [funcref boost::contract::make_old] copies the old value expression and creates an old value pointer.
|
||||
Otherwise, [funcref boost::contract::null_old] indicates that a null old value pointer should be created.
|
||||
|
||||
The [funcref boost::contract::make_old] and [funcref boost::contract::copy_old] functions are used exactly as shown above but without the extra `v` parameter when they are called from within non-virtual functions (see __Public_Function_Overrides__).
|
||||
The old value pointer returned by [funcref boost::contract::make_old] can be assigned to either [classref boost::contract::old_ptr] or [classref boost::contract::old_ptr_if_copyable] (see __Old_Value_Requirements__).
|
||||
|
||||
In general, it is recommended to use the [macroref BOOST_CONTRACT_OLDOF] macro whenever possible.
|
||||
|
||||
[heading Macro Interface (Variadic)]
|
||||
|
||||
Almost all macros defined in [headerref boost/contract_macro.hpp] are variadic macros.
|
||||
On compilers that do not support variadic macros, programmers can manually disable contract code compilation using `#ifdef` statements as shown in __Disable_Contract_Compilation__.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,75 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Full Table of Contents]
|
||||
|
||||
[pre
|
||||
__Introduction__
|
||||
__Full_Table_of_Contents__
|
||||
__Getting_Started__
|
||||
__This_Documentation__
|
||||
__Compilers_and_Platforms__
|
||||
__Code_Organization__
|
||||
__Install_and_Compile__
|
||||
__Contract_Programming_Overview__
|
||||
__Assertions__
|
||||
__Benefits_and_Costs__
|
||||
__Function_Calls__
|
||||
__Public_Function_Calls__
|
||||
__Constructor_Calls__
|
||||
__Destructor_Calls__
|
||||
__Constant_Correctness__
|
||||
__Specification_vs_Implementation__
|
||||
__On_Contract_Failure__
|
||||
__Feature_Summary__
|
||||
__Tutorial__
|
||||
__Non_Member_Functions__
|
||||
__Preconditions__
|
||||
__Postconditions__
|
||||
__Return_Value__
|
||||
__Old_Values__
|
||||
__Exception_Guarantees__
|
||||
__Class_Invariants__
|
||||
__Constructors__
|
||||
__Destructors__
|
||||
__Public_Functions__
|
||||
__Virtual_Public_Functions__
|
||||
__Public_Function_Overrides_Subcontracting__
|
||||
__Base_Classes_Subcontracting__
|
||||
__Static_Public_Functions__
|
||||
__Advanced__
|
||||
__Pure_Virtual_Public_Functions__
|
||||
__Optional_Return_Value__
|
||||
__Private_and_Protected_Functions__
|
||||
__Friend_Functions__
|
||||
__Function_Overloads__
|
||||
__Lambdas_Loops_Code_Blocks_and_constexpr__
|
||||
__Implementation_Checks__
|
||||
__Old_Copies_at_Body__
|
||||
__Named_Overrides__
|
||||
__Access_Specifiers__
|
||||
__Throw_on_Failure_and_noexcept__
|
||||
__Extras__
|
||||
__Old_Value_Requirements_Templates__
|
||||
__Assertion_Requirements_Templates__
|
||||
__Volatile_Public_Functions__
|
||||
__Move_Operations__
|
||||
__Unions__
|
||||
__Disable_Contract_Checking__
|
||||
__Assertion_Levels__
|
||||
__Disable_Contract_Compilation_Macro_Interface__
|
||||
__Separate_Body_Implementation__
|
||||
__No_Lambda_Functions_No_CXX11__
|
||||
__No_Macros_and_No_Variadic_Macros__
|
||||
__Reference__
|
||||
__Examples__
|
||||
__Release_Notes__
|
||||
__Bibliography__
|
||||
__Acknowledgments__
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,214 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Getting Started]
|
||||
|
||||
This section illustrates how to setup a system to use this library.
|
||||
|
||||
[section This Documentation]
|
||||
|
||||
Programmers should be able to start using this library after reading __Introduction__, __Getting_Started__, and __Tutorial__.
|
||||
Other sections of this documentation (e.g., __Advanced__ and __Extras__) can be consulted at a later point to gain a more in-depth knowledge of the library.
|
||||
__Contract_Programming_Overview__ can be skipped by programmers that are already well familiar with the contract programming methodology.
|
||||
|
||||
Some of the source code of the examples linked by this documentation contain special code comments of the form `//[...` and `//]`.
|
||||
These mark sections of the code that are automatically extracted from the source and presented as part of this documentation.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
This allows to make sure that most of the example code presented in this documentation is always up-to-date, builds and runs with the latest implementation of the library.
|
||||
]
|
||||
Also the purpose of all examples in this documentation is to illustrate how to use this library and not to represent real product code.
|
||||
|
||||
Some footnotes are marked by the word "*Rationale*".
|
||||
These explain reasons behind decisions made during the design and implementation of this library.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Compilers and Platforms]
|
||||
|
||||
In general, this library requires a C++ compiler with support for SFINAE and other template meta-programming techniques part of the C++03 standard.
|
||||
This library requires Boost (Boost.Optional, Boost.Thread, Boost.FunctionTypes, Boost.Traits, Boost.MPL, etc.).
|
||||
|
||||
It is possible to use this library without C++11 lambda functions but a large amount of boiler-plate code is required to manually program separate functor to specify preconditions, postconditions, etc. (so using this library without C++11 lambda functions is possible but not recommended, see __No_Lambda_Functions__).
|
||||
It is also possible to use this library without variadic macros by manually programming a small amount of boiler-plate code (but most if not all modern C++ compilers support variadic macros even before C++99 and C++11 so this should never be needed in practice, see __No_Macros__).
|
||||
|
||||
Some parts of this documentation use an operator [^['type-of](...)] to indicate an operator logically equivalent to C++11 `decltype(...)`.
|
||||
However, this library implementation does not actually use type deduction in these cases (because the library already knows the types in question) so support for C++11 `decltype` and other type-of implementations are not actually required by this library (that is why [^['type-of]] and not the real `decltype` operator is used in this documentation).
|
||||
|
||||
This library has been developed and tested using:
|
||||
|
||||
* Visual Studio 2015 on Windows (MSVC =cl= version 19.00.24215.1).
|
||||
* GCC version 5.4.0 on Cygwin (with C++11 features enabled =-std=c++11=).
|
||||
* Clang version 3.8.1 on Cygwin (with C++11 features enabled =-std=c++11=).
|
||||
* Boost C++ libraries version 1.62.0.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Code Organization]
|
||||
|
||||
Let [^['lib-root]] be the directory under which this library source files have been installed.
|
||||
This library flies are organized as follows:
|
||||
|
||||
[pre
|
||||
['lib-root/] # Directory where this library files were installed.
|
||||
build/ # Build files (using Boost.Jam).
|
||||
doc/ # Documentation (using Boost.QuickBook).
|
||||
html/ # This documentation (HTML).
|
||||
example/ # Examples (including those listed in this documentation).
|
||||
include/
|
||||
boost/
|
||||
contract.hpp # Include all headers at once.
|
||||
contract/ # Header files to be included one-by-one.
|
||||
core/ # Fundamental headers (usually indirectly included by other headers).
|
||||
detail/ # Implementation code (should never be included or used directly).
|
||||
src/ # Library source code to be compiled.
|
||||
test/ # Tests.
|
||||
]
|
||||
|
||||
All headers required by this library can be included at once by:
|
||||
|
||||
#include <boost/contract.hpp>
|
||||
|
||||
Alternatively, all =boost/contract/*.hpp= headers are independent from one another and they can be selectively included one-by-one based on the specific functionality of this library being used (this might somewhat reduce compilation time).
|
||||
The =boost/contract/core/*.hpp= headers are not independent from other headers and they do not need to be directly included in user code when =boost/contract.hpp= or =boost/contract/*.hpp= headers are included already.
|
||||
|
||||
Files in =boost/contract/detail/=, names in the `boost::contract::detail` namespace, macros starting with `BOOST_CONTRACT_DETAIL...`, and all names starting with `boost_contract_detail...` (in any namespace, including user-defined namespaces) are part of this library implementation and should never be used directly in user code.
|
||||
|
||||
Names starting with `BOOST_CONTRACT_ERROR...` are used by this library to report some compile-time errors (so spotting these names in compiler error messages might help troubleshooting).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Install and Compile]
|
||||
|
||||
Let [^['lib-root]] be the directory under which this library source files have been installed.
|
||||
Let [^['boost-root]] be the directory under which Boost source code has been installed and compiled following Boost's documentation (if pre-compiled Boost distributions are used instead, the [^['lib-boost]\/include] and [^['lib-boost]\/stage\/lib] directories below might be replaced by =/usr/include= and =/usr/lib= or similar directories depending on the specific Boost distribution, OS, etc.).
|
||||
|
||||
The steps below show how to compile this library as a shared library (a.k.a., Dynamically Linked Library or DLL) and then compile and run a sample program that uses this library (the [@../../example/features/introduction.cpp =introduction.cpp=] program shown in __Introduction__ is used as an example).
|
||||
|
||||
[warning
|
||||
By default, this library is compiled as a shared library (in which case this library automatically defines the [macroref BOOST_CONTRACT_DYN_LINK] macro).
|
||||
There are configuration macros [macroref BOOST_CONTRACT_STATIC_LINK] and [macroref BOOST_CONTRACT_HEADER_ONLY] that can be defined to compile this library as a static or header-only library respectively.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
[macroref BOOST_CONTRACT_DYN_LINK], [macroref BOOST_CONTRACT_STATIC_LINK], and [macroref BOOST_CONTRACT_HEADER_ONLY] are named after `BOOST_ALL_DYN_LINK`, `BOOST_ALL_DYN_LINK`, and `BOOST_CHRONO_HEADER_ONLY` respectively.
|
||||
]
|
||||
|
||||
The use of [macroref BOOST_CONTRACT_STATIC_LINK] and [macroref BOOST_CONTRACT_HEADER_ONLY] is discouraged because this library is not guaranteed to always work correctly at run-time when these macros are defined.
|
||||
Specifically, this library might not correctly disable contracts while checking other contracts and call the correct user-defined contract failure handlers unless it is compiled as a shared library when it is being used by different program units (different programs, different shared libraries of the same program, etc.).
|
||||
However, [macroref BOOST_CONTRACT_STATIC_LINK] and [macroref BOOST_CONTRACT_HEADER_ONLY] can be used for applications that check contracts in a single program unit (e.g., a single program with only statically linked libraries that check contracts).
|
||||
]
|
||||
|
||||
[heading Visual Studio (MSVC)]
|
||||
|
||||
Using MSVC on Windows (from a developer command prompt that automatically invokes the correct =vcvarsall.bat=):
|
||||
|
||||
[pre
|
||||
> cd ['lib-root]\build
|
||||
> cl ['lib-root]\src\contract.cpp \/MDd \/EHs -I ['lib-root]\include -I ['boost-root] /link /DLL /LIBPATH:['boost-root]\stage\lib /out:boost_contract.dll
|
||||
]
|
||||
|
||||
[pre
|
||||
> cd ['lib-root]\example\features
|
||||
> cl introduction.cpp \/MDd \/EHs -I ['lib-root]\include -I ['boost-root] /link /LIBPATH:['boost-root]\stage\lib ['lib-root]\build\boost_contract.lib
|
||||
]
|
||||
|
||||
[pre
|
||||
> set PATH=%PATH%;['lib-root]\build
|
||||
> introduction
|
||||
]
|
||||
|
||||
[heading GCC and CLang]
|
||||
|
||||
Using GCC on Cygwin (or some Linux-like OS):
|
||||
|
||||
[pre
|
||||
$ cd ['lib-root]\/build
|
||||
$ g++ ['lib-root]\/src\/contract.cpp -std=c++11 -shared -I ['lib-root]\/include -I ['boost-root] ['boost-root]\/stage\/lib\/libboost_system.a -o boost_contract.dll
|
||||
]
|
||||
|
||||
[pre
|
||||
$ cd ['lib-root]\/example\/features
|
||||
$ g++ introduction.cpp -std=c++11 -I ['lib-root]\/include -I ['boost-root] ['lib-root]\/build\/boost_contract.dll -o introduction
|
||||
]
|
||||
|
||||
[pre
|
||||
$ export PATH=$PATH:['lib-root]\/build
|
||||
$ .\/introduction
|
||||
]
|
||||
|
||||
The above steps also work for Clang replacing =g++= with =clang++=.
|
||||
|
||||
[heading Boost.Build (BJam)]
|
||||
|
||||
Alternatively, programmers can setup their build environments (BJam, Make, CMake, MSBuild, etc.) to compile this library source code into a shared library and then compile and link user code against it (if that is preferred instead of manually running the compiler as indicated by the steps above).
|
||||
For example, this library source comes with a complete set of BJam files that can be used to build the library, build and run its tests and examples (see [@../../example/Jamfile.v2 =example/Jamfile.v2=], [@../../test/Jamfile.v2 =test/Jamfile.v2=], [@../../build/Jamfile.v2 =build/Jamfile.v2=], [@../../Jamroot =Jammroot=], [@../../build/boost_contract_no.jam =build/boost_contract_no.jam=], etc.).
|
||||
|
||||
Prior to running BJam, it is necessary to install and configure Boost from source.
|
||||
That can be done following these instructions for Windows (and similarly for Linux, see the [@http://www.boost.org/users/index.html Boost website]):
|
||||
|
||||
* Download the Boost source file for Windows [@http://www.boost.org/users/download/ [^boost_['version].zip]] and unzip it to some directory [^['boost-root]].
|
||||
* Run (from a developer command prompt that automatically invokes the correct =vcvarsall.bat=):
|
||||
|
||||
[pre
|
||||
> cd [^['boost-root]]
|
||||
> bootstrap.bat
|
||||
> b2
|
||||
]
|
||||
|
||||
* Create an environment variable named `BOOST_ROOT` and set it to the [^['boost-root]] directory path.
|
||||
* Add %BOOST_ROOT% to the end of the `PATH` environment variable (so `bjam` and other Boost tools can be found).
|
||||
|
||||
Boost and BJam are now ready to build this library.
|
||||
For example, the following uses BJam to build and run the [@../../example/features/introduction.cpp [^['lib-root]/example/features/introduction.cpp]] program and also to automatically build this library if necessary (from a developer command prompt that automatically invokes the correct =vcvarsall.bat=):
|
||||
|
||||
[pre
|
||||
> cd ['lib-root]\example
|
||||
> bjam features-introduction
|
||||
]
|
||||
|
||||
In addition, the following commands build this library, build and run all the examples and tests (from a developer command prompt that automatically invokes the correct =vcvarsall.bat=):
|
||||
|
||||
[pre
|
||||
> cd ['lib-root]\build # Build just the library (as a shared library by default).
|
||||
> bjam
|
||||
|
||||
> cd ['lib-root]\example # Build and run all examples (also automatically build the library if needed).
|
||||
> bjam
|
||||
|
||||
> cd ['lib-root]\test # Build and run all tests (also automatically build the library if needed).
|
||||
> bjam
|
||||
]
|
||||
|
||||
From the example and test directories =bjam help= gives a list of options to build and run examples and tests individually, with some contracts turned off, using different compilers, with this library as a static or header-only library, etc.
|
||||
|
||||
[heading Boost.QuickBook (This Documentation)]
|
||||
|
||||
In general users will not need to rebuild this document so they can skip this section.
|
||||
|
||||
Prior to running BJam to rebuild this documentation and regenerate its HTML pages, it is necessary to install and configure Boost from source as explained in the section above.
|
||||
In addition, it is necessary to download and configure tools required by Boost.QuickBook as explained on the [@http://www.boost.org/doc/libs/release/doc/html/quickbook/install.html Boost.QuickBook website].
|
||||
Finally, it is necessary to install [@http://www.stack.nl/~dimitri/doxygen/download.html Doxygen] to some directory [^['doxygen-root]] and add the following to the =user-config.jam= file in your home directory (for example for Windows, but similarly for Linux, etc.):
|
||||
|
||||
[pre
|
||||
using doxygen : "['doxygen-root]/bin/doxygen.exe" ;
|
||||
]
|
||||
|
||||
Boost.QuickBook and BJam are now ready to rebuild this documentation and generate its HTML pages under the directory [^['lib-root]\doc\html]:
|
||||
[footnote
|
||||
In theory, it is possible to use Boost.QuickBook to build this documentation into a single PDF file instead of HTML pages, running =bjam pdf= from within the [^['lib-root]\doc] directory.
|
||||
For that, Apache FOP and Java need to be installed as explained on the [@http://www.boost.org/doc/libs/1_65_0/doc/html/boostbook/getting/started.html Boost.Book website] and a command similar to =using fop : "C:/PROGRA~1/RenderX/XEP/xep.bat -valid" : "C:/PROGRA~1/Java/jre7/bin" ;= needs to be added to =user-config.jam= (actual paths might different on specific installations).
|
||||
However, this is not configured by default and it might require extra effort to ensure that all links, code listings, tables, images, etc. correctly show in the generated PDF file.
|
||||
]
|
||||
|
||||
[pre
|
||||
> cd ['lib-root]\doc # Build this documentation.
|
||||
> bjam
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,80 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Introduction]
|
||||
|
||||
Contract Programming allows to specify preconditions, postconditions, and class invariants that are automatically checked when functions are executed at run-time.
|
||||
These conditions assert program specifications within the source code itself allowing to find bugs more quickly during testing, making the code self-documenting, and increasing overall software quality (see __Contract_Programming_Overview__).
|
||||
|
||||
For example, consider the following function `inc` that increments its argument `x` by `1` and let's write its contract using code comments (see [@../../example/features/introduction_comments.cpp =introduction_comments.cpp=]):
|
||||
|
||||
[import ../example/features/introduction_comments.cpp]
|
||||
[introduction_comments]
|
||||
|
||||
The precondition states that at function entry the argument `x` must be strictly smaller than the maximum allowable value of its type (so it can be incremented by `1` without overflowing).
|
||||
The postcondition states that at function exit the argument `x` must be incremented by `1` with respect to the /old value/ `x` had before executing the function indicated here by [^['oldof]`(x)` (note that postconditions shall be checked only when the execution of the function body did not throw an exception).
|
||||
|
||||
Now let's program this function and its contract using this library (see [@../../example/features/introduction.cpp =introduction.cpp=] and __Non_Member_Functions__):
|
||||
|
||||
[import ../example/features/introduction.cpp]
|
||||
[introduction]
|
||||
|
||||
When the above function `inc` is called, this library will:
|
||||
|
||||
* First, execute the functor passed to `.precondition(...)` that asserts `inc` preconditions.
|
||||
* Then, execute `inc` body (i.e., all the code that follows the `boost::contract::check c = ...` declaration).
|
||||
* Last, execute the functor passed to `.postcondition(...)` that asserts `inc` postconditions (unless `inc` body threw an exception).
|
||||
|
||||
For example, if there is a bug in the code calling `inc` so that the function is called with `x` equal to `std::numeric_limits<int>::max()` then the program will terminate with an error message similar to the following (and it will be evident that the bug is in the calling code):
|
||||
|
||||
[pre
|
||||
precondition assertion "x < std::numeric_limits<int>::max()" failed: file "introduction.cpp", line 17
|
||||
]
|
||||
|
||||
Instead, if there is a bug in the implementation of `inc` so that `x` is not incremented by `1` after the execution of the function body then the program will terminate with an error message similar to the following (and it will be evident that the bug is in `inc` body):
|
||||
[footnote
|
||||
In this example the function body is composed of a single trivial instruction `++x` so it easy to check by visual inspection that it does not contain any bug and it will always increment `x` by `1` thus the function postcondition will never fail.
|
||||
In real code, function bodies are rarely this simple and can hide bugs that make checking postconditions useful.
|
||||
]
|
||||
|
||||
[pre
|
||||
postcondition assertion "x == *old_x + 1" failed: file "introduction.cpp", line 20
|
||||
]
|
||||
|
||||
By default, when an assertion fails this library prints an error message such the ones above to the standard error `std::cerr` and terminates the program calling `std::terminate` (this behaviour can be customized to take any user-specified action including throwing exceptions, see __Throw_on_Failure__).
|
||||
Note that the error messages printed by this library contain all the information necessary to easily and uniquely identify the point in the code at which the contract assertions fail.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The assertion failure message printed by this library follows a format similar to the message printed by Clang when the C-style `assert` macro fails.
|
||||
]
|
||||
|
||||
[note
|
||||
C++11 lambda functions are necessary to use this library without manually writing a significant amount of boiler-plate code to program the functors that assert the contracts (see __No_Lambda_Functions__).
|
||||
Otherwise, this library does not use other C++11 features and should work on most modern C++ compilers (see __Getting_Started__).
|
||||
]
|
||||
|
||||
In addition to contracts for simple non-member functions as shown the in the example above, this library allows to program contracts for constructors, destructors, and member functions.
|
||||
These can check class invariants and can also /subcontract/ inheriting and extending contracts from base classes (see [@../../example/features/introduction_public.cpp =introduction_public.cpp=] and __Public_Function_Overrides__):
|
||||
[footnote
|
||||
The `pushable` base class is used in this example just to show subcontracting, it is somewhat arbitrary and it will likely not appear in real code.
|
||||
]
|
||||
|
||||
[import ../example/features/introduction_public.cpp]
|
||||
[introduction_public]
|
||||
|
||||
[heading Language Support]
|
||||
|
||||
The authors of this library advocate for contracts to be added to the core language.
|
||||
Adding contract programming to the C++ standard has a number of advantages over any library implementation (shorter and more concise syntax to program contracts, specify contracts in declarations instead of definitions, enforce contract constant-correctness, expected faster compile- and run-time, vendors could develop static analysis tools to recognize and check contracts statically when possible, compiler optimizations could be improved based on contract conditions, etc.).
|
||||
|
||||
Unfortunately, detailed and complete proposals to add contracts to the C++ standard such as __N1962__ were rejected by the C++ standard committee and it is not clear if the current proposal for adding contracts to C++ __P0380__ will actually be accepted by the standard.
|
||||
[footnote
|
||||
The authors find attractive the syntax that uses C++11 attributes `[[...]]` to specify contracts as indicated in __P0380__.
|
||||
]
|
||||
In any case, at least for now __P0380__ only supports pre- and postconditions while lacking basic features such as class invariants and old values in postconditions, not to mention the lack of more advanced features like subcontracting, all these features are instead supported by this library (see __Feature_Summary__ for a detailed comparison between the features supported by this library and the ones listed in different contract programming proposals, see __Bibliography__ for a list of references considered in designing and implementing this library including the vast majority of contract programming proposals submitted to the C++ standard committee).
|
||||
|
||||
[endsect]
|
||||
|
||||
155
doc/main.qbk
155
doc/main.qbk
@ -1,155 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[library Boost.Contract
|
||||
[quickbook 1.5]
|
||||
[version 1.0]
|
||||
[authors [Caminiti <email>lorcaminiti@gmail.com</email>, Lorenzo]]
|
||||
[copyright 2008-2017 Lorenzo Caminiti]
|
||||
[license Distributed under the Boost Software License, Version 1.0 (see accompanying file LICENSE_1_0.txt or a copy at [@http://www.boost.org/LICENSE_1_0.txt])]
|
||||
]
|
||||
|
||||
[def __Introduction__ [link boost_contract.introduction Introduction]]
|
||||
[def __Full_Table_of_Contents__ [link boost_contract.full_table_of_contents Full Table of Contents]]
|
||||
|
||||
[def __Getting_Started__ [link boost_contract.getting_started Getting Started]]
|
||||
[def __This_Documentation__ [link boost_contract.getting_started.this_documentation This Documentation]]
|
||||
[def __Compilers_and_Platforms__ [link boost_contract.getting_started.compilers_and_platforms Compilers and Platforms]]
|
||||
[def __Code_Organization__ [link boost_contract.getting_started.code_organization Code Organization]]
|
||||
[def __Install_and_Compile__ [link boost_contract.getting_started.install_and_compile Install and Compile]]
|
||||
|
||||
[def __Contract_Programming_Overview__ [link boost_contract.contract_programming_overview Contract Programming Overview]]
|
||||
[def __Assertions__ [link boost_contract.contract_programming_overview.assertions Assertions]]
|
||||
[def __Benefits_and_Costs__ [link boost_contract.contract_programming_overview.benefits_and_costs Benefits and Costs]]
|
||||
[def __Function_Calls__ [link boost_contract.contract_programming_overview.function_calls Function Calls]]
|
||||
[def __Public_Function_Calls__ [link boost_contract.contract_programming_overview.public_function_calls Public Function Calls]]
|
||||
[def __Constructor_Calls__ [link boost_contract.contract_programming_overview.constructor_calls Constructor Calls]]
|
||||
[def __Destructor_Calls__ [link boost_contract.contract_programming_overview.destructor_calls Destructor Calls]]
|
||||
[def __Constant_Correctness__ [link boost_contract.contract_programming_overview.constant_correctness Constant-Correctness]]
|
||||
[def __Specification_vs_Implementation__ [link boost_contract.contract_programming_overview.specification_vs__implementation Specification vs. Implementation]]
|
||||
[def __On_Contract_Failure__ [link boost_contract.contract_programming_overview.on_contract_failure On Contract Failure]]
|
||||
[def __Feature_Summary__ [link boost_contract.contract_programming_overview.feature_summary Feature Summary]]
|
||||
|
||||
[def __Tutorial__ [link boost_contract.tutorial Tutorial]]
|
||||
[def __Non_Member_Functions__ [link boost_contract.tutorial.non_member_functions Non-Member Functions]]
|
||||
[def __Preconditions__ [link boost_contract.tutorial.preconditions Preconditions]]
|
||||
[def __Postconditions__ [link boost_contract.tutorial.postconditions Postconditions]]
|
||||
[def __Return_Value__ [link boost_contract.tutorial.return_value Return Value]]
|
||||
[def __Old_Values__ [link boost_contract.tutorial.old_values Old Values]]
|
||||
[def __Exception_Guarantees__ [link boost_contract.tutorial.exception_guarantees Exception Guarantees]]
|
||||
[def __Class_Invariants__ [link boost_contract.tutorial.class_invariants Class Invariants]]
|
||||
[def __Constructors__ [link boost_contract.tutorial.constructors Constructors]]
|
||||
[def __Destructors__ [link boost_contract.tutorial.destructors Destructors]]
|
||||
[def __Public_Functions__ [link boost_contract.tutorial.public_functions Public Functions]]
|
||||
[def __Virtual_Public_Functions__ [link boost_contract.tutorial.virtual_public_functions Virtual Public Functions]]
|
||||
[def __Public_Function_Overrides__ [link boost_contract.tutorial.public_function_overrides__subcontracting_ Public Function Overrides]]
|
||||
[def __Public_Function_Overrides_Subcontracting__ [link boost_contract.tutorial.public_function_overrides__subcontracting_ Public Function Overrides (Subcontracting)]]
|
||||
[def __Base_Classes__ [link boost_contract.tutorial.base_classes__subcontracting_ Base Classes]]
|
||||
[def __Base_Classes_Subcontracting__ [link boost_contract.tutorial.base_classes__subcontracting_ Base Classes (Subcontracting)]]
|
||||
[def __Static_Public_Functions__ [link boost_contract.tutorial.static_public_functions Static Public Functions]]
|
||||
|
||||
[def __Advanced__ [link boost_contract.advanced Advanced]]
|
||||
[def __Pure_Virtual_Public_Functions__ [link boost_contract.advanced.pure_virtual_public_functions Pure Virtual Public Functions]]
|
||||
[def __Optional_Return_Value__ [link boost_contract.advanced.optional_return_value Optional Return Value]]
|
||||
[def __Private_and_Protected_Functions__ [link boost_contract.advanced.private_and_protected_functions Private and Protected Functions]]
|
||||
[def __Friend_Functions__ [link boost_contract.advanced.friend_functions Friend Functions]]
|
||||
[def __Function_Overloads__ [link boost_contract.advanced.function_overloads Function Overloads]]
|
||||
[def __Lambdas_Loops_Code_Blocks__ [link boost_contract.advanced.lambdas__loops__code_blocks__and__constexpr__ Lambdas, Loops, Code Blocks]]
|
||||
[def __Lambdas_Loops_Code_Blocks_and_constexpr__ [link boost_contract.advanced.lambdas__loops__code_blocks__and__constexpr__ Lambdas, Loops, Code Blocks (and `constexpr`)]]
|
||||
[def __Implementation_Checks__ [link boost_contract.advanced.implementation_checks Implementation Checks]]
|
||||
[def __Old_Copies_at_Body__ [link boost_contract.advanced.old_copies_at_body Old Copies at Body]]
|
||||
[def __Named_Overrides__ [link boost_contract.advanced.named_overrides Named Overrides]]
|
||||
[def __Access_Specifiers__ [link boost_contract.advanced.access_specifiers Access Specifiers]]
|
||||
[def __Throw_on_Failure__ [link boost_contract.advanced.throw_on_failure__and__noexcept__ Throw on Failure]]
|
||||
[def __Throw_on_Failure_and_noexcept__ [link boost_contract.advanced.throw_on_failure__and__noexcept__ Throw on Failure (and `noexcept`)]]
|
||||
|
||||
[def __Extras__ [link boost_contract.extras Extras]]
|
||||
[def __Old_Value_Requirements__ [link boost_contract.extras.old_value_requirements__templates_ Old Value Requirements]]
|
||||
[def __Old_Value_Requirements_Templates__ [link boost_contract.extras.old_value_requirements__templates_ Old Value Requirements (Templates)]]
|
||||
[def __Assertion_Requirements__ [link boost_contract.extras.assertion_requirements__templates_ Assertion Requirements]]
|
||||
[def __Assertion_Requirements_Templates__ [link boost_contract.extras.assertion_requirements__templates_ Assertion Requirements (Templates)]]
|
||||
[def __Volatile_Public_Functions__ [link boost_contract.extras.volatile_public_functions Volatile Public Functions]]
|
||||
[def __Move_Operations__ [link boost_contract.extras.move_operations Move Operations]]
|
||||
[def __Unions__ [link boost_contract.extras.unions Unions]]
|
||||
[def __Disable_Contract_Checking__ [link boost_contract.extras.disable_contract_checking Disable Contract Checking]]
|
||||
[def __Assertion_Levels__ [link boost_contract.extras.assertion_levels Assertion Levels]]
|
||||
[def __Disable_Contract_Compilation__ [link boost_contract.extras.disable_contract_compilation__macro_interface_ Disable Contract Compilation]]
|
||||
[def __Disable_Contract_Compilation_Macro_Interface__ [link boost_contract.extras.disable_contract_compilation__macro_interface_ Disable Contract Compilation (Macro Interface)]]
|
||||
[def __Separate_Body_Implementation__ [link boost_contract.extras.separate_body_implementation Separate Body Implementation]]
|
||||
[def __No_Lambda_Functions__ [link boost_contract.extras.no_lambda_functions__no_c__11_ No Lambda Functions]]
|
||||
[def __No_Lambda_Functions_No_CXX11__ [link boost_contract.extras.no_lambda_functions__no_c__11_ No Lambda Functions (No C++11)]]
|
||||
[def __No_Macros__ [link boost_contract.extras.no_macros__and_no_variadic_macros_ No Macros]]
|
||||
[def __No_Macros_and_No_Variadic_Macros__ [link boost_contract.extras.no_macros__and_no_variadic_macros_ No Macros (and No Variadic Macros)]]
|
||||
|
||||
[def __Reference__ [@reference.html Reference]]
|
||||
[def __Examples__ [link boost_contract.examples Examples]]
|
||||
[def __Release_Notes__ [link boost_contract.release_notes Release Notes]]
|
||||
[def __Bibliography__ [link boost_contract.bibliography Bibliography]]
|
||||
[def __Acknowledgments__ [link boost_contract.acknowledgments Acknowledgments]]
|
||||
|
||||
[def __AND__ [link and_anchor [^['AND]]]]
|
||||
[def __OR__ [link or_anchor [^['OR]]]]
|
||||
|
||||
[def __Bright04__ [link Bright04_anchor \[Bright04\]]]
|
||||
[def __Bright04b__ [link Bright04b_anchor \[Bright04b\]]]
|
||||
[def __C2__ [link C2_anchor \[C2\]]]
|
||||
[def __Chrome__ [link Chrome_anchor \[Chrome\]]]
|
||||
[def __Cline90__ [link Cline90_anchor \[Cline90\]]]
|
||||
[def __CodeContracts__ [link CodeContracts_anchor \[CodeContracts\]]]
|
||||
[def __iContract__ [link iContract_anchor \[iContract\]]]
|
||||
[def __Nana__ [link Nana_anchor \[Nana\]]]
|
||||
[def __Hoare73__ [link Hoare73_anchor \[Hoare73\]]]
|
||||
[def __Jcontract__ [link Jcontract_anchor \[Jcontract\]]]
|
||||
[def __Lindrud04__ [link Lindrud04_anchor \[Lindrud04\]]]
|
||||
[def __Maley99__ [link Maley99_anchor \[Maley99\]]]
|
||||
[def __Meyer97__ [link Meyer97_anchor \[Meyer97\]]]
|
||||
[def __Mitchell02__ [link Mitchell02_anchor \[Mitchell02\]]]
|
||||
[def __N1613__ [link N1613_anchor \[N1613\]]]
|
||||
[def __N1866__ [link N1866_anchor \[N1866\]]]
|
||||
[def __N1962__ [link N1962_anchor \[N1962\]]]
|
||||
[def __N2081__ [link N2081_anchor \[N2081\]]]
|
||||
[def __N2914__ [link N2914_anchor \[N2914\]]]
|
||||
[def __N3613__ [link N3613_anchor \[N3613\]]]
|
||||
[def __P0380__ [link P0380_anchor \[P0380\]]]
|
||||
[def __SPARKAda__ [link SPARKAda_anchor \[SPARKAda\]]]
|
||||
[def __SpecSharp__ [link SpecSharp_anchor \[SpecSharp\]]]
|
||||
[def __Stroustrup94__ [link Stroustrup94_anchor \[Stroustrup94\]]]
|
||||
[def __Stroustrup13__ [link Stroustrup13_anchor \[Stroustrup13\]]]
|
||||
[def __Tandin04__ [link Tandin04_anchor \[Tandin04\]]]
|
||||
|
||||
[def __substitution_principle__ [@http://en.wikipedia.org/wiki/Liskov_substitution_principle substitution principle]]
|
||||
|
||||
[:['["Our field needs more formality, but the profession has not realized it yet.]]]
|
||||
[:['-- Bertrand Meyer (see __Meyer97__ page 400)]]
|
||||
|
||||
This library implements
|
||||
[@http://en.wikipedia.org/wiki/Design_by_contract Contract Programming] (a.k.a., Design by Contract or DbC)
|
||||
[footnote
|
||||
Design by Contract (DbC) is a registered trademark of the Eiffel Software company and it was first introduced by the Eiffel programming language (see __Meyer97__).
|
||||
]
|
||||
for the C++ programming language.
|
||||
All Contract Programming features are supported by this library: subcontracting, class invariants (also for static and volatile member functions), postconditions (with old and return values), preconditions, customizable actions on assertion failure (e.g., terminate the program or throw exceptions), optional compilation of assertions, disable assertions while already checking other assertions (to avoid infinite recursion), and more (see __Feature_Summary__).
|
||||
|
||||
[note
|
||||
In one of its previous revisions, this library passed Boost formal review and it was accepted into the Boost libraries (see [@https://groups.google.com/forum/?fromgroups=#!topic/boost-list/jQ7OjAmos_Y]).
|
||||
However, the authors have not had time to add this library to a Boost release yet.
|
||||
]
|
||||
|
||||
This library source is hosted at [@https://github.com/lcaminiti/boost-contract].
|
||||
|
||||
[include introduction.qbk]
|
||||
[include full_table_of_contents.qbk]
|
||||
[include getting_started.qbk]
|
||||
[include contract_programming_overview.qbk]
|
||||
[include tutorial.qbk]
|
||||
[include advanced.qbk]
|
||||
[include extras.qbk]
|
||||
[include examples.qbk]
|
||||
[xinclude reference.xml]
|
||||
[include release_notes.qbk]
|
||||
[include bibliography.qbk]
|
||||
[include acknowledgments.qbk]
|
||||
|
||||
@ -1,171 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Release Notes]
|
||||
|
||||
This section contains notes on all releases of this library (from the latest to the oldest).
|
||||
|
||||
[section Release 0.5.0]
|
||||
|
||||
September 2, 2017
|
||||
|
||||
Notes:
|
||||
|
||||
# Using plain C++ code instead of macros to program contracts.
|
||||
# The removed macros very hard to use because they required programmers to learn a domain-specific embedded language that replaced the usual C++ syntax for declaring functions and classes.
|
||||
# The removed macros also made the code less readable, increased compilation time (because of extensive preprocessor meta-programming), and gave cryptic compiler errors.
|
||||
# However, the removed macros more correctly specified contracts in code declarations instead of definitions, and they completely removed extra code when contracts were disabled (both of those can be done by the current version of this library but at the cost of manually writing some boiler-plate code which was previous automatically handled by the macros instead, see __Separate_Body_Implementation__ and __Disable_Contract_Compilation__).
|
||||
# Simplified the library by removing some extra features that were not directly related to contract programming, specifically:
|
||||
# Removed loop variants (because these are rarely if ever used).
|
||||
# Removed named and deduced parameters (because these can be programmed directly using [@http://www.boost.org/doc/libs/release/libs/parameter/doc/html/index.html Boost.Parameter]).
|
||||
# Removed concepts (because these can be programmed directly using [@http://www.boost.org/doc/libs/1_65_0/libs/concept_check/concept_check.htm Boost.ConceptCheck]).
|
||||
# Removed emulation of virtual specifiers `override`, `final`, and `new` (because `override` can be programmed directly using C++11, while `final` and `new` are rarely if ever used).
|
||||
# Removed `static_assert` emulation (because this can be programmed directly using C++11, or using [@http://www.boost.org/doc/libs/1_65_0/doc/html/boost_staticassert.html Boost.StaticAssert]).
|
||||
# Ensuring that old values and return values are copied only once even when subcontracting is used with multiple inheritance.
|
||||
# Improved template meta-programming algorithm that searches the inheritance tree for subcontracting when multiple inheritance is used.
|
||||
# Exception specifications and function-try blocks apply also to exceptions thrown by the contracts, and not just to exceptions thrown by the body.
|
||||
# Added contracts for exception guarantees (using `.except(...)`, etc.).
|
||||
# Added predefined assertion levels for "audit" and "axiom".
|
||||
# Added `call_if` and `condition_if` (assertions requirements were supported also by previous revisions of this library but they were handled by internal code generated by the contract macros).
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_5_0 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.4.1]
|
||||
|
||||
[note
|
||||
This revision of the library passed Boost formal review and it was accepted into the Boost libraries (see [@https://groups.google.com/forum/?fromgroups=#!topic/boost-list/jQ7OjAmos_Y]).
|
||||
However, the authors have not had time to add this library to a Boost release yet.
|
||||
]
|
||||
|
||||
August 20, 2012
|
||||
|
||||
Notes:
|
||||
|
||||
# Using non-fix-spaced font in Full Table of Contents section.
|
||||
# Added a couple of notes to the documentation.
|
||||
# Changed `CONTRACT_MEMBER_BODY(class_type, function_name)` to `class_type::CONTRACT_MEMBER_BODY(function_name)` so the macro can also be used to declare derived classes avoiding using the library syntax even when the base class has contracts.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_4_1 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.4.0]
|
||||
|
||||
June 4, 2012
|
||||
|
||||
Notes:
|
||||
|
||||
# Simplified syntax by reducing extra parenthesis to the bare necessary minimum (using some of the preprocessor parsing techniques originally introduced by Boost.LocalFunction).
|
||||
# Postcondition old values only copy the old-of expression (e.g., copy just vector size instead of entire vector).
|
||||
This improves performance and introduces the `ConstantCopyConstructible` requirement just for the old value expression type (e.g., a vector might not be copyable while its size always is because it is an integral type).
|
||||
Removed the `copyable` tag.
|
||||
# Body defined outside the macros (so compiler-errors for definitions retain their usual meaning).
|
||||
# Added `CONTRACT_CLASS` macro and removed the need to duplicate declaration elements (do not repeat function declaration, do not repeat class name in function declaration, etc).
|
||||
# Using `_TPL` macros so to reduce compile-time (instead of internally making all templates contract functions so to use `typename` freely).
|
||||
# Overloading no longer requires unique parameter names.
|
||||
# Added C++11-like virtual specifiers.
|
||||
# Added constant assertions plus constant-expressions for select assertion if-conditions and for loop variants.
|
||||
# Added named and deduced parameters.
|
||||
# Added concept checking.
|
||||
# Removed the interface to use the library without the macro (programmers were required to write too much boiler-plate code for the non-macro interface to be actually usable, plus supporting both the macro and non-macro interfaces limited what the macros could do).
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_4_0 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.3.490]
|
||||
|
||||
March 7, 2010
|
||||
|
||||
Notes:
|
||||
|
||||
# Added support and examples for `volatile`, `auto`, `explicit`, `export`, `extern`, `friend`, `inline`, `struct`, and `throw` (for exception specifications).
|
||||
# Documented that `union` cannot be contracted.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_3_490 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.3.469]
|
||||
|
||||
February 21, 2010
|
||||
|
||||
Notes:
|
||||
|
||||
# Removed use of `self`, `variable.now`, and `variable.old` in writing contracts.
|
||||
Object `this` and variables are now accessed as usual in member functions.
|
||||
`CONTRACT_OLDOF(variable)` is used to access old values in postconditions.
|
||||
# Added `(precondition)`, `(postcondition)`, and `(body)` to specify contracts within the function signature sequence.
|
||||
If no preconditions then `(precondition) ({...})` is simply omitted from the sequence (same for postconditions, body is mandatory instead).
|
||||
For non-void functions, users can name the result argument with `(postcondition) (result-name) ({...})`.
|
||||
# Changed contract class template to use same syntax as Boost.Function (i.e., `F` function type).
|
||||
# Added support for free functions and static member functions.
|
||||
# Added support for subcontracting with multiple inheritance.
|
||||
# Added static class invariants which are always checked (also at constructors entry, destructor exit, and by static member functions).
|
||||
# Added block invariants and Eiffel-like loop variants.
|
||||
# Added handlers to customize action on contract failure (default to `std::terminate()`).
|
||||
# Removed feature for automatic contract documentation using Doxygen (this is not compatible with added `(precondition)`, `(postcondition)`, and `(body)` because Doxygen preprocessor is not capable to handle Boost.Preprocessor sequences).
|
||||
# Rewritten entire documentation (now using Boost.QuickBook instead of Doxygen).
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_3_469 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.2.190]
|
||||
|
||||
November 21, 2009
|
||||
|
||||
Notes:
|
||||
|
||||
# Compiled using both GCC (Linux and Cygwin) and MSVC (Windows XP).
|
||||
# Required to use void to specify empty function argument list.
|
||||
This is to comply with C++03 standard that does not allow to pass empty macro parameters so it does not support empty preprocessor sequences `()`.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_2_190 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.1.126]
|
||||
|
||||
June 17, 2009
|
||||
|
||||
Notes:
|
||||
|
||||
# Completed first documentation draft.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_1_126 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.1.55]
|
||||
|
||||
April 19, 2009
|
||||
|
||||
Notes:
|
||||
|
||||
# Reorganized files to cleanup root directory.
|
||||
# Added installation program.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_1_55 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Release 0.1.50]
|
||||
|
||||
April 19, 2009
|
||||
|
||||
Notes:
|
||||
|
||||
# First public release.
|
||||
|
||||
Released [@https://github.com/lcaminiti/boost-contract/tree/release/0_1_50 files] (e.g., select "Clone or download" and then "Download ZIP").
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,105 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE boostbook PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<boostbook id="boost" xmlns:xi="http://www.w3.org/2001/XInclude"
|
||||
last-revision="$Date$">
|
||||
<title>The Boost C++ Libraries BoostBook Documentation Subset</title>
|
||||
|
||||
<preface id="about">
|
||||
<title>What's Included in This Document</title>
|
||||
|
||||
<para>This document represents only a subset of the full Boost
|
||||
documentation: that part which is generated from BoostBook or
|
||||
QuickBook sources. Eventually all Boost libraries may use these
|
||||
formats, but in the meantime, much of Boost's documentation is not
|
||||
available here. Please
|
||||
see <ulink
|
||||
url="http://www.boost.org/libs">http://www.boost.org/libs</ulink>
|
||||
for complete documentation.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Documentation for some of the libraries described in this document is
|
||||
available in alternative formats:
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<simpara><link linkend="boost">HTML</link></simpara>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<simpara><ulink url="http://sourceforge.net/projects/boost/files/boost-docs/">PDF</ulink></simpara>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
|
||||
</preface>
|
||||
|
||||
<part id="libraries">
|
||||
<title>The Boost C++ Libraries (BoostBook Subset)</title>
|
||||
<xi:include href="accumulators.xml"/>
|
||||
<xi:include href="align.xml"/>
|
||||
<xi:include href="../../libs/any/doc/any.xml"/>
|
||||
<xi:include href="../../libs/array/doc/array.xml"/>
|
||||
<xi:include href="atomic.xml"/>
|
||||
<xi:include href="chrono.xml"/>
|
||||
<xi:include href="circular_buffer.auto_index.docbook"/>
|
||||
<xi:include href="container.auto_index.docbook"/>
|
||||
<xi:include href="../../libs/date_time/xmldoc/date_time.xml"/>
|
||||
<xi:include href="foreach.xml"/>
|
||||
<xi:include href="../../libs/function/doc/function.xml"/>
|
||||
<xi:include href="hash.xml"/>
|
||||
<xi:include href="heap.xml"/>
|
||||
<xi:include href="interprocess.auto_index.docbook"/>
|
||||
<xi:include href="intrusive.auto_index.docbook"/>
|
||||
<xi:include href="../../libs/lambda/doc/lambda.xml"/>
|
||||
<xi:include href="lexical_cast.xml"/>
|
||||
<xi:include href="lockfree.xml"/>
|
||||
<xi:include href="move.xml"/>
|
||||
<xi:include href="mpi.xml"/>
|
||||
<xi:include href="../../libs/program_options/doc/program_options.xml"/>
|
||||
<xi:include href="property_tree.xml"/>
|
||||
<xi:include href="proto.xml"/>
|
||||
<xi:include href="random.xml"/>
|
||||
<xi:include href="ratio.xml"/>
|
||||
<xi:include href="../../libs/signals/doc/signals.xml"/>
|
||||
<xi:include href="../../libs/signals2/doc/signals.xml"/>
|
||||
<xi:include href="static_assert.xml"/>
|
||||
<xi:include href="../../libs/algorithm/string/doc/string_algo.xml"/>
|
||||
<xi:include href="thread.xml"/>
|
||||
<xi:include href="tr1.xml"/>
|
||||
<xi:include href="../../libs/logic/doc/tribool.boostbook"/>
|
||||
<xi:include href="type_erasure.xml"/>
|
||||
<xi:include href="type_index.xml"/>
|
||||
<xi:include href="typeof.xml"/>
|
||||
<xi:include href="units.xml"/>
|
||||
<xi:include href="unordered.xml"/>
|
||||
<xi:include href="../../libs/variant/doc/variant.xml"/>
|
||||
<xi:include href="xpressive.xml"/>
|
||||
</part>
|
||||
|
||||
<part id="tools">
|
||||
<title>Boost Tools</title>
|
||||
<partintro>
|
||||
<para>
|
||||
Boost developers, testers, and maintainers have developed various programs to
|
||||
help with the administration of the Boost Libraries. Like everything else about
|
||||
Boost, these tools are available in source form, and are part of the regular
|
||||
Boost distribution.
|
||||
</para>
|
||||
<para>
|
||||
Users may find these tools useful when porting Boost libraries to a new platform,
|
||||
or for use with their own applications.
|
||||
</para>
|
||||
</partintro>
|
||||
<xi:include href="../../tools/boostbook/doc/boostbook.xml"/>
|
||||
<xi:include href="quickbook.xml"/>
|
||||
<xi:include href="jam_docs.xml"/>
|
||||
<xi:include href="../../tools/build/doc/src/userman.xml"/>
|
||||
</part>
|
||||
</boostbook>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,700 +0,0 @@
|
||||
|
||||
/*=============================================================================
|
||||
Copyright (c) 2004 Joel de Guzman
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
Copyright 2013 Niall Douglas additions for colors and alignment.
|
||||
Copyright 2013 Paul A. Bristow additions for more colors and alignments.
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompany-
|
||||
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
=============================================================================*/
|
||||
|
||||
/*=============================================================================
|
||||
Body defaults
|
||||
=============================================================================*/
|
||||
|
||||
body
|
||||
{
|
||||
margin: 1em;
|
||||
font-family: sans-serif;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Paragraphs
|
||||
=============================================================================*/
|
||||
|
||||
p
|
||||
{
|
||||
text-align: left;
|
||||
font-size: 10pt;
|
||||
line-height: 1.15;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Program listings
|
||||
=============================================================================*/
|
||||
|
||||
/* Code on paragraphs */
|
||||
p tt.computeroutput
|
||||
{
|
||||
font-size: 9pt;
|
||||
}
|
||||
|
||||
pre.synopsis
|
||||
{
|
||||
font-size: 9pt;
|
||||
margin: 1pc 4% 0pc 4%;
|
||||
padding: 0.5pc 0.5pc 0.5pc 0.5pc;
|
||||
}
|
||||
|
||||
.programlisting,
|
||||
.screen
|
||||
{
|
||||
font-size: 9pt;
|
||||
display: block;
|
||||
margin: 1pc 4% 0pc 4%;
|
||||
padding: 0.5pc 0.5pc 0.5pc 0.5pc;
|
||||
}
|
||||
|
||||
/* Program listings in tables don't get borders */
|
||||
td .programlisting,
|
||||
td .screen
|
||||
{
|
||||
margin: 0pc 0pc 0pc 0pc;
|
||||
padding: 0pc 0pc 0pc 0pc;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Headings
|
||||
=============================================================================*/
|
||||
|
||||
h1, h2, h3, h4, h5, h6
|
||||
{
|
||||
text-align: left;
|
||||
margin: 1em 0em 0.5em 0em;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
h1 { font-size: 140%; }
|
||||
h2 { font-weight: bold; font-size: 140%; }
|
||||
h3 { font-weight: bold; font-size: 130%; }
|
||||
h4 { font-weight: bold; font-size: 120%; }
|
||||
h5 { font-weight: normal; font-style: italic; font-size: 110%; }
|
||||
h6 { font-weight: normal; font-style: italic; font-size: 100%; }
|
||||
|
||||
/* Top page titles */
|
||||
title,
|
||||
h1.title,
|
||||
h2.title
|
||||
h3.title,
|
||||
h4.title,
|
||||
h5.title,
|
||||
h6.title,
|
||||
.refentrytitle
|
||||
{
|
||||
font-weight: bold;
|
||||
margin-bottom: 1pc;
|
||||
}
|
||||
|
||||
h1.title { font-size: 140% }
|
||||
h2.title { font-size: 140% }
|
||||
h3.title { font-size: 130% }
|
||||
h4.title { font-size: 120% }
|
||||
h5.title { font-size: 110% }
|
||||
h6.title { font-size: 100% }
|
||||
|
||||
.section h1
|
||||
{
|
||||
margin: 0em 0em 0.5em 0em;
|
||||
font-size: 140%;
|
||||
}
|
||||
|
||||
.section h2 { font-size: 140% }
|
||||
.section h3 { font-size: 130% }
|
||||
.section h4 { font-size: 120% }
|
||||
.section h5 { font-size: 110% }
|
||||
.section h6 { font-size: 100% }
|
||||
|
||||
/* Code on titles */
|
||||
h1 tt.computeroutput { font-size: 140% }
|
||||
h2 tt.computeroutput { font-size: 140% }
|
||||
h3 tt.computeroutput { font-size: 130% }
|
||||
h4 tt.computeroutput { font-size: 130% }
|
||||
h5 tt.computeroutput { font-size: 130% }
|
||||
h6 tt.computeroutput { font-size: 130% }
|
||||
|
||||
|
||||
/*=============================================================================
|
||||
Author
|
||||
=============================================================================*/
|
||||
|
||||
h3.author
|
||||
{
|
||||
font-size: 100%
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Lists
|
||||
=============================================================================*/
|
||||
|
||||
li
|
||||
{
|
||||
font-size: 10pt;
|
||||
line-height: 1.3;
|
||||
}
|
||||
|
||||
/* Unordered lists */
|
||||
ul
|
||||
{
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
/* Ordered lists */
|
||||
ol
|
||||
{
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Links
|
||||
=============================================================================*/
|
||||
|
||||
a
|
||||
{
|
||||
text-decoration: none; /* no underline */
|
||||
}
|
||||
|
||||
a:hover
|
||||
{
|
||||
text-decoration: underline;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Spirit style navigation
|
||||
=============================================================================*/
|
||||
|
||||
.spirit-nav
|
||||
{
|
||||
text-align: right;
|
||||
}
|
||||
|
||||
.spirit-nav a
|
||||
{
|
||||
color: white;
|
||||
padding-left: 0.5em;
|
||||
}
|
||||
|
||||
.spirit-nav img
|
||||
{
|
||||
border-width: 0px;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Copyright footer
|
||||
=============================================================================*/
|
||||
.copyright-footer
|
||||
{
|
||||
text-align: right;
|
||||
font-size: 70%;
|
||||
}
|
||||
|
||||
.copyright-footer p
|
||||
{
|
||||
text-align: right;
|
||||
font-size: 80%;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Table of contents
|
||||
=============================================================================*/
|
||||
|
||||
div.toc
|
||||
{
|
||||
margin: 1pc 4% 0pc 4%;
|
||||
padding: 0.1pc 1pc 0.1pc 1pc;
|
||||
font-size: 80%;
|
||||
line-height: 1.15;
|
||||
}
|
||||
|
||||
.boost-toc
|
||||
{
|
||||
float: right;
|
||||
padding: 0.5pc;
|
||||
}
|
||||
|
||||
/* Code on toc */
|
||||
.toc .computeroutput { font-size: 120% }
|
||||
|
||||
/* No margin on nested menus */
|
||||
|
||||
.toc dl dl { margin: 0; }
|
||||
|
||||
/*=============================================================================
|
||||
Tables
|
||||
=============================================================================*/
|
||||
|
||||
.table-title,
|
||||
div.table p.title
|
||||
{
|
||||
margin-left: 4%;
|
||||
padding-right: 0.5em;
|
||||
padding-left: 0.5em;
|
||||
}
|
||||
|
||||
.informaltable table,
|
||||
.table table
|
||||
{
|
||||
width: 92%;
|
||||
margin-left: 4%;
|
||||
margin-right: 4%;
|
||||
}
|
||||
|
||||
div.informaltable table,
|
||||
div.table table
|
||||
{
|
||||
padding: 4px;
|
||||
}
|
||||
|
||||
/* Table Cells */
|
||||
div.informaltable table tr td,
|
||||
div.table table tr td
|
||||
{
|
||||
padding: 0.5em;
|
||||
text-align: left;
|
||||
font-size: 9pt;
|
||||
}
|
||||
|
||||
div.informaltable table tr th,
|
||||
div.table table tr th
|
||||
{
|
||||
padding: 0.5em 0.5em 0.5em 0.5em;
|
||||
border: 1pt solid white;
|
||||
font-size: 80%;
|
||||
}
|
||||
|
||||
table.simplelist
|
||||
{
|
||||
width: auto !important;
|
||||
margin: 0em !important;
|
||||
padding: 0em !important;
|
||||
border: none !important;
|
||||
}
|
||||
table.simplelist td
|
||||
{
|
||||
margin: 0em !important;
|
||||
padding: 0em !important;
|
||||
text-align: left !important;
|
||||
font-size: 9pt !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Blurbs
|
||||
=============================================================================*/
|
||||
|
||||
div.note,
|
||||
div.tip,
|
||||
div.important,
|
||||
div.caution,
|
||||
div.warning,
|
||||
p.blurb
|
||||
{
|
||||
font-size: 9pt; /* A little bit smaller than the main text */
|
||||
line-height: 1.2;
|
||||
display: block;
|
||||
margin: 1pc 4% 0pc 4%;
|
||||
padding: 0.5pc 0.5pc 0.5pc 0.5pc;
|
||||
}
|
||||
|
||||
p.blurb img
|
||||
{
|
||||
padding: 1pt;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Variable Lists
|
||||
=============================================================================*/
|
||||
|
||||
div.variablelist
|
||||
{
|
||||
margin: 1em 0;
|
||||
}
|
||||
|
||||
/* Make the terms in definition lists bold */
|
||||
div.variablelist dl dt,
|
||||
span.term
|
||||
{
|
||||
font-weight: bold;
|
||||
font-size: 10pt;
|
||||
}
|
||||
|
||||
div.variablelist table tbody tr td
|
||||
{
|
||||
text-align: left;
|
||||
vertical-align: top;
|
||||
padding: 0em 2em 0em 0em;
|
||||
font-size: 10pt;
|
||||
margin: 0em 0em 0.5em 0em;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
div.variablelist dl dt
|
||||
{
|
||||
margin-bottom: 0.2em;
|
||||
}
|
||||
|
||||
div.variablelist dl dd
|
||||
{
|
||||
margin: 0em 0em 0.5em 2em;
|
||||
font-size: 10pt;
|
||||
}
|
||||
|
||||
div.variablelist table tbody tr td p,
|
||||
div.variablelist dl dd p
|
||||
{
|
||||
margin: 0em 0em 0.5em 0em;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Misc
|
||||
=============================================================================*/
|
||||
|
||||
/* Title of books and articles in bibliographies */
|
||||
span.title
|
||||
{
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
span.underline
|
||||
{
|
||||
text-decoration: underline;
|
||||
}
|
||||
|
||||
span.strikethrough
|
||||
{
|
||||
text-decoration: line-through;
|
||||
}
|
||||
|
||||
/* Copyright, Legal Notice */
|
||||
div div.legalnotice p
|
||||
{
|
||||
text-align: left
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Colors
|
||||
=============================================================================*/
|
||||
|
||||
@media screen
|
||||
{
|
||||
body {
|
||||
background-color: #FFFFFF;
|
||||
color: #000000;
|
||||
}
|
||||
|
||||
/* Syntax Highlighting */
|
||||
.keyword { color: #0000AA; }
|
||||
.identifier { color: #000000; }
|
||||
.special { color: #707070; }
|
||||
.preprocessor { color: #402080; }
|
||||
.char { color: teal; }
|
||||
.comment { color: #800000; }
|
||||
.string { color: teal; }
|
||||
.number { color: teal; }
|
||||
.white_bkd { background-color: #FFFFFF; }
|
||||
.dk_grey_bkd { background-color: #999999; }
|
||||
|
||||
/* Links */
|
||||
a, a .keyword, a .identifier, a .special, a .preprocessor
|
||||
a .char, a .comment, a .string, a .number
|
||||
{
|
||||
color: #005a9c;
|
||||
}
|
||||
|
||||
a:visited, a:visited .keyword, a:visited .identifier,
|
||||
a:visited .special, a:visited .preprocessor a:visited .char,
|
||||
a:visited .comment, a:visited .string, a:visited .number
|
||||
{
|
||||
color: #9c5a9c;
|
||||
}
|
||||
|
||||
h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
|
||||
h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
|
||||
h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
|
||||
{
|
||||
text-decoration: none; /* no underline */
|
||||
color: #000000;
|
||||
}
|
||||
|
||||
/* Copyright, Legal Notice */
|
||||
.copyright
|
||||
{
|
||||
color: #666666;
|
||||
font-size: small;
|
||||
}
|
||||
|
||||
div div.legalnotice p
|
||||
{
|
||||
color: #666666;
|
||||
}
|
||||
|
||||
/* Program listing */
|
||||
pre.synopsis
|
||||
{
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
.programlisting,
|
||||
.screen
|
||||
{
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
td .programlisting,
|
||||
td .screen
|
||||
{
|
||||
border: 0px solid #DCDCDC;
|
||||
}
|
||||
|
||||
/* Blurbs */
|
||||
div.note,
|
||||
div.tip,
|
||||
div.important,
|
||||
div.caution,
|
||||
div.warning,
|
||||
p.blurb
|
||||
{
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
/* Table of contents */
|
||||
div.toc
|
||||
{
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
/* Tables */
|
||||
div.informaltable table tr td,
|
||||
div.table table tr td
|
||||
{
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
div.informaltable table tr th,
|
||||
div.table table tr th
|
||||
{
|
||||
background-color: #F0F0F0;
|
||||
border: 1px solid #DCDCDC;
|
||||
}
|
||||
|
||||
.copyright-footer
|
||||
{
|
||||
color: #8F8F8F;
|
||||
}
|
||||
|
||||
/* Misc */
|
||||
span.highlight
|
||||
{
|
||||
color: #00A000;
|
||||
}
|
||||
}
|
||||
|
||||
@media print
|
||||
{
|
||||
/* Links */
|
||||
a
|
||||
{
|
||||
color: black;
|
||||
}
|
||||
|
||||
a:visited
|
||||
{
|
||||
color: black;
|
||||
}
|
||||
|
||||
.spirit-nav
|
||||
{
|
||||
display: none;
|
||||
}
|
||||
|
||||
/* Program listing */
|
||||
pre.synopsis
|
||||
{
|
||||
border: 1px solid gray;
|
||||
}
|
||||
|
||||
.programlisting,
|
||||
.screen
|
||||
{
|
||||
border: 1px solid gray;
|
||||
}
|
||||
|
||||
td .programlisting,
|
||||
td .screen
|
||||
{
|
||||
border: 0px solid #DCDCDC;
|
||||
}
|
||||
|
||||
/* Table of contents */
|
||||
div.toc
|
||||
{
|
||||
border: 1px solid gray;
|
||||
}
|
||||
|
||||
.informaltable table,
|
||||
.table table
|
||||
{
|
||||
border: 1px solid gray;
|
||||
border-collapse: collapse;
|
||||
}
|
||||
|
||||
/* Tables */
|
||||
div.informaltable table tr td,
|
||||
div.table table tr td
|
||||
{
|
||||
border: 1px solid gray;
|
||||
}
|
||||
|
||||
div.informaltable table tr th,
|
||||
div.table table tr th
|
||||
{
|
||||
border: 1px solid gray;
|
||||
}
|
||||
|
||||
table.simplelist tr td
|
||||
{
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
/* Misc */
|
||||
span.highlight
|
||||
{
|
||||
font-weight: bold;
|
||||
}
|
||||
}
|
||||
|
||||
/*=============================================================================
|
||||
Images
|
||||
=============================================================================*/
|
||||
|
||||
span.inlinemediaobject img
|
||||
{
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
/*==============================================================================
|
||||
Super and Subscript: style so that line spacing isn't effected, see
|
||||
http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&productId=1&postId=5341
|
||||
==============================================================================*/
|
||||
|
||||
sup,
|
||||
sub {
|
||||
height: 0;
|
||||
line-height: 1;
|
||||
vertical-align: baseline;
|
||||
position: relative;
|
||||
|
||||
}
|
||||
|
||||
/* For internet explorer: */
|
||||
|
||||
* html sup,
|
||||
* html sub {
|
||||
vertical-align: bottom;
|
||||
}
|
||||
|
||||
sup {
|
||||
bottom: 1ex;
|
||||
}
|
||||
|
||||
sub {
|
||||
top: .5ex;
|
||||
}
|
||||
|
||||
/*==============================================================================
|
||||
Indexes: pretty much the same as the TOC.
|
||||
==============================================================================*/
|
||||
|
||||
.index
|
||||
{
|
||||
font-size: 80%;
|
||||
padding-top: 0px;
|
||||
padding-bottom: 0px;
|
||||
margin-top: 0px;
|
||||
margin-bottom: 0px;
|
||||
margin-left: 0px;
|
||||
}
|
||||
|
||||
.index ul
|
||||
{
|
||||
padding-left: 3em;
|
||||
}
|
||||
|
||||
.index p
|
||||
{
|
||||
padding: 2px;
|
||||
margin: 2px;
|
||||
}
|
||||
|
||||
.index-entry-level-0
|
||||
{
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.index em
|
||||
{
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
|
||||
/*==============================================================================
|
||||
Alignment and coloring use 'role' feature, available from Quickbook 1.6 up.
|
||||
Added from Niall Douglas for role color and alignment.
|
||||
http://article.gmane.org/gmane.comp.lib.boost.devel/243318
|
||||
*/
|
||||
|
||||
/* Add text alignment (see http://www.w3schools.com/cssref/pr_text_text-align.asp) */
|
||||
span.aligncenter
|
||||
{
|
||||
display: inline-block; width: 100%; text-align: center;
|
||||
}
|
||||
span.alignright
|
||||
{
|
||||
display: inline-block; width: 100%; text-align: right;
|
||||
}
|
||||
/* alignleft is the default. */
|
||||
span.alignleft
|
||||
{
|
||||
display: inline-block; width: 100%; text-align: left;
|
||||
}
|
||||
|
||||
/* alignjustify stretches the word spacing so that each line has equal width
|
||||
within a chosen fraction of page width (here arbitrarily 20%).
|
||||
*Not* useful inside table items as the column width remains the total string width.
|
||||
Nor very useful, except to temporarily restrict the width.
|
||||
*/
|
||||
span.alignjustify
|
||||
{
|
||||
display: inline-block; width: 20%; text-align: justify;
|
||||
}
|
||||
|
||||
/* Text colors.
|
||||
Names at http://www.w3.org/TR/2002/WD-css3-color-20020219/ 4.3. X11 color keywords.
|
||||
Quickbook Usage: [role red Some red text]
|
||||
|
||||
*/
|
||||
span.red { inline-block; color: red; }
|
||||
span.green { color: green; }
|
||||
span.lime { color: #00FF00; }
|
||||
span.blue { color: blue; }
|
||||
span.navy { color: navy; }
|
||||
span.yellow { color: yellow; }
|
||||
span.magenta { color: magenta; }
|
||||
span.indigo { color: #4B0082; }
|
||||
span.cyan { color: cyan; }
|
||||
span.purple { color: purple; }
|
||||
span.gold { color: gold; }
|
||||
span.silver { color: silver; } /* lighter gray */
|
||||
span.gray { color: #808080; } /* light gray */
|
||||
@ -1,275 +0,0 @@
|
||||
/*
|
||||
:Author: David Goodger
|
||||
:Contact: goodger@python.org
|
||||
:Date: $Date$
|
||||
:Revision: $Revision$
|
||||
:Copyright: This stylesheet has been placed in the public domain.
|
||||
|
||||
Default cascading style sheet for the HTML output of Docutils.
|
||||
|
||||
See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
|
||||
customize this style sheet.
|
||||
*/
|
||||
|
||||
/* used to remove borders from tables and images */
|
||||
.borderless, table.borderless td, table.borderless th {
|
||||
border: 0 }
|
||||
|
||||
table.borderless td, table.borderless th {
|
||||
/* Override padding for "table.docutils td" with "! important".
|
||||
The right padding separates the table cells. */
|
||||
padding: 0 0.5em 0 0 ! important }
|
||||
|
||||
.first {
|
||||
/* Override more specific margin styles with "! important". */
|
||||
margin-top: 0 ! important }
|
||||
|
||||
.last, .with-subtitle {
|
||||
margin-bottom: 0 ! important }
|
||||
|
||||
.hidden {
|
||||
display: none }
|
||||
|
||||
a.toc-backref {
|
||||
text-decoration: none ;
|
||||
color: black }
|
||||
|
||||
blockquote.epigraph {
|
||||
margin: 2em 5em ; }
|
||||
|
||||
dl.docutils dd {
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
/* Uncomment (and remove this text!) to get bold-faced definition list terms
|
||||
dl.docutils dt {
|
||||
font-weight: bold }
|
||||
*/
|
||||
|
||||
div.abstract {
|
||||
margin: 2em 5em }
|
||||
|
||||
div.abstract p.topic-title {
|
||||
font-weight: bold ;
|
||||
text-align: center }
|
||||
|
||||
div.admonition, div.attention, div.caution, div.danger, div.error,
|
||||
div.hint, div.important, div.note, div.tip, div.warning {
|
||||
margin: 2em ;
|
||||
border: medium outset ;
|
||||
padding: 1em }
|
||||
|
||||
div.admonition p.admonition-title, div.hint p.admonition-title,
|
||||
div.important p.admonition-title, div.note p.admonition-title,
|
||||
div.tip p.admonition-title {
|
||||
font-weight: bold ;
|
||||
font-family: sans-serif }
|
||||
|
||||
div.attention p.admonition-title, div.caution p.admonition-title,
|
||||
div.danger p.admonition-title, div.error p.admonition-title,
|
||||
div.warning p.admonition-title {
|
||||
color: red ;
|
||||
font-weight: bold ;
|
||||
font-family: sans-serif }
|
||||
|
||||
/* Uncomment (and remove this text!) to get reduced vertical space in
|
||||
compound paragraphs.
|
||||
div.compound .compound-first, div.compound .compound-middle {
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
div.compound .compound-last, div.compound .compound-middle {
|
||||
margin-top: 0.5em }
|
||||
*/
|
||||
|
||||
div.dedication {
|
||||
margin: 2em 5em ;
|
||||
text-align: center ;
|
||||
font-style: italic }
|
||||
|
||||
div.dedication p.topic-title {
|
||||
font-weight: bold ;
|
||||
font-style: normal }
|
||||
|
||||
div.figure {
|
||||
margin-left: 2em ;
|
||||
margin-right: 2em }
|
||||
|
||||
div.footer, div.header {
|
||||
clear: both;
|
||||
font-size: smaller }
|
||||
|
||||
div.line-block {
|
||||
display: block ;
|
||||
margin-top: 1em ;
|
||||
margin-bottom: 1em }
|
||||
|
||||
div.line-block div.line-block {
|
||||
margin-top: 0 ;
|
||||
margin-bottom: 0 ;
|
||||
margin-left: 1.5em }
|
||||
|
||||
div.sidebar {
|
||||
margin-left: 1em ;
|
||||
border: medium outset ;
|
||||
padding: 1em ;
|
||||
background-color: #ffffee ;
|
||||
width: 40% ;
|
||||
float: right ;
|
||||
clear: right }
|
||||
|
||||
div.sidebar p.rubric {
|
||||
font-family: sans-serif ;
|
||||
font-size: medium }
|
||||
|
||||
div.system-messages {
|
||||
margin: 5em }
|
||||
|
||||
div.system-messages h1 {
|
||||
color: red }
|
||||
|
||||
div.system-message {
|
||||
border: medium outset ;
|
||||
padding: 1em }
|
||||
|
||||
div.system-message p.system-message-title {
|
||||
color: red ;
|
||||
font-weight: bold }
|
||||
|
||||
div.topic {
|
||||
margin: 2em }
|
||||
|
||||
h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
|
||||
h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
|
||||
margin-top: 0.4em }
|
||||
|
||||
h1.title {
|
||||
text-align: center }
|
||||
|
||||
h2.subtitle {
|
||||
text-align: center }
|
||||
|
||||
hr.docutils {
|
||||
width: 75% }
|
||||
|
||||
img.align-left {
|
||||
clear: left }
|
||||
|
||||
img.align-right {
|
||||
clear: right }
|
||||
|
||||
ol.simple, ul.simple {
|
||||
margin-bottom: 1em }
|
||||
|
||||
ol.arabic {
|
||||
list-style: decimal }
|
||||
|
||||
ol.loweralpha {
|
||||
list-style: lower-alpha }
|
||||
|
||||
ol.upperalpha {
|
||||
list-style: upper-alpha }
|
||||
|
||||
ol.lowerroman {
|
||||
list-style: lower-roman }
|
||||
|
||||
ol.upperroman {
|
||||
list-style: upper-roman }
|
||||
|
||||
p.attribution {
|
||||
text-align: right ;
|
||||
margin-left: 50% }
|
||||
|
||||
p.caption {
|
||||
font-style: italic }
|
||||
|
||||
p.credits {
|
||||
font-style: italic ;
|
||||
font-size: smaller }
|
||||
|
||||
p.label {
|
||||
white-space: nowrap }
|
||||
|
||||
p.rubric {
|
||||
font-weight: bold ;
|
||||
font-size: larger ;
|
||||
color: maroon ;
|
||||
text-align: center }
|
||||
|
||||
p.sidebar-title {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold ;
|
||||
font-size: larger }
|
||||
|
||||
p.sidebar-subtitle {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold }
|
||||
|
||||
p.topic-title {
|
||||
font-weight: bold }
|
||||
|
||||
pre.address {
|
||||
margin-bottom: 0 ;
|
||||
margin-top: 0 ;
|
||||
font-family: serif ;
|
||||
font-size: 100% }
|
||||
|
||||
pre.literal-block, pre.doctest-block {
|
||||
margin-left: 2em ;
|
||||
margin-right: 2em }
|
||||
|
||||
span.classifier {
|
||||
font-family: sans-serif ;
|
||||
font-style: oblique }
|
||||
|
||||
span.classifier-delimiter {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold }
|
||||
|
||||
span.interpreted {
|
||||
font-family: sans-serif }
|
||||
|
||||
span.option {
|
||||
white-space: nowrap }
|
||||
|
||||
span.pre {
|
||||
white-space: pre }
|
||||
|
||||
span.problematic {
|
||||
color: red }
|
||||
|
||||
span.section-subtitle {
|
||||
/* font-size relative to parent (h1..h6 element) */
|
||||
font-size: 80% }
|
||||
|
||||
table.citation {
|
||||
border-left: solid 1px gray;
|
||||
margin-left: 1px }
|
||||
|
||||
table.docinfo {
|
||||
margin: 2em 4em }
|
||||
|
||||
table.docutils {
|
||||
margin-top: 0.5em ;
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
table.footnote {
|
||||
border-left: solid 1px black;
|
||||
margin-left: 1px }
|
||||
|
||||
table.docutils td, table.docutils th,
|
||||
table.docinfo td, table.docinfo th {
|
||||
padding-left: 0.5em ;
|
||||
padding-right: 0.5em ;
|
||||
vertical-align: top }
|
||||
|
||||
table.docutils th.field-name, table.docinfo th.docinfo-name {
|
||||
font-weight: bold ;
|
||||
text-align: left ;
|
||||
white-space: nowrap ;
|
||||
padding-left: 0 }
|
||||
|
||||
h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
|
||||
h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
|
||||
font-size: 100% }
|
||||
|
||||
ul.auto-toc {
|
||||
list-style-type: none }
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 603 B |
Binary file not shown.
|
Before Width: | Height: | Size: 374 B |
Binary file not shown.
|
Before Width: | Height: | Size: 391 B |
@ -1,15 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M10.428,10.411h0.56c3.78,0,4.788-1.96,4.872-3.444h3.22v19.88h-3.92V13.154h-4.732V10.411z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 703 B |
Binary file not shown.
|
Before Width: | Height: | Size: 485 B |
@ -1,18 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.815,10.758h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.11H3.815V10.758z"/>
|
||||
<path style="fill:#FFFFFF;" d="M22.175,7.806c4.009,0,5.904,2.76,5.904,8.736c0,5.975-1.896,8.76-5.904,8.76
|
||||
c-4.008,0-5.904-2.785-5.904-8.76C16.271,10.566,18.167,7.806,22.175,7.806z M22.175,22.613c1.921,0,2.448-1.68,2.448-6.071
|
||||
c0-4.393-0.527-6.049-2.448-6.049c-1.92,0-2.448,1.656-2.448,6.049C19.727,20.934,20.255,22.613,22.175,22.613z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 410 B |
@ -1,16 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M5.209,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H5.209V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M18.553,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.359V12.764h-4.056V10.412z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 827 B |
Binary file not shown.
|
Before Width: | Height: | Size: 488 B |
@ -1,18 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M4.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.813V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M17.316,13.484c0-5.545,4.056-6.024,5.568-6.024c3.265,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.553,5.544c-2.256,1.584-3.432,2.353-3.815,3.145h7.392V24.5h-11.64c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.353-2.424c-2.352,0-2.423,1.944-2.447,3.192H17.316z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 509 B |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H3.813V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M20.611,14.636h0.529c1.008,0,2.855-0.096,2.855-2.304c0-0.624-0.288-2.185-2.137-2.185
|
||||
c-2.303,0-2.303,2.185-2.303,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.279,0,5.279,1.152,5.279,4.752
|
||||
c0,1.728-1.08,2.808-2.039,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.377,5.496-5.809,5.496
|
||||
c-1.607,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.52-0.911,2.52-2.808
|
||||
c0-2.328-2.256-2.424-3.816-2.424V14.636z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 499 B |
@ -1,17 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M4.146,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.146V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M28.457,20.732h-1.896V24.5h-3.36v-3.768h-6.72v-2.904L22.746,7.46h3.815v10.656h1.896V20.732z
|
||||
M23.201,18.116c0-4.128,0.072-6.792,0.072-7.32h-0.048l-4.272,7.32H23.201z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 906 B |
Binary file not shown.
|
Before Width: | Height: | Size: 507 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.479,11.079h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.43H3.479V11.079z"/>
|
||||
<path style="fill:#FFFFFF;" d="M19.342,14.943c0.625-0.433,1.392-0.937,3.048-0.937c2.279,0,5.16,1.584,5.16,5.496
|
||||
c0,2.328-1.176,6.121-6.192,6.121c-2.664,0-5.376-1.584-5.544-5.016h3.36c0.144,1.391,0.888,2.326,2.376,2.326
|
||||
c1.607,0,2.544-1.367,2.544-3.191c0-1.512-0.72-3.047-2.496-3.047c-0.456,0-1.608,0.023-2.256,1.223l-3-0.143l1.176-9.361h9.36
|
||||
v2.832h-6.937L19.342,14.943z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.1 KiB |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H3.813V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M24.309,11.78c-0.097-0.96-0.721-1.633-1.969-1.633c-2.184,0-2.688,2.496-2.808,4.704L19.58,14.9
|
||||
c0.456-0.624,1.296-1.416,3.191-1.416c3.529,0,5.209,2.712,5.209,5.256c0,3.72-2.28,6.216-5.568,6.216
|
||||
c-5.16,0-6.168-4.32-6.168-8.568c0-3.24,0.432-8.928,6.336-8.928c0.695,0,2.641,0.264,3.48,1.104
|
||||
c0.936,0.912,1.271,1.416,1.584,3.217H24.309z M22.172,16.172c-1.271,0-2.568,0.792-2.568,2.928c0,1.849,1.056,3.168,2.664,3.168
|
||||
c1.225,0,2.353-0.936,2.353-3.239C24.62,16.868,23.229,16.172,22.172,16.172z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
@ -1,17 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.479,11.079h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.43H3.479V11.079z"/>
|
||||
<path style="fill:#FFFFFF;" d="M27.838,11.006c-1.631,1.776-5.807,6.816-6.215,14.16h-3.457c0.36-6.816,4.632-12.24,6.072-13.776
|
||||
h-8.472l0.072-2.976h12V11.006z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 866 B |
@ -1,21 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M4.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.813V10.412z"/>
|
||||
<path style="fill:#FFFFFF;" d="M23.172,24.956c-4.392,0-5.904-2.856-5.904-5.185c0-0.863,0-3.119,2.592-4.319
|
||||
c-1.344-0.672-2.064-1.752-2.064-3.336c0-2.904,2.328-4.656,5.304-4.656c3.528,0,5.4,2.088,5.4,4.44
|
||||
c0,1.464-0.6,2.712-1.968,3.432c1.632,0.815,2.544,1.896,2.544,4.104C29.076,21.596,27.684,24.956,23.172,24.956z M23.124,16.916
|
||||
c-1.224,0-2.4,0.792-2.4,2.64c0,1.632,0.936,2.712,2.472,2.712c1.752,0,2.424-1.512,2.424-2.688
|
||||
C25.62,18.38,24.996,16.916,23.124,16.916z M25.284,12.26c0-1.296-0.888-2.112-1.968-2.112c-1.512,0-2.305,0.864-2.305,2.112
|
||||
c0,1.008,0.744,2.112,2.185,2.112C24.516,14.372,25.284,13.484,25.284,12.26z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.3 KiB |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M4.146,10.746h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.041h-3.36V13.097H4.146V10.746z"/>
|
||||
<path style="fill:#FFFFFF;" d="M20.225,20.898v0.023c0.192,1.176,0.936,1.68,1.968,1.68c1.392,0,2.783-1.176,2.808-4.752
|
||||
l-0.048-0.049c-0.768,1.152-2.088,1.441-3.24,1.441c-3.264,0-5.16-2.473-5.16-5.329c0-4.176,2.472-6.12,5.808-6.12
|
||||
c5.904,0,6,6.36,6,8.76c0,6.601-3.12,8.736-6.192,8.736c-2.904,0-4.992-1.68-5.28-4.391H20.225z M22.434,16.553
|
||||
c1.176,0,2.472-0.84,2.472-2.855c0-1.944-0.841-3.145-2.568-3.145c-0.864,0-2.424,0.433-2.424,2.88
|
||||
C19.913,16.001,21.161,16.553,22.434,16.553z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 446 B |
@ -1,17 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M9.668,12.328c0-6.469,4.732-7.028,6.496-7.028c3.808,0,6.833,2.24,6.833,6.271
|
||||
c0,3.416-2.213,5.152-4.145,6.469c-2.632,1.848-4.004,2.744-4.452,3.668h8.624v3.472H9.444c0.14-2.324,0.308-4.76,4.62-7.896
|
||||
c3.584-2.604,5.012-3.612,5.012-5.853c0-1.315-0.84-2.828-2.744-2.828c-2.744,0-2.828,2.269-2.856,3.725H9.668z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 926 B |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M23.172,7.46c4.008,0,5.904,2.76,5.904,8.736c0,5.976-1.896,8.76-5.904,8.76
|
||||
s-5.904-2.784-5.904-8.76C17.268,10.22,19.164,7.46,23.172,7.46z M23.172,22.268c1.92,0,2.448-1.68,2.448-6.071
|
||||
c0-4.393-0.528-6.049-2.448-6.049s-2.448,1.656-2.448,6.049C20.724,20.588,21.252,22.268,23.172,22.268z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
@ -1,18 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M5.306,13.151c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392v2.976H5.114c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H5.306z"/>
|
||||
<path style="fill:#FFFFFF;" d="M19.49,10.079h0.48c3.239,0,4.104-1.681,4.176-2.952h2.761v17.04h-3.361V12.431H19.49V10.079z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M17.316,13.484c0-5.545,4.056-6.024,5.568-6.024c3.265,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.553,5.544c-2.256,1.584-3.432,2.353-3.815,3.145h7.392V24.5h-11.64c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.353-2.424c-2.352,0-2.423,1.944-2.447,3.192H17.316z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M21.612,14.636h0.528c1.008,0,2.855-0.096,2.855-2.304c0-0.624-0.287-2.185-2.136-2.185
|
||||
c-2.304,0-2.304,2.185-2.304,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.28,0,5.28,1.152,5.28,4.752
|
||||
c0,1.728-1.08,2.808-2.04,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.377,5.496-5.809,5.496
|
||||
c-1.607,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.521-0.911,2.521-2.808
|
||||
c0-2.328-2.257-2.424-3.816-2.424V14.636z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.4 KiB |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M4.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H4.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H4.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M30.124,20.732h-1.896V24.5h-3.36v-3.768h-6.72v-2.904L24.412,7.46h3.816v10.656h1.896V20.732z
|
||||
M24.868,18.116c0-4.128,0.071-6.792,0.071-7.32h-0.047l-4.272,7.32H24.868z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.1 KiB |
@ -1,21 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M20.676,14.276c0.624-0.433,1.393-0.937,3.049-0.937c2.279,0,5.16,1.584,5.16,5.496
|
||||
c0,2.328-1.177,6.12-6.193,6.12c-2.664,0-5.375-1.584-5.543-5.016h3.36c0.144,1.392,0.889,2.327,2.376,2.327
|
||||
c1.608,0,2.544-1.367,2.544-3.191c0-1.513-0.72-3.048-2.496-3.048c-0.455,0-1.607,0.023-2.256,1.224l-3-0.144l1.176-9.36h9.36
|
||||
v2.832h-6.937L20.676,14.276z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.3 KiB |
@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M25.309,11.78c-0.097-0.96-0.721-1.633-1.969-1.633c-2.184,0-2.688,2.496-2.808,4.704L20.58,14.9
|
||||
c0.456-0.624,1.296-1.416,3.191-1.416c3.529,0,5.209,2.712,5.209,5.256c0,3.72-2.28,6.216-5.568,6.216
|
||||
c-5.16,0-6.168-4.32-6.168-8.568c0-3.24,0.432-8.928,6.336-8.928c0.695,0,2.641,0.264,3.48,1.104
|
||||
c0.936,0.912,1.271,1.416,1.584,3.217H25.309z M23.172,16.172c-1.271,0-2.568,0.792-2.568,2.928c0,1.849,1.056,3.168,2.664,3.168
|
||||
c1.225,0,2.353-0.936,2.353-3.239C25.62,16.868,24.229,16.172,23.172,16.172z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.4 KiB |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M29.172,10.34c-1.632,1.776-5.808,6.816-6.216,14.16H19.5c0.36-6.816,4.632-12.24,6.072-13.776
|
||||
H17.1l0.072-2.976h12V10.34z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.1 KiB |
@ -1,23 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M23.172,24.956c-4.392,0-5.904-2.856-5.904-5.185c0-0.863,0-3.119,2.592-4.319
|
||||
c-1.344-0.672-2.064-1.752-2.064-3.336c0-2.904,2.328-4.656,5.304-4.656c3.528,0,5.4,2.088,5.4,4.44
|
||||
c0,1.464-0.6,2.712-1.968,3.432c1.632,0.815,2.544,1.896,2.544,4.104C29.076,21.596,27.684,24.956,23.172,24.956z M23.124,16.916
|
||||
c-1.224,0-2.4,0.792-2.4,2.64c0,1.632,0.936,2.712,2.472,2.712c1.752,0,2.424-1.512,2.424-2.688
|
||||
C25.62,18.38,24.996,16.916,23.124,16.916z M25.284,12.26c0-1.296-0.888-2.112-1.968-2.112c-1.512,0-2.305,0.864-2.305,2.112
|
||||
c0,1.008,0.744,2.112,2.185,2.112C24.516,14.372,25.284,13.484,25.284,12.26z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.5 KiB |
@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
|
||||
c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
|
||||
c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
|
||||
<path style="fill:#FFFFFF;" d="M20.893,20.564v0.023c0.191,1.176,0.936,1.68,1.967,1.68c1.393,0,2.785-1.176,2.809-4.752
|
||||
l-0.048-0.048c-0.769,1.152-2.088,1.44-3.24,1.44c-3.264,0-5.16-2.473-5.16-5.328c0-4.176,2.472-6.12,5.807-6.12
|
||||
c5.904,0,6.001,6.36,6.001,8.76c0,6.601-3.12,8.736-6.192,8.736c-2.904,0-4.992-1.68-5.28-4.392H20.893z M23.1,16.22
|
||||
c1.176,0,2.473-0.84,2.473-2.855c0-1.944-0.84-3.145-2.568-3.145c-0.863,0-2.424,0.433-2.424,2.88
|
||||
C20.58,15.668,21.828,16.22,23.1,16.22z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 431 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M15.127,14.005h0.616c1.176,0,3.332-0.112,3.332-2.688c0-0.728-0.336-2.548-2.492-2.548
|
||||
c-2.688,0-2.688,2.548-2.688,3.248h-3.64c0-3.724,2.1-6.384,6.58-6.384c2.66,0,6.16,1.344,6.16,5.544
|
||||
c0,2.016-1.261,3.276-2.38,3.78v0.056c0.699,0.196,2.996,1.232,2.996,4.62c0,3.752-2.772,6.412-6.776,6.412
|
||||
c-1.876,0-6.916-0.42-6.916-6.636h3.836l-0.028,0.027c0,1.064,0.28,3.473,2.912,3.473c1.568,0,2.94-1.064,2.94-3.276
|
||||
c0-2.716-2.632-2.828-4.452-2.828V14.005z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M8.268,14.636h0.528c1.008,0,2.856-0.096,2.856-2.304c0-0.624-0.288-2.185-2.136-2.185
|
||||
c-2.304,0-2.304,2.185-2.304,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.28,0,5.28,1.152,5.28,4.752
|
||||
c0,1.728-1.08,2.808-2.04,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.376,5.496-5.808,5.496
|
||||
c-1.608,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.52-0.911,2.52-2.808
|
||||
c0-2.328-2.256-2.424-3.816-2.424V14.636z"/>
|
||||
<path style="fill:#FFFFFF;" d="M23.172,7.46c4.008,0,5.904,2.76,5.904,8.736c0,5.976-1.896,8.76-5.904,8.76
|
||||
s-5.904-2.784-5.904-8.76C17.268,10.22,19.164,7.46,23.172,7.46z M23.172,22.268c1.92,0,2.448-1.68,2.448-6.071
|
||||
c0-4.393-0.528-6.049-2.448-6.049s-2.448,1.656-2.448,6.049C20.724,20.588,21.252,22.268,23.172,22.268z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 441 B |
@ -1,16 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M21.891,20.784h-2.212v4.396h-3.92v-4.396h-7.84v-3.389L15.227,5.3h4.452v12.432h2.212V20.784z
|
||||
M15.759,17.731c0-4.815,0.084-7.924,0.084-8.54h-0.056l-4.984,8.54H15.759z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 783 B |
Binary file not shown.
|
Before Width: | Height: | Size: 423 B |
@ -1,18 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M14.035,14.252c0.728-0.504,1.624-1.092,3.556-1.092c2.66,0,6.02,1.848,6.02,6.411
|
||||
c0,2.717-1.372,7.141-7.224,7.141c-3.108,0-6.272-1.849-6.468-5.853h3.92c0.168,1.624,1.036,2.717,2.772,2.717
|
||||
c1.876,0,2.968-1.597,2.968-3.725c0-1.764-0.839-3.556-2.912-3.556c-0.532,0-1.876,0.028-2.632,1.428l-3.5-0.168l1.372-10.92
|
||||
h10.919v3.304h-8.092L14.035,14.252z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 967 B |
Binary file not shown.
|
Before Width: | Height: | Size: 431 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M19.106,10.673c-0.112-1.12-0.84-1.904-2.296-1.904c-2.548,0-3.136,2.912-3.276,5.488l0.056,0.056
|
||||
c0.532-0.728,1.512-1.651,3.724-1.651c4.116,0,6.077,3.164,6.077,6.131c0,4.34-2.66,7.252-6.497,7.252
|
||||
c-6.02,0-7.196-5.039-7.196-9.996c0-3.78,0.504-10.416,7.392-10.416c0.812,0,3.08,0.308,4.061,1.288
|
||||
c1.092,1.063,1.483,1.652,1.848,3.752H19.106z M16.614,15.797c-1.484,0-2.996,0.924-2.996,3.416c0,2.156,1.232,3.697,3.108,3.697
|
||||
c1.428,0,2.745-1.094,2.745-3.781C19.471,16.609,17.846,15.797,16.614,15.797z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 397 B |
@ -1,16 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M24.28,9.66c-1.904,2.071-6.776,7.951-7.252,16.52h-4.032c0.42-7.952,5.404-14.28,7.084-16.072
|
||||
h-9.884l0.084-3.472h14V9.66z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 738 B |
Binary file not shown.
|
Before Width: | Height: | Size: 434 B |
@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M16.28,26.712c-5.124,0-6.888-3.332-6.888-6.048c0-1.009,0-3.641,3.024-5.04
|
||||
c-1.568-0.784-2.408-2.044-2.408-3.893c0-3.388,2.716-5.432,6.188-5.432c4.116,0,6.3,2.436,6.3,5.18
|
||||
c0,1.708-0.7,3.164-2.296,4.004c1.903,0.952,2.968,2.212,2.968,4.788C23.168,22.792,21.544,26.712,16.28,26.712z M16.224,17.332
|
||||
c-1.428,0-2.8,0.924-2.8,3.08c0,1.903,1.092,3.164,2.884,3.164c2.043,0,2.829-1.765,2.829-3.137
|
||||
C19.137,19.04,18.408,17.332,16.224,17.332z M18.744,11.899c0-1.512-1.036-2.464-2.296-2.464c-1.764,0-2.688,1.008-2.688,2.464
|
||||
c0,1.177,0.868,2.464,2.548,2.464C17.848,14.363,18.744,13.328,18.744,11.899z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 420 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448) -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY ns_svg "http://www.w3.org/2000/svg">
|
||||
<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
|
||||
]>
|
||||
<svg version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
|
||||
style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
|
||||
<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
|
||||
<g>
|
||||
<g style="enable-background:new ;">
|
||||
<path style="fill:#FFFFFF;" d="M13.953,21.921v0.027c0.224,1.372,1.092,1.961,2.296,1.961c1.624,0,3.248-1.372,3.276-5.545
|
||||
l-0.057-0.056c-0.896,1.344-2.436,1.68-3.78,1.68c-3.808,0-6.02-2.884-6.02-6.216c0-4.872,2.884-7.14,6.776-7.14
|
||||
c6.888,0,7,7.42,7,10.22c0,7.7-3.641,10.192-7.224,10.192c-3.388,0-5.824-1.96-6.16-5.124H13.953z M16.529,16.853
|
||||
c1.372,0,2.884-0.979,2.884-3.332c0-2.268-0.98-3.668-2.996-3.668c-1.008,0-2.828,0.504-2.828,3.36
|
||||
C13.589,16.209,15.045,16.853,16.529,16.853z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.2 KiB |
@ -1,68 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Generator: Adobe Illustrator 12.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 51448) --><svg height="120.648" id="Layer_1" inkscape:version="0.42" sodipodi:docbase="F:\openclip\svg da inviare" sodipodi:docname="Attenzione.svg" sodipodi:version="0.32" space="preserve" style="overflow:visible;enable-background:new 0 0 133.878 120.648;" version="1.1" viewBox="0 0 133.878 120.648" width="133.878" xmlns="http://www.w3.org/2000/svg" xmlns:cc="http://web.resource.org/cc/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:svg="http://www.w3.org/2000/svg">
|
||||
<metadata>
|
||||
<rdf:RDF xmlns:cc="http://web.resource.org/cc/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
|
||||
<cc:Work rdf:about="">
|
||||
<dc:title>Attenzione</dc:title>
|
||||
<dc:description></dc:description>
|
||||
<dc:subject>
|
||||
<rdf:Bag>
|
||||
<rdf:li>pulsante</rdf:li>
|
||||
</rdf:Bag>
|
||||
</dc:subject>
|
||||
<dc:publisher>
|
||||
<cc:Agent rdf:about="http://www.openclipart.org/">
|
||||
<dc:title>Open Clip Art Library</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:publisher>
|
||||
<dc:creator>
|
||||
<cc:Agent>
|
||||
<dc:title>Architetto Francesco Rollandin</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:creator>
|
||||
<dc:rights>
|
||||
<cc:Agent>
|
||||
<dc:title>Architetto Francesco Rollandin</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:rights>
|
||||
<dc:date></dc:date>
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
|
||||
<cc:license rdf:resource="http://web.resource.org/cc/PublicDomain"/>
|
||||
<dc:language>en</dc:language>
|
||||
</cc:Work>
|
||||
<cc:License rdf:about="http://web.resource.org/cc/PublicDomain">
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/Reproduction"/>
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/Distribution"/>
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/DerivativeWorks"/>
|
||||
</cc:License>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<defs id="defs43"/>
|
||||
<sodipodi:namedview bordercolor="#666666" borderopacity="1.0" id="base" inkscape:current-layer="Layer_1" inkscape:cx="66.939003" inkscape:cy="60.324001" inkscape:pageopacity="0.0" inkscape:pageshadow="2" inkscape:window-height="510" inkscape:window-width="787" inkscape:window-x="44" inkscape:window-y="58" inkscape:zoom="2.9838869" pagecolor="#ffffff"/>
|
||||
<g id="g3">
|
||||
<linearGradient gradientTransform="matrix(56.9977 90.4964 90.4964 -56.9977 -27343.9609 47971.0547)" gradientUnits="userSpaceOnUse" id="XMLID_4_" x1="-244.5732" x2="-242.8169" y1="455.4199" y2="455.4199">
|
||||
<stop id="stop6" offset="0" style="stop-color:#FFFA5F"/>
|
||||
<stop id="stop8" offset="1" style="stop-color:#9F3300"/>
|
||||
</linearGradient>
|
||||
<path d="M51.333,8.834C34.985,37.343,18.638,65.854,2.289,94.363 c-7.081,12.352,3.352,26.285,16.453,26.285c6.708,0,13.418,0,20.128,0c22.109,0,44.217,0,66.327,0c3.644,0,7.286,0,10.931,0 c13.293,0,20.963-14.273,16.452-26.031c-4.114-10.729-11.861-20.99-17.542-30.922c-8.81-15.403-17.618-30.809-26.429-46.212 c-1.813-3.167-3.622-6.333-5.434-9.5C76.601-3.516,57.616-2.03,51.333,8.834 M53.973,9.064" id="path10" style="fill:url(#XMLID_4_);"/>
|
||||
<path d="M55.474,12.388c-8.247,14.279-16.492,28.559-24.739,42.839 c-5.526,9.567-11.05,19.137-16.577,28.707c-2.732,4.73-7.323,10.456-8.284,16c-3.799,21.9,34.927,15.743,46.734,15.743 c20.073,0,40.144,0,60.215,0c13.716,0,18.636-11.963,12.229-23.063c-6.462-11.195-12.927-22.388-19.389-33.582 c-7.249-12.557-14.499-25.113-21.75-37.671c-1.682-2.916-3.364-5.829-5.049-8.745C73.767,3.785,60.676,3.364,55.474,12.388" id="path12" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFF200;"/>
|
||||
<path d="M55.474,12.388c-8.247,14.279-16.492,28.559-24.739,42.839c-5.526,9.567-11.05,19.137-16.577,28.707 c-2.732,4.73-7.323,10.456-8.284,16c-3.799,21.9,34.927,15.743,46.734,15.743c20.073,0,40.144,0,60.215,0 c13.716,0,18.636-11.963,12.229-23.063c-6.462-11.195-12.927-22.388-19.389-33.582c-7.249-12.557-14.499-25.113-21.75-37.671 c-1.682-2.916-3.364-5.829-5.049-8.745C73.767,3.785,60.676,3.364,55.474,12.388" id="path14" style="fill:#FFCE00;"/>
|
||||
<path d="M126.731,95.522c-8.733-15.127-17.468-30.253-26.201-45.379 c-5.537-9.595-11.078-19.188-16.616-28.781c-3.938-6.821-7.459-15.689-16.813-15.689c1.013,0,5.901,10.225,6.469,11.196 c5.451,9.314,10.902,18.63,16.352,27.947c9.217,15.749,18.433,31.498,27.646,47.249c2.302,3.933,5.356,10.555,1.308,14.397 c-3.148,2.987-7.99,3.196-12.099,3.196c-7.225,0-14.448,0-21.674,0c-22.125,0-44.251,0-66.377,0c-3.598,0-7.197,0-10.794,0 c5.285,7.909,16.341,6.02,24.546,6.02c13.009,0,26.017,0,39.023,0c11.979,0,23.958,0,35.937,0c2.516,0,5.032,0,7.547,0 C125.136,115.678,131.878,104.435,126.731,95.522" id="path16" style="fill:#FFB600;"/>
|
||||
<path d="M14.615,112.457c-4.483-7.751,1.908-16.103,5.793-22.834 c4.698-8.138,9.398-16.276,14.097-24.414C44.54,47.83,54.574,30.448,64.61,13.069c0.789-1.367,3.725-4.568,2.594-5.539 c-3.913-3.353-10.287,1.936-12.107,5.087c-3.129,5.417-6.258,10.835-9.386,16.252c-11.105,19.226-22.209,38.453-33.313,57.68 c-1.649,2.854-3.299,5.713-4.95,8.569c-4.771,8.265-0.075,19.162,9.658,20.446C16.124,114.65,15.294,113.615,14.615,112.457" id="path18" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFE600;"/>
|
||||
<path d="M77.076,34.654c0,10.183-1.788,20.758-3.439,30.772 c-0.369,2.239-4.03,23.609-7.796,14.179c-4.247-10.632-4.832-23.419-5.958-34.696c-0.363-3.638-1.538-8.425-0.563-12.06 C61.667,24.099,77.076,25.199,77.076,34.654" id="path20" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFE1;"/>
|
||||
<path d="M77.076,34.654c-2.018,0.995-1.521,8.717-1.797,11.395c-0.685,6.643-1.505,13.282-2.614,19.869 c-0.79,4.701-1.301,10.862-3.954,14.981c-1.642,2.567-3.405-5.958-3.634-6.932c-2.948-12.443-4.464-25.664-5.09-38.43 c-0.272-5.52,5.164-8.854,10.277-7.622c3.87,0.933,5.217,7.36,7.688,6.738c0.009-11.451-19.755-11.453-19.746,0 c0.017,11.956,2.087,24.599,4.423,36.294c0.501,2.507,1.642,12.376,5.449,12.376c4.059-0.021,5.285-11.432,5.79-14.137 c1.261-6.765,2.139-13.605,2.887-20.444C77.084,45.722,79.281,35.942,77.076,34.654" id="path22" style="fill:#FFFFFF;"/>
|
||||
<linearGradient gradientTransform="matrix(68.2284 33.0019 33.0019 -68.2284 1613.9791 39385.6641)" gradientUnits="userSpaceOnUse" id="XMLID_5_" x1="-246.981" x2="-245.2275" y1="458.29" y2="458.29">
|
||||
<stop id="stop25" offset="0" style="stop-color:#FFFA5F"/>
|
||||
<stop id="stop27" offset="1" style="stop-color:#9F3300"/>
|
||||
</linearGradient>
|
||||
<path d="M57.957,34.654c0,10.053,1.632,20.54,3.242,30.431 c0.479,2.936,4.912,26.502,9.99,15.164c4.987-11.134,5.351-25.201,6.386-37.184c0.273-3.169,1.153-7.045,0.421-10.221 C75.628,22.587,57.957,23.788,57.957,34.654 M60.207,34.654c0-8.061,13.138-9.015,15.459-1.792c1.156,3.597-0.13,8.748-0.508,12.38 c-1.135,10.904-2.052,22.602-5.501,33.069c-2.816,8.545-5.546-10.187-5.934-12.522C62.039,55.63,60.207,44.985,60.207,34.654" id="path29" style="fill-rule:evenodd;clip-rule:evenodd;fill:url(#XMLID_5_);"/>
|
||||
<path d="M77.076,96.788c0,11.964-18.555,11.964-18.555,0 C58.521,84.822,77.076,84.822,77.076,96.788" id="path31" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFE1;"/>
|
||||
<path d="M77.076,96.788c-2.605,1.661-2.157,6.757-7.044,8.101c-6.178,1.7-12.033-4.159-10.336-10.335 c1.439-5.23,7.657-7.767,12.341-5.021c2.91,1.704,3.164,7.913,5.915,7.256c0-14.267-22.698-12.238-20.143,1.826 c0.987,5.444,6.375,9.15,11.814,8.162C72.417,106.271,81.44,98.19,77.076,96.788" id="path33" style="fill:#FFFFFF;"/>
|
||||
<linearGradient gradientTransform="matrix(68.2241 32.9998 32.9998 -68.2241 1604.682 39402.625)" gradientUnits="userSpaceOnUse" id="XMLID_6_" x1="-246.998" x2="-245.2348" y1="458.0625" y2="458.0625">
|
||||
<stop id="stop36" offset="0" style="stop-color:#FFFA5F"/>
|
||||
<stop id="stop38" offset="1" style="stop-color:#9F3300"/>
|
||||
</linearGradient>
|
||||
<path d="M57.395,96.788c0,13.41,20.805,13.41,20.805,0 C78.2,83.376,57.395,83.375,57.395,96.788 M59.647,96.788c0-10.514,16.301-10.514,16.301,0 C75.948,107.3,59.647,107.3,59.647,96.788" id="path40" style="fill-rule:evenodd;clip-rule:evenodd;fill:url(#XMLID_6_);"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 8.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 358 B |
@ -1,26 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill-rule:nonzero;clip-rule:nonzero;fill:#FFFFFF;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st1 "fill:none;stroke:none;">
|
||||
<!ENTITY st2 "fill:#000000;">
|
||||
<!ENTITY st3 "fill:none;stroke:#FFFFFF;stroke-width:6.3469;stroke-linejoin:round;">
|
||||
<!ENTITY st4 "fill-rule:evenodd;clip-rule:evenodd;stroke:none;">
|
||||
<!ENTITY st5 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_3" style="&st0;">
|
||||
<g style="&st4;">
|
||||
<path style="&st3;" d="M22.9,7.1L5.1,21.8l0,0c-0.3,0.3-0.5,0.8-0.5,1.2c0,0.2,0,0.4,0.1,0.6c0.3,0.6,0.9,1,1.6,1c0,0,1.1,0,2.2,0c0,2.4,0,14.2,0,14.2c0,1.1,0.8,1.9,1.8,1.9h27.4c1.1,0,1.9-0.9,1.9-2c0,0,0-11.8,0-14.2c1,0,2,0,2,0c0.8,0,1.4-0.5,1.7-1.2
|
||||
c0.1-0.2,0.1-0.4,0.1-0.6c0-0.5-0.2-1-0.7-1.4c0,0-3.6-3-4.5-3.7c0-1.2,0-6.9,0-6.9c0-1.2-0.8-2-2-2h-4.8c-1,0-1.7,0.6-1.9,1.5c-1.9-1.6-4.1-3.5-4.1-3.5l0.1,0.1c-0.7-0.7-1.8-0.8-2.7-0.1z"/>
|
||||
<path style="&st2;" d="M22.9,7.1L5.1,21.8l0,0c-0.3,0.3-0.5,0.8-0.5,1.2c0,0.2,0,0.4,0.1,0.6c0.3,0.6,0.9,1,1.6,1c0,0,1.1,0,2.2,0c0,2.4,0,14.2,0,14.2c0,1.1,0.8,1.9,1.8,1.9h27.4c1.1,0,1.9-0.9,1.9-2c0,0,0-11.8,0-14.2c1,0,2,0,2,0c0.8,0,1.4-0.5,1.7-1.2
|
||||
c0.1-0.2,0.1-0.4,0.1-0.6c0-0.5-0.2-1-0.7-1.4c0,0-3.6-3-4.5-3.7c0-1.2,0-6.9,0-6.9c0-1.2-0.8-2-2-2h-4.8c-1,0-1.7,0.6-1.9,1.5c-1.9-1.6-4.1-3.5-4.1-3.5l0.1,0.1c-0.7-0.7-1.8-0.8-2.7-0.1z"/>
|
||||
<path style="&st2;" d="M41.8,22.8l-5.1-4.2v-0.1L31,13.7v0l-6.5-5.5C24.2,8,24,8,23.8,8.2L6.2,22.9c-0.1,0.1-0.1,0.3,0.1,0.3h1.6H10h28.1h1.2h2.3c0.2,0,0.4-0.2,0.2-0.4z"/>
|
||||
<path d="M35.8,16.8l0-5.1c0-0.2-0.1-0.4-0.3-0.4h-3.2c-0.2,0-0.3,0.1-0.3,0.3v2.2l3.9,2.9z"/>
|
||||
<path d="M11.9,24.7V37c0,0.3,0.1,0.4,0.3,0.4h23.6c0.3,0,0.4-0.2,0.4-0.4V24.7H11.9z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st5;">
|
||||
<path style="&st1;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 2.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 722 B |
@ -1,25 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:#FFFFFF;stroke:none;">
|
||||
<!ENTITY st1 "fill:#FFFFFF;stroke-width:6.6112;stroke-linecap:round;stroke-linejoin:round;">
|
||||
<!ENTITY st2 "stroke:#FFFFFF;stroke-width:6.6112;">
|
||||
<!ENTITY st3 "fill:none;stroke:none;">
|
||||
<!ENTITY st4 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st5 "stroke:none;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_3" style="&st4;">
|
||||
<g>
|
||||
<path style="&st2;" d="M41.7,35.3L26.6,9.4c-0.6-1-1.7-1.7-2.9-1.6c-1.2,0-2.3,0.7-2.9,1.7L6.3,35.4c-0.6,1-0.6,2.3,0,3.3c0.6,1,1.7,1.6,2.9,1.6h29.6c1.2,0,2.3-0.6,2.9-1.7c0.6-1,0.6-2.3,0-3.3z"/>
|
||||
<path style="&st1;" d="M23.7,11L9.2,37h29.6L23.7,11z"/>
|
||||
<path style="&st0;" d="M23.7,11.9L10.3,36.1h27.5l-14-24.1z"/>
|
||||
<g>
|
||||
<path style="&st5;" d="M24.1,34c-1.1,0-1.8-0.8-1.8-1.8c0-1.1,0.7-1.8,1.8-1.8c1.1,0,1.8,0.7,1.8,1.8c0,1-0.7,1.8-1.8,1.8h0z M22.9,29.3l-0.4-9.1h3.2l-0.4,9.1h-2.3z"/>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st4;">
|
||||
<path style="&st3;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 336 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:none;stroke:none;">
|
||||
<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
|
||||
<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st3 "stroke:none;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_3" style="&st2;">
|
||||
<g>
|
||||
<path style="&st1;" d="M22.4,41.1c0,0.3,0.3,0.3,0.5,0.2l16.6-16.9c0.5-0.5,0.4-0.7,0-1L22.9,6.7c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.9c-0.3,0-0.5,0.2-0.5,0.4l0,13.3C8.4,30.9,8.6,31,9,31h13.5l-0.1,10.1z"/>
|
||||
<path style="&st3;" d="M22.4,41.1c0,0.3,0.3,0.3,0.5,0.2l16.6-16.9c0.5-0.5,0.4-0.7,0-1L22.9,6.7c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.9c-0.3,0-0.5,0.2-0.5,0.4l0,13.3C8.4,30.9,8.6,31,9,31h13.5l-0.1,10.1z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st2;">
|
||||
<path style="&st0;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 490 B |
@ -1,33 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:none;stroke:#FFFFFF;stroke-width:12.1438;stroke-linejoin:round;">
|
||||
<!ENTITY st1 "fill:none;stroke-width:1.2429;">
|
||||
<!ENTITY st2 "fill:#FFFFFF;stroke:none;">
|
||||
<!ENTITY st3 "fill:none;stroke:#FFFFFF;stroke-width:12.7649;stroke-linejoin:round;">
|
||||
<!ENTITY st4 "fill:#FFFFFF;stroke-width:6.3824;stroke-linejoin:round;">
|
||||
<!ENTITY st5 "fill:none;stroke:none;">
|
||||
<!ENTITY st6 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st7 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:12.7649;stroke-linejoin:round;">
|
||||
<!ENTITY st8 "stroke:none;">
|
||||
<!ENTITY st9 "fill:none;stroke-width:4.9715;stroke-linejoin:round;">
|
||||
]>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve">
|
||||
<g id="Layer_x0020_1" style="&st6;">
|
||||
<path style="&st0;" d="M35.7,19.8v18.9H11V8.8h13.9l10.8,11z"/>
|
||||
<path style="&st3;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
|
||||
<path style="&st7;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
|
||||
<path style="&st4;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
|
||||
<path style="&st2;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
|
||||
</g>
|
||||
<g id="Layer_x0020_4" style="&st6;">
|
||||
<path style="&st9;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
|
||||
<path style="&st8;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
|
||||
<path style="&st8;" d="M20.6,14.7l-2.5,2.5L17,13.4l3.6,1.3z"/>
|
||||
<path style="&st1;" d="M19.6,22.2l3-0.3l2.4-2.4l0.4-2.8"/>
|
||||
<path style="&st2;" d="M20.4,14.9L18.3,17l1.6,5.2l2.7-0.3l2.4-2.4l0.3-2.4l-5-2.2z"/>
|
||||
</g>
|
||||
<g id="crop" style="&st6;">
|
||||
<path style="&st5;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.7 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 334 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:none;stroke:none;">
|
||||
<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
|
||||
<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st3 "stroke:none;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_3" style="&st2;">
|
||||
<g>
|
||||
<path style="&st1;" d="M25.6,6.9c0-0.3-0.3-0.3-0.5-0.2L8.4,23.6c-0.5,0.5-0.4,0.7,0,1l16.6,16.6c0.1,0.1,0.4,0.1,0.4-0.1v-10h13.6c0.3,0,0.5-0.2,0.5-0.4l0-13.3c0-0.3-0.2-0.5-0.5-0.5H25.5l0.1-10.1z"/>
|
||||
<path style="&st3;" d="M25.6,6.9c0-0.3-0.3-0.3-0.5-0.2L8.4,23.6c-0.5,0.5-0.4,0.7,0,1l16.6,16.6c0.1,0.1,0.4,0.1,0.4-0.1v-10h13.6c0.3,0,0.5-0.2,0.5-0.4l0-13.3c0-0.3-0.2-0.5-0.5-0.5H25.5l0.1-10.1z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st2;">
|
||||
<path style="&st0;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 867 B |
Binary file not shown.
|
Before Width: | Height: | Size: 449 B |
@ -1,84 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) --><svg height="1052.3622047" id="svg2" inkscape:version="0.42.2" sodipodi:docbase="/home/sergio/tmp/downloads" sodipodi:docname="lamp.svg" sodipodi:version="0.32" width="744.09448819" xmlns="http://www.w3.org/2000/svg" xmlns:cc="http://web.resource.org/cc/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<metadata>
|
||||
<rdf:RDF xmlns:cc="http://web.resource.org/cc/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
|
||||
<cc:Work rdf:about="">
|
||||
<dc:title>lamp</dc:title>
|
||||
<dc:description></dc:description>
|
||||
<dc:subject>
|
||||
<rdf:Bag>
|
||||
<rdf:li>office</rdf:li>
|
||||
<rdf:li></rdf:li>
|
||||
<rdf:li>lamp</rdf:li>
|
||||
</rdf:Bag>
|
||||
</dc:subject>
|
||||
<dc:publisher>
|
||||
<cc:Agent rdf:about="http://www.openclipart.org/">
|
||||
<dc:title>Open Clip Art Library</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:publisher>
|
||||
<dc:creator>
|
||||
<cc:Agent>
|
||||
<dc:title>Sergio Luiz Araujo Silva</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:creator>
|
||||
<dc:rights>
|
||||
<cc:Agent>
|
||||
<dc:title>Public Domain</dc:title>
|
||||
</cc:Agent>
|
||||
</dc:rights>
|
||||
<dc:date>set 2005</dc:date>
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
|
||||
<cc:license rdf:resource="http://web.resource.org/cc/PublicDomain"/>
|
||||
<dc:language>en</dc:language>
|
||||
</cc:Work>
|
||||
<cc:License rdf:about="http://web.resource.org/cc/PublicDomain">
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/Reproduction"/>
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/Distribution"/>
|
||||
<cc:permits rdf:resource="http://web.resource.org/cc/DerivativeWorks"/>
|
||||
</cc:License>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<defs id="defs4">
|
||||
<linearGradient id="linearGradient13125">
|
||||
<stop id="stop13127" offset="0.0000000" style="stop-color:#ffffff;stop-opacity:1.0000000;"/>
|
||||
<stop id="stop13129" offset="1" style="stop-color:#fffeff;stop-opacity:0;"/>
|
||||
</linearGradient>
|
||||
<linearGradient id="linearGradient12389">
|
||||
<stop id="stop12391" offset="0.0000000" style="stop-color:#fefefe;stop-opacity:1.0000000;"/>
|
||||
<stop id="stop12393" offset="1.0000000" style="stop-color:#fffefe;stop-opacity:1.0000000;"/>
|
||||
</linearGradient>
|
||||
<radialGradient cx="358.25909" cy="186.06468" fx="358.25909" fy="186.06468" gradientTransform="matrix(1.000001,-8.244061e-7,3.143917e-7,0.381356,-4.028738e-4,115.1081)" gradientUnits="userSpaceOnUse" id="radialGradient13131" inkscape:collect="always" r="27.486719" xlink:href="#linearGradient13125"/>
|
||||
<radialGradient cx="358.25909" cy="186.06468" fx="358.25909" fy="186.06468" gradientTransform="matrix(1.000001,-8.244061e-7,3.143917e-7,0.381356,-4.028738e-4,115.1081)" gradientUnits="userSpaceOnUse" id="radialGradient14587" inkscape:collect="always" r="27.486719" xlink:href="#linearGradient13125"/>
|
||||
<radialGradient cx="358.25909" cy="186.06468" fx="358.25909" fy="186.06468" gradientTransform="matrix(1.000001,-8.244061e-7,3.143917e-7,0.381356,-4.028738e-4,115.1081)" gradientUnits="userSpaceOnUse" id="radialGradient15390" inkscape:collect="always" r="27.486719" xlink:href="#linearGradient13125"/>
|
||||
<radialGradient cx="358.25909" cy="186.06468" fx="358.25909" fy="186.06468" gradientTransform="matrix(1.000001,-8.244061e-7,3.143917e-7,0.381356,-4.028738e-4,115.1081)" gradientUnits="userSpaceOnUse" id="radialGradient16141" inkscape:collect="always" r="27.486719" xlink:href="#linearGradient13125"/>
|
||||
</defs>
|
||||
<sodipodi:namedview bordercolor="#666666" borderopacity="1.0" id="base" inkscape:current-layer="layer1" inkscape:cx="344.34505" inkscape:cy="795.78292" inkscape:document-units="px" inkscape:guide-bbox="true" inkscape:pageopacity="0.0" inkscape:pageshadow="2" inkscape:window-height="693" inkscape:window-width="1024" inkscape:window-x="0" inkscape:window-y="25" inkscape:zoom="0.72123084" pagecolor="#ffffff" showguides="true"/>
|
||||
<g id="layer1" inkscape:groupmode="layer" inkscape:label="Layer 1">
|
||||
<path d="M 369.44028,121.86683 C 302.64703,119.68096 242.59223,184.30679 250.47188,250.87980 C 252.47522,280.21980 267.84094,306.49880 285.94332,328.82253 C 303.71281,358.65039 312.13900,393.24133 313.51068,427.73030 C 317.00419,446.97288 338.01608,454.57063 355.35334,455.26572 C 375.18456,456.91501 395.94281,455.09265 414.43470,447.69729 C 430.92724,435.70557 427.37713,413.20597 430.74488,395.55648 C 434.70351,361.57615 449.78002,329.76555 471.07843,303.26619 C 504.41026,252.31528 488.56419,176.76397 437.75400,143.26422 C 417.82956,129.49394 393.70573,121.69096 369.44028,121.86683 z " id="path1384" style="opacity:1.0000000;fill:#f3f2f3;fill-opacity:0.83333331;stroke:#000000;stroke-width:0.58960420;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.0000000;stroke-opacity:1.0000000"/>
|
||||
<path d="M 425.72698,154.07768 C 437.68158,164.87540 453.68534,182.03604 451.17873,203.82428 C 455.99913,200.54641 460.81954,197.26853 465.63995,193.99066 C 459.85546,170.27425 448.28648,162.75442 425.72698,154.07768 z " id="path2153" sodipodi:nodetypes="cccc" style="fill:#fefefe;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 506.99897 296.94009 A 37.120701 18.718985 0 1 1 432.75756,296.94009 A 37.120701 18.718985 0 1 1 506.99897 296.94009 z" id="path2881" sodipodi:cx="469.87827" sodipodi:cy="296.94009" sodipodi:rx="37.120701" sodipodi:ry="18.718985" sodipodi:type="arc" style="opacity:1.0000000;color:#000000;fill:#fefefe;fill-opacity:1.0000000;fill-rule:nonzero;stroke:none;stroke-width:0.64700001;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.0000000;stroke-opacity:1.0000000;visibility:visible;display:inline;overflow:visible" transform="matrix(0.818103,0.000000,0.000000,0.896150,-13.89510,-26.68653)"/>
|
||||
<path d="M 359.20536,314.30802 L 336.64585,244.31570 C 362.29042,230.62575 382.72895,234.28926 403.16748,243.15881 L 379.45107,315.46491 L 379.45107,315.46491" id="path3617" sodipodi:nodetypes="ccccc" style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#8f9595;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 513.73605 514.32300 A 52.508934 11.885468 0 1 1 408.71818,514.32300 A 52.508934 11.885468 0 1 1 513.73605 514.32300 z" id="path4361" sodipodi:cx="461.22711" sodipodi:cy="514.32300" sodipodi:rx="52.508934" sodipodi:ry="11.885468" sodipodi:type="arc" style="opacity:1.0000000;color:#000000;fill:#a0a0a0;fill-opacity:1.0000000;fill-rule:nonzero;stroke:none;stroke-width:0.64700001;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.0000000;stroke-opacity:1.0000000;visibility:visible;display:inline;overflow:visible" transform="matrix(0.982435,0.000000,0.000000,1.387810,-83.52495,-281.2705)"/>
|
||||
<path d="M 315.87677,433.07959 C 319.14672,442.90428 329.03398,448.82383 338.76816,450.68840 C 362.00206,456.37952 386.74882,455.38004 409.63484,448.57985 C 414.28840,447.19363 419.18392,445.42184 422.06530,441.25295 C 423.42527,439.84003 425.68582,434.46169 424.07088,434.30126 C 411.81432,444.17256 395.75685,447.78808 380.34111,448.56322 C 362.85475,449.05661 344.64886,448.26521 328.51659,440.79114 C 324.02706,438.71576 319.76022,436.14612 315.87677,433.07959 z " id="path4363" style="fill:#d6dee6;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 400.47436,522.16227 C 396.48542,528.09177 392.49650,534.02126 388.50756,539.95076 C 383.93367,541.47295 366.98819,546.44954 353.57745,538.01018 C 350.34318,532.29631 347.10892,526.58244 343.87465,520.86856 C 364.35835,531.64946 396.48542,523.99502 400.47436,522.16227 z " id="path5094" sodipodi:nodetypes="ccccc" style="fill:#090a0c;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#000000;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 419.65600,444.27781 C 419.97026,446.39906 420.28452,448.52031 420.59878,450.64156 C 421.46299,450.95582 422.32720,451.27008 423.19142,451.58434 C 423.19142,452.91994 423.19142,454.25554 423.19142,455.59114 C 422.32720,455.98397 421.46299,456.37678 420.59878,456.76961 C 420.36308,459.20512 420.12739,461.64063 419.89170,464.07614 C 420.52021,464.23327 421.14873,464.39039 421.77725,464.54753 C 421.69869,466.59021 421.62012,468.63289 421.54156,470.67558 C 420.83447,471.46123 420.12739,472.24688 419.42030,473.03253 C 419.57744,474.05387 419.73456,475.07522 419.89170,476.09656 C 420.91303,477.11790 421.93438,478.13925 422.95572,479.16058 C 422.87716,480.18193 422.79859,481.20328 422.72003,482.22461 C 422.01294,483.01026 421.30586,483.79591 420.59878,484.58156 C 420.36308,485.05294 420.12739,485.52433 419.89170,485.99572 C 419.57744,486.70280 419.26317,487.40989 418.94892,488.11697 C 419.10605,489.05975 419.26317,490.00253 419.42030,490.94531 C 419.89170,491.65239 420.36308,492.35947 420.83447,493.06655 C 420.67734,494.71641 420.52021,496.36627 420.36308,498.01614 C 415.02067,505.24410 409.67827,512.47206 404.33587,519.70003 C 403.15740,520.24998 401.97892,520.79994 400.80045,521.34989 C 397.81498,522.29266 394.82952,523.23544 391.84406,524.17822 C 386.34452,524.80674 380.84498,525.43525 375.34545,526.06378 C 371.96717,525.90664 368.58887,525.74952 365.21059,525.59238 C 362.46082,525.51382 359.71105,525.43525 356.96128,525.35669 C 353.42587,524.49247 349.89045,523.62827 346.35503,522.76405 C 345.17656,521.82128 343.99809,520.87850 342.81962,519.93572 C 339.75559,517.81447 336.69157,515.69322 333.62754,513.57197 C 328.75652,508.30813 323.88551,503.04429 319.01448,497.78044 C 319.01448,496.52341 319.01448,495.26636 319.01448,494.00933 C 319.87870,494.00933 320.74291,494.00933 321.60712,494.00933 C 321.13574,492.83086 320.66435,491.65239 320.19296,490.47392 C 319.09305,488.19554 317.99314,485.91716 316.89323,483.63878 C 316.89323,482.93170 316.89323,482.22461 316.89323,481.51753 C 318.38597,480.26049 319.87869,479.00345 321.37143,477.74642 C 320.03583,475.54660 318.70022,473.34679 317.36462,471.14697 C 317.28606,470.83271 317.20748,470.51845 317.12892,470.20419 C 318.46453,468.39720 319.80013,466.59021 321.13574,464.78322 C 320.74291,463.68331 320.35009,462.58341 319.95726,461.48350 C 319.09305,460.38359 318.22883,459.28369 317.36462,458.18378 C 317.12892,457.31956 316.89323,456.45536 316.65753,455.59114 C 317.75744,454.17697 318.85735,452.76281 319.95726,451.34864 C 319.87870,450.01304 319.80013,448.67744 319.72157,447.34184 C 319.32874,446.71332 318.93592,446.08480 318.54310,445.45628 C 318.62166,444.74920 318.70023,444.04212 318.77879,443.33503 C 319.48588,443.25647 320.19296,443.17790 320.90004,443.09934 C 324.04263,445.22059 327.18523,447.34184 330.32782,449.46309 C 348.08347,456.92674 391.76550,461.09068 419.65600,444.27781 z " id="path7284" sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccc" style="fill:#fba246;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#000000;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 389.86281,523.00744 C 389.46998,521.82897 391.23336,522.26765 390.84054,521.08918 C 383.37688,521.01061 375.91323,520.93205 368.44957,520.85348 C 368.44957,520.53923 368.44957,520.22496 368.44957,519.91070 C 374.10624,519.75357 379.76290,519.59645 385.41957,519.43932 C 388.24790,518.88937 391.07623,518.33941 393.90457,517.78946 C 395.39730,517.55377 396.89003,517.31807 398.38277,517.08237 C 401.44679,515.03969 404.51082,512.99701 407.57485,510.95432 C 407.49629,510.64006 407.41771,510.32580 407.33915,510.01153 C 401.36822,510.48292 395.39730,510.95432 389.42637,511.42571 C 387.30512,511.81853 385.18387,512.21135 383.06263,512.60418 C 379.13438,512.36849 375.20615,512.13279 371.27790,511.89710 C 369.78518,511.73997 368.29244,511.58284 366.79971,511.42571 C 364.44277,510.32580 362.08582,509.22589 359.72888,508.12598 C 376.54175,507.18320 396.89003,507.18320 415.11707,493.98432 C 391.31192,502.15506 371.27790,500.19093 355.01499,497.99112 C 375.91322,494.06288 396.57577,493.19867 417.00262,478.42849 C 387.38368,489.42756 366.24975,485.57788 349.35832,483.84946 C 371.51360,479.29269 403.56804,478.27136 414.40998,466.64376 C 383.06263,474.89306 355.95776,473.47890 338.75207,469.47210 C 352.81517,467.58654 366.87827,465.70098 380.94137,463.81543 C 374.10624,463.18691 367.27110,462.55840 360.43596,461.92988 C 373.32059,459.73006 386.20522,457.53024 399.08985,455.33043 C 381.88416,456.19465 346.53000,460.82997 319.89653,444.48849 C 323.66763,447.63108 328.61721,449.83090 331.20985,453.91627 C 327.28161,453.44487 323.35338,452.97349 319.42513,452.50210 C 319.66083,453.83770 319.89653,455.17330 320.13222,456.50890 C 324.13902,459.02298 328.14582,461.53704 332.15263,464.05112 C 327.43875,466.25093 322.72485,468.45075 318.01096,470.65057 C 323.90332,472.53612 329.79568,474.42169 335.68805,476.30724 C 330.03138,478.66418 322.48915,476.30724 318.71804,483.37807 C 325.55318,486.59923 335.21666,487.22774 339.22346,493.04154 C 333.33110,493.51293 326.73166,489.27043 321.54639,494.45571 C 327.67444,498.06968 333.80249,501.68367 339.93055,505.29765 C 336.55226,504.82626 333.17397,504.35487 329.79568,503.88348 C 334.58814,509.30445 341.26727,513.37780 346.05972,518.79877 C 362.00838,520.29150 373.91416,521.51471 389.86281,523.00744 z " id="path6556" sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccc" style="fill:#ffc080;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 410.63580,448.38806 C 375.91016,459.46570 347.07688,453.33765 330.49970,448.38806 C 332.54238,449.09515 334.58507,449.80223 336.62775,450.50931 C 365.30391,460.56561 396.80839,453.41621 407.80747,450.27362 C 408.75025,449.64510 409.69303,449.01658 410.63580,448.38806 z " id="path7286" sodipodi:nodetypes="ccccc" style="fill:#ffffff;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 431.22109,368.33927 C 427.74256,388.71364 424.26401,409.08801 420.78546,429.46237 C 416.60557,437.06563 407.94091,440.30372 400.07083,442.61238 C 391.48668,445.18530 382.40444,445.05799 373.54205,444.61656 C 371.08048,446.38986 364.99205,442.92177 370.06503,441.81235 C 377.17154,440.98795 384.60188,442.10538 391.38552,439.26558 C 401.04319,435.47671 410.26670,429.97354 417.05844,422.00834 C 421.19961,403.95301 425.34070,385.89766 429.48184,367.84233 C 430.06159,368.00798 430.64135,368.17360 431.22109,368.33927 z " id="path3629" style="fill:#ffffff;fill-opacity:0.64285713;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 353.42087,428.84088 L 351.10708,419.00725 L 351.68553,378.22661 L 353.13164,373.45440 L 353.05576,339.28565 L 349.95018,336.28751 L 349.37173,316.04336 C 363.86558,304.49563 376.56238,306.21837 388.70625,316.23514 L 388.12780,336.28907 L 385.23556,339.18131 L 384.65711,373.58108 L 386.39245,378.21491 L 385.81401,427.68398 L 382.34331,429.99778 L 374.24503,428.84088 L 371.35278,425.37019 L 366.14675,425.37019 L 360.94071,429.41933 L 353.42087,428.84088 z " id="path3619" sodipodi:nodetypes="ccccccccccccccccccc" style="fill:#c1c1c1;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#9b989f;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 358.25832,325.31572 L 358.25832,416.41507" id="path5096" style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#ffffff;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 380.15345,325.31572 L 380.15345,416.41507" id="path5824" style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#ffffff;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 361.91098,325.31572 L 361.91098,416.41507" id="path5826" style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#8f8f92;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 376.52161,325.31572 L 376.52161,416.41507" id="path6554" style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#8f8f92;stroke-width:0.91160071px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<g id="g9475" transform="matrix(0.911601,0.000000,0.000000,0.911601,328.5961,-156.2531)">
|
||||
<path d="M 86.864034,673.56687 L 79.199560,676.97330 L 77.155700,678.67652 L 75.793127,679.69845 L 65.573829,679.35780 L 65.403508,678.33587 L 70.683478,676.97330 C 70.683478,676.97330 74.430554,676.63266 75.111841,676.46234 C 75.793127,676.29201 78.688595,674.92944 78.688595,674.92944 L 84.649852,671.52301 L 87.034355,671.52301 L 86.864034,673.56687 z " id="path8741" style="fill:#ffffff;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 91.973683,686.34099 L 88.056285,686.17067 L 85.331139,687.53324 L 81.073098,689.23646 L 77.836987,691.45064 L 75.111841,692.30225 L 70.853800,692.64289 L 69.320905,693.15386 L 71.024122,693.83514 L 75.963449,693.83514 L 80.221490,694.51643 L 83.627923,693.83514 L 87.545320,690.42871 C 87.545320,690.42871 90.270466,689.23646 90.951753,688.89581 C 91.633039,688.55517 93.165934,687.87388 93.165934,687.87388 L 91.973683,686.34099 z " id="path8743" style="fill:#ffffff;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 94.017542,700.30736 L 89.078215,703.03251 L 85.842104,705.07637 L 83.457601,706.94991 L 77.836987,708.14216 L 75.622806,708.14216 L 81.584063,710.01570 L 86.353069,707.97184 L 91.292396,705.58733 L 92.825291,704.05444 L 94.017542,700.30736 z " id="path8745" style="fill:#ffffff;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 91.462718,717.85049 C 91.462718,717.85049 81.924706,721.59757 81.584063,722.27885 C 81.243420,722.96014 78.688595,723.98207 78.688595,723.98207 L 72.897660,724.66336 L 71.024122,725.68529 L 76.644736,726.36657 L 82.435671,724.49304 L 86.693712,724.32271 L 89.929823,722.10853 L 91.462718,720.40532 L 91.462718,717.85049 z " id="path8747" style="fill:#ffffff;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
</g>
|
||||
<path d="M 378.14273,525.28637 C 377.57434,530.51553 378.00099,537.83204 377.43261,543.06120 C 372.27918,543.00443 367.82875,543.82657 360.97078,541.72320 C 359.43614,536.89190 356.80919,529.30796 355.27454,524.47667 C 356.26507,524.72572 356.68741,524.86790 357.82038,524.93742 C 358.95335,525.00694 360.79692,524.96593 361.90337,525.03791 C 363.00981,525.10990 364.25012,525.06768 365.31257,525.13480 C 366.37503,525.20191 367.41113,525.22689 368.41214,525.28180 C 369.41314,525.33669 370.37905,525.38365 371.30113,525.41898 C 372.22321,525.45432 374.35115,525.55378 375.17683,525.56221 C 376.00251,525.57065 375.56381,525.48806 376.27564,525.46225 C 376.98745,525.43643 377.56225,525.35378 378.14273,525.28637 z " id="path10207" sodipodi:nodetypes="ccccsssssssc" style="fill:#ffffff;fill-opacity:0.31547615;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000"/>
|
||||
<path d="M 467.06377,199.37552 L 453.69293,208.53364 L 451.86130,221.53816 L 468.71223,214.21167 L 467.06377,199.37552 z " id="path16869" style="fill:#fefefe;fill-opacity:1.0000000;fill-rule:evenodd;stroke:none;stroke-width:1.0000000px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1.0000000;opacity:1.0000000;color:#000000;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0;visibility:visible;display:inline;overflow:visible"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 318 B |
Binary file not shown.
|
Before Width: | Height: | Size: 259 B |
Binary file not shown.
|
Before Width: | Height: | Size: 264 B |
Binary file not shown.
|
Before Width: | Height: | Size: 370 B |
@ -1,19 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:none;stroke:none;">
|
||||
<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
|
||||
<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st3 "stroke:none;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_3" style="&st2;">
|
||||
<g>
|
||||
<path style="&st1;" d="M41.1,25.6c0.3,0,0.3-0.3,0.2-0.5L24.4,8.4c-0.5-0.5-0.7-0.4-1,0L6.7,25.1c-0.1,0.1-0.1,0.4,0.1,0.4h10v13.6c0,0.3,0.2,0.5,0.4,0.5l13.3,0c0.3,0,0.5-0.2,0.5-0.5V25.5l10.1,0.1z"/>
|
||||
<path style="&st3;" d="M41.1,25.6c0.3,0,0.3-0.3,0.2-0.5L24.4,8.4c-0.5-0.5-0.7-0.4-1,0L6.7,25.1c-0.1,0.1-0.1,0.4,0.1,0.4h10v13.6c0,0.3,0.2,0.5,0.4,0.5l13.3,0c0.3,0,0.5-0.2,0.5-0.5V25.5l10.1,0.1z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st2;">
|
||||
<path style="&st0;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.2 KiB |
@ -1,23 +0,0 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In -->
|
||||
<!DOCTYPE svg [
|
||||
<!ENTITY st0 "fill:#000000;stroke:#FFFFFF;stroke-width:7.9139;stroke-linejoin:round;">
|
||||
<!ENTITY st1 "fill-rule:nonzero;clip-rule:nonzero;fill:#FFFFFF;stroke:#000000;stroke-miterlimit:4;">
|
||||
<!ENTITY st2 "fill:none;stroke:none;">
|
||||
<!ENTITY st3 "fill:#000000;">
|
||||
<!ENTITY st4 "fill-rule:evenodd;clip-rule:evenodd;stroke:none;">
|
||||
<!ENTITY st5 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
|
||||
]>
|
||||
<svg width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
|
||||
<g id="Layer_x0020_4" style="&st1;">
|
||||
<g style="&st4;">
|
||||
<path style="&st0;" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2L31.6,42.3H16.4z"/>
|
||||
<path style="&st3;" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2L31.6,42.3H16.4z"/>
|
||||
<path d="M11.7,17.7l18.7,18.7l5.9-5.9L17.6,11.7l-5.9,5.9z"/>
|
||||
<path d="M11.7,30.5l5.9,5.9l18.7-18.7l-5.9-5.9L11.7,30.5z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="crop_x0020_marks" style="&st5;">
|
||||
<path style="&st2;" d="M48,48H0V0h48v48z"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 1.1 KiB |
@ -1,22 +0,0 @@
|
||||
/*
|
||||
|
||||
© Copyright Beman Dawes, 2007
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
See www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
*/
|
||||
|
||||
/*******************************************************************************
|
||||
Body
|
||||
*******************************************************************************/
|
||||
|
||||
body { font-family: sans-serif; margin: 1em; }
|
||||
|
||||
/*******************************************************************************
|
||||
Table
|
||||
*******************************************************************************/
|
||||
|
||||
table { margin: 0.5em; }
|
||||
|
||||
/*** end ***/
|
||||
@ -1,11 +0,0 @@
|
||||
/*============================================================================
|
||||
Copyright 2003-2004 Douglas Gregor
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompany-
|
||||
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
============================================================================*/
|
||||
|
||||
PRE.synopsis {
|
||||
background-color: #e0ffff;
|
||||
border: thin solid blue;
|
||||
padding: 1em
|
||||
}
|
||||
848
doc/tutorial.qbk
848
doc/tutorial.qbk
@ -1,848 +0,0 @@
|
||||
|
||||
[/ Copyright (C) 2008-2017 Lorenzo Caminiti]
|
||||
[/ Distributed under the Boost Software License, Version 1.0 (see accompanying]
|
||||
[/ file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).]
|
||||
[/ See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html]
|
||||
|
||||
[section Tutorial]
|
||||
|
||||
This section is a guide to basic usages of this library.
|
||||
|
||||
[section Non-Member Functions]
|
||||
|
||||
Contracts for non-member functions are programmed using [funcref boost::contract::function].
|
||||
For example (see [@../../example/features/non_member.cpp =non_member.cpp=]):
|
||||
|
||||
[import ../example/features/non_member.cpp]
|
||||
[non_member]
|
||||
|
||||
All necessary header files of this library are included by `#include <boost/contract.hpp>`.
|
||||
Alternatively, programmers can selectively include only the header files they actually need among =boost/contract/*.hpp= (see __Getting_Started__).
|
||||
|
||||
It is possible to specify preconditions, postconditions, and exception guarantees for non-member functions (see __Preconditions__, __Postconditions__, and __Exception_Guarantees__).
|
||||
|
||||
The [funcref boost::contract::function] function returns an RAII object that must always be assigned to a local variable of type [classref boost::contract::check] (otherwise this library will generate a run-time error, see [macroref BOOST_CONTRACT_ON_MISSING_CHECK_DECL]).
|
||||
[footnote
|
||||
The name of this local variable is arbitrary, but `c` is often used in this documentation.
|
||||
]
|
||||
Furthermore, C++11 `auto` declarations cannot be used here and the [classref boost::contract::check] type must be explicitly specified (otherwise this library will generate a compile-time error).
|
||||
The function body is programmed right after the declaration of the RAII object.
|
||||
|
||||
[note
|
||||
In some cases, it might be necessary to program some code before the contract.
|
||||
For example for acquiring resources that will be used while checking the contract like old values, but also to lock mutexes (or other synchronization mechanisms) in multi-threaded programs.
|
||||
]
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for non-member functions does the following (enclosing function entry):
|
||||
|
||||
# Check preconditions, by calling the nullary functor [^['r]]`()` passed to `.precondition(`[^['r]]`)`.
|
||||
|
||||
At destruction instead (enclosing function exit):
|
||||
|
||||
# If the function body did not throw an exception:
|
||||
# Check postconditions, by calling the nullary functor [^['s]]`()` passed to `.postcondition(`[^['s]]`)`.
|
||||
# Else:
|
||||
# Check exception guarantees, by calling the nullary functor [^['e]]`()` passed to `.except(`[^['e]]`)`.
|
||||
|
||||
This ensures that non-member function contracts are correctly checked at run-time (see __Function_Calls__).
|
||||
(Also note that functions will correctly check their contracts even when they are called via function pointers, function objects, etc.)
|
||||
|
||||
[note
|
||||
A non-member function can avoid calling [funcref boost::contract::function] for efficiency but only when it has no preconditions, no postconditions, and no exception guarantees.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Preconditions]
|
||||
|
||||
When preconditions are specified, they are programmed using a functor [^['r]] passed to `.precondition(`[^['r]]`)` that can be called with no parameters as [^['r]]`()`.
|
||||
Contracts that do not have preconditions simply do not call `.precondition(...)`.
|
||||
Preconditions must appear before postconditions and exception guarantees when these are all present (see __Postconditions__ and __Exception_Guarantees__).
|
||||
|
||||
C++11 lambda functions are convenient to program preconditions, but any other nullary functor can be used (see __No_Lambda_Functions__).
|
||||
[footnote
|
||||
Lambda functions with no parameters can be programmed in C++11 as `[...] () { ... }` but also equivalently as `[...] { ... }`.
|
||||
This second from is often used in this documentation omitting the empty parameter list `()` for brevity.
|
||||
]
|
||||
For example, for [funcref boost::contract::function] (same for public functions, but destructors do not have preconditions and constructors use [classref boost::contract::constructor_precondition] instead, see __Destructors__ and __Constructors__):
|
||||
|
||||
boost::contract::check c = boost::contract::function() // Same for all other contracts.
|
||||
.precondition([&] { // Capture by reference or value...
|
||||
BOOST_CONTRACT_ASSERT(...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
...
|
||||
;
|
||||
|
||||
The precondition functor should capture all the variables that it needs to assert the preconditions.
|
||||
These variables can be captured by value when the overhead of copying such variables is acceptable.
|
||||
[footnote
|
||||
In this documentation preconditions often capture variables by reference to avoid extra copies.
|
||||
]
|
||||
In any case, precondition assertions should not modify the value of the captured variables, even when those are captured by reference (see __Constant_Correctness__).
|
||||
|
||||
Any code can be programmed in the precondition functor, but it is recommended to keep this code simple using mainly assertions and if-statements (to avoid programming complex preconditions that might be buggy and also slow to check at run-time).
|
||||
It is also recommended to use [macroref BOOST_CONTRACT_ASSERT] to program precondition assertions because this enables the library to print informative error messages when the asserted conditions are evaluated to be false (this is not a variadic macro, see __No_Macros__):
|
||||
|
||||
BOOST_CONTRACT_ASSERT(``/boolean-condition/``)
|
||||
// Or, if boolean-condition contains commas `,` not already within parenthesis `()`...
|
||||
BOOST_CONTRACT_ASSERT((``/boolean-condition/``)) // ...use extra parenthesis.
|
||||
|
||||
This library will automatically call the failure handler [funcref boost::contract::precondition_failure] if any of the [macroref BOOST_CONTRACT_ASSERT] conditions are `false` and, more in general, if calling the functor specified to `.precondition(...)` throws any exception.
|
||||
By default, this failure handler prints an error message to `std::cerr` and terminates the program calling `std::terminate` (see __Throw_on_Failure__ to change the failure handler to throw exceptions, exit the program with an error code, etc.).
|
||||
|
||||
[note
|
||||
Contracts are most useful when their assertions only use public members that are accessible to the caller so the caller can properly check and use the contract.
|
||||
In particular, preconditions of a public function or constructor that use non-public members are essentially incorrect because they cannot be fully checked by the caller (in fact, Eiffel generates a compile-time error in this case).
|
||||
However, this library does not enforce such a constraint and it leaves it up to programmers to only use public members when programming contracts, and especially when asserting preconditions (see __Specification_vs_Implementation__).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Postconditions]
|
||||
|
||||
When postconditions are specified, they are programmed using a functor [^['s]] passed to `.postcondition(`[^['s]]`)` that can be called with no parameters as [^['s]]`()`.
|
||||
Contracts that do not have postconditions simply do not call `.postcondition(...)`.
|
||||
Postconditions must appear after preconditions but before exception guarantees when these are all present (see __Preconditions__ and __Exception_Guarantees__).
|
||||
|
||||
C++11 lambda functions are convenient to program postconditions, but any other nullary functor can be used (see __No_Lambda_Functions__).
|
||||
For example, for [funcref boost::contract::function] (but same for all other contracts):
|
||||
|
||||
boost::contract::check c = boost::contract::function() // Same for all other contracts.
|
||||
...
|
||||
.postcondition([&] { // Capture by reference...
|
||||
BOOST_CONTRACT_ASSERT(...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
...
|
||||
;
|
||||
|
||||
The postcondition functor should capture all variables that it needs to assert the postconditions.
|
||||
In general, these variables should be captured by reference and not by value (because postconditions need to access the value that these variables will have at function exit, and not the value these variables had when the postcondition functor was first constructed).
|
||||
Postconditions can also capture return and old values (see __Return_Value__ and __Old_Values__).
|
||||
In any case, postcondition assertions should not modify the value of the captured variables (see __Constant_Correctness__).
|
||||
|
||||
Any code can be programmed in the postcondition functor, but it is recommended to keep this code simple using mainly assertions and if-statements (to avoid programming complex postconditions that might be buggy and slow to check at run-time).
|
||||
It is also recommended to use [macroref BOOST_CONTRACT_ASSERT] to program postcondition assertions because this enables the library to print informative error messages when the asserted conditions are evaluated to be false (this is not a variadic macro, see __No_Macros__):
|
||||
|
||||
BOOST_CONTRACT_ASSERT(``/boolean-condition/``)
|
||||
// Or, if boolean-condition has commas `,` not already within parenthesis `()`...
|
||||
BOOST_CONTRACT_ASSERT((``/boolean-condition/``)) // ...use extra parenthesis.
|
||||
|
||||
This library will automatically call the failure handler [funcref boost::contract::postcondition_failure] if any of the [macroref BOOST_CONTRACT_ASSERT] conditions are `false` and, more in general, if calling the functor specified via `.postcondition(...)` throws any exception.
|
||||
By default, this failure handler prints an error message to `std::cerr` and terminates the program calling `std::terminate` (see __Throw_on_Failure__ to change the failure handler to throw exceptions, exit the program with an error code, etc.).
|
||||
|
||||
For non-void virtual public functions and public function overrides, the functor [^['s]] passed to `.postcondition(`[^['s]]`)` is not a nullary functor, instead it is a unary functor taking a variable holding the return value as its one parameter [^['s]]`(`[^['result]]`)` (this is to properly support subcontracting, see __Virtual_Public_Functions__ and __Public_Function_Overrides__).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Return Value]
|
||||
|
||||
In non-void functions, postconditions can access the function return value to program assertions.
|
||||
In this case, programmers are responsible to declare a local variable before the contract and to assign it to the return value at function exit (when the function does not throw an exception).
|
||||
[footnote
|
||||
The name of the local variable that holds the return value is arbitrary, but `result` is often used in this documentation.
|
||||
]
|
||||
For example, for [funcref boost::contract::function] (but same for all other contracts):
|
||||
|
||||
``/return-type/`` result; // Must be assigned to return value.
|
||||
boost::contract::check c = boost::contract::function() // Same for all other contracts.
|
||||
...
|
||||
.postcondition([&] { // Also capture `result` reference...
|
||||
BOOST_CONTRACT_ASSERT(result ...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
...
|
||||
;
|
||||
|
||||
At any point where the enclosing function returns, programmers are responsible to assign the result variable to the expression being returned.
|
||||
This can be easily done by making sure that /all/ `return` statements in the function are of the form:
|
||||
|
||||
return result = ``/expression/``; // Assign `result` at each return.
|
||||
|
||||
The functor used to program postconditions should capture the result variable by reference and not by value (because postconditions must access the value the result variable will have at function exit, and not the value the result variable had when the postcondition functor was first constructed).
|
||||
The return value should never be used in preconditions, old value copies, or exception guarantees (because the return value is not yet correctly evaluated and set when preconditions are checked, old values are copied, or if the function throws an exception).
|
||||
In any case, programmers should not modify the result variable in the contract assertions (see __Constant_Correctness__).
|
||||
|
||||
It is also possible to declared the result variable using `boost::optional` when the function return type does not have a default constructor, or if the default constructor is too expensive or undesirable to execute when declaring the result variable (see __Optional_Return_Value__).
|
||||
|
||||
Non-void virtual public functions and public function overrides must always declare and use a result variable even when postconditions do not directly use the function return value (this is to properly support subcontracting, see __Virtual_Public_Functions__ and __Public_Function_Overrides__).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Old Values]
|
||||
|
||||
When old values are used in postconditions or in exception guarantees, programmes are responsible to declare local variables before the contract and to assign them to related old value expressions using [macroref BOOST_CONTRACT_OLDOF].
|
||||
[footnote
|
||||
The name of a local variable that holds an old value is arbitrary, but [^old_['variable-name]] is often used in this documentation.
|
||||
]
|
||||
For example, for [funcref boost::contract::function] (but same for all other contracts):
|
||||
|
||||
boost::contract::old_ptr<``/type/``> old_``/name/`` = BOOST_CONTRACT_OLDOF(``/expression/``);
|
||||
boost::contract::check c = boost::contract::function() // Same for all other contracts.
|
||||
...
|
||||
.postcondition([&] { // Capture by reference...
|
||||
BOOST_CONTRACT_ASSERT(*old_``/name/`` ...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
.except([&] { // Capture by reference...
|
||||
BOOST_CONTRACT_ASSERT(*old_``/name/`` ...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
;
|
||||
|
||||
Old values are handled by this library using the smart pointer class template [classref boost::contract::old_ptr] (so programmers do not directly manage allocation and deallocation of the pointed memory).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
Old values are optional values because they need to be left uninitialized in case postconditions and exception guarantees are disabled defining [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] and [macroref BOOST_CONTRACT_NO_EXCEPTS] to avoid old value copies in that case (so a pointer or better a `boost::optional` can be used for that).
|
||||
In addition, old values need to be pointers internally allocated by this library so that they are never copied twice even when calling an overridden function multiple times to check preconditions, postconditions, etc. to implement subcontracting (so a smart pointer class template was used).
|
||||
]
|
||||
The pointed old value is automatically qualified as `const` (so old values cannot be mistakenly changed by contract assertions, see __Constant_Correctness__).
|
||||
This library ensures that old value pointers are always not null by the time postconditions and exception guarantees are checked (so programmers can safely dereference these pointers in postcondition and exception guarantee assertions using `operator*` or `operator->` without having to check if old value pointers are not null first).
|
||||
|
||||
Old values should not be used in preconditions and this library does not guarantee that old value pointers are always not null when preconditions are checked.
|
||||
[footnote
|
||||
For example, old value pointers might be null in preconditions when postconditions and exception guarantees are disabled defining [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] and [macroref BOOST_CONTRACT_NO_EXCEPTS], when checking an overridden virtual public function contract via subcontracting, and possibly in other cases.
|
||||
]
|
||||
See __Old_Copies_at_Body__ for delaying the assignment of old values until after class invariants (for constructors, destructors, and public functions) and preconditions are checked (this allows to program old value expressions under the simplifying assumption that class invariant and precondition assertions are satisfied already).
|
||||
|
||||
[macroref BOOST_CONTRACT_OLDOF] is a variadic macro and it takes an extra parameter when used in virtual public functions or public function overrides (see __Virtual_Public_Functions__ and __Public_Function_Overrides__).
|
||||
C++11 auto declarations can be used with [macroref BOOST_CONTRACT_OLDOF] for brevity `auto `[^old_['variable-name] = BOOST_CONTRACT_OLDOF(['expression])].
|
||||
See __No_Macros__ to program old values without using [macroref BOOST_CONTRACT_OLDOF] (e.g., on compilers that do not support variadic macros).
|
||||
|
||||
[note
|
||||
This library ensures that old values are copied only once.
|
||||
This library also ensures that old values are never copied when postconditions and exception guarantees are disabled defining both [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] and [macroref BOOST_CONTRACT_NO_EXCEPTS] (note that both these two macros must be defined, defining only [macroref BOOST_CONTRACT_NO_POSTCONDITIONS] or only [macroref BOOST_CONTRACT_NO_EXCEPTS] is not sufficient to prevent the run-time cost of old value copies).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Exception Guarantees]
|
||||
|
||||
When exception guarantees are specified, they are programmed using a functor [^['e]] passed to `.except(`[^['e]]`)` that can be called with no parameters as [^['e]]`()`.
|
||||
Contracts that do not have exception guarantees simply do not call `.except(...)`.
|
||||
Exception guarantees must appear after both preconditions and postconditions when these are all present (see __Preconditions__ and __Postconditions__).
|
||||
|
||||
C++11 lambda functions are convenient to program exception guarantees, but any other nullary functor can be used (see __No_Lambda_Functions__).
|
||||
For example, for [funcref boost::contract::function] (but same for all other contracts):
|
||||
|
||||
boost::contract::check c = boost::contract::function() // Same for all other contracts.
|
||||
...
|
||||
.except([&] { // Capture by reference...
|
||||
BOOST_CONTRACT_ASSERT(...); // ...but should not modify captures.
|
||||
...
|
||||
})
|
||||
;
|
||||
|
||||
The exception guarantee functor should capture all variables that it needs to assert the exception guarantees.
|
||||
In general, these variables should be captured by reference and not by value (because exception guarantees need to access the value that these variables will have when the function throws, and not the value these variables had when the exception guarantee functor was first constructed).
|
||||
Exception guarantees can also capture old values (see __Old_Values__) but they should not access the return value instead (because the return value will not be properly set when the function throws an exception).
|
||||
In any case, exception guarantee assertions should not modify the value of the captured variables (see __Constant_Correctness__).
|
||||
|
||||
[note
|
||||
In real code, it might be difficult to program meaningful exception guarantees without resorting to expensive old value copies that will slow down execution.
|
||||
Therefore, the authors recognize that exception guarantees, even if supported by this library, might not be used often in practice (and they are not used in most of the examples listed in the rest of this documentation).
|
||||
Instead, exception guarantees might be useful in those cases when they can be programmed just reusing the old value copies already present because used by postconditions.
|
||||
]
|
||||
|
||||
Any code can be programmed in the exception guarantee functor, but it is recommended to keep this code simple using mainly assertions and if-statements (to avoid programming complex exception guarantees that might be buggy and slow to check at run-time).
|
||||
It is also recommended to use [macroref BOOST_CONTRACT_ASSERT] to program exception guarantee assertions because this enables the library to print informative error messages when the asserted conditions are evaluated to be false (this is not a variadic macro, see __No_Macros__):
|
||||
|
||||
BOOST_CONTRACT_ASSERT(``/boolean-condition/``)
|
||||
// Or, if boolean-condition has commas `,` not already within parenthesis `()`...
|
||||
BOOST_CONTRACT_ASSERT((``/boolean-condition/``)) // ...use extra parenthesis.
|
||||
|
||||
This library will automatically call the failure handler [funcref boost::contract::except_failure] if any of the [macroref BOOST_CONTRACT_ASSERT] conditions are `false` and, more in general, if calling the functor specified via `.except(...)` throws any exception.
|
||||
By default, this failure handler prints an error message to `std::cerr` and terminates the program calling `std::terminate` (see __Throw_on_Failure__ to change the failure handler to exit the program with an error code or to take some other custom action).
|
||||
|
||||
[important
|
||||
While it is technically possible for programmers to specify an exception guarantee handler that throws an exception in case of an exception guarantee failure, this will force C++ to terminate the program anyway.
|
||||
That is because the handler will throw an exception while there is already an active exception on the stack (the exception thrown by the function body that caused the exception guarantees to be checked in the first place).
|
||||
Therefore, programmers should not change the exception guarantee failure handler to throw exceptions.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Class Invariants]
|
||||
|
||||
When class invariants are specified, they are programmed in a public `const` function named `invariant` taking no argument and returning `void`.
|
||||
Classes that do not have invariants, simply do not declare the `invariant` function.
|
||||
[footnote
|
||||
This library uses template meta-programming (SFINAE-based introspection techniques) to check invariants only for classes that declare a member function named [macroref BOOST_CONTRACT_INVARIANT_FUNC].
|
||||
]
|
||||
For example:
|
||||
|
||||
class a {
|
||||
public: // Must be public.
|
||||
void invariant() const { // Must be const.
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
|
||||
This member function must be `const` because contracts should not modify the object state (see __Constant_Correctness__).
|
||||
This library will generate a compile-time error if the `const` qualifier is missing (unless [macroref BOOST_CONTRACT_PERMISSIVE] is defined).
|
||||
|
||||
Any code can be programmed in the `invariant` function, but it is recommended to keep this code simple using mainly assertions and if-statements (to avoid programming complex invariants that might be buggy and slow to check at run-time).
|
||||
It is also recommended to use [macroref BOOST_CONTRACT_ASSERT] to program class invariant assertions because this enables the library to print informative error messages when the asserted conditions are evaluated to be false (this is not a variadic macro, see __No_Macros__):
|
||||
|
||||
BOOST_CONTRACT_ASSERT(``/boolean-condition/``)
|
||||
// Or, if boolean-condition has commas `,` not already within parenthesis `()`...
|
||||
BOOST_CONTRACT_ASSERT((``/boolean-condition/``)) // ...use extra parenthesis.
|
||||
|
||||
This library will automatically call failure handlers [funcref boost::contract::entry_invariant_failure] or [funcref boost::contract::exit_invariant_failure] if any of the [macroref BOOST_CONTRACT_ASSERT] conditions are `false` and, more in general, if the `invariant` function throws an exception when invariants are checked at function entry or exit respectively.
|
||||
By default, these handlers print an error message to `std::cerr` and terminate the program calling `std::terminate` (see __Throw_on_Failure__ to change these failure handlers to throw exceptions, exit the program with an error code, etc.).
|
||||
|
||||
See __Access_Specifiers__ to avoid making the `invariant` member function `public`.
|
||||
[footnote
|
||||
In this documentation the `invariant` member function is often declared `public` for simplicity.
|
||||
However, in production code it might not be acceptable to augment the public members of a class adding the `invariant` function (and that can be avoided using [classref boost::contract::access] as explained in __Access_Specifiers__).
|
||||
]
|
||||
See [macroref BOOST_CONTRACT_INVARIANT_FUNC] to use a name different from `invariant` (e.g., because `invariant` clashes with other names in user-defined classes).
|
||||
|
||||
[note
|
||||
Contract assertions are not checked (not even class invariants) when data members are accessed directly (this is different from Eiffel where even accessing public data members checks class invariants).
|
||||
Therefore, it might be best for both `class`es and `struct`s (and also `union`s, see __Unions__) that have invariants to have no mutable public data members and to access data members publicly only via appropriate public functions (e.g., setters and getters) that can check the class invariants.
|
||||
]
|
||||
|
||||
See __Volatile_Public_Functions__ to program invariants for classes with `volatile` public functions.
|
||||
|
||||
[heading Static Class Invariants]
|
||||
|
||||
When static class invariants are specified, they are programmed in a public `static` function named `static_invariant` taking no argument and returning `void`.
|
||||
Classes that do not have static class invariants, simply do not declare the `static_invariant` function.
|
||||
[footnote
|
||||
This library uses template meta-programming (SFINAE-based introspection techniques) to check static invariants only for classes that declare a member function named [macroref BOOST_CONTRACT_STATIC_INVARIANT_FUNC].
|
||||
]
|
||||
For example:
|
||||
|
||||
class a {
|
||||
public: // Must be public.
|
||||
static void static_invariant() { // Must be static.
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
|
||||
This member function must be `static` (and it correctly cannot access the object `this`).
|
||||
This library will generate a compile-time error if the `static` classifier is missing (unless the [macroref BOOST_CONTRACT_PERMISSIVE] macro is defined).
|
||||
|
||||
Any code can be programmed in the `static_invariant` function, but it is recommended to keep this code simple using mainly assertions and if-statements (to avoid programming complex static invariants that might be buggy and slow to check at run-time).
|
||||
It is also recommended to use [macroref BOOST_CONTRACT_ASSERT] to program the assertions because this enables the library to print informative error messages when the asserted conditions are evaluated to be false (this is not a variadic macro, see __No_Macros__):
|
||||
|
||||
BOOST_CONTRACT_ASSERT(``/boolean-condition/``)
|
||||
// Or, if condition has commas `,` not already within parenthesis `()`...
|
||||
BOOST_CONTRACT_ASSERT((``/boolean-condition/``)) // ...use extra parenthesis.
|
||||
|
||||
This library will automatically call failure handlers [funcref boost::contract::entry_invariant_failure] or [funcref boost::contract::exit_invariant_failure] if any of the [macroref BOOST_CONTRACT_ASSERT] conditions are `false` and, more in general, if the `static_invariant` function throws an exception when invariants are checked at function entry or exit respectively.
|
||||
By default, these handlers print an error message to `std::cerr` and terminate the program calling `std::terminate` (see __Throw_on_Failure__ to change these failure handlers to throw exceptions, exit the program with an error code, etc.).
|
||||
|
||||
See __Access_Specifiers__ to avoid making `static_invariant` member function `public`.
|
||||
[footnote
|
||||
In this documentation the `static_invariant` member function is often declared `public` for simplicity.
|
||||
However, in production code it might not be acceptable to augment the public members of a class adding the `static_invariant` function (and that can be avoided using [classref boost::contract::access] as explained in __Access_Specifiers__).
|
||||
]
|
||||
See [macroref BOOST_CONTRACT_STATIC_INVARIANT_FUNC] to use a name different from `static_invariant` (e.g., because `static_invariant` clashes with other names in user-defined classes).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
In C++, it is not possible to overload a member function based on the `static` classifier.
|
||||
Therefore, this library has to use different names for the member functions checking non-static and static class invariants (namely [macroref BOOST_CONTRACT_INVARIANT_FUNC] and [macroref BOOST_CONTRACT_STATIC_INVARIANT_FUNC]).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Constructors]
|
||||
|
||||
Contracts for constructors are programmed using the [funcref boost::contract::constructor] function and the [classref boost::contract::constructor_precondition] base class.
|
||||
For example (see [@../../example/features/public.cpp =public.cpp=]):
|
||||
|
||||
[import ../example/features/public.cpp]
|
||||
[public_class_begin]
|
||||
[public_constructor]
|
||||
[public_class_end]
|
||||
|
||||
It is not possible to specify preconditions using `.precondition(...)` for constructors (this library will generate a compile-time error if `.precondition(...)` is used on the object returned by [funcref boost::contract::constructor]).
|
||||
Constructor preconditions are specified using the [classref boost::contract::constructor_precondition] base class instead (but the considerations from __Preconditions__ apply also to the precondition functor passed to [classref boost::contract::constructor_precondition]).
|
||||
Programmes should not access the object `*this` from constructor preconditions (because the object does not exists yet before the constructor body is executed).
|
||||
[footnote
|
||||
See __No_Lambda_Functions__ to enforce this constraint at compile-time (but still not recommended because of extra boiler-plate code).
|
||||
]
|
||||
Constructors without preconditions simply do not explicitly initialize the [classref boost::contract::constructor_precondition] base (in fact [classref boost::contract::constructor_precondition] default constructor checks no contract).
|
||||
When [classref boost::contract::constructor_precondition] is used:
|
||||
[footnote
|
||||
There is a MSVC bug that was fixed in MSVC 2013 for which lambdas cannot be used in constructor member initialization lists for templates.
|
||||
On MSVC compilers with that bug, an extra (static) member function can be used (together with `bind` and `cref` as needed) to program constructor preconditions instead of using lambdas (see __No_Lambda_Functions__).
|
||||
]
|
||||
|
||||
* It should be specified as the /first/ class in the inheritance list (so constructor preconditions are checked before initializing any other base class or data member).
|
||||
* Its inheritance access specifier should always be `private` (so this extra base class does not alter the public inheritance tree of the derived class).
|
||||
* It takes the derived class as template parameter (the Curiously Recursive Template Pattern (CRTP) is used here to avoid ambiguity errors with multiple inheritance).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The [classref boost::contract::constructor_precondition] takes the derived class as its template parameter so the instantiated template type is unique for each derived class.
|
||||
This always avoids base class ambiguity errors even when multiple inheritance is used.
|
||||
Note that virtual inheritance could not be used instead of the template parameter here to avoid ambiguity errors (because virtual bases are initialized only once by the out-most derived class, and that would not allow to properly check preconditions of all base classes).
|
||||
]
|
||||
|
||||
[note
|
||||
A class can avoid inheriting from [classref boost::contract::constructor_precondition] for efficiency but only when all its constructors have no preconditions.
|
||||
]
|
||||
|
||||
It is possible to specify postconditions for constructors (see __Postconditions__).
|
||||
Programmers should not access the old value of the object `*this` in constructor postconditions (because the object did not exist yet before the constructor body was executed).
|
||||
[footnote
|
||||
See __No_Lambda_Functions__ to enforce this constraint at compile-time (but still not recommended because of extra boiler-plate code).
|
||||
]
|
||||
The [funcref boost::contract::constructor] function takes `this` as a parameter (because constructors check class invariants, see __Class_Invariants__).
|
||||
|
||||
The [funcref boost::contract::constructor] function returns an RAII object that must always be assigned to a local variable of type [classref boost::contract::check] (otherwise this library will generate a run-time error, see [macroref BOOST_CONTRACT_ON_MISSING_CHECK_DECL]).
|
||||
Furthermore, C++11 `auto` declarations cannot be used here and the [classref boost::contract::check] type must be explicitly specified (otherwise this library will generate a compile-time error).
|
||||
The constructor body is programmed right after the declaration of the RAII object.
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for constructors does the following (enclosing constructor entry):
|
||||
|
||||
# Check static class invariants, by calling [^['type-of]]`(*this)::static_invariant()` (but not non-static class invariants because the object does not exist yet).
|
||||
|
||||
At destruction instead (enclosing constructor exit):
|
||||
|
||||
# Check static class invariants, by calling [^['type-of]]`(*this)::static_invariant()`.
|
||||
# If the constructor body did not throw an exception:
|
||||
# Check non-static class invariants, by calling `this->invariant()`.
|
||||
# Check postconditions, by calling the nullary functor [^['s]]`()` passed to `.postcondition(`[^['s]]`)`.
|
||||
# Else:
|
||||
# Check exception guarantees, by calling the nullary functor [^['e]]`()` passed to `.except(`[^['e]]`)`.
|
||||
|
||||
This together with C++ object construction mechanism of base classes and the use of [classref boost::contract::constructor_precondition] ensures that the constructor contracts are correctly checked at run-time (see __Constructor_Calls__).
|
||||
|
||||
[note
|
||||
A constructor can avoid calling [funcref boost::contract::constructor] for efficiency but only when it has no postconditions, no exception guarantees, and its class has no invariants (even if [funcref boost::contract::constructor] is not used by a derived class, contracts of base class constructors will still be correctly checked by C++ object construction mechanism).
|
||||
|
||||
The default constructor and copy constructor automatically generated by C++ will not check contracts.
|
||||
Therefore, unless these constructors are not public or they have no preconditions, no postconditions, no exception guarantees, and their class has no invariants, programmers should manually define them using [funcref boost::contract::constructor] and [classref boost::contract::constructor_precondition].
|
||||
Similar considerations apply to all other constructors automatically generated by C++ (e.g., move constructor).
|
||||
]
|
||||
|
||||
Private and protected constructors can omit [funcref boost::contract::constructor] (because they are not part of the public interface of the class so they are not required to check class invariants, see __Constructor_Calls__).
|
||||
They could still use [classref boost::contract::constructor_precondition] to check preconditions before member initializations, and even use [funcref boost::contract::function] (but not [funcref boost::contract::constructor]) to only check postconditions and exception guarantees without checking class invariants and without calling `.precondition(...)` (see __Private_and_Protected_Functions__).
|
||||
For example:
|
||||
|
||||
class a : private boost::contract::constructor_precondition<a> {
|
||||
protected:
|
||||
// Contract for a protected constructor (same for private constructors).
|
||||
a() : // Still use this base class to check constructor preconditions.
|
||||
boost::contract::constructor_precondition<a>([&] {
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
})
|
||||
{
|
||||
// Following will correctly not check class invariants.
|
||||
boost::contract::check c = boost::contract::function()
|
||||
// Do not use `.precondition(...)` here.
|
||||
.postcondition([&] {
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
})
|
||||
.except([&] {
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
})
|
||||
;
|
||||
|
||||
... // Constructor body.
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Destructors]
|
||||
|
||||
Contracts for destructors are programmed using [funcref boost::contract::destructor].
|
||||
For example (see [@../../example/features/public.cpp =public.cpp=]):
|
||||
|
||||
[public_class_begin]
|
||||
[public_destructor]
|
||||
[public_class_end]
|
||||
|
||||
It is not possible to specify preconditions for destructors (this library will generate a compile-time error if `.precondition(...)` is used here because destructors can be called at any time after construction so they have no precondition).
|
||||
It is possible to specify postconditions for destructors (see __Postconditions__, and also __Static_Public_Functions__ for an example).
|
||||
Programmers should not access the object `*this` in destructor postconditions (because the object no longer exists after the destructor body has been executed).
|
||||
[footnote
|
||||
See __No_Lambda_Functions__ to enforce this constraint at compile-time (but still not recommended because of extra boiler-plate code).
|
||||
]
|
||||
The [funcref boost::contract::destructor] function takes `this` as a parameter (because destructors check class invariants, see __Class_Invariants__).
|
||||
|
||||
The [funcref boost::contract::destructor] function returns an RAII object that must always be assigned to a local variable of type [classref boost::contract::check] (otherwise this library will generate a run-time error, see [macroref BOOST_CONTRACT_ON_MISSING_CHECK_DECL]).
|
||||
Furthermore, C++11 `auto` declarations cannot be used here and the [classref boost::contract::check] type must be explicitly specified (otherwise this library will generate a compile-time error).
|
||||
The destructor body is programmed right after the declaration of the RAII object.
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for destructors does the following (enclosing destructor entry):
|
||||
|
||||
# Check static and non-static class invariants, by calling ['[^type-of]]`(*this)::static_invariant()` __AND__ `this->invariant()`.
|
||||
|
||||
At destruction instead (enclosing destructor exit):
|
||||
|
||||
# Check static class invariants, by calling [^['type-of]]`(*this)::static_invariant()`.
|
||||
# If the destructor body did not throw an exception:
|
||||
# Check postconditions, by calling the nullay functor [^['s]]`()` passed to `.postcondition(`[^['s]]`)`.
|
||||
# Else (even if destructors should generally be programmed not to throw in C++):
|
||||
# Check non-static class invariants, by calling `this->invariant()` (because the object was not successfully destructed).
|
||||
# Check exception guarantees, by calling the nullary functor [^['e]]`()` passed to `.except(`[^['e]]`)`.
|
||||
|
||||
This together with C++ object destruction mechanism of base classes ensures that destructor contracts are correctly checked at run-time (see __Destructor_Calls__).
|
||||
|
||||
[note
|
||||
A destructor can avoid calling [funcref boost::contract::destructor] for efficiency but only when it has no postconditions, no exception guarantees, and its class has no invariants (even if [funcref boost::contract::destructor] is not used by a derived class, contracts of base class destructors will still be correctly checked by C++ object destruction mechanism).
|
||||
|
||||
The default destructor automatically generated by C++ will not check contracts.
|
||||
Therefore, unless the destructor is not public or it has no postconditions, no exception guarantees, and its class has no invariants, programmers should manually define it using [funcref boost::contract::destructor].
|
||||
]
|
||||
|
||||
Private and protected destructors can omit [funcref boost::contract::destructor] (because they are not part of the public interface of the class so they are not required to check class invariants, see __Destructor_Calls__).
|
||||
They could use [funcref boost::contract::function] (but not [funcref boost::contract::destructor]) to only check postconditions and exception guarantees without checking class invariants and without calling `.precondition(...)` (see __Private_and_Protected_Functions__).
|
||||
For example:
|
||||
|
||||
class a {
|
||||
protected:
|
||||
// Contract for a protected destructor (same for private destructors).
|
||||
virtual ~a() {
|
||||
// Following will correctly not check class invariants.
|
||||
boost::contract::check c = boost::contract::function()
|
||||
// Do not use `.precondition(...)` here.
|
||||
.postcondition([&] {
|
||||
BOOST_CONTRACT_ASSERT(...);
|
||||
...
|
||||
})
|
||||
;
|
||||
|
||||
... // Destructor body.
|
||||
}
|
||||
|
||||
...
|
||||
};
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Public Functions]
|
||||
|
||||
Contracts for public functions are programmed using [funcref boost::contract::public_function].
|
||||
In this section, let's consider public functions that are not static, not virtual, and do not override any function from base classes.
|
||||
For example (see [@../../example/features/public.cpp =public.cpp=]):
|
||||
|
||||
[public_class_begin]
|
||||
[public_function]
|
||||
[public_class_end]
|
||||
|
||||
It is possible to specify preconditions, postconditions, and exception guarantees for public functions (see __Preconditions__, __Postconditions__, and __Exception_Guarantees__).
|
||||
When called from non-static public functions, the [funcref boost::contract::public_function] function takes `this` as a parameter (because public functions check class invariants, see __Class_Invariants__).
|
||||
|
||||
The [funcref boost::contract::public_function] function returns an RAII object that must always be assigned to a local variable of type [classref boost::contract::check] (otherwise this library will generate a run-time error, see [macroref BOOST_CONTRACT_ON_MISSING_CHECK_DECL]).
|
||||
Furthermore, C++11 `auto` declarations cannot be used here and the [classref boost::contract::check] type must be explicitly specified (otherwise this library will generate a compile-time error).
|
||||
The public function body is programmed right after the declaration of the RAII object.
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for public functions does the following (enclosing public function entry):
|
||||
|
||||
# Check static and non-static class invariants, by calling [^['type-of]]`(*this)::static_invariant()` __AND__ `this->invariant()`.
|
||||
# Check preconditions, by calling the nullary functor [^['r]]`()` passed to `.precondition(`[^['r]]`)`.
|
||||
|
||||
At destruction instead (enclosing public function exit):
|
||||
|
||||
# Check static and non-static class invariants, by calling [^['type-of]]`(*this)::static_invariant()` __AND__ `this->invariant()` (even if the function body threw an exception).
|
||||
# If the function body did not throw an exception:
|
||||
# Check postconditions, by calling the nullary functor [^['s]]`()` passed to `.postcondition(`[^['s]]`)`.
|
||||
# Else:
|
||||
# Check exception guarantees, by calling the nullary functor [^['e]]`()` passed to `.except(`[^['e]]`)`.
|
||||
|
||||
This ensures that public function contracts are correctly checked at run-time (see __Public_Function_Calls__).
|
||||
|
||||
[note
|
||||
A public function can avoid calling [funcref boost::contract::public_function] for efficiency but only when it has no preconditions, no postconditions, no exception guarantees, it is not virtual, it does not override any virtual function, and its class has no invariants.
|
||||
|
||||
The default copy assignment operator automatically generated by C++ will not check contracts.
|
||||
Therefore, unless this operator is not public or it has no preconditions, no postconditions, no exception guarantees, and its class has no invariants, programmers should manually define it using [funcref boost::contract::public_function].
|
||||
Similar considerations apply to all other operations automatically generated by C++ (move operator, etc.).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Virtual Public Functions]
|
||||
|
||||
Contracts for public functions are programmed using [funcref boost::contract::public_function].
|
||||
In this section, let's consider public functions that are virtual but that do not override any function from base classes.
|
||||
For example (see [@../../example/features/public.cpp =public.cpp=]):
|
||||
|
||||
[public_class_begin]
|
||||
[public_virtual_function]
|
||||
[public_class_end]
|
||||
|
||||
Virtual public functions must declare an extra trailing parameter of type [classref boost::contract::virtual_]`*` with default value `0` (i.e., `nullptr`).
|
||||
[footnote
|
||||
The name of this extra parameter is arbitrary, but `v` is often used in this documentation.
|
||||
]
|
||||
This extra parameter is the last parameter and it has a default value so it does not alter the calling interface of the virtual function (in practice, callers will rarely, if ever, have to explicitly deal with this extra parameter, a part from when manipulating the virtual function type directly for function pointer type-casting, etc.).
|
||||
Programmers must pass the extra virtual parameter as the very first argument to all [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::public_function] calls in the virtual public function definition.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The [classref boost::contract::virtual_]`*` parameter is used by this library to determine that a function is virtual (in C++ it is not possible to introspect if a function is declared `virtual`).
|
||||
Furthermore, this parameter is internally used by this library to pass result and old values that are evaluated by the overriding function to overridden virtual functions in base classes, and also to check preconditions, postconditions, and exception guarantees of overridden virtual functions to implement subcontracting.
|
||||
]
|
||||
|
||||
When called from virtual public functions, the [funcref boost::contract::public_function] function takes `this` as a parameter (because public functions check class invariants, see __Class_Invariants__).
|
||||
For virtual public functions returning `void`:
|
||||
|
||||
// In a void virtual public function (that does not override).
|
||||
boost::contract::check c = boost::contract::public_function(v, this) // No result parameter...
|
||||
.precondition([&] { ... })
|
||||
.postcondition([&] { ... }) // ...so nullary functor.
|
||||
.except([&] { ... })
|
||||
;
|
||||
|
||||
For virtual public functions not returning `void`, programmers must also pass a reference to the function return value as the second argument to [funcref boost::contract::public_function].
|
||||
In this case, the library will pass this return value reference to the postcondition functor that must therefore take one single argument matching the return type, otherwise this library will generate a compile-time error (the functor parameter can be a constant reference `const&` to avoid extra copies of the return value):
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The extra function result parameter taken by the functor passed to `.postcondition(...)` is used by this library to pass the return value evaluated by the overriding function to all its overridden virtual functions when subcontracting.
|
||||
]
|
||||
|
||||
// In a non-void virtual public function (that does not override).
|
||||
``['return-type]`` result;
|
||||
boost::contract::check c = boost::contract::public_function(v, result, this) // Result parameter...
|
||||
.precondition([&] { ... })
|
||||
.postcondition([&] (``['return-type]`` const& result) { ... }) // ...so unary functor.
|
||||
.except([&] { ... })
|
||||
;
|
||||
|
||||
[important
|
||||
It is the responsibility of the programmers to pass the extra virtual parameter `v` to all [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::public_function] calls within virtual public functions, and also to pass the return value reference after `v` to [funcref boost::contract::public_function] for non-void virtual public functions.
|
||||
This library cannot automatically generate compile-time errors if programmers fail to do so (but in general this will prevent the library from correctly checking contracts at run-time).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
This library does not require programmers to specify the function type when using [funcref boost::contract::public_function] for non-overriding virtual public functions.
|
||||
Therefore, this library does not know if the enclosing function has a non-void return type so it cannot check if the return value reference is passed as required for non-overriding virtual public functions.
|
||||
Instead the function type is passed to this library for virtual public function overrides and that also allows this library to give a compile-time error if the return value reference is missing in those cases.
|
||||
]
|
||||
Remember:
|
||||
[:Always pass the function parameter `v` as the first argument to [macroref BOOST_CONTRACT_OLDOF] and to [funcref boost::contract::public_function].]
|
||||
[:Always pass the function return value to [funcref boost::contract::public_function] right after `v` (for non-void virtual public functions).]
|
||||
]
|
||||
|
||||
For the rest, considerations made in __Public_Functions__ apply to virtual public functions as well.
|
||||
|
||||
[note
|
||||
A virtual public function should always call [funcref boost::contract::public_function] (even if it has no preconditions, no postconditions, no exception guarantees, and its class has no invariants), otherwise this library will not be able to correctly use it for subcontracting.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Public Function Overrides (Subcontracting)]
|
||||
|
||||
Contracts for public functions are programmed using [funcref boost::contract::public_function].
|
||||
In this section, let's consider public functions (virtual or not) that override virtual public functions from one or more public base classes.
|
||||
For example (see [@../../example/features/public.cpp =public.cpp=]):
|
||||
[footnote
|
||||
In this documentation, function overrides are often marked with the code comment `/* override */`.
|
||||
On compilers that support C++11 virtual specifiers, the `override` identifier can be used instead (`override` is not used in the documentation only because virtual specifiers are not widely supported yet, even by compilers that support C++11 lambda functions).
|
||||
]
|
||||
|
||||
[public_derived_class_begin]
|
||||
[public_function_override]
|
||||
[public_derived_class_end]
|
||||
|
||||
The extra `typedef` declared using [macroref BOOST_CONTRACT_BASE_TYPES] is required by this library for derived classes and it is internally used detect base classes for subcontracting (see __Base_Classes__).
|
||||
|
||||
When called from public function overrides, the [funcref boost::contract::public_function] function template takes an explicit template argument `override_`[^['function-name]] that must be defined using [macroref BOOST_CONTRACT_OVERRIDE]:
|
||||
|
||||
BOOST_CONTRACT_OVERRIDE(``['function-name]``)
|
||||
|
||||
This can be declared at any point in the public section of the enclosing class (see __Access_Specifiers__ to use [macroref BOOST_CONTRACT_OVERRIDE] in a non-public section of the class instead).
|
||||
[macroref BOOST_CONTRACT_OVERRIDE] must be used only once in a class for a given function name and overloaded functions can reuse the same [^override_['function-name]] definition (see __Function_Overloads__).
|
||||
[macroref BOOST_CONTRACT_NAMED_OVERRIDE] can be used to generate a name different than [^override_['function-name]] (e.g., to avoid generating C++ reserved names containing double underscores "`__`" for function names that already start with an underscore "`_`", see __Named_Overrides__).
|
||||
For convenience [macroref BOOST_CONTRACT_OVERRIDES] can be used with multiple function names instead of repeating [macroref BOOST_CONTRACT_OVERRIDE] for each function name (on compilers that support variadic macros).
|
||||
For example, for three functions named `f`, `g`, and `h` (but same for any other number of functions), the following:
|
||||
|
||||
BOOST_CONTRACT_OVERRIDES(f, g, h)
|
||||
|
||||
Is equivalent to:
|
||||
[footnote
|
||||
This library does not provider an equivalent of [macroref BOOST_CONTRACT_NAMED_OVERRIDE] that operates on multiple function names at once (simply because programmers will probably not use [macroref BOOST_CONTRACT_NAMED_OVERRIDE] often in the first place).
|
||||
]
|
||||
|
||||
BOOST_CONTRACT_OVERRIDE(f)
|
||||
BOOST_CONTRACT_OVERRIDE(g)
|
||||
BOOST_CONTRACT_OVERRIDE(h)
|
||||
|
||||
This library will generate a compile-time error if there is no suitable virtual function to override in any of the public base classes for subcontracting.
|
||||
[footnote
|
||||
The compile-time error generated by the library in this case is similar in principle to the error generated by the C++11 `override` specifier, but it is limited to functions with the extra [classref boost::contract::virtual_]`*` parameter and searched recursively only in `public` base classes passed to [macroref BOOST_CONTRACT_BASE_TYPES] because only those are considered for subcontracting.
|
||||
]
|
||||
|
||||
Public function overrides must always list the extra trailing parameter of type [classref boost::contract::virtual_]`*` with default value `0` (i.e., `nullptr`), even when they are not declared `virtual` (because this parameter is present in the signature of the virtual function being overridden from base classes).
|
||||
Programmers must pass the extra virtual parameter as the very first argument to all [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::public_function] calls in the public function override definition (see __Virtual_Public_Functions__).
|
||||
|
||||
When called from public function overrides, the [funcref boost::contract::public_function] function takes a pointer to the enclosing function, the object `this` (because public function overrides check class invariants, see __Class_Invariants__), and references to each function argument in the order they appear in the function declaration.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The object `this` is passed after the function pointer to follow `bind`'s syntax.
|
||||
The function pointer and references to all function arguments are needed for public function overrides because this library has to call overridden virtual public functions to check their contracts for subcontracting (even if this library will not actually execute the bodies of the overridden functions).
|
||||
]
|
||||
For public function overrides returning `void`:
|
||||
|
||||
// In a void public function override.
|
||||
boost::contract::check c = boost::contract::public_function<override_``['function-name]``>(
|
||||
v, &``['class-name]``::``['function-name]``, this, // No result parameter...
|
||||
``['function-argument_1]``, ``['function-argument_2]``, ...
|
||||
)
|
||||
.precondition([&] { ... })
|
||||
.postcondition([&] { ... }) // ...so nullary functor.
|
||||
.except([&] { ... })
|
||||
;
|
||||
|
||||
For public function overrides not returning `void`, programmers must also pass a reference to the function return value as the second argument to [funcref boost::contract::public_function] (this library will generate a compile-time error otherwise).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
As for non-overriding virtual public functions, also public function overrides use the extra return value parameter to pass it to the overridden functions when subcontracting.
|
||||
In the case of public function overrides this library also has the function pointer so it will generate a compile-time error if the function is non-void and programmers forget to specify the extra return value parameter (this extra error checking is not possible instead for non-overriding virtual public functions because their contracts do not take the function pointer as a parameter, see __Virtual_Public_Functions__).
|
||||
]
|
||||
In this case, the library will pass this return value reference to the postcondition functor that must therefore take one single argument matching the return type, otherwise this library will generate a compile-time error (the functor parameter can be a constant reference `const&` to avoid extra copies of the return value):
|
||||
|
||||
// In non-void public function override.
|
||||
``['return-type]`` result;
|
||||
boost::contract::check c = boost::contract::public_function<override_``['function-name]``>(
|
||||
v, result, &``['class-name]``::``['function-name]``, this, // Result parameter...
|
||||
``['function-argument_1]``, ``['function-argument_2]``, ...
|
||||
)
|
||||
.precondition([&] { ... })
|
||||
.postcondition([&] (``['return-type]`` const& result) { ... }) // ...so unary functor.
|
||||
.except([&] { ... })
|
||||
;
|
||||
|
||||
This library will throw [classref boost::contract::bad_virtual_result_cast] if programmers specify return values for public function overrides in derived classes that are not consistent with the return types of the virtual public functions being overridden in the base classes.
|
||||
[footnote
|
||||
*Rationale:*
|
||||
The `boost::bad_any_cast` exception could not used here because it does not print the from- and to- type names (so it is not descriptive enough).
|
||||
]
|
||||
|
||||
[important
|
||||
It is the responsibility of the programmers to pass the extra virtual parameter `v` to all [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::public_function] calls within public function overrides, and also to pass the return value reference after `v` to [funcref boost::contract::public_function] for non-void public function overrides.
|
||||
This library cannot always generate compile-time errors if programmers fail to do so (but in general this will prevent the library from correctly checking contracts at run-time).
|
||||
Remember:
|
||||
[:Always pass the function parameter `v` as the first argument to [macroref BOOST_CONTRACT_OLDOF] and [funcref boost::contract::public_function].]
|
||||
[:Always pass the function return value to [funcref boost::contract::public_function] right after `v` (for non-void public function overrides).]
|
||||
]
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for public function overrides does the following (enclosing public function override entry):
|
||||
|
||||
# Check static and non-static class invariants for all overridden bases and for the derived class in __AND__ with each other, by calling [^['type-of](['overridden-base_1])]`::static_invariant()` __AND__ [^['overridden-base_1]]`.invariant()` __AND__... [^['type-of](['overridden-base_n])]`::static_invariant()` __AND__ [^['overridden-base_n]]`.invariant()` __AND__ [^['type-of]]`(*this)::static_invariant()` __AND__ `this->invariant()`.
|
||||
# Check preconditions for all overridden base functions and for the overriding derived function in __OR__ with each other, by calling the nullary functors [^['r_1]]`()` __OR__... [^['r_n]]`()` __OR__ [^['r]]`()` passed to `.precondition(`[^['r_1]]`)`, ... `.precondition(`[^['r_n]]`)`, `.precondition(`[^['r]]`)` for all of the overridden and overriding functions respectively.
|
||||
|
||||
At destruction instead (enclosing public function override exit):
|
||||
|
||||
# Check static and non-static class invariants for all overridden bases and for the derived class in __AND__ with each other, by calling [^['type-of](['overridden-base_1])]`::static_invariant()` __AND__ [^['overridden-base_1]]`.invariant()` __AND__... [^['type-of](['overridden-base_n])]`::static_invariant()` __AND__ [^['overridden-base_n]]`.invariant()` __AND__ [^['type-of]]`(*this)::static_invariant()` __AND__ `this->invariant()` (even if the function body threw an exception).
|
||||
# If the function body did not throw an exception:
|
||||
# Check postconditions for all overridden base functions and for the overriding derived function in __AND__ with each other, by calling the nullary functors [^['s_1]]`()` __AND__... [^['s_n]]`()` __AND__ [^['s]]`()` passed to `.postcondition(`[^['s_1]]`)`, ... `.postcondition(`[^['s_n]]`)`, `.postcondition(`[^['s]]`)` for all of the overridden and overriding functions respectively (or the unary functors [^['s_1]]`(`[^['result]]`)` __AND__... [^['s_n]]`(`[^['result]]`)` __AND__ [^['s]]`(`[^['result]]`)` for non-void public function overrides).
|
||||
# Else:
|
||||
# Check exception guarantees for all overridden base functions and for the overriding derived function in __AND__ with each other, by calling the nullary functors [^['e_1]]`()` __AND__... [^['e_n]]`()` __AND__ [^['e]]`()` passed to `.except(`[^['e_1]]`)`, ... `.except(`[^['e_n]]`)`, `.except(`[^['e]]`)` for all of the overridden and overriding functions respectively.
|
||||
|
||||
This ensures that public function override contracts and subcontracts are correctly checked at run-time (see __Public_Function_Calls__).
|
||||
|
||||
For the rest, considerations made in __Virtual_Public_Functions__ apply to public function overrides as well.
|
||||
|
||||
[note
|
||||
A public function override should always call [funcref boost::contract::public_function] (even if it has no preconditions, no postconditions, no exception guarantees, and its class has no invariants), otherwise this library will not be able to correctly use it for subcontracting.
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Base Classes (Subcontracting)]
|
||||
|
||||
In order for this library to support subcontracting, programmers must specify the bases of a derived class declaring a public member type named `base_types` via a `typedef` using [macroref BOOST_CONTRACT_BASE_TYPES].
|
||||
For example (see [@../../example/features/base_types.cpp =base_types.cpp=]):
|
||||
|
||||
[import ../example/features/base_types.cpp]
|
||||
[base_types]
|
||||
|
||||
For convenience, a local macro named `BASES` can be used to avoid repeating the base list twice (first in the derived class declaration `class `[^['class-name]]` : `[^['base-list]] and then again when invoking [macroref BOOST_CONTRACT_BASE_TYPES]`(`[^['base-list]]`)`).
|
||||
Being a local macro, `BASES` must be undefined using `#undef BASES` after it has been used to declare `base_types` (to avoid name clashes and macro redefinition errors).
|
||||
[footnote
|
||||
The name of this local macro is arbitrary, but `BASES` is often used in this documentation.
|
||||
]
|
||||
|
||||
[macroref BOOST_CONTRACT_BASE_TYPES] is a variadic macro and accepts a list of bases separated by commas (see __No_Macros__ to program `base_types` without using macros).
|
||||
As already noted in __Constructors__, when the extra base [classref boost::contract::constructor_precondition] is used to program constructor preconditions, its inheritance access level must always be `private` and it must be specified as the very first base.
|
||||
|
||||
[important
|
||||
Each base passed to [macroref BOOST_CONTRACT_BASE_TYPES] must /explicitly/ specify its inheritance access level `public`, `protected`, or `private` (but `virtual` is optional and can be specified either before or after the access level as usual in C++).
|
||||
[footnote
|
||||
*Rationale:*
|
||||
This library explicitly requires the inheritance access level because derived classes must subcontract only from public bases, but not from protected or private bases (see __Public_Function_Calls__).
|
||||
Therefore, [macroref BOOST_CONTRACT_BASE_TYPES] inspects each inheritance access level (using preprocessor meta-programming) and removes non-public bases from the list of bases inspected for subcontracting (i.e., from `base_types`).
|
||||
]
|
||||
This library will generate a compile-time error if the first base is missing its inheritance access level, but this library will not be able to always generate an error if the access level is missing for bases after the first one.
|
||||
It is the responsibility of the programmers to make sure that all bases passed to [macroref BOOST_CONTRACT_BASE_TYPES] explicitly specify their inheritance access level (inheritance access levels are instead optional in C++ because `private` is implicitly assumed for `class` types and `public` for `struct` types).
|
||||
Remember:
|
||||
[:Always explicitly specify the inheritance access level `public`, `protected`, or `private` for base classes of derived classes with contracts.]
|
||||
]
|
||||
|
||||
See __Access_Specifiers__ to avoid making the `base_types` member type `public`.
|
||||
[footnote
|
||||
In this documentation the `base_type` member type is often declared `public` for simplicity.
|
||||
However, in production code it might not be acceptable to augment the public members of a class adding the `base_types` type (and that can be avoided using [classref boost::contract::access] as explained in __Access_Specifiers__).
|
||||
]
|
||||
See [macroref BOOST_CONTRACT_BASES_TYPEDEF] to use a name different from `base_types` (e.g., because `base_types` clashes with other names in user-defined classes).
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Static Public Functions]
|
||||
|
||||
Contracts for public functions are programmed using [funcref boost::contract::public_function].
|
||||
In this section, let's consider static public functions.
|
||||
For example (see [@../../example/features/static_public.cpp =static_public.cpp=]):
|
||||
|
||||
[import ../example/features/static_public.cpp]
|
||||
[static_public]
|
||||
|
||||
It is possible to specify preconditions, postconditions, and exception guarantees for static public functions (see __Preconditions__, __Postconditions__, and __Exception_Guarantees__).
|
||||
However, when called from static public functions, [funcref boost::contract::public_function] cannot take the object `this` as a parameter (because there is no object `this` in static member functions) so the enclosing class type is is specified as an explicit template parameter (because the class type is necessary to check static class invariants, see __Class_Invariants__):
|
||||
|
||||
// In a static public function.
|
||||
boost::contract::check c = boost::contract::public_function<``[^['class-type]]``>() // Explicit class type template parameter.
|
||||
.precondition([&] { ... })
|
||||
.postcondition([&] { ... })
|
||||
.except([&] { ... })
|
||||
;
|
||||
|
||||
The [funcref boost::contract::public_function] function returns an RAII object that must be assigned to a local variable of type [classref boost::contract::check] (otherwise this library will generate a run-time error, see [macroref BOOST_CONTRACT_ON_MISSING_CHECK_DECL]).
|
||||
Furthermore, C++11 `auto` declarations cannot be used here and the [classref boost::contract::check] type must be explicitly specified (otherwise this library will generate a compile-time error).
|
||||
The static public functions body is programmed right after the declaration of the RAII object.
|
||||
|
||||
At construction, the [classref boost::contract::check] RAII object for static public functions does the following (enclosing static public function entry):
|
||||
|
||||
# Check static class invariants, by calling [^['class-type]]`::static_invariant()` (but never non-static class invariants).
|
||||
# Check preconditions, by calling the nullary functor [^['r]]`()` passed to `.precondition(`[^['r]]`)`.
|
||||
|
||||
At destruction instead (enclosing static public function exit):
|
||||
|
||||
# Check static class invariants, by calling [^['class-type]]`::static_invariant()` (even if the function body threw an exception, but never non-static class invariants).
|
||||
# If the function body did not throw an exception:
|
||||
# Check postconditions, by calling the nullary functor [^['s]]`()` passed to `.postcondition(`[^['s]]`)`.
|
||||
# Else:
|
||||
# Check exception guarantees, by calling the nullary functor [^['e]]`()` passed to `.except(`[^['e]]`)`.
|
||||
|
||||
This ensures that static public function contracts are correctly checked at run-time (see __Public_Function_Calls__).
|
||||
[footnote
|
||||
Note that static public functions do not subcontract because they have no object `this` and therefore there is no inheritance.
|
||||
]
|
||||
|
||||
[note
|
||||
A static public function can avoid calling [funcref boost::contract::public_function] for efficiency but only when it has no preconditions, no postconditions, no exception guarantees, and its class has no static invariants (the class can still have non-static invariants or base classes instead).
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -1,85 +0,0 @@
|
||||
|
||||
# Copyright (C) 2008-2017 Lorenzo Caminiti
|
||||
# Distributed under the Boost Software License, Version 1.0 (see accompanying
|
||||
# file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
# See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
|
||||
|
||||
make help : : help_exit ;
|
||||
explicit help ;
|
||||
|
||||
test-suite features :
|
||||
[ subdir-run features : introduction_comments ]
|
||||
[ subdir-run features : introduction ]
|
||||
[ subdir-run features : introduction_public ]
|
||||
|
||||
[ subdir-run features : non_member ]
|
||||
[ subdir-run features : lambda ]
|
||||
[ subdir-run features : loop ]
|
||||
[ subdir-run features : code_block ]
|
||||
[ subdir-run features : public ]
|
||||
[ subdir-run features : base_types ]
|
||||
[ subdir-run features : static_public ]
|
||||
[ subdir-run features : private_protected ]
|
||||
[ subdir-run features : private_protected_virtual ]
|
||||
[ subdir-run features : private_protected_virtual_multi ]
|
||||
[ subdir-run features : check ]
|
||||
|
||||
[ subdir-run features : friend ]
|
||||
[ subdir-run features : friend_invariant ]
|
||||
[ subdir-run features : old ]
|
||||
[ subdir-run features : optional_result ]
|
||||
[ subdir-run features : optional_result_virtual ]
|
||||
[ subdir-run features : pure_virtual_public ]
|
||||
[ subdir-run features : overload ]
|
||||
[ subdir-run features : named_override ]
|
||||
[ subdir-run features : move ]
|
||||
[ subdir-run features : union ]
|
||||
[ subdir-run features : volatile ]
|
||||
[ subdir-run features : old_if_copyable ]
|
||||
[ subdir-run features : condition_if ]
|
||||
[ subdir-run features : call_if_cxx14 : # Requires C++14.
|
||||
<toolset>clang:<cxxflags>-std=c++1y ]
|
||||
[ subdir-run features : access ]
|
||||
[ subdir-run features : separate_body ]
|
||||
[ subdir-run features : throw_on_failure ]
|
||||
[ subdir-run features : ifdef ]
|
||||
[ subdir-run features : assertion_level ]
|
||||
[ subdir-run features : ifdef_macro ]
|
||||
[ subdir-run features : base_types_no_macro ]
|
||||
[ subdir-run features : old_no_macro ]
|
||||
[ subdir-run features : no_lambdas ]
|
||||
[ subdir-run features : no_lambdas_local_func ]
|
||||
;
|
||||
|
||||
test-suite n1962 :
|
||||
[ subdir-run n1962 : vector ]
|
||||
[ subdir-run n1962 : sqrt ]
|
||||
[ subdir-run n1962 : circle ]
|
||||
[ subdir-run n1962 : equal ]
|
||||
[ subdir-run n1962 : factorial ]
|
||||
[ subdir-run n1962 : sum ]
|
||||
;
|
||||
|
||||
test-suite meyer97 :
|
||||
[ subdir-run meyer97 : stack4_main ]
|
||||
[ subdir-run meyer97 : stack3 ]
|
||||
;
|
||||
|
||||
test-suite mitchell02 :
|
||||
[ subdir-run mitchell02 : stack ]
|
||||
[ subdir-run mitchell02 : simple_queue ]
|
||||
[ subdir-run mitchell02 : dictionary ]
|
||||
[ subdir-run mitchell02 : customer_manager ]
|
||||
[ subdir-run mitchell02 : name_list ]
|
||||
[ subdir-run mitchell02 : courier ]
|
||||
[ subdir-run mitchell02 : observer_main ]
|
||||
[ subdir-run mitchell02 : counter_main ]
|
||||
;
|
||||
|
||||
test-suite cline90 :
|
||||
[ subdir-run cline90 : stack ]
|
||||
[ subdir-run cline90 : vector_main ]
|
||||
[ subdir-run cline90 : vstack ]
|
||||
[ subdir-run cline90 : calendar ]
|
||||
;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user