blob: caf364df06e5333f8ea31dfd7e686cc4e54cbaa5 (
plain)
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
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PPAPI_CPP_DEV_OPTIONAL_DEV_H_
#define PPAPI_CPP_DEV_OPTIONAL_DEV_H_
#include "ppapi/c/dev/pp_optional_structs_dev.h"
#include "ppapi/c/pp_bool.h"
#include "ppapi/cpp/dev/may_own_ptr_dev.h"
#include "ppapi/cpp/dev/string_wrapper_dev.h"
#include "ppapi/cpp/logging.h"
#include "ppapi/cpp/var.h"
namespace pp {
template <typename T>
class Optional;
template <>
class Optional<double> {
public:
typedef const PP_Optional_Double_Dev* CInputType;
Optional() {}
Optional(double value) { set(value); }
// Creates an accessor to |storage| but doesn't take ownership of the memory.
// |storage| must live longer than this object.
Optional(PP_Optional_Double_Dev* storage, NotOwned)
: storage_(storage, NOT_OWNED) {
}
Optional(const Optional<double>& other) { *storage_ = *other.storage_; }
Optional<double>& operator=(const Optional<double>& other) {
return operator=(*other.storage_);
}
Optional<double>& operator=(const PP_Optional_Double_Dev& other) {
if (storage_.get() == &other)
return *this;
*storage_ = other;
return *this;
}
bool is_set() const { return PP_ToBool(storage_->is_set); }
void unset() { storage_->is_set = PP_FALSE; }
double get() const {
PP_DCHECK(is_set());
return storage_->value;
}
void set(double value) {
storage_->value = value;
storage_->is_set = PP_TRUE;
}
const PP_Optional_Double_Dev* ToCInput() const { return storage_.get(); }
PP_Optional_Double_Dev* StartRawUpdate() { return storage_.get(); }
void EndRawUpdate() {}
private:
internal::MayOwnPtr<PP_Optional_Double_Dev> storage_;
};
template <>
class Optional<std::string> {
public:
typedef const PP_Var& CInputType;
Optional() {}
Optional(const std::string& value) : wrapper_(value) {}
Optional(const char* value) : wrapper_(value) {}
// Creates an accessor to |storage| but doesn't take ownership of the memory.
// |storage| must live longer than this object.
//
// Although this object doesn't own the memory of |storage|, it manages the
// ref count and sets the var to undefined when destructed.
Optional(PP_Var* storage, NotOwned) : wrapper_(storage, NOT_OWNED) {}
Optional(const Optional<std::string>& other) : wrapper_(other.wrapper_) {}
Optional<std::string>& operator=(const Optional<std::string>& other) {
wrapper_ = other.wrapper_;
return *this;
}
Optional<std::string>& operator=(const PP_Var& other) {
wrapper_ = other;
return *this;
}
bool is_set() const { return wrapper_.is_set(); }
void unset() { wrapper_.unset(); }
std::string get() const { return wrapper_.get(); }
void set(const std::string& value) { wrapper_.set(value); }
const PP_Var& ToCInput() const { return wrapper_.ToVar(); }
PP_Var* StartRawUpdate() { return wrapper_.StartRawUpdate(); }
void EndRawUpdate() { wrapper_.EndRawUpdate(); }
private:
internal::OptionalStringWrapper wrapper_;
};
} // namespace pp
#endif // PPAPI_CPP_DEV_OPTIONAL_DEV_H_
|
