iterator resolve(
    const query & q);

iterator resolve(
    const query & q,
    boost::system::error_code & ec);

// Дано:
result api::f1(); // все nothrow
result api::f2();
result api::f3();

// использование

checked_result r(error_code1 | error_code2);  
r = api::f1();
r = api::f2();
r = api::f3();

remove_file remove(std::nothrow); // любые ошибки игнорируются
std::for_each(v.begin(), v.end(), remove);

//...

// not_found трансформируется в исключение, 
// остальные ошибки просто возвращаются.
remove_file remove(not_found);

result r = remove(filename); 
if(r == access_denied)
{
  //...
}

/// \pre x > 10, p != NULL
ЮЖ>void f(int x, int* p)
ЮЖ>{
ЮЖ>  assert(x > 10);
ЮЖ>  assert(p);

ЮЖ>  if(x > 10)
ЮЖ>   throw std::invalid_argument("f::x"); // В клинических случаях добавляется запись в лог, etc.
ЮЖ>                                        // Тип исключения в принципе не так важен, но это по  
ЮЖ>                                        // сути логическая ошибка (std::logic_error).
ЮЖ>                                        // Иногда можно увидеть std::runtime_error - но это уже похоже на саботаж

ЮЖ>  if(!p)
ЮЖ>   throw std::invalid_argument("f::p");

ЮЖ>  //...
ЮЖ>}

namespace Impl
{
    void throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line);
}

#define CHECK_PRECONDITION(expr) \
    (assert(expr), (expr) ? void() : Impl::throw_precondition_error(#expr, __FILE__, __LINE__))
    
class PreconditionError : public std::exception
{
public:
    virtual char const *what() const throw()
        { return "Precondition error detected"; }
    char const *condition() const
        { return m_condition; }
    char const *file() const
        { return m_file; }
    long line() const
        { return m_line; }
    ~PreconditionError() throw() {}
private:
    PreconditionError(char const *condition, char const *file, long line) :
        m_condition(condition),
        m_file(file),
        m_line(line)
    {}

    char const *m_condition;
    char const *m_file;
    long m_line;
    
    friend void Impl::throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line);
};

namespace Impl
{
    void throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line)
    {
        throw PreconditionError(string_literal_condition, string_literal_file, line);
    }
}

/// \pre x > 10, p != NULL
void f(int x, int* p)
{
  CHECK_PRECONDITION(x > 10);
  CHECK_PRECONDITION(p);
  //...
}

int func(int param, std::error_code& ec = throws())

//  Интерфейс для скармливания исключений принимающей стороне.
class IExceptionsTransmitter {
public:
    struct IExceptionHolder {
        virtual ~IExceptionHolder() {}
        virtual std::exception& Get() = 0; 
        virtual void ThrowIt() = 0;
        virtual IExceptionHolder* Clone() const = 0;
    };
    
    template<typename TException>
    void operator = ( const TException& e ) const
    {
        TransmitException( exceptionHolder<TException>( e ) );
    }

protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const = 0;

private:
    template<typename TException> struct exceptionHolder : IExceptionHolder {
        TException Data;
        virtual TException& Get() { return Data; }
        virtual void ThrowIt() { throw Data; }
        virtual IExceptionHolder* Clone() const { return new IExceptionHolder( *this ); }
    };
};

class ExceptionsTransmitter : public IExceptionsTransmitter {
public:
    mutable std::vector<shared_ptr<IExceptionHolder> > TransmittedExceptions;
protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const 
        { TransmittedExceptions.push_back( holder.Clone() ); }
};

class ExceptionsThrower : public IExceptionsTransmitter {
protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const { holder.ThrowIt(); }
};

inline ExceptionsThrower throws() { return ExceptionsThrower(); }

int func(int param, const IExceptionsTransmitter& et = throws())
{
  if(param == invalid_param_value){
    et = std::invalid_argument("param");
    return EINVAL;
  }
    // ... do the work
}

If ......, calls setstate(failbit), which may throw ios_base::failure (27.4.4.3).

iostate exceptions() const;
void exceptions(iostate except);

A mask that determines what elements set in rdstate() cause exceptions to be thrown.

/// \pre x > 10, p != NULL
void f(int x, int* p)
{
  assert(x > 10);
  assert(p);

  if(x > 10)
   throw std::invalid_argument("f::x"); // В клинических случаях добавляется запись в лог, etc.
                                        // Тип исключения в принципе не так важен, но это по  
                                        // сути логическая ошибка (std::logic_error).
                                        // Иногда можно увидеть std::runtime_error - но это уже похоже на саботаж

  if(!p)
   throw std::invalid_argument("f::p");

  //...
}

