text:
/*!
 * \file   atomic/detail/atomic_template.hpp
 *
 * This header contains interface definition of \c atomic template.
 */

#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_

#include <cstddef>
#include <boost/cstdint.hpp>
#include <boost/assert.hpp>
#include <boost/atomic/detail/config.hpp>
#include <boost/atomic/detail/storage_type.hpp>
#include <boost/atomic/detail/bitwise_cast.hpp>
#include <boost/atomic/detail/integral_extend.hpp>
#include <boost/atomic/detail/operations_fwd.hpp>
#include <boost/atomic/detail/extra_operations_fwd.hpp>
#include <boost/atomic/detail/type_traits/is_signed.hpp>
#include <boost/atomic/detail/type_traits/is_integral.hpp>
#include <boost/atomic/detail/type_traits/is_function.hpp>
#include <boost/atomic/detail/type_traits/is_floating_point.hpp>
#include <boost/atomic/detail/type_traits/is_trivially_default_constructible.hpp>
#include <boost/atomic/detail/type_traits/conditional.hpp>
#include <boost/atomic/detail/type_traits/integral_constant.hpp>
#if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
#include <boost/atomic/detail/bitwise_fp_cast.hpp>
#include <boost/atomic/detail/fp_operations_fwd.hpp>
#include <boost/atomic/detail/extra_fp_operations_fwd.hpp>
#endif

#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif

#if defined(BOOST_MSVC)
#pragma warning(push)
// 'boost::atomics::atomic<T>' : multiple assignment operators specified
#pragma warning(disable: 4522)
#endif

/*
 * IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE,
 *                      see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp.
 */

namespace boost {
namespace atomics {
namespace detail {

BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memory_order order) BOOST_NOEXCEPT
{
    return order == memory_order_acq_rel ? memory_order_acquire : (order == memory_order_release ? memory_order_relaxed : order);
}

BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
{
    // 15 == (memory_order_seq_cst | memory_order_consume), see memory_order.hpp
    // Given the enum values we can test the strength of memory order requirements with this single condition.
    return (static_cast< unsigned int >(failure_order) & 15u) <= (static_cast< unsigned int >(success_order) & 15u);
}

template< typename T, bool IsFunction = atomics::detail::is_function< T >::value >
struct classify_pointer
{
    typedef void* type;
};

template< typename T >
struct classify_pointer< T, true >
{
    typedef void type;
};

template< typename T, bool IsInt = atomics::detail::is_integral< T >::value, bool IsFloat = atomics::detail::is_floating_point< T >::value >
struct classify
{
    typedef void type;
};

template< typename T >
struct classify< T, true, false > { typedef int type; };

#if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
template< typename T >
struct classify< T, false, true > { typedef float type; };
#endif

template< typename T >
struct classify< T*, false, false > { typedef typename classify_pointer< T >::type type; };

template< >
struct classify< void*, false, false > { typedef void type; };

template< >
struct classify< const void*, false, false > { typedef void type; };

template< >
struct classify< volatile void*, false, false > { typedef void type; };

template< >
struct classify< const volatile void*, false, false > { typedef void type; };

template< typename T, typename U >
struct classify< T U::*, false, false > { typedef void type; };

#if defined(BOOST_INTEL) || (defined(BOOST_GCC) && (BOOST_GCC+0) < 40700) ||\
    (defined(BOOST_CLANG) && !defined(__apple_build_version__) && ((__clang_major__+0) * 100 + (__clang_minor__+0)) < 302) ||\
    (defined(__clang__) && defined(__apple_build_version__) && ((__clang_major__+0) * 100 + (__clang_minor__+0)) < 402)
// Intel compiler (at least 18.0 update 1) breaks if noexcept specification is used in defaulted function declarations:
// error: the default constructor of "boost::atomics::atomic<T>" cannot be referenced -- it is a deleted function
// GCC 4.6 doesn't seem to support that either. Clang 3.1 deduces wrong noexcept for the defaulted function and fails as well.
#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL
#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL BOOST_NOEXCEPT
#else
#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL BOOST_NOEXCEPT
#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL
#endif

template< typename T, bool IsTriviallyDefaultConstructible = atomics::detail::is_trivially_default_constructible< T >::value >
class base_atomic_generic;

template< typename T >
class base_atomic_generic< T, true >
{
public:
    typedef T value_type;

protected:
    typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
    typedef typename atomics::detail::conditional< sizeof(value_type) <= sizeof(void*), value_type, value_type const& >::type value_arg_type;

public:
    typedef typename operations::storage_type storage_type;

protected:
    typename operations::aligned_storage_type m_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic_generic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE explicit base_atomic_generic(value_arg_type v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v))
    {
    }
};

template< typename T >
class base_atomic_generic< T, false >
{
public:
    typedef T value_type;

protected:
    typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
    typedef typename atomics::detail::conditional< sizeof(value_type) <= sizeof(void*), value_type, value_type const& >::type value_arg_type;

public:
    typedef typename operations::storage_type storage_type;

protected:
    typename operations::aligned_storage_type m_storage;

public:
    BOOST_FORCEINLINE explicit base_atomic_generic(value_arg_type v = value_type()) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v))
    {
    }
};

template< typename T, typename Kind >
class base_atomic;

//! General template. Implementation for user-defined types, such as structs and enums, and pointers to non-object types
template< typename T >
class base_atomic< T, void > :
    public base_atomic_generic< T >
{
private:
    typedef base_atomic_generic< T > base_type;

public:
    typedef typename base_type::value_type value_type;
    typedef typename base_type::storage_type storage_type;

protected:
    typedef typename base_type::operations operations;
    typedef typename base_type::value_arg_type value_arg_type;

private:
    typedef atomics::detail::integral_constant< bool, sizeof(value_type) == sizeof(storage_type) > value_matches_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v)
    {
    }

    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_consume);
        BOOST_ASSERT(order != memory_order_acquire);
        BOOST_ASSERT(order != memory_order_acq_rel);

        operations::store(this->m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order);
    }

    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_release);
        BOOST_ASSERT(order != memory_order_acq_rel);

        return atomics::detail::bitwise_cast< value_type >(operations::load(this->m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(operations::exchange(this->m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order));
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))

