chapter-4.cpp

Go to the documentation of this file.

// ===-- chapter-4/chapter-4.cpp -------------------------- -*- C++ -*- --=== //
#include "exercise-4-0.hpp"
#include "exercise-4-1.hpp"
#include "exercise-4-2.hpp"
#include "exercise-4-3.hpp"
#include "exercise-4-4.hpp"
#include "exercise-4-5.hpp"
 
#include <stdio.h>
#include <vector>
 
 
namespace test_4_1 {
using namespace exercise_4_1;
 
// Test logical_or...
BOOST_STATIC_ASSERT(
    (logical_or< undefined_false<true>, undefined_false<false> >::value));
BOOST_STATIC_ASSERT(
    (logical_or< boost::mpl::false_, boost::mpl::true_ >::value));
BOOST_STATIC_ASSERT(
    (!logical_or< boost::mpl::false_, boost::mpl::false_ >::value));
 
// Test logical_and...
BOOST_STATIC_ASSERT(
    (!logical_and< undefined_true<false>, undefined_true<true> >::value));
BOOST_STATIC_ASSERT(
    (!logical_and< boost::mpl::true_, boost::mpl::false_ >::value));
BOOST_STATIC_ASSERT(
    (logical_and< boost::mpl::true_, boost::mpl::true_ >::value));
 
} // namespace test_4_1
 
 
namespace test_4_2 {
using namespace exercise_4_2;
 
 
BOOST_STATIC_ASSERT(
    (logical_or5<
     undefined_false<true>,
     undefined_false<false>
     >::value));
BOOST_STATIC_ASSERT(
    (logical_or5<
     boost::mpl::false_,
     boost::mpl::true_
     >::value));
BOOST_STATIC_ASSERT(
    (!logical_or5<
     boost::mpl::false_,
     boost::mpl::false_
     >::value));
BOOST_STATIC_ASSERT(
    (!logical_or5<
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::false_
     >::value));
BOOST_STATIC_ASSERT(
    (logical_or5<
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::false_,
     boost::mpl::true_
     >::value));
BOOST_STATIC_ASSERT(
    (logical_or5<
     undefined_false<true>,
     undefined_false<true>,
     undefined_false<true>,
     undefined_false<true>,
     undefined_false<false>
     >::value));
 
} // namespace test_4_2
 
 
namespace test_4_3 {
using namespace exercise_4_3;
 
// Algorithm 1:
typedef next_if< mpl::int_<1>, mpl::greater<mpl::int_<0>, _1> > shouldBe1;
typedef next_if< mpl::int_<1>, mpl::greater<mpl::int_<3>, _1> > shouldBe2;
 
BOOST_STATIC_ASSERT((shouldBe1::value == 1));
BOOST_STATIC_ASSERT((shouldBe2::value == 2));
 
// Algorithm 2:
typedef formula< mpl::int_<2>, mpl::int_<2> > shouldBe6;
typedef formula< mpl::int_<3>, mpl::int_<4> > shouldBe3;
typedef formula< mpl::int_<9>, mpl::int_<2> > shouldBe7;
BOOST_STATIC_ASSERT((shouldBe6::value == 6));
BOOST_STATIC_ASSERT((shouldBe3::value == 3));
BOOST_STATIC_ASSERT((shouldBe7::value == 7));
 
} // namespace test_4_3
 
 
namespace test_4_4 {
using namespace exercise_4_4;
 
class test_class { };
 
BOOST_STATIC_ASSERT((is_data_member_pointer<int*(test_class::*)>::value));
BOOST_STATIC_ASSERT((!is_data_member_pointer<int*>::value));
 
BOOST_STATIC_ASSERT((!is_pointer_to_function<void()>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<void(*[])()>::value));
BOOST_STATIC_ASSERT((is_pointer_to_function<void(*)()>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<int*>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<int(*&)()>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<int>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<void(test_class::*)()>::value));
 
BOOST_STATIC_ASSERT((is_reference_to_function_pointer<void(*&)()>::value));
BOOST_STATIC_ASSERT((!is_reference_to_function_pointer<void(*)()>::value));
BOOST_STATIC_ASSERT((!is_reference_to_function_pointer<void(&)()>::value));
BOOST_STATIC_ASSERT((!is_reference_to_function_pointer<void()>::value));
BOOST_STATIC_ASSERT((!is_reference_to_function_pointer<int&>::value));
BOOST_STATIC_ASSERT((!is_reference_to_function_pointer<int*>::value));
BOOST_STATIC_ASSERT((!is_pointer_to_function<void(test_class::*&)()>::value));
 
BOOST_STATIC_ASSERT((!is_reference_to_non_const<int const>::value));
BOOST_STATIC_ASSERT((!is_reference_to_non_const<int const&>::value));
BOOST_STATIC_ASSERT((is_reference_to_non_const<int&>::value));
 
} // namespace test_4_4
 
 
namespace {
 
static void test_exercise_4_5()
{
#ifdef EXERCISE_4_5
    using namespace exercise_4_5;
 
    static int const values[] = {1, 2, 3, 4};
    std::vector<int> v(values, values + (sizeof(values) / sizeof(*values)));
 
    std::vector<int>::iterator const it = container_find(v, 2);
 
    std::vector<int> const& v_ref = v;
    std::vector<int>::const_iterator const it_const = container_find(v_ref, 2);
    printf("it %s it_const\n", (*it == *it_const) ? "==" : "!=");
#endif
}
 
} // namespace <anon>
 
 
int main()
{
    test_exercise_4_5();
    return 0;
}