File Manager - SEOINDICAXploit

Editing: old.hpp

#ifndef BOOST_CONTRACT_OLD_HPP_
#define BOOST_CONTRACT_OLD_HPP_

// Copyright (C) 2008-2018 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

/** @file
Handle old values.
*/

#include <boost/contract/core/config.hpp>
#include <boost/contract/core/virtual.hpp>
#ifndef BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION
 #include <boost/contract/detail/checking.hpp>
#endif
#include <boost/contract/detail/operator_safe_bool.hpp>
#include <boost/contract/detail/declspec.hpp>
#include <boost/contract/detail/debug.hpp>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/is_copy_constructible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/static_assert.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/config/config.hpp>
#include <queue>

#if !BOOST_PP_VARIADICS

#define BOOST_CONTRACT_OLDOF \
BOOST_CONTRACT_ERROR_macro_OLDOF_requires_variadic_macros_otherwise_manually_program_old_values

#else // variadics

#include <boost/preprocessor/facilities/overload.hpp>
#include <boost/preprocessor/facilities/empty.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/config.hpp>

/* PRIVATE */

/** @cond */

#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
 #define BOOST_CONTRACT_OLDOF_AUTO_TYPEOF_(value) /* nothing */
#else
 #include <boost/typeof/typeof.hpp>
 // Explicitly force old_ptr<...> conversion to allow for C++11 auto decl.
 #define BOOST_CONTRACT_OLDOF_AUTO_TYPEOF_(value) \
 boost::contract::old_ptr<BOOST_TYPEOF(value)>
#endif

#define BOOST_CONTRACT_ERROR_macro_OLDOF_has_invalid_number_of_arguments_2( \
        v, value) \
    BOOST_CONTRACT_OLDOF_AUTO_TYPEOF_(value)(boost::contract::make_old(v, \
        boost::contract::copy_old(v) ? (value) : boost::contract::null_old() \
    ))

#define BOOST_CONTRACT_ERROR_macro_OLDOF_has_invalid_number_of_arguments_1( \
        value) \
    BOOST_CONTRACT_OLDOF_AUTO_TYPEOF_(value)(boost::contract::make_old( \
        boost::contract::copy_old() ? (value) : boost::contract::null_old() \
    ))

/** @endcond */

/* PUBLIC */

// NOTE: Leave this #defined the same regardless of ..._NO_OLDS.
/**
Macro typically used to copy an old value expression and assign it to an old
value pointer.

The expression expanded by this macro should be assigned to an old value
pointer of type @RefClass{boost::contract::old_ptr} or
@RefClass{boost::contract::old_ptr_if_copyable}.
This is an overloaded variadic macro and it can be used in the following
different ways.

1\. From within virtual public functions and public functions overrides:

@code
BOOST_CONTRACT_OLDOF(v, old_expr)
@endcode

2\. From all other operations:

@code
BOOST_CONTRACT_OLDOF(old_expr)
@endcode

Where:

@arg <c>v</c> is the extra parameter of type
 @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0
 from the enclosing virtual public function or public function
 overrides declaring the contract.
@arg <c>old_expr</c> is the expression to be evaluated and copied into
 the old value pointer.
 (This is not a variadic macro parameter so any comma it might contain
 must be protected by round parenthesis and
 <c>BOOST_CONTRACT_OLDOF(v, (old_expr))</c> will always work.)

On compilers that do not support variadic macros, programmers can manually copy
old value expressions without using this macro (see
@RefSect{extras.no_macros__and_no_variadic_macros_, No Macros}).

@see @RefSect{tutorial.old_values, Old Values}
*/
#define BOOST_CONTRACT_OLDOF(...) \
    BOOST_PP_CAT( /* CAT(..., EMTPY()) required on MSVC */ \
        BOOST_PP_OVERLOAD( \
  BOOST_CONTRACT_ERROR_macro_OLDOF_has_invalid_number_of_arguments_, \
            __VA_ARGS__ \
        )(__VA_ARGS__), \
        BOOST_PP_EMPTY() \
    )

#endif // variadics

/* CODE */