private:
    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_strong(this->m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_strong(this->m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_cast< value_type >(old_value);
        return res;
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_weak(this->m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_weak(this->m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_cast< value_type >(old_value);
        return res;
    }
};

//! Implementation for integers
template< typename T >
class base_atomic< T, int >
{
public:
    typedef T value_type;
    typedef T difference_type;

protected:
    typedef atomics::detail::operations< storage_size_of< value_type >::value, atomics::detail::is_signed< T >::value > operations;
    typedef atomics::detail::extra_operations< operations, operations::storage_size, operations::is_signed > extra_operations;
    typedef value_type value_arg_type;

public:
    typedef typename operations::storage_type storage_type;

private:
    typedef atomics::detail::integral_constant< bool, sizeof(value_type) == sizeof(storage_type) > value_matches_storage;

protected:
    typename operations::aligned_storage_type m_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE BOOST_CONSTEXPR explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : m_storage(v) {}

    // Standard methods
    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_consume);
        BOOST_ASSERT(order != memory_order_acquire);
        BOOST_ASSERT(order != memory_order_acq_rel);

        operations::store(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_release);
        BOOST_ASSERT(order != memory_order_acq_rel);

        return atomics::detail::integral_truncate< value_type >(operations::load(m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::fetch_add(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::fetch_sub(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::exchange(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE value_type fetch_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::fetch_and(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type fetch_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::fetch_or(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type fetch_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(operations::fetch_xor(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    // Boost.Atomic extensions
    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::fetch_negate(m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type fetch_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::fetch_complement(m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::add(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::sub(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::negate(m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type bitwise_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_and(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type bitwise_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_or(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type bitwise_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_xor(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order));
    }

    BOOST_FORCEINLINE value_type bitwise_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_complement(m_storage.value, order));
    }

    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_add(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_sub(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_negate(m_storage.value, order);
    }

    BOOST_FORCEINLINE void opaque_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_and(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE void opaque_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_or(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE void opaque_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_xor(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE void opaque_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_complement(m_storage.value, order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::add_and_test(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::sub_and_test(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE bool negate_and_test(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::negate_and_test(m_storage.value, order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool and_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::and_and_test(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool or_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::or_and_test(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool xor_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::xor_and_test(m_storage.value, atomics::detail::integral_extend< operations::is_signed, storage_type >(v), order);
    }

    BOOST_FORCEINLINE bool complement_and_test(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::complement_and_test(m_storage.value, order);
    }

    BOOST_FORCEINLINE bool bit_test_and_set(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
        return extra_operations::bit_test_and_set(m_storage.value, bit_number, order);
    }

    BOOST_FORCEINLINE bool bit_test_and_reset(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
        return extra_operations::bit_test_and_reset(m_storage.value, bit_number, order);
    }

    BOOST_FORCEINLINE bool bit_test_and_complement(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
        return extra_operations::bit_test_and_complement(m_storage.value, bit_number, order);
    }

    // Operators
    BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
    {
        return fetch_add(1);
    }

    BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
    {
        return add(1);
    }

    BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
    {
        return fetch_sub(1);
    }

    BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
    {
        return sub(1);
    }

    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return add(v);
    }

    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return sub(v);
    }

    BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOEXCEPT
    {
        return bitwise_and(v);
    }

    BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOEXCEPT
    {
        return bitwise_or(v);
    }

    BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOEXCEPT
    {
        return bitwise_xor(v);
    }

    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))

private:
    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::integral_extend< operations::is_signed, storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::integral_extend< operations::is_signed, storage_type >(expected);
        const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::integral_extend< operations::is_signed, storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::integral_truncate< value_type >(old_value);
        return res;
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::integral_extend< operations::is_signed, storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::integral_extend< operations::is_signed, storage_type >(expected);
        const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::integral_extend< operations::is_signed, storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::integral_truncate< value_type >(old_value);
        return res;
    }
};

//! Implementation for bool
template< >
class base_atomic< bool, int >
{
public:
    typedef bool value_type;

protected:
    typedef atomics::detail::operations< 1u, false > operations;
    typedef value_type value_arg_type;

public:
    typedef operations::storage_type storage_type;

private:
    typedef atomics::detail::integral_constant< bool, sizeof(value_type) == sizeof(storage_type) > value_matches_storage;

protected:
    operations::aligned_storage_type m_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE BOOST_CONSTEXPR explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : m_storage(v) {}

    // Standard methods
    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_consume);
        BOOST_ASSERT(order != memory_order_acquire);
        BOOST_ASSERT(order != memory_order_acq_rel);

        operations::store(m_storage.value, static_cast< storage_type >(v), order);
    }

    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_release);
        BOOST_ASSERT(order != memory_order_acq_rel);

        return !!operations::load(m_storage.value, order);
    }

    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return !!operations::exchange(m_storage.value, static_cast< storage_type >(v), order);
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))

private:
    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = static_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_strong(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
        expected = !!old_value;
        return res;
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = static_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_weak(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
        expected = !!old_value;
        return res;
    }
};

#if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)

//! Implementation for floating point types
template< typename T >
class base_atomic< T, float >
{
public:
    typedef T value_type;
    typedef T difference_type;

protected:
    typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
    typedef atomics::detail::extra_operations< operations, operations::storage_size, operations::is_signed > extra_operations;
    typedef atomics::detail::fp_operations< extra_operations, value_type, operations::storage_size > fp_operations;
    typedef atomics::detail::extra_fp_operations< fp_operations, value_type, operations::storage_size > extra_fp_operations;
    typedef value_type value_arg_type;

public:
    typedef typename operations::storage_type storage_type;

private:
    typedef atomics::detail::integral_constant< bool, atomics::detail::value_sizeof< value_type >::value == sizeof(storage_type) > value_matches_storage;

protected:
    typename operations::aligned_storage_type m_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_fp_cast< storage_type >(v)) {}

    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_consume);
        BOOST_ASSERT(order != memory_order_acquire);
        BOOST_ASSERT(order != memory_order_acq_rel);

        operations::store(m_storage.value, atomics::detail::bitwise_fp_cast< storage_type >(v), order);
    }

    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_release);
        BOOST_ASSERT(order != memory_order_acq_rel);

        return atomics::detail::bitwise_fp_cast< value_type >(operations::load(m_storage.value, order));
    }

    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return fp_operations::fetch_add(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return fp_operations::fetch_sub(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_fp_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_fp_cast< storage_type >(v), order));
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    // Boost.Atomic extensions
    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_fp_operations::fetch_negate(m_storage.value, order);
    }

    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_fp_operations::add(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_fp_operations::sub(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_fp_operations::negate(m_storage.value, order);
    }

    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_fp_operations::opaque_add(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_fp_operations::opaque_sub(m_storage.value, v, order);
    }

    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_fp_operations::opaque_negate(m_storage.value, order);
    }

    // Operators
    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return add(v);
    }

    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return sub(v);
    }

    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))

private:
    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_fp_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_fp_cast< value_type >(old_value);
        return res;
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_fp_cast< storage_type >(expected);
        const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_fp_cast< value_type >(old_value);
        return res;
    }
};

#endif // !defined(BOOST_ATOMIC_NO_FLOATING_POINT)

//! Implementation for pointers to object types
template< typename T >
class base_atomic< T*, void* >
{
public:
    typedef T* value_type;
    typedef std::ptrdiff_t difference_type;

protected:
    typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
    typedef atomics::detail::extra_operations< operations, operations::storage_size, operations::is_signed > extra_operations;
    typedef value_type value_arg_type;

public:
    typedef typename operations::storage_type storage_type;

private:
    typedef atomics::detail::integral_constant< bool, sizeof(value_type) == sizeof(storage_type) > value_matches_storage;

    // uintptr_storage_type is the minimal storage type that is enough to store pointers. The actual storage_type theoretically may be larger,
    // if the target architecture only supports atomic ops on larger data. Typically, though, they are the same type.
#if defined(BOOST_HAS_INTPTR_T)
    typedef uintptr_t uintptr_storage_type;
#else
    typedef typename atomics::detail::make_storage_type< sizeof(value_type) >::type uintptr_storage_type;
#endif

protected:
    typename operations::aligned_storage_type m_storage;

public:
    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< uintptr_storage_type >(v))
    {
    }

    // Standard methods
    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_consume);
        BOOST_ASSERT(order != memory_order_acquire);
        BOOST_ASSERT(order != memory_order_acq_rel);

        operations::store(m_storage.value, atomics::detail::bitwise_cast< uintptr_storage_type >(v), order);
    }

    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(order != memory_order_release);
        BOOST_ASSERT(order != memory_order_acq_rel);

        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(operations::load(m_storage.value, order)));
    }

    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(operations::fetch_add(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
    }

    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(operations::fetch_sub(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
    }

    BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< uintptr_storage_type >(v), order)));
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
    {
        BOOST_ASSERT(failure_order != memory_order_release);
        BOOST_ASSERT(failure_order != memory_order_acq_rel);
        BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));

        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage());
    }

    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
    }

    // Boost.Atomic extensions
    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(extra_operations::add(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
    }

    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(extra_operations::sub(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
    }

    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_add(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order);
    }

    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        extra_operations::opaque_sub(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::add_and_test(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order);
    }

    BOOST_ATOMIC_DETAIL_HIGHLIGHT_OP_AND_TEST
    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        return extra_operations::sub_and_test(m_storage.value, static_cast< uintptr_storage_type >(v * sizeof(T)), order);
    }

    // Operators
    BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
    {
        return fetch_add(1);
    }

    BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
    {
        return add(1);
    }

    BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
    {
        return fetch_sub(1);
    }

    BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
    {
        return sub(1);
    }

    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return add(v);
    }

    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
    {
        return sub(v);
    }

    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))