/// \pre arg > 0
void f(int arg);

/// \pre arg none
void my_main(int arg)
{
  // Я хочу вызвать функцию 'f'...

  if(arg <= 0) // <- Несоответстиве(*) предусловий для my_main#arg и f#arg - сигнал о необходимости проверки.
  {
    // Вот тут доступен весь контекст. Нужно в лог - пишем в лог...
    // + Не нужно протаскивать никакие данные через исключения.
    log_error(arg);
    return;
  }

  // Я обеспечил выполнение предусловий - выполнил свою сторону контракта.
  f(arg); 
}

// * Буквальное несоответстиве не всегда приводит к проверке

Q>>boost::bind(&f, boost::ref(boost::system::throws));

Q>>boost::system::error_code error;
Q>>boost::bind(&f, boost::ref(error));
Q>>

boost::function<void ()> const func(boost::bind(&f, boost::ref(boost::system::throws)));

boost::function<void ()> const func(boost::bind((void (*)())&f));

IRO>А что делать если f1 возвращает значение? делать через out параметры? не всегда удобно/красиво

result r;
value v = api::f(.., &r);
if(r == X)
  throw exception(r);

//...

value v = api::f(...);
if(v == Y)
  throw exception(get_last_error());

// для первого случая
result r;
value v = api::f(.., &r);
ensure(r, r == X);

//...
result r;
value v = api::f(.., &f);
ENSURE(r == X);           // макрос для избавления от первого аргумента

// для второго
value v = api::f(...);
ensure(v == Y);

//...
value v = ensure_not_Y(api::f(...));

//...
value v = api::f(...), THROW_IF(v == Y); // макрос

void f(error_code& ec=throws());

IRO>>>А что делать если f1 возвращает значение? делать через out параметры? не всегда удобно/красиво

result r = api::f1(...);
if(r == error_code1)
  throw exception(...);

r = api::f2(...);
if(r == error_code1)
  throw exception(...);
 
r = api::f3(...);
if(r == error_code1)
  throw exception(...);

checked_result r(error_code1);  
r = api::f1();
r = api::f2();
r = api::f3();

        void lock()
        {
            if(owns_lock())
            {
                throw boost::lock_error();
            }
            m->lock();
            is_locked=true;
        }

for(...)
{
  if(boost:optional<file> f = open_file(...))
    process_file(*f);
}

//...
void process_file(file& f)
{
  try
  {
    // read/write
    // some action
    // ...
  }
  catch(const runtime_error& ex)
  {    
    handle_exception(ex);
  }
}

AS>        void lock()
AS>        {
AS>            if(owns_lock())
AS>            {
AS>                throw boost::lock_error();
AS>            }
            m->>lock();
AS>            is_locked=true;
AS>        }
AS>

AS>Правомерно ли тут использование именно исключения, а не ассерта? На самом деле, вопрос интересный. С одной стороны, ситуация похожа на то, что мы видели ранее со стримом. С другой стороны, ситуация _кардинально_ отличается. В случае со стримом кейс, где идет работа далее с невалидным объектом — основной сценарий использования. Тут же — дополнительный (например, из-за ошибки пытаемся залочить рекурсивно). Разница в том, что в одном случае это отлавливается сразу же, и не приводит к фатальному изменению состояния объекта (ну или не должна приводить). Тут же — приводит, очевидным образом, сделав 2 раза лок (первый раз неявно, в конструкторе), сделать 2 раза анлок мы уже не сможем, по вполне очевидным причинам

Lockable Concept

The Lockable concept models exclusive ownership. A type that implements the Lockable concept shall provide the following member functions:

void lock();
bool try_lock();
void unlock();

void lock()

Effects:
The current thread blocks until ownership can be obtained for the current thread.

Postcondition:
The current thread owns *this.

Throws:
boost::thread_resource_error if an error occurs.

Specializations of boost::unique_lock model the TimedLockable concept if the supplied Lockable type itself models TimedLockable concept (e.g. boost::unique_lock<boost::timed_mutex>), or the Lockable concept otherwise.

Q>>Нельзя невольно проигнорировать ошибку, исключает необходимость дублирования интерфейса

J>И исключает возможность привязки по указателю на функцию

boost::bind(&f, boost::ref(boost::system::throws));

boost::system::error_code error;
boost::bind(&f, boost::ref(error));

Q>Тут тоже интересный момент, в ином случае, когда их две :