namespace boost { namespace contract {

/**
Trait to check if an old value type can be copied or not.

By default, this unary boolean meta-function is equivalent to
@c boost::is_copy_constructible<T> but programmers can chose to specialize it
for user-defined types (in general some kind of specialization is also needed on
compilers that do not support C++11, see
<a href="http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/boost_typetraits/reference/is_copy_constructible.html">
<c>boost::is_copy_constructible</c></a>):

@code
class u; // Some user-defined type for which old values shall not be copied.

namespace boost { namespace contract {
 template<> // Specialization to not copy old values of type `u`.
 struct is_old_value_copyable : boost::false_type {};
} } // namespace
@endcode

A given old value type @c T is copied only if
@c boost::contract::is_old_value_copyable<T>::value is @c true.
A copyable old value type @c V is always copied using
@c boost::contract::old_value_copy<V>.
A non-copyable old value type @c W generates a compile-time error when
@c boost::contract::old_ptr<W> is dereferenced, but instead leaves
@c boost::contract::old_ptr_if_copyable<W> always null (without generating
compile-time errors).

@see @RefSect{extras.old_value_requirements__templates_,
 Old Value Requirements}
*/
template<typename T>
struct is_old_value_copyable : boost::is_copy_constructible<T> {};

/** @cond */
class old_value;

template<> // Needed because `old_value` incomplete type when trait first used.
struct is_old_value_copyable<old_value> : boost::true_type {};
/** @endcond */

/**
Trait to copy an old value.

By default, the implementation of this trait uses @c T's copy constructor to
make one single copy of the specified value.
However, programmers can specialize this trait to copy old values using
user-specific operations different from @c T's copy constructor.
The default implementation of this trait is equivalent to:

@code
template<typename T>
class old_value_copy {
public:
 explicit old_value_copy(T const& old) :
 old_(old) // One single copy of value using T's copy constructor.
 {}

T const& old() const { return old_; }

private:
    T const old_; // The old value copy.
};
@endcode

This library will instantiate and use this trait only on old value types @c T
that are copyable (i.e., for which
<c>boost::contract::is_old_value_copyable<T>::value</c> is @c true).

@see @RefSect{extras.old_value_requirements__templates_,
 Old Value Requirements}
*/
template<typename T> // Used only if is_old_value_copyable<T>.
struct old_value_copy {
 /**
 Construct this object by making one single copy of the specified old value.

This is the only operation within this library that actually copies old
    values.
    This ensures this library makes one and only one copy of an old value (if
    they actually need to be copied, see @RefMacro{BOOST_CONTRACT_NO_OLDS}).

@param old The old value to copy.
    */
    explicit old_value_copy(T const& old) :
            old_(old) {} // This makes the one single copy of T.

/**
    Return a (constant) reference to the old value that was copied.
    
    Contract assertions should not change the state of the program so the old
    value copy is returned as @c const (see
    @RefSect{contract_programming_overview.constant_correctness,
    Constant Correctness}).
    */
    T const& old() const { return old_; }

private:
    T const old_;
};

template<typename T>
class old_ptr_if_copyable;

/**
Old value pointer that requires the pointed old value type to be copyable.

This pointer can be set to point an actual old value copy using either
@RefMacro{BOOST_CONTRACT_OLDOF} or @RefFunc{boost::contract::make_old} (that is
why this class does not have public non-default constructors):

@code
class u {
public:
 virtual void f(..., boost::contract::virtual_* v = 0) {
 boost::contract::old_ptr<old_type> old_var = // For copyable `old_type`.
 BOOST_CONTRACT_OLDOF(v, old_expr);
 ...
 }

...
};
@endcode

@see @RefSect{tutorial.old_values, Old Values}

@tparam T Type of the pointed old value.
 This type must be copyable (i.e.,
 <c>boost::contract::is_old_value_copyable<T>::value</c> must be
 @c true), otherwise this pointer will always be null and this library
 will generate a compile-time error when the pointer is dereferenced.
*/
template<typename T>
class old_ptr { /* copyable (as *) */
public:
 /** Pointed old value type. */
 typedef T element_type;

/** Construct this old value pointer as null. */
    old_ptr() {}

/**
    Dereference this old value pointer.

This will generate a run-time error if this pointer is null and a
 compile-time error if the pointed type @c T is not copyable (i.e., if
 @c boost::contract::is_old_value_copyable<T>::value is @c false).
 
 @return The pointed old value.
 Contract assertions should not change the state of the program so
 this member function is @c const and it returns the old value as a
 reference to a constant object (see
 @RefSect{contract_programming_overview.constant_correctness,
 Constant Correctness}).
 */
 T const& operator*() const {
 BOOST_STATIC_ASSERT_MSG(
 boost::contract::is_old_value_copyable<T>::value,
 "old_ptr<T> requires T copyable (see is_old_value_copyable<T>), "
 "otherwise use old_ptr_if_copyable<T>"
 );
 BOOST_CONTRACT_DETAIL_DEBUG(typed_copy_);
 return typed_copy_->old();
 }

/**
    Structure-dereference this old value pointer.

This will generate a compile-time error if the pointed type @c T is not
 copyable (i.e., if @c boost::contract::is_old_value_copyable<T>::value is
 @c false).

@return A pointer to the old value (null if this old value pointer is null).
 Contract assertions should not change the state of the program so
 this member function is @c const and it returns the old value as a
 pointer to a constant object (see
 @RefSect{contract_programming_overview.constant_correctness,
 Constant Correctness}).
 */
 T const* operator->() const {
 BOOST_STATIC_ASSERT_MSG(
 boost::contract::is_old_value_copyable<T>::value,
 "old_ptr<T> requires T copyble (see is_old_value_copyable<T>), "
 "otherwise use old_ptr_if_copyable<T>"
 );
 if(typed_copy_) return &typed_copy_->old();
 return 0;
 }

#ifndef BOOST_CONTRACT_DETAIL_DOXYGEN
 BOOST_CONTRACT_DETAIL_OPERATOR_SAFE_BOOL(old_ptr<T>,
 !!typed_copy_)
 #else
 /**
 Query if this old value pointer is null or not (safe-bool operator).

(This is implemented using safe-bool emulation on compilers that do not
        support C++11 explicit type conversion operators.)

@return True if this pointer is not null, false otherwise.
        */
        explicit operator bool() const;
    #endif

/** @cond */
private:
 #ifndef BOOST_CONTRACT_NO_OLDS
 explicit old_ptr(boost::shared_ptr<old_value_copy<T> > old)
 : typed_copy_(old) {}
 #endif

boost::shared_ptr<old_value_copy<T> > typed_copy_;

friend class old_pointer;
 friend class old_ptr_if_copyable<T>;
/** @endcond */
};

/**
Old value pointer that does not require the pointed old value type to be
copyable.

This pointer can be set to point to an actual old value copy using either
@RefMacro{BOOST_CONTRACT_OLDOF} or @RefFunc{boost::contract::make_old}:

@code
template<typename T> // Type `T` might or not be copyable.
class u {
public:
 virtual void f(..., boost::contract::virtual_* v = 0) {
 boost::contract::old_ptr_if_copyable<T> old_var =
 BOOST_CONTRACT_OLDOF(v, old_expr);
 ...
 if(old_var) ... // Always null for non-copyable types.
 ...
 }

...
};
@endcode

@see    @RefSect{extras.old_value_requirements__templates_,
        Old Value Requirements}

@tparam T Type of the pointed old value.
 If this type is not copyable (i.e.,
 <c>boost::contract::is_old_value_copyable<T>::value</c> is @c false),
 this pointer will always be null (but this library will not generate a
 compile-time error when this pointer is dereferenced).
*/
template<typename T>
class old_ptr_if_copyable { /* copyable (as *) */
public:
 /** Pointed old value type. */
 typedef T element_type;

/** Construct this old value pointer as null. */
    old_ptr_if_copyable() {}

/**
    Construct this old value pointer from an old value pointer that requires
    the old value type to be copyable.
    
    Ownership of the pointed value object is transferred to this pointer.
    This constructor is implicitly called by this library when assigning an
    object of this type using @RefMacro{BOOST_CONTRACT_OLDOF} (this constructor
    is usually not explicitly called by user code).

@param other Old value pointer that requires the old value type to be
 copyable.
 */
 /* implicit */ old_ptr_if_copyable(old_ptr<T> const& other) :
 typed_copy_(other.typed_copy_) {}

/**
    Dereference this old value pointer.

This will generate a run-time error if this pointer is null, but no
 compile-time error is generated if the pointed type @c T is not copyable
 (i.e., if @c boost::contract::is_old_value_copyable<T>::value is @c false).
 
 @return The pointed old value.
 Contract assertions should not change the state of the program so
 this member function is @c const and it returns the old value as a
 reference to a constant object (see
 @RefSect{contract_programming_overview.constant_correctness,
 Constant Correctness}).
 */
 T const& operator*() const {
 BOOST_CONTRACT_DETAIL_DEBUG(typed_copy_);
 return typed_copy_->old();
 }

/**
    Structure-dereference this old value pointer.

This will return null but will not generate a compile-time error if the
 pointed type @c T is not copyable (i.e., if
 @c boost::contract::is_old_value_copyable<T>::value is @c false).

#ifndef BOOST_CONTRACT_DETAIL_DOXYGEN
 BOOST_CONTRACT_DETAIL_OPERATOR_SAFE_BOOL(old_ptr_if_copyable<T>,
 !!typed_copy_)
 #else
 /**
 Query if this old value pointer is null or not (safe-bool operator).

(This is implemented using safe-bool emulation on compilers that do not
        support C++11 explicit type conversion operators.)

@return True if this pointer is not null, false otherwise.
        */
        explicit operator bool() const;
    #endif

/** @cond */
private:
 #ifndef BOOST_CONTRACT_NO_OLDS
 explicit old_ptr_if_copyable(boost::shared_ptr<old_value_copy<T> > old)
 : typed_copy_(old) {}
 #endif

boost::shared_ptr<old_value_copy<T> > typed_copy_;

friend class old_pointer;
/** @endcond */
};

/**
Convert user-specified expressions to old values.

This class is usually only implicitly used by this library and it does not
explicitly appear in user code.

On older compilers that cannot correctly deduce the
@c boost::contract::is_old_value_copyable trait used in the declaration of this
class, programmers can manually specialize that trait to make sure that only old
value types that are copyable are actually copied.

@see    @RefSect{extras.old_value_requirements__templates_,
        Old Value Requirements}
*/
class old_value { // Copyable (as *). 
public:
    // Following implicitly called by ternary operator `... ? ... : null_old()`.

/**
    Construct this object from the specified old value when the old value type
    is copy constructible.

The specified old value @c old is copied (one time only) using
    @c boost::contract::old_value_copy, in which case the related old value
    pointer will not be null (but no copy is made if postconditions and
    exception  guarantees are not being checked, see
    @RefMacro{BOOST_CONTRACT_NO_OLDS}).

@param old Old value to be copied.

@tparam T Old value type.
 */
 template<typename T>
 /* implicit */ old_value(
 T const&
 #if !defined(BOOST_CONTRACT_NO_OLDS) || \
 defined(BOOST_CONTRACT_DETAIL_DOXYGEN)
 old
 #endif // Else, no name (avoid unused param warning).
 ,
 typename boost::enable_if<boost::contract::is_old_value_copyable<T>
 >::type* = 0
 )
 #ifndef BOOST_CONTRACT_NO_OLDS
 : untyped_copy_(new old_value_copy<T>(old))
 #endif // Else, leave ptr_ null (thus no copy of T).
 {}
 
 /**
 Construct this object from the specified old value when the old value type
 is not copyable.

The specified old value @c old cannot be copied in this case so it is not
 copied and the related old value pointer will always be null (thus calls to
 this constructor have no effect and they will likely be optimized away by
 most compilers).
 
 @param old Old value (that will not be copied in this case).
 
 @tparam T Old value type.
 */
 template<typename T>
 /* implicit */ old_value(
 T const&
 #ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
 old
 #endif // Else, no name (avoid unused param warning).
 ,
 typename boost::disable_if<boost::contract::is_old_value_copyable<T>
 >::type* = 0
 ) {} // Leave ptr_ null (thus no copy of T).

/** @cond */
private:
 explicit old_value() {}
 
 #ifndef BOOST_CONTRACT_NO_OLDS
 boost::shared_ptr<void> untyped_copy_; // Type erasure.
 #endif

friend class old_pointer;
    friend BOOST_CONTRACT_DETAIL_DECLSPEC old_value null_old();
/** @endcond */
};

/**
Convert old value copies into old value pointers.

This class is usually only implicitly used by this library and it does not
explicitly appear in user code (that is why this class does not have public
constructors, etc.).
*/
class old_pointer { // Copyable (as *).
public:
    /**
    Convert this object to an actual old value pointer for which the old value
    type @c T might or not be copyable.

For example, this is implicitly called when assigning or initializing old
 value pointers of type @c boost::contract::old_ptr_if_copyable.
 
 @tparam T Type of the pointed old value.
 The old value pointer will always be null if this type is not
 copyable (see
 @c boost::contract::is_old_value_copyable), but this library
 will not generate a compile-time error.
 */
 template<typename T>
 /* implicit */ operator old_ptr_if_copyable<T>() {
 return get<old_ptr_if_copyable<T> >();
 }
 
 /**
 Convert this object to an actual old value pointer for which the old value
 type @c T must be copyable.

For example, this is implicitly called when assigning or initializing old
 value pointers of type @c boost::contract::old_ptr.
 
 @tparam T Type of the pointed old value. This type must be copyable
 (see @c boost::contract::is_old_value_copyable),
 otherwise this library will generate a compile-time error when
 the old value pointer is dereferenced.
 */
 template<typename T>
 /* implicit */ operator old_ptr<T>() {
 return get<old_ptr<T> >();
 }

/** @cond */
private:
 #ifndef BOOST_CONTRACT_NO_OLDS
 explicit old_pointer(virtual_* v, old_value const& old)
 : v_(v), untyped_copy_(old.untyped_copy_) {}
 #else
 explicit old_pointer(virtual_* /* v */, old_value const& /* old */) {}
 #endif
 
 template<typename Ptr>
 Ptr get() {
 #ifndef BOOST_CONTRACT_NO_OLDS
 if(!boost::contract::is_old_value_copyable<typename
 Ptr::element_type>::value) {
 BOOST_CONTRACT_DETAIL_DEBUG(!untyped_copy_);
 return Ptr(); // Non-copyable so no old value and return null.
 #ifndef BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION
 } else if(!v_ && boost::contract::detail::checking::already()) {
 return Ptr(); // Not checking (so return null).
 #endif
 } else if(!v_) {
 BOOST_CONTRACT_DETAIL_DEBUG(untyped_copy_);
 typedef old_value_copy<typename Ptr::element_type> copied_type;
 boost::shared_ptr<copied_type> typed_copy = // Un-erase type.
 boost::static_pointer_cast<copied_type>(untyped_copy_);
 BOOST_CONTRACT_DETAIL_DEBUG(typed_copy);
 return Ptr(typed_copy);
 } else if(
 v_->action_ == boost::contract::virtual_::push_old_init_copy ||
 v_->action_ == boost::contract::virtual_::push_old_ftor_copy
 ) {
 BOOST_CONTRACT_DETAIL_DEBUG(untyped_copy_);
 std::queue<boost::shared_ptr<void> >& copies = v_->action_ ==
 boost::contract::virtual_::push_old_ftor_copy ?
 v_->old_ftor_copies_
 :
 v_->old_init_copies_
 ;
 copies.push(untyped_copy_);
 return Ptr(); // Pushed (so return null).
 } else if(
 boost::contract::virtual_::pop_old_init_copy(v_->action_) ||
 v_->action_ == boost::contract::virtual_::pop_old_ftor_copy
 ) {
 // Copy not null, but still pop it from the queue.
 BOOST_CONTRACT_DETAIL_DEBUG(!untyped_copy_);

std::queue<boost::shared_ptr<void> >& copies = v_->action_ ==
 boost::contract::virtual_::pop_old_ftor_copy ?
 v_->old_ftor_copies_
 :
 v_->old_init_copies_
 ;
 boost::shared_ptr<void> untyped_copy = copies.front();
 BOOST_CONTRACT_DETAIL_DEBUG(untyped_copy);
 copies.pop();

typedef old_value_copy<typename Ptr::element_type> copied_type;
 boost::shared_ptr<copied_type> typed_copy = // Un-erase type.
 boost::static_pointer_cast<copied_type>(untyped_copy);
 BOOST_CONTRACT_DETAIL_DEBUG(typed_copy);
 return Ptr(typed_copy);
 }
 BOOST_CONTRACT_DETAIL_DEBUG(!untyped_copy_);
 #endif
 return Ptr();
 }

#ifndef BOOST_CONTRACT_NO_OLDS
 virtual_* v_;
 boost::shared_ptr<void> untyped_copy_; // Type erasure.
 #endif
 
 friend BOOST_CONTRACT_DETAIL_DECLSPEC
 old_pointer make_old(old_value const&);

friend BOOST_CONTRACT_DETAIL_DECLSPEC
    old_pointer make_old(virtual_*, old_value const&);
/** @endcond */
};

/**
Return a "null" old value.

The related old value pointer will also be null.
This function is usually only called by the code expanded by
@RefMacro{BOOST_CONTRACT_OLDOF}.