private:
    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_strong_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_cast< uintptr_storage_type >(expected);
        const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(old_value));
        return res;
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
    {
#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS)
        return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
#else
        return compare_exchange_weak_impl(expected, desired, success_order, failure_order, atomics::detail::false_type());
#endif
    }

    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
    {
        storage_type old_value = atomics::detail::bitwise_cast< uintptr_storage_type >(expected);
        const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
        expected = atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(old_value));
        return res;
    }
};

} // namespace detail

template< typename T >
class atomic :
    public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type >
{
private:
    typedef atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type > base_type;
    typedef typename base_type::value_arg_type value_arg_type;

public:
    typedef typename base_type::value_type value_type;
    typedef typename base_type::storage_type storage_type;

public:
    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = base_type::operations::is_always_lock_free;

public:
    BOOST_DEFAULTED_FUNCTION(atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
    BOOST_FORCEINLINE BOOST_CONSTEXPR atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v) {}

    BOOST_FORCEINLINE value_type operator= (value_arg_type v) BOOST_NOEXCEPT
    {
        this->store(v);
        return v;
    }

    BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile BOOST_NOEXCEPT
    {
        this->store(v);
        return v;
    }

    BOOST_FORCEINLINE operator value_type() const volatile BOOST_NOEXCEPT
    {
        return this->load();
    }

    BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
    {
        // C++17 requires all instances of atomic<> return a value consistent with is_always_lock_free here
        return is_always_lock_free;
    }

    BOOST_FORCEINLINE storage_type& storage() BOOST_NOEXCEPT { return this->m_storage.value; }
    BOOST_FORCEINLINE storage_type volatile& storage() volatile BOOST_NOEXCEPT { return this->m_storage.value; }
    BOOST_FORCEINLINE storage_type const& storage() const BOOST_NOEXCEPT { return this->m_storage.value; }
    BOOST_FORCEINLINE storage_type const volatile& storage() const volatile BOOST_NOEXCEPT { return this->m_storage.value; }

    BOOST_DELETED_FUNCTION(atomic(atomic const&))
    BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&))
    BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&) volatile)
};

template< typename T >
BOOST_CONSTEXPR_OR_CONST bool atomic< T >::is_always_lock_free;

#undef BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL
#undef BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL

typedef atomic< char > atomic_char;
typedef atomic< unsigned char > atomic_uchar;
typedef atomic< signed char > atomic_schar;
typedef atomic< uint8_t > atomic_uint8_t;
typedef atomic< int8_t > atomic_int8_t;
typedef atomic< unsigned short > atomic_ushort;
typedef atomic< short > atomic_short;
typedef atomic< uint16_t > atomic_uint16_t;
typedef atomic< int16_t > atomic_int16_t;
typedef atomic< unsigned int > atomic_uint;
typedef atomic< int > atomic_int;
typedef atomic< uint32_t > atomic_uint32_t;
typedef atomic< int32_t > atomic_int32_t;
typedef atomic< unsigned long > atomic_ulong;
typedef atomic< long > atomic_long;
typedef atomic< uint64_t > atomic_uint64_t;
typedef atomic< int64_t > atomic_int64_t;
#ifdef BOOST_HAS_LONG_LONG
typedef atomic< boost::ulong_long_type > atomic_ullong;
typedef atomic< boost::long_long_type > atomic_llong;
#endif
typedef atomic< void* > atomic_address;
typedef atomic< bool > atomic_bool;
typedef atomic< wchar_t > atomic_wchar_t;
#if !defined(BOOST_NO_CXX11_CHAR16_T)
typedef atomic< char16_t > atomic_char16_t;
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T)
typedef atomic< char32_t > atomic_char32_t;
#endif

typedef atomic< int_least8_t > atomic_int_least8_t;
typedef atomic< uint_least8_t > atomic_uint_least8_t;
typedef atomic< int_least16_t > atomic_int_least16_t;
typedef atomic< uint_least16_t > atomic_uint_least16_t;
typedef atomic< int_least32_t > atomic_int_least32_t;
typedef atomic< uint_least32_t > atomic_uint_least32_t;
typedef atomic< int_least64_t > atomic_int_least64_t;
typedef atomic< uint_least64_t > atomic_uint_least64_t;
typedef atomic< int_fast8_t > atomic_int_fast8_t;
typedef atomic< uint_fast8_t > atomic_uint_fast8_t;
typedef atomic< int_fast16_t > atomic_int_fast16_t;
typedef atomic< uint_fast16_t > atomic_uint_fast16_t;
typedef atomic< int_fast32_t > atomic_int_fast32_t;
typedef atomic< uint_fast32_t > atomic_uint_fast32_t;
typedef atomic< int_fast64_t > atomic_int_fast64_t;
typedef atomic< uint_fast64_t > atomic_uint_fast64_t;
typedef atomic< intmax_t > atomic_intmax_t;
typedef atomic< uintmax_t > atomic_uintmax_t;

#if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
typedef atomic< float > atomic_float_t;
typedef atomic< double > atomic_double_t;
typedef atomic< long double > atomic_long_double_t;
#endif

typedef atomic< std::size_t > atomic_size_t;
typedef atomic< std::ptrdiff_t > atomic_ptrdiff_t;

#if defined(BOOST_HAS_INTPTR_T)
typedef atomic< intptr_t > atomic_intptr_t;
typedef atomic< uintptr_t > atomic_uintptr_t;
#endif

} // namespace atomics
} // namespace boost

#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif

#endif // BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_

redpajama_set_name: RedPajamaGithub


text:
TOM TORNADO und SHANE ALEXANDER
Nachrichten aus dem Trikont Universum
Den CREATIVE OUTLAWS ist ein musikalischer Coupe gelungen…
…Wie uns ein Vögelchen zwitscherte befindet sich der amerikanische Singer-Songwriter SHANE ALEXANDER zur Zeit auf Urlaub in Deutschland. Deshalb haben wir unsere Flügel ausgebreitet und die Ruhrgebietstrommel erklingen lassen und…..ES IST UNS GELUNGEN!
EINZIGES DEUTSCHLAND KONZERT!!!!
SHANE ALEXANDER am 9.7.2014 um 20.00 Uhr "Wohnzimmerkonzert" bei TOM TORNADO (Breite Str. 16/45657 Recklinghausen-Gasse an der Alten Apotheke in RE-City, Eingang neben FRISÖR DAHMS/Name steht auf der Klingel). Da wie immer limitiert auf 40 Leute bitte UNBEDINGT Karten unter (tornadostyle@t-online.de) vorbestellen oder via CREATIVE OUTLAW bei Facebook. Einalss ist um 19.30 Uhr. Für Getränke ist gesorgt. VVK: 10,- AK: 15,-
Zu Shane:
Er ist einer der grössten und wichtigsten neuen Singer/Songwriter der USA, nicht umsonst beweist seine musikalische Fähigkeit, dass in unzähligen prämierten US TV Serien seine Songs erklingen (s. beigefügte Liste). Unzählige Künstler haben sein "Feels like the End" Song gecovert (schaut mal in youtube). Stimmlich ist er eine Mischung zwischen dem jungen TIM BUCKLEY/ACKSON BROWN/JEFF BUCKLEY
Mehr könnt Ihr beigefügtem Text entnehmen.
Also nix Sommerloch/Sommerpause/Weltmeisterschat…….
Hoffen Ihr haltet uns die Treue und Unterstützung
Tom Tornado
Zu hören unter:
http://www.youtube.com/watch?v=7UN484JDQaI&feature=youtu.be
http://www.youtube.com/watch?v=9d0LebM3CYc
https://www.youtube.com/watch?v=XnutP5bq_I4
Nicht vergessen, am 09.07.2014 kommt der großartige Shane Alexander nach Recklinghausen zu einem Wohnzimmerkonzert.
Gehört habt ihr Songs von Shane vermutlich alle schon, ohne es zu wissen. Shane ist zigfach in den meisten der großen US Serien (Criminal Minds, Bones, White Collar, uvm.) mit seinen Songs vertreten.
Karten bitte per PN bei mir oder den CreativeOutlaws RE bestellen. VVK 10€; AK 15€
Hartz IV Empfänger, Vagabunden, Studenten und wem es sonst noch schwer fälltt sich so einen Abend nebenbei mal zu gönnen, zahlt das was er/sie kann.
Alle sind herzlichst willkommen. Denn darum geht es bei unseren Konzerten, alles sollen dabei sein können.
Wir bringen Kultur dorthin, wo sie passiert. Und das ist überall dort, wo Menschen sich begegnen.
Wir freuen uns,
Shane Alexander
Born San Diego, California, United States
Occupations Singer-songwriter, Performer, Producer
Instruments Guitar, vocals, keyboard, mandolin, banjo
Website www.shanealexandermusic.com
Shane Alexander is a contemporary American singer-songwriter and musician. Alexander was born in San Diego, California, raised in Pennsylvania and Maryland, and is currently residing in Southern California.
Alexander's songs range from dark and stirring to subtle and romantic, and are centered around evocative vocals and complex, soulful guitar playing. His smooth vocal style has drawn comparisons to singers Jeff Buckley, Jackson Browne and Art Garfunkel.
Dozens of his songs have appeared on television shows, including The Real World, Laguna Beach, Brothers & Sisters, Bones, Big Shots, "White Collar", Criminal Minds, and Wildfire.
The Early 1990s
Shane Alexander moved from his hometown in Butler, Pennsylvania to Los Angeles in the early '90's. During those early years in California, he attended Musician's Institute in Hollywood and played guitar with the psychedelic instrumental band Trippin, led by virtuoso keyboardist and composer, Jim Michaelson. The band's spectacular live shows drew record crowds in Los Angeles. In 1994, legendary producer Richard Podolor (Alice Cooper, Steppenwolf, Iron Butterfly, Three Dog Night) spotted the band at Coconut Teaszer and invited Alexander to lend his emotive guitar playing to a project he was producing called Young Art. While working with Podolor, Alexander learned invaluable lessons about songwriting and arranging.[2] Later joining the rock band Young Art, he performed as a guitarist and back-up singer. It was not long before Alexander began writing songs for the band as well. Alexander recorded two albums with the group, one produced by Podolor and the other produced by Richie Zito (Cheap Trick, Joe Cocker, Berlin).
In 1997, Alexander formed and fronted Damone with friends from Pennsylvania. The band toured the West Coast club circuit and enjoyed a steadily growing base of loyal fans. They were featured in an interview and fashion layout for Los Angeles Times magazine, and their song "She Likes the Ocean" was used on the extreme sports show Blue Torch, exposing the band to new fans all over the world. The band released a self-titled album and a four-song EP before disbanding in 2002. Just as they were splitting up, the band sold their name for a hefty sum to Damone, a new rock group on RCA records.[3]
Around this time Alexander also began working at Irving Azoff's label Giant Records in the Finance Department. The following year he joined Azoff's executive office as an assistant and runner to the artists – a position that would get the aspiring songwriter up close and personal with The Eagles, Christina Aguilera, Seal, Jewel, Eddie Van Halen, Brian Wilson, Bush, and many other top acts.
2003–2004: Start of a Solo Career
In early 2003, Alexander began a busy schedule of writing and performing solo shows, sometimes performing with a revolving band on bass, drums, mandolin, piano, accordion, and lap steel.
Alexander produced and recorded a self-titled EP that was released in late 2003. The four song disc, described as a collection of "stripped down acoustic songs with vivid lyrics and haunting melodies," included the track "Last Day on Earth," which was later covered by 1980s New Wave band Berlin. Shane Alexander toured extensively on both coasts in 2004, beginning to bring his music to a wider audience.
2004–2005: The Middle Way
In January 2005, Alexander released his debut full-length album The Middle Way, a collection of "rootsy, folk rock with intimate vocals and a rich instrumental backdrop." The album was critically acclaimed, particularly in Europe.
"The Open Road," the lead single from The Middle Way, received national airplay on numerous stations across the Netherlands, and Alexander signed with the Dutch label Lucky Dice Records. Beginning to tour internationally, Alexander performed at clubs and theaters in Canada, UK, Netherlands, Germany, Belgium, France, Austria, Sweden, and Denmark and across the United States. Alexander subsequently opened two US tours for Jewel and a west coast/Canada tour with Lisa Marie Presley in 2005.
2006–2007: Stargazer
In 2006, Alexander released his second full-length album, Stargazer on his own imprint BuddhaLand Records. The album was produced by Heroes & Villains (Billy Mohler and Dan Burns) and featured some of Los Angeles' most respected musicians: Charlie Paxon (James Blunt, Colin Hay, Anastasia) on drums; Billy Mohler (Macy Gray, Liz Phair, Herbie Hancock) on bass; Krister Axel on piano; Chris Pierce on harmonica; and veteran session ace Kim Bullard (Tori Amos, Goo Goo Dolls, David Crosby, Eddie Money) on Hammond organ. The album was recorded in only four days and tracked mostly live using vintage gear, giving the album a rich, timeless sound. The album was called "stunning" by Performing Songwriter Magazine. Several songs from Stargazer were licensed for television and film. More international touring followed.[4]
2008–2009: Sky Below
In late 2007, Alexander once again teamed up with Heroes & Villains to produce his third full-length album. Many musicians returned from Stargazer – drummer Charlie Paxon, Billy Mohler on electric guitar, piano, keyboards and bass, and Kim Bullard on Hammond organ, with additional performances from Chad Crawford (bass) and Jeff Friedl (drums). Toby Wright (Alice In Chains, Wallflowers, Chris Whitley, Trey Anastasio) mixed the record. Alexander sought to get back to a band sound on this album and added more up-tempo songs than in his previous effort. The album was released on BuddaLand Records in February 2008. Alexander supported the album with extensive touring in The United States and Europe and later that year, opened Seal's U.S. tour. Alone in front of the biggest audiences of his career, Alexander captivated audiences night after night.
Several songs from The Sky Below were licensed for television and film.
2010–2011: Mono Solo
On June 1, 2010, Alexander released Mono Solo, his fourth full-length album. Billy Mohler, who co-produced Stargazer and The Sky Below, produced the album. The new collection marked a quantum leap, both in songwriting and in production, for Alexander. Inspired by stories picked up while touring the U.S. and Europe, the effect of the economic crisis on those around him, and the tragic death of a lifelong friend, each track on Mono Solo conveys a sense of reverence for life, love, and stability. "Corey's Song" is Alexander's farewell ode to Corey James Daum, who was killed in a drunk driving accident in Nashville. The album is dedicated to his friend.[5][not in citation given]
The track "Carrollton" was licensed for the television show One Tree Hill on the WB Network before the album was even released.
In late 2010 Alexander signed with Warner Chappell Europe and Rough Trade Records Benelux. The album was released internationally in Spring 2011 and the single "Good as Gold" reached 126 on the Dutch pop chart.[6][not in citation given] Alexander has been touring constantly across the United States and internationally in support of the album. In 2011, Shane Alexander opened for Styx and Yes in 22 cities during their cross-country Summer Tour.
2012: The Greater Good
In spring of 2012, The Greater Good released their self-titled debut on the German label, Stockfisch Records. Recorded in Northeim, Germany the previous spring, the record features Alexander, NYC songwriter Eugene Ruffolo, and Dutch songwriter Dennis Kolen. The album, recorded in less than a week, has a stripped folk-pop sound with lush three-part vocal harmonies. The success of the first single, "All the Lonely Times" (Kolen) and second single, "Nowhere Fast" (Alexander/Silver) in the Netherlands led to the band's first Dutch tour in the fall of 2012.
2013: Ladera
In April 2013, Alexander released his 5th album, Ladera. The production of the new album is far more sparse and ambient than his previous work, and pays tribute to many of Alexander's more psychedelic influences. Teaming up for the 4th time with producer Billy Mohler, and recorded at Mohler's Groundswell Studios in Culver City, CA, the latest collection also showcases Peter Adams (Five For Fighting, Josh Groban, Rickie Lee Jones) on keyboards and newcomer, Jesse Siebenberg (Supertramp, A Fine Frenzy, Lissie) on lapsteel. In spring of 2013, Alexander signed with Dutch label Harlem Recordings, a division of Suburban Records.
Damone 2000
Shane Alexander EP 2004
The Middle Way 2005
Stargazer 2006
The Sky Below 2008
Mono Solo 2010
Ladera 2013
Song Appearances
Brothers & Sisters Love Is Difficult "Ripe" Stargazer
Samantha Who Episode "Spaces In Between" Stargazer
Big Shots Episode "Difference of Opinion" The Sky Below
What About Brian? Episode "Ripe" Stargazer
ABC Family
Wildfire Goodbye "Ripe" Stargazer
Wildfire Heartless "Little Woman" Stargazer
Wildfire Episode "One Track Mind" The Middle Way
The Secret Life of the American Teenager Three Moons Over Milford "Spaces In Between" Stargazer
Criminal Minds DVD "Living Out Loud" The Middle Way
Bones Spaceman in a Crater "Shipwrecked" Stargazer
White Collar All In "Feels Like The End" The Sky Below
The Real World 4 Episodes "Saving Grace" The Sky Below
Road Rules Camped Out "Difference of Opinion" The Sky Below
Road Rules Camped Out "Feels Like the End" The Sky Below
True Life I Am Looking for My Child "Outside the Lines" The Sky Below
True Life I Am Looking for My Child "Ripe" Stargazer
True Life I Am Looking for My Child "Spaces In Between" Stargazer
True Life I Am Looking for My Child "Feels Like the End" The Sky Below
Laguna Beach – The Real OC Episode "Ride the Tides" Stargazer
My Life as Liz Episode 104 "The Sky Below" The Sky Below
Degrassi/The Next Generation Holiday Road "The Sky Below" The Sky Below
Life On Tour Web Series
Teen Cribs Episode 238 "Difference of Opinion" The Sky Below
Basketball Wives Episode "Feels Like the End" The Sky Below
One Tree Hill Last Day of Our Acquaintance "Carrollton" Mono Solo
One Tree Hill Episode "Feels Like The End" The Sky Below
Damages You Got Your Prom Date Pregnant "The Sky Below" The Sky Below
DISCOVERY HEALTH
Dr. G Medical Examiner Episode "Feels Like the End" The Sky Below
What if God Were the Sun Movie of the Week "Shipwrecked" Stargazer
NICKELODEON'S THE N
The Best Years Dangerous Liaisons "The Sky Below" The Sky Below
What Goes On Episode "Where Were You" Stargazer
SOAPS (the Netherlands)
Goede Tijden Slechte Tijden Episodes "Mina" Shane Alexander EP
Jack and Jill vs. the World Freddie Prinze Jr and Taryn Manning "The Open Road" The Middle Way
The House That Jack Built Joe Montegna[7] "Feels like The End" The Sky Below
The Ones Kate Atkinson "Front Porch Serenade" Stargazer
Alpine Audio (Web)
"Afterwhile" "The Open Road"
"Ride the Tides"
"Miles for Days"
http://www.billboard.com/artist/shane-alexander/659617#/artist/shane-alexander/659617
http://allmusic.com/artist/shane-alexander-p705285/biography
http://articles.latimes.com/2003/mar/20/news/wk-bands20
http://www.last.fm/music/Shane+Alexander/+wiki
https://www.facebook.com/events/1459690527602542/?ref=ts&fref=ts
Thema Die Trikont-Story
Mehr Die Trikont-Story (10)
Albaum: Eine Million Bäume für den Klimaschutz CD, Vinyl
Expose yourself to Trikont Vol. VI - 50 JAHRE TRIKONT - Der Jubiläums-Sampler CD 0490
Our Own Voices - Expose Yourself To Trikont Vol. 5 CD 0476
Our Own Voices - Vol. 4 CD 0430
Our Own Voices - Vol. 3 CD, Download 0370
Gnadenlose Unterhaltung - Trikont, Hier und Jetzt CD, Download 0230
From Coast to Coast - Trikont, International Connection CD, Download 0229
Bewegliche Ziele - Trikont, Die frühen Jahre CD, Download 0228

