boost_core 0.1.0

Boost C++ library boost_core packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// Copyright 2023 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#include <boost/core/memory_resource.hpp>
#include <boost/core/lightweight_test.hpp>
#include <new>
#include <cstddef>

static bool do_allocate_called;
static std::size_t do_allocate_bytes;
static std::size_t do_allocate_alignment;

static bool do_deallocate_called;
static void* do_deallocate_p;
static std::size_t do_deallocate_bytes;
static std::size_t do_deallocate_alignment;

struct R1: public boost::core::memory_resource
{
    void* do_allocate( std::size_t bytes, std::size_t alignment )
    {
        do_allocate_called = true;
        do_allocate_bytes = bytes;
        do_allocate_alignment = alignment;

        return ::operator new( bytes );
    }

    void do_deallocate( void* p, std::size_t bytes, std::size_t alignment )
    {
        do_deallocate_called = true;
        do_deallocate_p = p;
        do_deallocate_bytes = bytes;
        do_deallocate_alignment = alignment;

        ::operator delete( p );
    }

    bool do_is_equal( memory_resource const & /*other*/ ) const BOOST_NOEXCEPT
    {
        return true;
    }
};

struct R2: public boost::core::memory_resource
{
    void* do_allocate( std::size_t bytes, std::size_t /*alignment*/ )
    {
        return ::operator new( bytes );
    }

    void do_deallocate( void* p, std::size_t /*bytes*/, std::size_t /*alignment*/ )
    {
        ::operator delete( p );
    }

    bool do_is_equal( memory_resource const & other ) const BOOST_NOEXCEPT
    {
        return this == &other;
    }
};

int main()
{
    {
        R1 r1;

        do_allocate_called = false;
        do_allocate_bytes = 0;
        do_allocate_alignment = 0;

        void* p = r1.allocate( 31 );

        BOOST_TEST( do_allocate_called );
        BOOST_TEST_EQ( do_allocate_bytes, 31 );
        BOOST_TEST_EQ( do_allocate_alignment, boost::core::max_align );

        do_deallocate_called = false;
        do_deallocate_p = 0;
        do_deallocate_bytes = 0;
        do_deallocate_alignment = 0;

        r1.deallocate( p, 31 );

        BOOST_TEST( do_deallocate_called );
        BOOST_TEST_EQ( do_deallocate_p, p );
        BOOST_TEST_EQ( do_deallocate_bytes, 31 );
        BOOST_TEST_EQ( do_deallocate_alignment, boost::core::max_align );
    }

    {
        R1 r1;

        do_allocate_called = false;
        do_allocate_bytes = 0;
        do_allocate_alignment = 0;

        void* p = r1.allocate( 1, 8 );

        BOOST_TEST( do_allocate_called );
        BOOST_TEST_EQ( do_allocate_bytes, 1 );
        BOOST_TEST_EQ( do_allocate_alignment, 8 );

        do_deallocate_called = false;
        do_deallocate_p = 0;
        do_deallocate_bytes = 0;
        do_deallocate_alignment = 0;

        r1.deallocate( p, 1, 8 );

        BOOST_TEST( do_deallocate_called );
        BOOST_TEST_EQ( do_deallocate_p, p );
        BOOST_TEST_EQ( do_deallocate_bytes, 1 );
        BOOST_TEST_EQ( do_deallocate_alignment, 8 );
    }

    {
        R1 r1;
        R1 r2;

        BOOST_TEST( r1 == r1 );
        BOOST_TEST_NOT( r1 != r1 );

        BOOST_TEST( r1 == r2 );
        BOOST_TEST_NOT( r1 != r2 );
    }

    {
        R2 r1;
        R2 r2;

        BOOST_TEST( r1 == r1 );
        BOOST_TEST_NOT( r1 != r1 );

        BOOST_TEST_NOT( r1 == r2 );
        BOOST_TEST( r1 != r2 );
    }

    return boost::report_errors();
}