1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "automotive.vehicle@2.0-impl"
18
19#include "VehicleUtils.h"
20
21#include <log/log.h>
22
23namespace android {
24namespace hardware {
25namespace automotive {
26namespace vehicle {
27namespace V2_0 {
28
29//namespace utils {
30
31std::unique_ptr<VehiclePropValue> createVehiclePropValue(
32    VehiclePropertyType type, size_t vecSize) {
33    auto val = std::unique_ptr<VehiclePropValue>(new VehiclePropValue);
34    switch (type) {
35        case VehiclePropertyType::INT32:      // fall through
36        case VehiclePropertyType::INT32_VEC:  // fall through
37        case VehiclePropertyType::BOOLEAN:
38            val->value.int32Values.resize(vecSize);
39            break;
40        case VehiclePropertyType::FLOAT:      // fall through
41        case VehiclePropertyType::FLOAT_VEC:
42            val->value.floatValues.resize(vecSize);
43            break;
44        case VehiclePropertyType::INT64:
45            val->value.int64Values.resize(vecSize);
46            break;
47        case VehiclePropertyType::BYTES:
48            val->value.bytes.resize(vecSize);
49            break;
50        case VehiclePropertyType::STRING:
51        case VehiclePropertyType::COMPLEX:
52            break; // Valid, but nothing to do.
53        default:
54            ALOGE("createVehiclePropValue: unknown type: %d", type);
55            val.reset(nullptr);
56    }
57    return val;
58}
59
60size_t getVehicleRawValueVectorSize(
61    const VehiclePropValue::RawValue& value, VehiclePropertyType type) {
62    switch (type) {
63        case VehiclePropertyType::INT32:      // fall through
64        case VehiclePropertyType::INT32_VEC:  // fall through
65        case VehiclePropertyType::BOOLEAN:
66            return value.int32Values.size();
67        case VehiclePropertyType::FLOAT:      // fall through
68        case VehiclePropertyType::FLOAT_VEC:
69            return value.floatValues.size();
70        case VehiclePropertyType::INT64:
71            return value.int64Values.size();
72        case VehiclePropertyType::BYTES:
73            return value.bytes.size();
74        default:
75            return 0;
76    }
77}
78
79template<typename T>
80inline void copyHidlVec(hidl_vec <T>* dest, const hidl_vec <T>& src) {
81    for (size_t i = 0; i < std::min(dest->size(), src.size()); i++) {
82        (*dest)[i] = src[i];
83    }
84}
85
86void copyVehicleRawValue(VehiclePropValue::RawValue* dest,
87                         const VehiclePropValue::RawValue& src) {
88    dest->int32Values = src.int32Values;
89    dest->floatValues = src.floatValues;
90    dest->int64Values = src.int64Values;
91    dest->bytes = src.bytes;
92    dest->stringValue = src.stringValue;
93}
94
95template<typename T>
96void shallowCopyHidlVec(hidl_vec <T>* dest, const hidl_vec <T>& src) {
97    if (src.size() > 0) {
98        dest->setToExternal(const_cast<T*>(&src[0]), src.size());
99    } else if (dest->size() > 0) {
100        dest->resize(0);
101    }
102}
103
104void shallowCopyHidlStr(hidl_string* dest, const hidl_string& src) {
105    if (src.empty()) {
106        dest->clear();
107    } else {
108        dest->setToExternal(src.c_str(), src.size());
109    }
110}
111
112void shallowCopy(VehiclePropValue* dest, const VehiclePropValue& src) {
113    dest->prop = src.prop;
114    dest->areaId = src.areaId;
115    dest->timestamp = src.timestamp;
116    shallowCopyHidlVec(&dest->value.int32Values, src.value.int32Values);
117    shallowCopyHidlVec(&dest->value.int64Values, src.value.int64Values);
118    shallowCopyHidlVec(&dest->value.floatValues, src.value.floatValues);
119    shallowCopyHidlVec(&dest->value.bytes, src.value.bytes);
120    shallowCopyHidlStr(&dest->value.stringValue, src.value.stringValue);
121}
122
123
124//}  // namespace utils
125
126}  // namespace V2_0
127}  // namespace vehicle
128}  // namespace automotive
129}  // namespace hardware
130}  // namespace android
131