redpajama_set_name: RedPajamaCommonCrawl


Howard County Poetry & Literature Society (HoCoPoLitSo), in partnership with Howard Community College's Office of Student Life, English and World Languages Division, and Arts & Humanities Division, presents the annual Blackbird Poetry Festival on Thursday, April 24, 2014, at Howard Community College. The all-day event features readings by two-term National Poet Laureate Billy Collins, called "the most popular poet in America" by The New York Times; workshops for HCC students by Bruce George, poet and co-founder of HBO's Def Poetry Jam; readings by student poets from HCC; and on-campus patrols by the Poetry Police, who will award individuals carrying a poem in recognition of national Poem in Your Pocket Day. The theme of this year's Blackbird Poetry Festival is "Poetry Unmasked," exploring the bare truth of poetry.
Collins will read and discuss his work at Nightbird, the Blackbird Poetry Festival's evening event, at 7:30 p.m. at Smith Theatre, located in the Horowitz Visual and Performing Arts Center at HCC in Columbia. A book signing and reception will follow. Collins will give a short free reading at Smith Theater with student poets at 2:30 p.m. He will also tape an episode of The Writing Life, HoCoPoLitSo's Bravo-TV Arts for Change Award-winning interview show seen on YouTube. George will facilitate creative writing/performance poetry workshops in morning classes at HCC.
Tickets to Nightbird are $50 for the first five rows in the center aisle and $30 for orchestra and balcony ($15 for students). Tickets can be purchased at www.brownpapertickets.com/event/523094 or www.hocopolitso.org . For more information, call HoCoPoLitSo at (443) 518-4568 or email hocopolitso@yahoo.com. Seniors in Columbia can request transportation by calling the Senior Events Shuttle at (410) 715-3087. HCC is an accessible campus. Accommodation requests should be made to HoCoPoLitSo by April 17, 2014.
HoCoPoLitSo is a nonprofit organization designed to enlarge the audience for contemporary poetry and literature and celebrate culturally diverse literary heritages. Founded in 1974 by National Book Award finalist Ellen Conroy Kennedy, HoCoPoLitSo accomplishes its mission by sponsoring readings with critically acclaimed writers; literary workshops; programs for students; and The Writing Life, a writer-to-writer interview show seen on YouTube, HCC-TV, and other local stations. HoCoPoLitSo receives funding from the Maryland State Arts Council, an agency funded by the state of Maryland and the National Endowment for the Arts; Howard County Arts Council through a grant from Howard County government; The Columbia Film Society; Community Foundation of Howard County; the Jim and Patty Rouse Charitable Foundation; and individual contributors.
For a pdf of this press release, click here: Blackbird 2014 Press Release.


