|
|
Contract-violation information | ||||
contract_violation (C++26) | ||||
(C++26) | ||||
(C++26) | ||||
(C++26) | ||||
Helper functions | ||||
Defined in header <contracts> | ||
class contract_violation; | (since C++26) | |
The classstd::contracts::contract_violation
defines the type of objects used to represent a contract violation that has been detected during the evaluation of acontract assertion with a particular evaluation semantic.
Objects of this type can only be created by the implementation when thecontract-violation handler needs to be invoked. Users cannot create such objects directly.
(constructor) [deleted] | contract_violation objects cannot be constructed by users(public member function) |
operator= [deleted] | contract_violation objects cannot be assigned(public member function) |
(destructor) [possibly virtual] | destructs thecontract_violation object(public member function) |
General contract-violation information | |
kind | returns the kind of the contract assertion violated (public member function) |
semantic | returns the evaluation semantic when the contract violation occurs (public member function) |
is_terminating | returns whether the evaluation semantic is terminating (public member function) |
detection_mode | returns the reason that causes the contract violation (public member function) |
evaluation_exception | returns anstd::exception_ptr to the exception thrown from the predicate evaulation (public member function) |
Miscellaneous contract-violation information | |
comment | returns the explanatory string about the contract violation (public member function) |
location | returns astd::source_location indicating the location of the contract violation (public member function) |
contract_violation(const contract_violation&)= delete; | (since C++26) | |
The copy destructor is defined as deleted.std::contracts::contract_violation
is notCopyConstructible.
Other constructors are for internal usage only, they are not user-accessible.
contract_violation& operator=(const contract_violation&)= delete; | (since C++26) | |
The copy assignment operator is defined as deleted.std::contracts::contract_violation
is notCopyAssignable.
/* see below */ ~contract_violation(); | (since C++26) | |
Destructs thecontract_violation
object.
It is implementation-defined whether the destructor is virtual.
std::contracts::assertion_kind kind()constnoexcept; | (since C++26) | |
Returns the enumerator value corresponding to the syntactic form of the violated contract assertion.
std::contracts::evaluation_semantic semantic()constnoexcept; | (since C++26) | |
Returns the enumerator value corresponding to the evaluation semantic with which the violated contract assertion was evaluated.
bool is_terminating()constnoexcept; | (since C++26) | |
If the evaluation semantic is aterminating semantic, returnstrue. Otherwise returnsfalse.
std::contracts::detection_mode detection_mode()constnoexcept; | (since C++26) | |
Returns the enumerator value corresponding to the reasons that cause the contract violation.
std::exception_ptr evaluation_exception()constnoexcept; | (since C++26) | |
If the contract violation occurred because the evaluation of the predicate exited via an exception, returns anstd::exception_ptr object that refers to that exception or a copy of that exception. Otherwise, returns a nullstd::exception_ptr object.
constchar* comment()constnoexcept; | (since C++26) | |
Returns an implementation-definednull-terminated multibyte string in theordinary literal encoding.
The C++ standard recommends that the string returned should contain a textual representation of the predicate of the violated contract assertion or an empty string if storing a textual representation is undesired.
std::source_location location()constnoexcept; | (since C++26) | |
Returns astd::source_location object with implementation-defined value.
The C++ standard recommends that the value returned should be a default constructedstd::source_location object or a value identifying the violated contract assertion: