Add support for PersistableBundle in C++
Add support for PersistableBundle, a mapping from
String values to various types, in C++.
BUG: 25815410
Change-Id: If609b294a1709314bb4220afc4f2269b556babb8
diff --git a/include/binder/PersistableBundle.h b/include/binder/PersistableBundle.h
new file mode 100644
index 0000000..fe5619f
--- /dev/null
+++ b/include/binder/PersistableBundle.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_PERSISTABLE_BUNDLE_H
+#define ANDROID_PERSISTABLE_BUNDLE_H
+
+#include <map>
+#include <vector>
+
+#include <binder/Parcelable.h>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+namespace os {
+
+/*
+ * C++ implementation of PersistableBundle, a mapping from String values to
+ * various types that can be saved to persistent and later restored.
+ */
+class PersistableBundle : public Parcelable {
+public:
+ PersistableBundle() = default;
+ virtual ~PersistableBundle() = default;
+ PersistableBundle(const PersistableBundle& bundle) = default;
+
+ status_t writeToParcel(Parcel* parcel) const override;
+ status_t readFromParcel(const Parcel* parcel) override;
+
+ bool empty() const;
+ size_t size() const;
+ size_t erase(const String16& key);
+
+ /*
+ * Setters for PersistableBundle. Adds a a key-value pair instantiated with
+ * |key| and |value| into the member map appropriate for the type of |value|.
+ * If there is already an existing value for |key|, |value| will replace it.
+ */
+ void putBoolean(const String16& key, bool value);
+ void putInt(const String16& key, int32_t value);
+ void putLong(const String16& key, int64_t value);
+ void putDouble(const String16& key, double value);
+ void putString(const String16& key, const String16& value);
+ void putBooleanVector(const String16& key, const std::vector<bool>& value);
+ void putIntVector(const String16& key, const std::vector<int32_t>& value);
+ void putLongVector(const String16& key, const std::vector<int64_t>& value);
+ void putDoubleVector(const String16& key, const std::vector<double>& value);
+ void putStringVector(const String16& key, const std::vector<String16>& value);
+ void putPersistableBundle(const String16& key, const PersistableBundle& value);
+
+ /*
+ * Getters for PersistableBundle. If |key| exists, these methods write the
+ * value associated with |key| into |out|, and return true. Otherwise, these
+ * methods return false.
+ */
+ bool getBoolean(const String16& key, bool* out) const;
+ bool getInt(const String16& key, int32_t* out) const;
+ bool getLong(const String16& key, int64_t* out) const;
+ bool getDouble(const String16& key, double* out) const;
+ bool getString(const String16& key, String16* out) const;
+ bool getBooleanVector(const String16& key, std::vector<bool>* out) const;
+ bool getIntVector(const String16& key, std::vector<int32_t>* out) const;
+ bool getLongVector(const String16& key, std::vector<int64_t>* out) const;
+ bool getDoubleVector(const String16& key, std::vector<double>* out) const;
+ bool getStringVector(const String16& key, std::vector<String16>* out) const;
+ bool getPersistableBundle(const String16& key, PersistableBundle* out) const;
+
+ friend bool operator==(const PersistableBundle& lhs, const PersistableBundle& rhs) {
+ return (lhs.mBoolMap == rhs.mBoolMap && lhs.mIntMap == rhs.mIntMap &&
+ lhs.mLongMap == rhs.mLongMap && lhs.mDoubleMap == rhs.mDoubleMap &&
+ lhs.mStringMap == rhs.mStringMap && lhs.mBoolVectorMap == rhs.mBoolVectorMap &&
+ lhs.mIntVectorMap == rhs.mIntVectorMap &&
+ lhs.mLongVectorMap == rhs.mLongVectorMap &&
+ lhs.mDoubleVectorMap == rhs.mDoubleVectorMap &&
+ lhs.mStringVectorMap == rhs.mStringVectorMap &&
+ lhs.mPersistableBundleMap == rhs.mPersistableBundleMap);
+ }
+
+ friend bool operator!=(const PersistableBundle& lhs, const PersistableBundle& rhs) {
+ return !(lhs == rhs);
+ }
+
+private:
+ status_t writeToParcelInner(Parcel* parcel) const;
+ status_t readFromParcelInner(const Parcel* parcel, size_t length);
+
+ std::map<String16, bool> mBoolMap;
+ std::map<String16, int32_t> mIntMap;
+ std::map<String16, int64_t> mLongMap;
+ std::map<String16, double> mDoubleMap;
+ std::map<String16, String16> mStringMap;
+ std::map<String16, std::vector<bool>> mBoolVectorMap;
+ std::map<String16, std::vector<int32_t>> mIntVectorMap;
+ std::map<String16, std::vector<int64_t>> mLongVectorMap;
+ std::map<String16, std::vector<double>> mDoubleVectorMap;
+ std::map<String16, std::vector<String16>> mStringVectorMap;
+ std::map<String16, PersistableBundle> mPersistableBundleMap;
+};
+
+} // namespace os
+
+} // namespace android
+
+#endif // ANDROID_PERSISTABLE_BUNDLE_H