text:
The Hilmersberg is a hill, 362 metres above sea level in the Solling, a hill range in the German state of Lower Saxony. It lies west of Kammerborn and east of Polier, part of the borough of Bodenfelde in the Solling-Vogler Nature Park.

Hills of Lower Saxony

redpajama_set_name: RedPajamaWikipedia


Shop till you drop - it's for a worthy cause!
The perfect place for all your Christmas shopping – it's St Peter's Hospice's annual Christmas Market! It returns to the magical Great Hall at Bristol Grammar School, University Road, off the Clifton Triangle on Saturday 18 November with doors opening at 10.30am.
The perfect place for all your Christmas shopping – it's St Peter's Hospice's annual Christmas Market! It returns to the magical Great Hall at Bristol Grammar School, University Road, off the Clifton Triangle on Saturday 18 November with doors opening at 10.30am. Free parking is available and customers will enjoy seasonal music performances throughout the day with Father Christmas making an appearance at 2pm for children of all ages to enjoy!
Stalls are brimming with hand-crafted toys, beautiful candles & glassware, gorgeous jewellery and lovingly home-made chocolates, cakes, preserves and chutneys. You'll find a Christmas present for everyone with gift stalls including books and games, knitwear, stationary and hand-made cards and Christmas decorations. The smell of mulled wine and mince pies fills a cosy tearoom, where shoppers can have a break, a cup of tea and a bite to eat.
Esther Hall, Community Fundraiser for St Peter's Hospice said: "This year's market will be our largest yet, offering even more hand-crafted, locally-made gifts and delicious seasonal treats than ever before.
St Peter's Hospice is Bristol's only adult hospice and each year cares for more than 2,200 patients as well as supporting family members. All money raised from our Christmas Market will go towards caring for people with life-limiting illnesses in the Bristol area. For more info, visit www.stpetershospice.org.


text:
Q: Allow landscape when UIWebView is playing video I have a UIViewController with a UIWebView that will eventually play a video stream.
The whole app is made for portrait orientation only, but I'd like the video to play on landscape as well.
The furthest I could get was implement this method on the AppDelegate:
- (NSUInteger)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window {
  return [[window rootViewController] isMemberOfClass:[UIViewController class]] ?
          UIInterfaceOrientationMaskAllButUpsideDown : // If current view is the player, allow landscape
          UIInterfaceOrientationMaskPortrait;          // Otherwise, portrait-only
}

Debugging the top-most view controller, I found out that when the video player appears it is a member of UIViewController, and since my app does not display any other VC of that class (only subclasses), that would work.
It does allow me to rotate the video (and only the video), what is great, but when I close the video and the app returns to the previous VC, the navigation bar breaks: instead of having the regular 64 pt height (20 from the status bar + 44 of the navbar itself), the status bar portion goes way and the bar will be 44 pt tall only:

How can I improve this solution and make it work perfectly?

redpajama_set_name: RedPajamaStackExchange


The Financial Institutions file is an electronic directory of deposit-taking institutions and individual locations (branches) of Canadian Payments Association (CPA) members. This geocoded location database of Canadian financial institutions contains records flagged as valid and/or seasonal in the master Canadian Payments file. Considerable effort has been put into verifying address and other locational data, while a variety of methods are used to attain the highest match rate and most precise geocoding results. Organizations must be licensed by the CPA in order to use this file.
Understand the investment behaviour of Canadians and develop a comprehensive picture of their assets, liabilities and net worth. Make smarter marketing decisions, size the market, improve product mix, assess spending power and monitor trade areas based on spending and investment behaviour. Choose from 10 databases, including WealthScapes, Canada's most comprehensive financial database.
Get the most out of your GIS software products by linking your customer data to geographic areas to help improve site selection and location analysis, strategic planning, product distribution and competitor analysis. We offer a suite of mapping and data products for use in media planning, target marketing and consumer profiling.


text:
A Igreja de Nossa Senhora dos Remédios localiza-se na Vila dos Remédios, na ilha de Fernando de Noronha, no estado de Pernambuco, no Brasil. Constitui-se no principal templo católico do arquipélago.

História
O templo foi iniciado em 1737, assim como a Fortaleza dos Remédios, mas apenas foi concluído em 1772, data que ostenta em sua fachada, sendo-lhe acrescidos os ornamentos e paramentos a partir de então, processo que estaria concluído em 1784.

Em 1789 foi eclesiasticamente ligada à Paróquia de São Frei Pedro Gonçalves (Igreja da Madre de Deus), no Recife. Já a festa de Nossa Senhora dos Remédios foi institucionalizada em 1947, por decreto do Major Mário Fernandes Imbiriba, então governador do Território Federal Militar, que instituiu o dia 29 de agosto como o dia da Padroeira, fazendo dessa data feriado distrital na ilha, com festas religiosas e profanas.

Em 2017, o Arcebispo Metropolitano da Arquidiocese de Olinda e Recife, Dom Antônio Fernando Saburido, OSB criou oficialmente a Paróquia Nossa Senhora dos Remédios de Fernando de Noronha, passando o templo a ser a Igreja Matriz.

O templo sofreu obras de restauração em 1891, seguidas de novas intervenções em 1915 e 1919. A última intervenção de restauração teve lugar em 1988, com recursos federais, e a sua reinauguração foi presidida pelo então Arcebispo Emérito de Olinda e Recife, Dom Hélder Câmara. Em 1997-1998 o templo foi revitalizado pela iluminação noturna, período em que a pintura voltou a ter as suas cores originais.

Encontra-se tombada a nível federal pelo Decreto-Lei nº 25, de 11 de novembro de 1937.

Características
A igreja apresenta nave-salão única com coro, e capela-mor, em cantaria de arenito.

Ver também
 Lista do patrimônio histórico em Pernambuco

Ligações externas
 Governo de Pernambuco

Fernando de Noronha
Igrejas de Pernambuco
Igrejas do século XVIII
Patrimônio tombado pelo IPHAN em Pernambuco


Man, I really love Quarterbacks, the 19-song album by the twee-punk band of the same name. But back before they played really fast in a shed in New Paltz, and before they went on a house-show tour of America with a writer for this website, frontman Dean Engle made music with a four-track recorder. The lo-fi love songs on his Quarterboy tape, many of which were re-made for the album, are beautiful in their simplicity, all drum-machine beats and creaky, clumsy chords. That early version of "Knicks," a minute-long song about a gas station and a six pack and a basketball game, still completely and totally crushes me.
Because not everything is always bad, Team Love is re-releasing Quarterboy on tape. It comes with a new-old song, which you can stream down below. According to Engle, he wrote "Park" in 2015, played it live a bunch, but didn't put it to tape until recently. "I sat down in my living room last week, recorded the song on my old machine, and bounced it to the computer to take a listen," he told me in an email. "Right after, the four track shut off and won't turn back on, so this might be the last Qboy track." If that's true, it's a hell of a note to go out on.
Order the 2018 version of Quarterboy here.


Note: This conversation was created from a reply on: How to stop the notification of data theft protection.
Hello joeburge and welcome to the community!
We separated your reply from the post where you posted this reply since this is not relevant to the topic.
We understand that you are getting that error and we would like to inform you that it is not a Unwanted Application, it is one of the feature of our Trend Micro program. You can refer to the link below on what you can do when you are getting this popup.


The TCO (total cost of ownership) arguments for using solid state, lamp-free video projectors for installed AV applications are well established. And the market has spoken: the best, most popular, most robust lamp-free projectors today are laser phosphor projectors–now commonly called "laser projectors". But not all laser projectors are created equal. The best new-generation laser projectors perform way beyond just providing better TCO with a lamp-free design. How can you be sure you're future-proofing your AV installation for years to come, not just getting another "me-too" laser projector?
Today, with the proliferation of laser projectors, an AV integrator or end user may think, "the choice is now simple: lamp-based projectors mean too many lamps to buy down the road, LED projectors don't have the lumens I need, nor do the 'hybrid' projectors…so I'll just pick a laser [phosphor] projector, and we're good to go." Smart integrators and projection users know that down that road lies costly mistakes, namely performance, TCO, quality and reliability shortfalls in a few short months or years after the initial purchase.
Those mistakes can consume both limited budgets and manpower. Smart integrators know that the best laser projectors are not just about the "lamp-free" TCO math. The best projectors for the classroom, boardroom, meeting room and any installed AV application must have new-generation, key features that deliver not just better TCO but superior image quality, state-of-the-art engineering, installation options, and networking performance.
It all starts with DLP: the preferred technology for those seeking the best new-generation projectors. LCD projectors have always had high maintenance costs due to having to aggressively cool the heat-gathering LCD panels. Since LCD is a transmissive not a reflective technology like DLP, the LCD panels absorb heat– a deal-killer for panel longevity and so projector longevity. And the DMD chip at the heart of DLP is all about image quality and longevity. LCD panels fade over time and will need replacement. And for DLP, a high quality single-chip DLP projector with 3X speed color wheel is intrinsically convergent, as opposed to 3-chip LCD systems, since the same device draws up R, G and B. On the other hand, a laser phosphor engine in concert with a color wheel is simply splitting color, with no adverse corollary effects. As a result, a 1-chip DLP laser phosphor projection such as Panasonic's yields the best image processing by delivering the same image quality without artifacts as 1-chip UHD lamp-based projection.
And for the best image contrast–the technical limitations of LCD prevent it from reproducing the deep blacks needed for high contrast. This is because LCD crystals cannot ever be turned fully "off" or moved instantaneously into a black/no transmission mode, as they are part of a transmissive architecture that is slower than DMD mirrors to respond to image changes– slower by orders of magnitude. Also, DLP is more efficient with light as it does not require, as does LCD, pre-polarization.
But just as all laser projectors are not created equal, not al DLP projectors are created equal. The details of a DLP laser projector's features and performance are key. And beyond the performance specs of individual projectors, installed AV is also about networking and about an integration landscape that is changing– and how the best new generation laser projectors fit into that landscape.
Click here to download a new, in-depth White Paper-New-Generation Projectors for Installed AV- that looks at the industry challenges and business issues when when choosing the best laser projectors.
Click here for information on industry-first displays and projection technologies, like 3-Chip DLP Fisheye Lens and LinkRay launched at InfoComm 2017.
Click here to read a Case Study on the University of Copenhagen's selection of laser projectors for teaching spaces and auditoriums.


text:
Those Pesky Messiah-Peddlers
The Didache - Chapter 12
The community should be on guard not to overburden its members by continually providing for the needs of a few individuals who are fully capable of doing so themselves.
DidacheAug 26, 2019
Another peddler at the door, concept (Image: © Bigstock)
By Toby Janicki
The Didache is sixteen chapters long, and there are exactly sixteen Sabbaths between Shavu'ot and Rosh HaShanah. In turn, it presents a perfect opportunity to study one chapter of the Didache per week throughout the summer. We will be presenting a blog each week previewing some of the commentary of The Way of Life.
Chapter 12 continues with instructions on hospitality for travelers. Unlike chapter 11, however, the travelers discussed in this chapter are not teachers, emissaries, or prophets but rather ordinary disciples.
The Didache gives instructions for providing for these strangers' needs, including procedures for integrating them into community life if they so desired.
The Idle Messiah Peddlers
Let anyone who comes in the name of the Lord be received, but then after you have scrutinized him, you will know if he is true, because you will be able to discern between right and wrong. If the one who comes is a traveler, help him as much as you can, but he may not stay with you more than two, or if necessary three, days. But if he wants to live among you and is a craftsman, let him work and eat. If he does not have a skill, according to your discernment take into consideration how he will avoid living idly among you as a follower of the Messiah. But if he is not willing to do so, he is a Messiah peddler. Guard yourselves from people like this! (Didache 12)
As was the case in chapter 11 regarding teachers, emissaries, and prophets, the open-handed hospitality of the community and their generous charity to strangers invited abuse. The Didache warns: "If he is not willing to do so [i.e., work], he is a Messiah peddler. Guard yourselves from people like this!" (12.5). There was and always will be those who abuse the kindness of others in an attempt to support their idle lifestyle. Thomas O'Loughlin laments:
Everyone who has been involved in running a charity knows this dilemma in one way or another. Welcome and support is something that Christians should give; but at the same time no one should be allowed to abuse the generosity and sponge rather than work. Such people are not brothers who should be welcomed in Christ as coming in the Lord's name but people who are using the name of Christian for their own ends. [1]
This was especially true for the budding communities of new believers, who could be easily swayed and abused due to their innocence and childlike trust. Furthermore, Didache 1 and 4 are filled with admonishments for the believers to be generous and to give freely to those in need; to balance this, chapter 12 now stresses the importance of the disciples being on guard against falsehood even in their giving. It contains clear-cut guidelines so that hospitality would not be trampled upon and abused.
This was especially important in a community that depended on a collectivist model: "The community was based on all pulling together and sharing the task of welcome: so no individual was to live within a community and take advantage of it." [2] To have lazy members mooch off the hard work of others could ruin the delicate balance of the community and quickly deplete its resources. Everyone needed to pull his or her own weight.
The Didache's instructions on hospitality are pertinent for believers today. Open and generous hospitality should be the norm for Messianic communities. Whether it be hosting people for dinner or for lodging in our homes, we should receive anyone "who comes in the name of the Lord." It is important as well, however, that we use discernment in dealing with friends and strangers alike.
It is also true today that everyone in a community needs to do their share. While most people will not admit outright that they do not want to work to provide for themselves and their families, many do use excuses and sometimes even "spiritual" pretenses as to why they are unable to find and hold a job. In such cases the community should be on guard not to overburden its members by continually providing for the needs of a few individuals who are fully capable of doing so themselves. The instructions of the Didache provide a solid foundation on this matter to help us use discernment and common sense in our acts of charity and hospitality.
Thomas O'Loughlin, The Didache: A Window on the Earliest Christians (Grand Rapids, MI: Baker, 2010), 122.
community, Didache, generosity, hospitality, idleness, work
About the Author: Toby Janicki is a teacher and writer for First Fruits of Zion. He is also the Theological Support Coordinator for the Torah Club program and has authored several books including God-Fearers and a comprehensive commentary on the Didache titled: The Way of Life. More articles by Toby Janicki
The Way of Life
The Way of Life is a brand new commentary on the Didache, published by Vine of David. This is a major work from a Messianic Jewish perspective on an ancient New Testament-era manuscript that will benefit both Messianic Jews and Gentiles who desire to study the priorities and life of the earliest believers in Yeshua.
Preview pages from the book and watch several related videos.
LEARN MORE / ORDER
Apostolic Gemara on the Words of the Master
Five Levels of Love: The Didache and Loving Your Neighbor as Yourself
Building a Culture
Pray as the Lord Commanded
Do Not Be Led Astray


The inscription "REPUBLICA POPULARA ROMANA" meaning "ROMANIAN PEOPLE'S REPUBLIC", oat ear, corncob and wheat ear. Along the rim in the lower part of the coin, somehow right, is placed H.I. standing for Haralamb Ionescu, the engraver's name.
After the monetary reform of January 28th 1952 the coins of 1 ban, 3, 5, 10 and 25 bani (presented on the following pages of the site) were introduced into circulation. The old coins were withdrawn from circulation, the aluminum 1 leu and 2 lei from 1952 included, the later having thus circulated for a very short time. Probably, very few aluminum coins of 1952 were introduced into circulation the days before the monetary reform of January.
The mintages of these coins are not known. It is certain that 2 lei 1952 is a key date, one of the rarest and hardest to find coins issued during the communist era, the rarest maybe.
The pictures 2 lei 1951 coin above are present on Romanian coins through the kind permission of an anonymous donor.
The pictures of 2 lei 1952 coin above are present on Romanian coins through the kind permission of Mr. Radu Lissner.
Below you can see a double strike of the 2 lei of 1951 coin and a detail of the most apparent region on it.
Below you can see atriple strike of the 2 lei of 1951 coin and a detail of the most apparent region on it and an off-center struck coin. The pictures are present on Romanian coins through the kind contribution of Mr. Adrian Popovici.


Sarah's search and rescue work, and to Sarah to send blessings.
mpatriots Sarah's search and rescue, Barcelona star Lionel messi in the personal social media also called for the event.
scue, don't give up, although there have been the expert points out, has little Sarah's survival probability.
o reveal our country for the economic and technology improvement.
e age of dazed and confused, don't think should become more mature and rational some?
ittle less so now on the way PanShanDao caused a tragedy, a private cars and buses.
hildren just ran to the station, but look at the car away, they told the mother didn't catch the bus.
irectly ryu speed up, on the way PanShanDao for overtaking.But after overtaking behavior have been angry!
e safe and stopped the car, to call the police.And ryu to get off on the car, then call to: why not let my daughter get on the bus.


text:
Q: How to print rows from database via ajax and javascript? I'm newbie in php and JavaScript, and I want to print all rows in my table
I use this code, it works but no output have come from it, and no errors occurs
function show(){//function get data and send it to Ajax, and I can make 1 function get 3 parameters
    //   var formData = new FormData();
    //  formData.append('result', $(("#a").val()));//php elem , html element
    //  formData.append('contactUsEmail', $("#contactUsEmail").val());
    //  formData.append('contactUsMessage', $("#contactUsMessage").val());
    if(false){
        swal("Attention !", "Please fill in all fields", "error");
    }else  {
        //Ajax
        if (window.XMLHttpRequest) {
            ajax = new XMLHttpRequest();
        } else {
            ajax = new ActiveXObject("Microsoft.XMLHTTP");
        }

        ajax.onreadystatechange = function () {
            if (this.readyState == 4 && this.status == 200) {
                var text =this.responseText; // 0 unvalid , 1 true
                // document.getElementById("a").innerHTML = this.responseText;
            }
        }

        ajax.open("GET", "one.php", true);
        ajax.send(formData);
    }
}

php code here :
<?php
function OpenCon()
{
    $dbhost = "localhost";
    $dbuser = "root";
    $dbpass = "";
    $db = "chat";
    $conn = new mysqli($dbhost, $dbuser, $dbpass,$db) or die("Connect failed: %s\n". $conn -> error);

    return $conn;
}

function show(){
    $sql = "SELECT id FROM masseges";
    $result = OpenCon()->query($sql);

    if ($result->num_rows > 0) {
        // output data of each row
        while($row = $result->fetch_assoc()) {
            echo "id: ". $row["id"]."bb";
        }
    } else {
        echo "0 results";
    }

    OpenCon()->close();
 }

No errors in page, but a blank page. How can I fix it ?

A: You are not actually returning any html tags back to your website.
You should be able to see the result from the php echo in the network tab of your development console.
If you want to fill a table, I suggest you create the table structure on your website and add the data from php as a new table row.
HTML:

        id

PHP:
echo "
id: ". $row['id']."bb
";

Another word of advide:
Have a look at jquery! Gonna save you a a lot of time!
I have been where you are half a year ago :-)


text:
oscany dejesus ... captured by joseph greene
Today we like to show you photos out of a session with photographer Joseph Greene and model Oscany DeJesus.
Joseph met Oscany at a mall in Manchester, New Hampshire and asked her if she had ever modeled. She said, that she had done a shoot or two before and was interested. Asking like this was totally out of character for Joseph, but she really stood out. "Oscany is absolutely stunning! Tall and lean with an athletic physique." said Joseph.
They set up a shoot for the following week in the Manchester Millyard.
They have chosen to set up the shoot in the Millyard for a few reasons. First of all it was familiar to both of them. Additional Joseph figured an urban setting worked better, since nothing is blooming in New England cause of the late start to spring weather. Finally there are dozens of different looks in and around the Millyard.
The day of the shoot was overcast, which Joseph loves. "Oscany took directions very well and is an absolute natural, when it comes to modeling. She is definitely going places if she chooses to model. She would fit right in as a fashion model." said Joseph "We took a break during the shoot and when we resumed, she was full with ideas. She is so easy to work with and I highly recommend her!
Oscan told us "I had a lot of fun and Joe is very easy to work with. I've just started modeling so this was my first experience with being professionally photographed."
Josephs focus on that day was urban portraiture. For the shoot he used his Sony A7R III with a Sony 85mm GM lens, ISO 100 and F stop: 4-5.6. The exact location was Manchester Millyard (also known as Amoskeag Millyard) - Manchester, New Hampshire, USA.
We like to thank both, Oscany and Joseph, to give us the opportunity to show these excellent photos here in Streetfashion MagZZine.
We hope, that more shoots of this team are going to follow.
Get a 15% discount ... use Streetfashion MagZZine's promo code: STREET15