1 // +------------------------------------------------------------------+
2 // | ____ _ _ __ __ _ __ |
3 // | / ___| |__ ___ ___| | __ | \/ | |/ / |
4 // | | | | '_ \ / _ \/ __| |/ / | |\/| | ' / |
5 // | | |___| | | | __/ (__| < | | | | . \ |
6 // | \____|_| |_|\___|\___|_|\_\___|_| |_|_|\_\ |
8 // | Copyright Mathias Kettner 2014 mk@mathias-kettner.de |
9 // +------------------------------------------------------------------+
11 // This file is part of Check_MK.
12 // The official homepage is at http://mathias-kettner.de/check_mk.
14 // check_mk is free software; you can redistribute it and/or modify it
15 // under the terms of the GNU General Public License as published by
16 // the Free Software Foundation in version 2. check_mk is distributed
17 // in the hope that it will be useful, but WITHOUT ANY WARRANTY; with-
18 // out even the implied warranty of MERCHANTABILITY or FITNESS FOR A
19 // PARTICULAR PURPOSE. See the GNU General Public License for more de-
20 // tails. You should have received a copy of the GNU General Public
21 // License along with GNU Make; see the file COPYING. If not, write
22 // to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
23 // Boston, MA 02110-1301 USA.
25 #include "AndingFilter.h"
30 #include <type_traits>
33 #include "OringFilter.h"
37 std::unique_ptr
<Filter
> AndingFilter::make(Kind kind
, Filters subfilters
) {
39 for (const auto &filter
: subfilters
) {
40 if (filter
->is_contradiction()) {
41 return OringFilter::make(kind
, Filters());
43 auto conjuncts
= filter
->conjuncts();
44 filters
.insert(filters
.end(),
45 std::make_move_iterator(conjuncts
.begin()),
46 std::make_move_iterator(conjuncts
.end()));
48 return filters
.size() == 1 ? std::move(filters
[0])
49 : std::make_unique
<AndingFilter
>(
50 kind
, std::move(filters
), Secret());
53 bool AndingFilter::accepts(Row row
, const contact
*auth_user
,
54 std::chrono::seconds timezone_offset
) const {
55 for (const auto &filter
: _subfilters
) {
56 if (!filter
->accepts(row
, auth_user
, timezone_offset
)) {
63 std::unique_ptr
<Filter
> AndingFilter::partialFilter(
64 std::function
<bool(const Column
&)> predicate
) const {
67 _subfilters
.begin(), _subfilters
.end(), std::back_inserter(filters
),
68 [&](const auto &filter
) { return filter
->partialFilter(predicate
); });
69 return make(kind(), std::move(filters
));
72 std::optional
<std::string
> AndingFilter::stringValueRestrictionFor(
73 const std::string
&column_name
) const {
74 for (const auto &filter
: _subfilters
) {
75 if (auto value
= filter
->stringValueRestrictionFor(column_name
)) {
82 std::optional
<int32_t> AndingFilter::greatestLowerBoundFor(
83 const std::string
&column_name
,
84 std::chrono::seconds timezone_offset
) const {
85 std::optional
<int32_t> result
;
86 for (const auto &filter
: _subfilters
) {
88 filter
->greatestLowerBoundFor(column_name
, timezone_offset
)) {
89 result
= result
? std::max(*result
, *glb
) : glb
;
95 std::optional
<int32_t> AndingFilter::leastUpperBoundFor(
96 const std::string
&column_name
,
97 std::chrono::seconds timezone_offset
) const {
98 std::optional
<int32_t> result
;
99 for (const auto &filter
: _subfilters
) {
101 filter
->leastUpperBoundFor(column_name
, timezone_offset
)) {
102 result
= result
? std::min(*result
, *lub
) : lub
;
108 std::optional
<std::bitset
<32>> AndingFilter::valueSetLeastUpperBoundFor(
109 const std::string
&column_name
,
110 std::chrono::seconds timezone_offset
) const {
111 std::optional
<std::bitset
<32>> result
;
112 for (const auto &filter
: _subfilters
) {
113 if (auto foo
= filter
->valueSetLeastUpperBoundFor(column_name
,
115 result
= result
? (*result
& *foo
) : foo
;
121 std::unique_ptr
<Filter
> AndingFilter::copy() const {
122 return make(kind(), conjuncts());
125 std::unique_ptr
<Filter
> AndingFilter::negate() const {
127 std::transform(_subfilters
.begin(), _subfilters
.end(),
128 std::back_inserter(filters
),
129 [](const auto &filter
) { return filter
->negate(); });
130 return OringFilter::make(kind(), std::move(filters
));
133 bool AndingFilter::is_tautology() const { return _subfilters
.empty(); }
135 bool AndingFilter::is_contradiction() const { return false; }
137 Filters
AndingFilter::disjuncts() const {
139 filters
.push_back(copy());
143 Filters
AndingFilter::conjuncts() const {
145 std::transform(_subfilters
.begin(), _subfilters
.end(),
146 std::back_inserter(filters
),
147 [](const auto &filter
) { return filter
->copy(); });
151 std::ostream
&AndingFilter::print(std::ostream
&os
) const {
152 for (const auto &filter
: _subfilters
) {
153 os
<< *filter
<< "\\n";
162 case Kind::wait_condition
:
163 os
<< "WaitConditionAnd";
166 return os
<< ": " << _subfilters
.size();