Q>boost::function<void ()> const func(boost::bind((void (*)())&f));
Q>

typedef void (*VoidFunc)();
VoidFunc p_func = &f;

struct A
{
  /// \pre a > 0
  virtual void f(int a) = 0;
};

struct B : A
{
  /// \pre a > 100 
  void f(int a);
};

struct A
ЮЖ>>{
ЮЖ>>  /// \pre a > 0
ЮЖ>>  virtual void f(int a) = 0;
ЮЖ>>};

ЮЖ>>struct B : A
ЮЖ>>{
ЮЖ>>  /// \pre a > 100 
ЮЖ>>  void f(int a);
ЮЖ>>};

non-member function lock:

template<typename ForwardIterator>
void lock(ForwardIterator begin,ForwardIterator end);

Preconditions:
The value_type of ForwardIterator must implement the Lockable concept

/// \pre ???
template<class Lockable>
void f(Lockable& arg);

Liskov's notion of a behavioral subtype defines a notion of substitutability for mutable objects; that is, if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program (e.g., correctness).

Specializations of boost::unique_lock model the TimedLockable concept if the supplied Lockable type itself models TimedLockable concept (e.g. boost::unique_lock<boost::timed_mutex>), or the Lockable concept otherwise

boost::recursive_mutex implements the Lockable concept

unsigned int x(unsigned int a, unsigned int b)
{
  return a + b;
}

НИ>/// \pre ???
НИ>template<class Lockable>
НИ>void f(Lockable& arg);

НИ>Данная функция, помимо принадлежности arg к Lockable, должна описывать характер использования arg (впрочем, тогда в ряде случаев можно вообще обойтись без упоминания о Lockable ). Исходя из этого описания пользователь функции должен сделать выводы о том, соблюдаются предусловия для его случая или нет.

30.4.1/12 (mutext::lock)
Error conditions:
...
— resource_deadlock_would_occur — if the current thread already owns the mutex and is able
to detect it.

30.4.3.2.2/4 (unique_lock::lock)
Error conditions:
...
— resource_deadlock_would_occur — if the current thread already owns the mutex (i.e., on entry,
owns is true).

НИ>>/// \pre ???
НИ>>template<class Lockable>
НИ>>void f(Lockable& arg);

НИ>>Данная функция, помимо принадлежности arg к Lockable, должна описывать характер использования arg (впрочем, тогда в ряде случаев можно вообще обойтись без упоминания о Lockable ). Исходя из этого описания пользователь функции должен сделать выводы о том, соблюдаются предусловия для его случая или нет.

explicit unique_lock(mutex_type& m);
Precondition: If mutex_type is not a recursive mutex the calling thread does not own the mutex.

The behavior of a program is undefined if:
[...]
— a thread that owns a mutex object calls lock() or try_lock() on that object

17.6.3.11/1:
Violation of the preconditions specified in a function’s Required behavior: paragraph results in undefined
behavior unless the function’s Throws: paragraph specifies throwing an exception when the precondition is
violated.

basic_string(const basic_string<charT,traits,Allocator>& str,
             size_type pos, size_type n = npos,
             const Allocator& a = Allocator());

Requires: pos <= str.size()
Throws: out_of_range if pos > str.size().

int func(int param, std::error_code& ec = throws())
{
  if(param == invalid_param_value){
    if(&ec == &throws())
      throw std::invalid_argument("param");
     else
            return EINVAL;
        }
    }
    // ... do the work
}

static const std::error_code* const _g_ec_throws = nullptr;

inline std::error_code& throws() { return *_g_ec_throws; }

//  пусть где-то в хедере библиотеки объявлено:
//  void LibFunc( T1 arg1, T2 arg2, T3 arg3, LIB_RESULT& funcRes );
//  Дальше пишем в своём хедере так:
    extern LIB_RESULT libResult;
    void LibFunc( T1 arg1, T2 arg2, T3 arg3, LIB_RESULT& funcRes = libResult );
void

    inline LIB_RESULT LibFunc( T1 arg1, T2 arg2, T3 arg3 )
    {
        LIB_RESULT funcRes = 0;
        LibFunc( arg1, arg2, arg3, funcRes );
        return funcRes;
    }

typedef bool (*ShouldThrowIt_t)( const std::exception* e );
extern ShouldThrowIt_t ShouldThrowItCallback; // = 0;

template<typename T>
void throwIfShould( const T& e ) 
{
    if( ShouldThrowItCallback == 0 || ShouldThrowItCallback( &e ) ) {
        throw e;
    }
}

asin(-2)

char x = 0xFF;
x *= 2;