-
Notifications
You must be signed in to change notification settings - Fork 192
/
QualifiedName.h
106 lines (88 loc) · 2.97 KB
/
QualifiedName.h
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
/*
* Souffle - A Datalog Compiler
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved
* Licensed under the Universal Permissive License v 1.0 as shown at:
* - https://opensource.org/licenses/UPL
* - <souffle root>/licenses/SOUFFLE-UPL.txt
*/
/************************************************************************
*
* @file QualifiedName.h
*
* Defines qualified names so that objects in components (types,
* relations, etc.) can be accessed via either a fully/partially
* qualified name.
*
***********************************************************************/
#pragma once
#include "utility/StreamUtil.h"
#include <algorithm>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
namespace souffle {
/**
* Qualified Name class for fully/partially qualified names
* to identify objects in components.
*/
class AstQualifiedName {
public:
AstQualifiedName() : qualifiers() {}
AstQualifiedName(const std::string& name) : qualifiers({name}) {}
AstQualifiedName(const char* name) : AstQualifiedName(std::string(name)) {}
AstQualifiedName(const std::vector<std::string> qualifiers) : qualifiers(qualifiers) {}
AstQualifiedName(const AstQualifiedName&) = default;
AstQualifiedName(AstQualifiedName&&) = default;
AstQualifiedName& operator=(const AstQualifiedName&) = default;
AstQualifiedName& operator=(AstQualifiedName&&) = default;
/** append qualifiers */
void append(std::string name) {
qualifiers.push_back(std::move(name));
}
/** prepend qualifiers */
void prepend(std::string name) {
qualifiers.insert(qualifiers.begin(), std::move(name));
}
/** check for emptiness */
bool empty() const {
return qualifiers.empty();
}
/** get qualifiers */
const std::vector<std::string>& getQualifiers() const {
return qualifiers;
}
/** convert to a string separated by fullstop */
std::string toString() const {
std::stringstream ss;
ss << join(qualifiers, ".");
return ss.str();
}
bool operator==(const AstQualifiedName& other) const {
return qualifiers == other.qualifiers;
}
bool operator!=(const AstQualifiedName& other) const {
return !(*this == other);
}
bool operator<(const AstQualifiedName& other) const {
return std::lexicographical_compare(
qualifiers.begin(), qualifiers.end(), other.qualifiers.begin(), other.qualifiers.end());
}
/** print qualified name */
void print(std::ostream& out) const {
out << join(qualifiers, ".");
}
friend std::ostream& operator<<(std::ostream& out, const AstQualifiedName& id) {
id.print(out);
return out;
}
private:
/* array of name qualifiers */
std::vector<std::string> qualifiers;
};
inline AstQualifiedName operator+(const std::string& name, const AstQualifiedName& id) {
AstQualifiedName res = id;
res.prepend(name);
return res;
}
} // namespace souffle