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 (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef REFERENCE_H_
#define REFERENCE_H_
#include <android-base/logging.h>
#include <hidl-util/FQName.h>
#include "Location.h"
namespace android {
/**
* Reference placeholder
*/
template <class T>
struct Reference {
Reference() = default;
virtual ~Reference() {}
Reference(const FQName& fqName, const Location& location)
: mResolved(nullptr), mFqName(fqName), mLocation(location) {}
Reference(T* type, const Location& location) : mResolved(type), mLocation(location) {
CHECK(type != nullptr);
}
template <class OtherT>
Reference(const Reference<OtherT>& ref)
: mResolved(ref.mResolved), mFqName(ref.mFqName), mLocation(ref.mLocation) {}
/* Returns true iff referred type is resolved
Referred type's field might be not resolved */
bool isResolved() const { return mResolved != nullptr; }
operator T*() const { return get(); }
T* operator->() const { return get(); }
T* get() const {
CHECK(mResolved != nullptr);
return mResolved;
}
void set(T* resolved) {
CHECK(!isResolved());
CHECK(resolved != nullptr);
mResolved = resolved;
}
/* Returns true iff this is reference to null:
not resolved and has not name for lookup */
bool isEmptyReference() const { return !isResolved() && !hasLookupFqName(); }
const FQName& getLookupFqName() const {
CHECK(hasLookupFqName());
return mFqName;
}
bool hasLocation() const { return mLocation.isValid(); }
const Location& location() const {
CHECK(hasLocation());
return mLocation;
}
private:
/* Referred type */
T* mResolved = nullptr;
/* Reference name for lookup */
FQName mFqName;
/* Reference location is mainly used for printing errors */
Location mLocation;
bool hasLookupFqName() const {
// Valid only while not resolved to prevent confusion when
// ref.hasLookupFqName() is false while ref,get()->fqName is valid.
CHECK(!isResolved());
return mFqName.isValid();
}
template <class OtherT>
friend struct Reference;
};
template <class T>
struct NamedReference : public Reference<T> {
NamedReference(const std::string& name, const Reference<T>& reference)
: Reference<T>(reference), mName(name) {}
const std::string& name() const { return mName; }
// TODO(b/64715470) Legacy
const T& type() const { return *Reference<T>::get(); }
private:
const std::string mName;
};
} // namespace android
#endif // REFERENCE_H_
|
