diff options
Diffstat (limited to 'cmds/statsd/src/dimension.cpp')
| -rw-r--r-- | cmds/statsd/src/dimension.cpp | 400 |
1 files changed, 0 insertions, 400 deletions
diff --git a/cmds/statsd/src/dimension.cpp b/cmds/statsd/src/dimension.cpp deleted file mode 100644 index 8a2e87128319..000000000000 --- a/cmds/statsd/src/dimension.cpp +++ /dev/null @@ -1,400 +0,0 @@ -/* - * 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. - */ - -#include "Log.h" - -#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" -#include "frameworks/base/cmds/statsd/src/statsd_internal.pb.h" -#include "dimension.h" - - -namespace android { -namespace os { -namespace statsd { - -const DimensionsValue* getSingleLeafValue(const DimensionsValue* value) { - if (value->value_case() == DimensionsValue::ValueCase::kValueTuple) { - return getSingleLeafValue(&value->value_tuple().dimensions_value(0)); - } else { - return value; - } -} - -DimensionsValue getSingleLeafValue(const DimensionsValue& value) { - const DimensionsValue* leafValue = getSingleLeafValue(&value); - return *leafValue; -} - -void appendLeafNodeToTree(const Field& field, - const DimensionsValue& value, - DimensionsValue* parentValue) { - if (field.child_size() <= 0) { - *parentValue = value; - parentValue->set_field(field.field()); - return; - } - parentValue->set_field(field.field()); - int idx = -1; - for (int i = 0; i < parentValue->mutable_value_tuple()->dimensions_value_size(); ++i) { - if (parentValue->mutable_value_tuple()->dimensions_value(i).field() == - field.child(0).field()) { - idx = i; - } - } - if (idx < 0) { - parentValue->mutable_value_tuple()->add_dimensions_value(); - idx = parentValue->mutable_value_tuple()->dimensions_value_size() - 1; - } - appendLeafNodeToTree( - field.child(0), value, - parentValue->mutable_value_tuple()->mutable_dimensions_value(idx)); -} - -void appendLeafNodeToTrees(const Field& field, - const DimensionsValue& node, - std::vector<DimensionsValue>* rootTrees) { - if (rootTrees == nullptr) { - return; - } - if (rootTrees->empty()) { - DimensionsValue tree; - appendLeafNodeToTree(field, node, &tree); - rootTrees->push_back(tree); - } else { - for (size_t i = 0; i < rootTrees->size(); ++i) { - appendLeafNodeToTree(field, node, &rootTrees->at(i)); - } - } -} - -namespace { - -void findDimensionsValues( - const FieldValueMap& fieldValueMap, - const FieldMatcher& matcher, - Field* rootField, - Field* leafField, - std::vector<DimensionsValue>* rootDimensionsValues); - -void findNonRepeatedDimensionsValues( - const FieldValueMap& fieldValueMap, - const FieldMatcher& matcher, - Field* rootField, - Field* leafField, - std::vector<DimensionsValue>* rootValues) { - if (matcher.child_size() > 0) { - Field* newLeafField = leafField->add_child(); - for (const auto& childMatcher : matcher.child()) { - newLeafField->set_field(childMatcher.field()); - findDimensionsValues(fieldValueMap, childMatcher, rootField, newLeafField, rootValues); - } - leafField->clear_child(); - } else { - auto ret = fieldValueMap.equal_range(*rootField); - int found = 0; - for (auto it = ret.first; it != ret.second; ++it) { - found++; - } - // Not found. - if (found <= 0) { - return; - } - if (found > 1) { - ALOGE("Found multiple values for optional field."); - return; - } - appendLeafNodeToTrees(*rootField, ret.first->second, rootValues); - } -} - -void findRepeatedDimensionsValues(const FieldValueMap& fieldValueMap, - const FieldMatcher& matcher, - Field* rootField, - Field* leafField, - std::vector<DimensionsValue>* rootValues) { - if (matcher.position() == Position::FIRST) { - leafField->set_position_index(0); - findNonRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField, rootValues); - leafField->clear_position_index(); - } else { - auto itLower = fieldValueMap.lower_bound(*rootField); - if (itLower == fieldValueMap.end()) { - return; - } - const int leafFieldNum = leafField->field(); - leafField->set_field(leafFieldNum + 1); - auto itUpper = fieldValueMap.lower_bound(*rootField); - // Resets the field number. - leafField->set_field(leafFieldNum); - - switch (matcher.position()) { - case Position::LAST: - { - itUpper--; - if (itUpper != fieldValueMap.end()) { - int last_index = getPositionByReferenceField(*rootField, itUpper->first); - if (last_index < 0) { - return; - } - leafField->set_position_index(last_index); - findNonRepeatedDimensionsValues( - fieldValueMap, matcher, rootField, leafField, rootValues); - leafField->clear_position_index(); - } - } - break; - case Position::ANY: - { - std::set<int> indexes; - for (auto it = itLower; it != itUpper; ++it) { - int index = getPositionByReferenceField(*rootField, it->first); - if (index >= 0) { - indexes.insert(index); - } - } - if (!indexes.empty()) { - std::vector<DimensionsValue> allValues; - for (const int index : indexes) { - leafField->set_position_index(index); - std::vector<DimensionsValue> newValues = *rootValues; - findNonRepeatedDimensionsValues( - fieldValueMap, matcher, rootField, leafField, &newValues); - allValues.insert(allValues.end(), newValues.begin(), newValues.end()); - leafField->clear_position_index(); - } - rootValues->clear(); - rootValues->insert(rootValues->end(), allValues.begin(), allValues.end()); - } - } - break; - default: - break; - } - } -} - -void findDimensionsValues( - const FieldValueMap& fieldValueMap, - const FieldMatcher& matcher, - Field* rootField, - Field* leafField, - std::vector<DimensionsValue>* rootDimensionsValues) { - if (!matcher.has_position()) { - findNonRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField, - rootDimensionsValues); - } else { - findRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField, - rootDimensionsValues); - } -} - -} // namespace - -void findDimensionsValues( - const FieldValueMap& fieldValueMap, - const FieldMatcher& matcher, - std::vector<DimensionsValue>* rootDimensionsValues) { - Field rootField; - buildSimpleAtomField(matcher.field(), &rootField); - findDimensionsValues(fieldValueMap, matcher, &rootField, &rootField, rootDimensionsValues); -} - -void buildSimpleAtomFieldMatcher(const int tagId, FieldMatcher* matcher) { - matcher->set_field(tagId); -} - -void buildSimpleAtomFieldMatcher(const int tagId, const int fieldNum, FieldMatcher* matcher) { - matcher->set_field(tagId); - matcher->add_child()->set_field(fieldNum); -} - -constexpr int ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO = 1; -constexpr int UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO = 1; -constexpr int TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO = 2; - -void buildAttributionUidFieldMatcher(const int tagId, const Position position, - FieldMatcher* matcher) { - matcher->set_field(tagId); - auto child = matcher->add_child(); - child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO); - child->set_position(position); - child->add_child()->set_field(UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO); -} - -void buildAttributionTagFieldMatcher(const int tagId, const Position position, - FieldMatcher* matcher) { - matcher->set_field(tagId); - FieldMatcher* child = matcher->add_child(); - child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO); - child->set_position(position); - child->add_child()->set_field(TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO); -} - -void buildAttributionFieldMatcher(const int tagId, const Position position, FieldMatcher* matcher) { - matcher->set_field(tagId); - FieldMatcher* child = matcher->add_child(); - child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO); - child->set_position(position); - child->add_child()->set_field(UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO); - child->add_child()->set_field(TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO); -} - -void DimensionsValueToString(const DimensionsValue& value, std::string *flattened) { - if (!value.has_field()) { - return; - } - *flattened += std::to_string(value.field()); - *flattened += ":"; - switch (value.value_case()) { - case DimensionsValue::ValueCase::kValueStr: - *flattened += value.value_str(); - break; - case DimensionsValue::ValueCase::kValueInt: - *flattened += std::to_string(value.value_int()); - break; - case DimensionsValue::ValueCase::kValueLong: - *flattened += std::to_string(value.value_long()); - break; - case DimensionsValue::ValueCase::kValueBool: - *flattened += std::to_string(value.value_bool()); - break; - case DimensionsValue::ValueCase::kValueFloat: - *flattened += std::to_string(value.value_float()); - break; - case DimensionsValue::ValueCase::kValueTuple: - { - *flattened += "{"; - for (int i = 0; i < value.value_tuple().dimensions_value_size(); ++i) { - DimensionsValueToString(value.value_tuple().dimensions_value(i), flattened); - *flattened += "|"; - } - *flattened += "}"; - } - break; - case DimensionsValue::ValueCase::VALUE_NOT_SET: - break; - } -} - -std::string DimensionsValueToString(const DimensionsValue& value) { - std::string flatten; - DimensionsValueToString(value, &flatten); - return flatten; -} - -bool IsSubDimension(const DimensionsValue& dimension, const DimensionsValue& sub) { - if (dimension.field() != sub.field()) { - return false; - } - if (dimension.value_case() != sub.value_case()) { - return false; - } - switch (dimension.value_case()) { - case DimensionsValue::ValueCase::kValueStr: - return dimension.value_str() == sub.value_str(); - case DimensionsValue::ValueCase::kValueInt: - return dimension.value_int() == sub.value_int(); - case DimensionsValue::ValueCase::kValueLong: - return dimension.value_long() == sub.value_long(); - case DimensionsValue::ValueCase::kValueBool: - return dimension.value_bool() == sub.value_bool(); - case DimensionsValue::ValueCase::kValueFloat: - return dimension.value_float() == sub.value_float(); - case DimensionsValue::ValueCase::kValueTuple: { - if (dimension.value_tuple().dimensions_value_size() < - sub.value_tuple().dimensions_value_size()) { - return false; - } - bool allSub = true; - for (int i = 0; allSub && i < sub.value_tuple().dimensions_value_size(); ++i) { - bool isSub = false; - for (int j = 0; !isSub && - j < dimension.value_tuple().dimensions_value_size(); ++j) { - isSub |= IsSubDimension(dimension.value_tuple().dimensions_value(j), - sub.value_tuple().dimensions_value(i)); - } - allSub &= isSub; - } - return allSub; - } - break; - case DimensionsValue::ValueCase::VALUE_NOT_SET: - return false; - default: - return false; - } -} - -long getLongFromDimenValue(const DimensionsValue& dimensionValue) { - switch (dimensionValue.value_case()) { - case DimensionsValue::ValueCase::kValueInt: - return dimensionValue.value_int(); - case DimensionsValue::ValueCase::kValueLong: - return dimensionValue.value_long(); - case DimensionsValue::ValueCase::kValueBool: - return dimensionValue.value_bool() ? 1 : 0; - case DimensionsValue::ValueCase::kValueFloat: - return (int64_t)dimensionValue.value_float(); - case DimensionsValue::ValueCase::kValueTuple: - case DimensionsValue::ValueCase::kValueStr: - case DimensionsValue::ValueCase::VALUE_NOT_SET: - return 0; - } -} - -bool getSubDimension(const DimensionsValue& dimension, const FieldMatcher& matcher, - DimensionsValue* subDimension) { - if (!matcher.has_field()) { - return false; - } - if (matcher.field() != dimension.field()) { - return false; - } - if (matcher.child_size() <= 0) { - if (dimension.value_case() == DimensionsValue::ValueCase::kValueTuple || - dimension.value_case() == DimensionsValue::ValueCase::VALUE_NOT_SET) { - return false; - } - *subDimension = dimension; - return true; - } else { - if (dimension.value_case() != DimensionsValue::ValueCase::kValueTuple) { - return false; - } - bool found_value = true; - auto value_tuple = dimension.value_tuple(); - subDimension->set_field(dimension.field()); - for (int i = 0; found_value && i < matcher.child_size(); ++i) { - int j = 0; - for (; j < value_tuple.dimensions_value_size(); ++j) { - if (value_tuple.dimensions_value(j).field() == matcher.child(i).field()) { - break; - } - } - if (j < value_tuple.dimensions_value_size()) { - found_value &= getSubDimension(value_tuple.dimensions_value(j), matcher.child(i), - subDimension->mutable_value_tuple()->add_dimensions_value()); - } else { - found_value = false; - } - } - return found_value; - } -} - -} // namespace statsd -} // namespace os -} // namespace android |