← Back to branch summary

~centralelyon2010/inkscape/imagelinks2

« back to all changes in this revision

Viewing changes to src/libnr/nr-maybe.h

  • Committer: JazzyNico
  • Date: 2011-08-29 20:25:30 UTC
  • Revision ID: nicoduf@yahoo.fr-20110829202530-6deuoz11q90usldv
Code refactoring and merging with trunk (revision 10599).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libnr/nr-maybe.h
1
 
#ifndef __NR_MAYBE_H__
2
 
#define __NR_MAYBE_H__
3
 
 
4
 
/*
5
 
 * Nullable values for C++
6
 
 *
7
 
 * Copyright 2004, 2007  MenTaLguY <mental@rydia.net>
8
 
 *
9
 
 * This code is licensed under the GNU GPL; see COPYING for more information.
10
 
 */
11
 
 
12
 
#if HAVE_CONFIG_H
13
 
#include "config.h"
14
 
#endif
15
 
 
16
 
#include <stdexcept>
17
 
#include <string>
18
 
#include <algorithm>
19
 
 
20
 
namespace NR {
21
 
 
22
 
class IsNothing : public std::domain_error {
23
 
public:
24
 
    IsNothing() : domain_error(std::string("Is nothing")) {}
25
 
};
26
 
 
27
 
struct Nothing {};
28
 
 
29
 
template <typename T>
30
 
class MaybeStorage {
31
 
public:
32
 
    MaybeStorage() : _is_nothing(true) {}
33
 
    MaybeStorage(T const &value)
34
 
    : _value(value), _is_nothing(false) {}
35
 
 
36
 
    bool is_nothing() const { return _is_nothing; }
37
 
    T &value() { return _value; }
38
 
    T const &value() const { return _value; }
39
 
 
40
 
private:
41
 
    T _value;
42
 
    bool _is_nothing;
43
 
};
44
 
 
45
 
template <typename T>
46
 
class Maybe {
47
 
public:
48
 
    Maybe() {}
49
 
    Maybe(Nothing) {}
50
 
    Maybe(T const &t) : _storage(t) {}
51
 
    Maybe(Maybe const &m) : _storage(m._storage) {}
52
 
 
53
 
    template <typename T2>
54
 
    Maybe(Maybe<T2> const &m) {
55
 
        if (m) {
56
 
            _storage = *m;
57
 
        }
58
 
    }
59
 
 
60
 
    template <typename T2>
61
 
    Maybe(Maybe<T2 const &> m) {
62
 
        if (m) {
63
 
            _storage = *m;
64
 
        }
65
 
    }
66
 
 
67
 
    operator bool() const { return !_storage.is_nothing(); }
68
 
 
69
 
    T const &operator*() const throw(IsNothing) {
70
 
        if (_storage.is_nothing()) {
71
 
            throw IsNothing();
72
 
        } else {
73
 
            return _storage.value();
74
 
        }
75
 
    }
76
 
    T &operator*() throw(IsNothing) {
77
 
        if (_storage.is_nothing()) {
78
 
            throw IsNothing();
79
 
        } else {
80
 
            return _storage.value();
81
 
        }
82
 
    }
83
 
 
84
 
    T const *operator->() const throw(IsNothing) {
85
 
        if (_storage.is_nothing()) {
86
 
            throw IsNothing();
87
 
        } else {
88
 
            return &_storage.value();
89
 
        }
90
 
    }
91
 
    T *operator->() throw(IsNothing) {
92
 
        if (_storage.is_nothing()) {
93
 
            throw IsNothing();
94
 
        } else {
95
 
            return &_storage.value();
96
 
        }
97
 
    }
98
 
 
99
 
    template <typename T2>
100
 
    bool operator==(Maybe<T2> const &other) const {
101
 
        bool is_nothing = _storage.is_nothing();
102
 
        if ( is_nothing || !other ) {
103
 
            return is_nothing && !other;
104
 
        } else {
105
 
            return _storage.value() == *other;
106
 
        }
107
 
    }
108
 
    template <typename T2>
109
 
    bool operator!=(Maybe<T2> const &other) const {
110
 
        bool is_nothing = _storage.is_nothing();
111
 
        if ( is_nothing || !other ) {
112
 
            return !is_nothing || other;
113
 
        } else {
114
 
            return _storage.value() != *other;
115
 
        }
116
 
    }
117
 
 
118
 
private:
119
 
    MaybeStorage<T> _storage;
120
 
};
121
 
 
122
 
template <typename T>
123
 
class Maybe<T &> {
124
 
public:
125
 
    Maybe() : _ref(NULL) {}
126
 
    Maybe(Nothing) : _ref(NULL) {}
127
 
    Maybe(T &t) : _ref(&t) {}
128
 
 
129
 
    template <typename T2>
130
 
    Maybe(Maybe<T2> const &m) {
131
 
        if (m) {
132
 
            _ref = &*m;
133
 
        } 
134
 
    }
135
 
 
136
 
    template <typename T2>
137
 
    Maybe(Maybe<T2 &> m) {
138
 
        if (m) {
139
 
            _ref = *m;
140
 
        }
141
 
    }
142
 
 
143
 
    template <typename T2>
144
 
    Maybe(Maybe<T2 const &> m) {
145
 
        if (m) {
146
 
            _ref = *m;
147
 
        }
148
 
    }
149
 
 
150
 
    operator bool() const { return _ref; }
151
 
 
152
 
    T &operator*() const throw(IsNothing) {
153
 
        if (!_ref) {
154
 
            throw IsNothing();
155
 
        } else {
156
 
            return *_ref;
157
 
        }
158
 
    }
159
 
    T *operator->() const throw(IsNothing) {
160
 
        if (!_ref) {
161
 
            throw IsNothing();
162
 
        } else {
163
 
            return _ref;
164
 
        }
165
 
    }
166
 
 
167
 
    template <typename T2>
168
 
    bool operator==(Maybe<T2> const &other) const {
169
 
        if ( !_ref || !other ) {
170
 
            return !_ref && !other;
171
 
        } else {
172
 
            return *_ref == *other;
173
 
        }
174
 
    }
175
 
    template <typename T2>
176
 
    bool operator!=(Maybe <T2> const &other) const {
177
 
        if ( !_ref || !other ) {
178
 
            return _ref || other;
179
 
        } else {
180
 
            return *_ref != *other;
181
 
        }
182
 
    }
183
 
 
184
 
private:
185
 
    T *_ref;
186
 
};
187
 
 
188
 
} /* namespace NR */
189
 
 
190
 
#endif
191
 
 
192
 
/*
193
 
  Local Variables:
194
 
  mode:c++
195
 
  c-file-style:"stroustrup"
196
 
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
197
 
  indent-tabs-mode:nil
198
 
  fill-column:99
199
 
  End:
200
 
*/
201
 
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :