blob: bcf7a4af735b1a8432277d92ea134dc0909f90d1 (
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
118
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
#pragma once
#include <string>
#include "include/types.h"
#include "common/Formatter.h"
static std::string RGW_STORAGE_CLASS_STANDARD = "STANDARD";
struct rgw_placement_rule {
std::string name;
std::string storage_class;
rgw_placement_rule() {}
rgw_placement_rule(const std::string& _n, const std::string& _sc) : name(_n), storage_class(_sc) {}
rgw_placement_rule(const rgw_placement_rule& _r, const std::string& _sc) : name(_r.name) {
if (!_sc.empty()) {
storage_class = _sc;
} else {
storage_class = _r.storage_class;
}
}
bool empty() const {
return name.empty() && storage_class.empty();
}
void inherit_from(const rgw_placement_rule& r) {
if (name.empty()) {
name = r.name;
}
if (storage_class.empty()) {
storage_class = r.storage_class;
}
}
void clear() {
name.clear();
storage_class.clear();
}
void init(const std::string& n, const std::string& c) {
name = n;
storage_class = c;
}
static const std::string& get_canonical_storage_class(const std::string& storage_class) {
if (storage_class.empty()) {
return RGW_STORAGE_CLASS_STANDARD;
}
return storage_class;
}
const std::string& get_storage_class() const {
return get_canonical_storage_class(storage_class);
}
int compare(const rgw_placement_rule& r) const {
int c = name.compare(r.name);
if (c != 0) {
return c;
}
return get_storage_class().compare(r.get_storage_class());
}
bool operator==(const rgw_placement_rule& r) const {
return (name == r.name &&
get_storage_class() == r.get_storage_class());
}
bool operator!=(const rgw_placement_rule& r) const {
return !(*this == r);
}
void encode(bufferlist& bl) const {
/* no ENCODE_START/END due to backward compatibility */
std::string s = to_str();
ceph::encode(s, bl);
}
void decode(bufferlist::const_iterator& bl) {
std::string s;
ceph::decode(s, bl);
from_str(s);
}
std::string to_str() const {
if (standard_storage_class()) {
return name;
}
return to_str_explicit();
}
std::string to_str_explicit() const {
return name + "/" + storage_class;
}
void from_str(const std::string& s) {
size_t pos = s.find("/");
if (pos == std::string::npos) {
name = s;
storage_class.clear();
return;
}
name = s.substr(0, pos);
storage_class = s.substr(pos + 1);
}
bool standard_storage_class() const {
return storage_class.empty() || storage_class == RGW_STORAGE_CLASS_STANDARD;
}
};
WRITE_CLASS_ENCODER(rgw_placement_rule)
|
