blob: cc030cc1078b77d1ceca4eb613d37dd431256eda (
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
|
/*
* Copyright 2018 Google
*
* 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 FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_AUTH_USER_H_
#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_AUTH_USER_H_
#if defined(__OBJC__)
#import <Foundation/Foundation.h>
#include "Firestore/core/src/firebase/firestore/util/string_apple.h"
#endif // defined(__OBJC__)
#include <string>
#include "absl/strings/string_view.h"
namespace firebase {
namespace firestore {
namespace auth {
/**
* Simple wrapper around a nullable UID. Mostly exists to make code more
* readable and for compatibility with other clients where map keys cannot be
* null.
*/
class User {
public:
/** Construct an unauthenticated user. */
User();
/** Construct an authenticated user with the given UID. */
explicit User(absl::string_view uid);
const std::string& uid() const {
return uid_;
}
// PORTING NOTE: Here use more clear naming is_authenticated() instead of
// is_unauthenticated().
bool is_authenticated() const {
return is_authenticated_;
}
/** Returns an unauthenticated instance. */
static const User& Unauthenticated();
#if defined(__OBJC__)
/**
* Returns an authenticated user if uid is non-nil, otherwise an
* unauthenticated user.
*/
static User FromUid(NSString* _Nullable uid) {
if (uid == nil) {
return Unauthenticated();
} else {
return User(util::MakeStringView(uid));
}
}
#endif // defined(__OBJC__)
User& operator=(const User& other) = default;
friend bool operator==(const User& lhs, const User& rhs);
private:
std::string uid_;
bool is_authenticated_;
};
inline bool operator==(const User& lhs, const User& rhs) {
return lhs.is_authenticated_ == rhs.is_authenticated_ &&
(!lhs.is_authenticated_ || lhs.uid_ == rhs.uid_);
}
inline bool operator!=(const User& lhs, const User& rhs) {
return !(lhs == rhs);
}
// Specializations of std::hash is prohibited. We define a hash function to be
// passed through manually.
struct HashUser {
inline int64_t operator()(const User& user) const {
return std::hash<std::string>{}(user.uid());
}
};
} // namespace auth
} // namespace firestore
} // namespace firebase
#endif // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_AUTH_USER_H_
|
