-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(bundle C)
-
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(bundle C CXX)
IF("${VERSION}" STREQUAL "")
- MESSAGE(FATAL_ERROR "VERSION is not defined")
+ MESSAGE(FATAL_ERROR "VERSION is not defined")
ENDIF()
STRING(REGEX MATCH "^[0-9]+" VERSION_MAJOR ${VERSION})
IF("${VERSION_MAJOR}" STREQUAL "")
- MESSAGE(FATAL_ERROR "can't get VERSION_MAJOR")
+ MESSAGE(FATAL_ERROR "can't get VERSION_MAJOR")
ENDIF()
-### Required packages
INCLUDE(FindPkgConfig)
-pkg_check_modules(pkgs REQUIRED glib-2.0 dlog capi-base-common json-glib-1.0)
+pkg_check_modules(pkgs REQUIRED
+ glib-2.0 dlog capi-base-common json-glib-1.0
+)
+
FOREACH(flag ${pkgs_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ENDFOREACH(flag)
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -flto -Wall -Werror -Winline")
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++11")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fvisibility=hidden -flto")
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/src)
-### Local include directories
-include_directories(${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/src)
+AUX_SOURCE_DIRECTORY(src SOURCES)
-### Build
-aux_source_directory(src SRCS)
-add_library(bundle SHARED ${SRCS})
+ADD_LIBRARY (${PROJECT_NAME} SHARED ${SOURCES})
set_target_properties(bundle PROPERTIES SOVERSION ${VERSION_MAJOR})
set_target_properties(bundle PROPERTIES VERSION "${VERSION}")
-message(STATUS "Version from debian/changelog: ${VERSION}, Major version: ${VERSION_MAJOR}")
-target_link_libraries(bundle ${pkgs_LDFLAGS})
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${EXTRA_CFLAGS} -fPIE")
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-pie")
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS})
### Make pkgconfig file
SET(PREFIX ${CMAKE_INSTALL_PREFIX})
install(TARGETS bundle DESTINATION ${LIB_INSTALL_DIR})
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ DESTINATION include/)
install(FILES ${CMAKE_BINARY_DIR}/bundle.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig/)
+
+IF(NOT DEFINED MINIMUM_BUILD)
+ENABLE_TESTING()
+SET(BUNDLE_UNITTESTS bundle_unittests)
+ADD_TEST(NAME ${BUNDLE_UNITTESTS} COMMAND ${BUNDLE_UNITTESTS}
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/unit_tests)
+
+ADD_SUBDIRECTORY(unit_tests)
+ADD_DEPENDENCIES(bundle_unittests bundle)
+ENDIF(NOT DEFINED MINIMUM_BUILD)
Requires: capi-base-common
Libs: -L${libdir} -lbundle
Cflags: -I${includedir}
+cppflags: -I${includedir}
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ *
+ * 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 BUNDLE_CPP_H_
+#define BUNDLE_CPP_H_
+
+/**
+ * @file bundle_cpp.h
+ * @brief This file declares API of the bundle C++ library.
+ */
+
+/**
+ * @addtogroup CORE_LIB_BUNDLE_CPP_MODULE
+ * @{
+ */
+
+#include <bundle.h>
+#include <dlog.h>
+
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "BUNDLE"
+
+#ifndef EXPORT_API
+#define EXPORT_API __attribute__((visibility("default")))
+#endif
+
+namespace tizen_base {
+
+/**
+ * @brief The class for bundle APIs.
+ * @since_tizen 5.5
+ */
+class EXPORT_API Bundle final {
+ public:
+ /**
+ * @brief The type for raw bundle.
+ * @since_tizen 5.5
+ */
+ using BundleRaw =
+ std::pair<std::unique_ptr<bundle_raw, decltype(std::free)*>, int>;
+
+ /**
+ * @brief The class for information of keys.
+ * @since_tizen 5.5
+ */
+ class KeyInfo final {
+ public:
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ * @param[in] handle The handle for type bundle_keyval_t
+ * @param[in] name The key string
+ */
+ KeyInfo(const bundle_keyval_t* handle, std::string name);
+
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ */
+ KeyInfo();
+
+ /**
+ * @brief Destructor.
+ * @since_tizen 5.5
+ */
+ ~KeyInfo();
+
+ /**
+ * @brief Copy-constructor.
+ * @since_tizen 5.5
+ * @param[in] b The object to copy
+ */
+ KeyInfo(const KeyInfo& b);
+
+ /**
+ * @brief Assignment.
+ * @since_tizen 5.5
+ * @param[in] b The object to copy
+ */
+ KeyInfo& operator = (const KeyInfo& b);
+
+ /**
+ * @brief Move-constructor.
+ * @since_tizen 5.5
+ * @param[in] b The object to move
+ */
+ KeyInfo(KeyInfo&& b) noexcept;
+
+ /**
+ * @brief Assignment.
+ * @since_tizen 5.5
+ * @param[in] b The object to move
+ */
+ KeyInfo& operator = (KeyInfo&& b) noexcept;
+
+ /**
+ * @brief Gets the type of a key-value pair.
+ * @since_tizen 5.5
+ * @return The type
+ */
+ bundle_type GetType() const;
+
+ /**
+ * @brief Determines whether the type of a key-value pair is an array.
+ * @since_tizen 5.5
+ * @return True when it is an array
+ */
+ bool IsArray() const;
+
+ /**
+ * @brief Gets the key string.
+ * @since_tizen 5.5
+ * @return The key string
+ */
+ const std::string& GetName() const;
+
+ private:
+ class Impl;
+ std::unique_ptr<Impl> impl_;
+ };
+
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ */
+ Bundle();
+
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ * @param[in] raw The object for BundleRaw
+ */
+ explicit Bundle(BundleRaw raw);
+
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ * @param[in] raw The string object for raw bundle
+ */
+ explicit Bundle(const std::string& raw);
+
+ /**
+ * @brief Constructor.
+ * @since_tizen 5.5
+ * @param[in] b The handle for bundle
+ * @param[in] copy True if this object wants to copy it from the handle
+ * @param[in] own True if this object owns the handle
+ */
+ explicit Bundle(bundle* b, bool copy = true, bool own = true);
+
+ /**
+ * @brief Destructor.
+ * @since_tizen 5.5
+ */
+ ~Bundle();
+
+ /**
+ * @brief Copy-constructor.
+ * @since_tizen 5.5
+ * @param[in] b The object to copy
+ */
+ Bundle(const Bundle& b);
+
+ /**
+ * @brief Assignment.
+ * @since_tizen 5.5
+ * @param[in] b The object to copy
+ */
+ Bundle& operator = (const Bundle& b);
+
+ /**
+ * @brief Move-constructor.
+ * @since_tizen 5.5
+ * @param[in] b The object to move
+ */
+ Bundle(Bundle&& b) noexcept;
+
+ /**
+ * @brief Assignment.
+ * @since_tizen 5.5
+ * @param[in] b The object to move
+ */
+ Bundle& operator = (Bundle&& b) noexcept;
+
+ /**
+ * @brief Gets keys in bundle object.
+ * @since_tizen 5.5
+ * @return A string array of object KeyInfo
+ */
+ std::vector<KeyInfo> GetKeys();
+
+ /**
+ * @brief Adds a string type key-value pair into a bundle.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @param[in] val The string value
+ * @return The operation result
+ * @retval BUNDLE_ERROR_NONE Success
+ * @retval BUNDLE_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval BUNDLE_ERROR_KEY_EXISTS Key already exists
+ * @retval BUNDLE_ERROR_OUT_OF_MEMORY Out of memory
+ */
+ int Add(const std::string& key, const std::string& val);
+
+ /**
+ * @brief Adds a string type key-value pair into a bundle.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @param[in] val The array of strings
+ * @return The operation result
+ * @retval BUNDLE_ERROR_NONE Success
+ * @retval BUNDLE_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval BUNDLE_ERROR_KEY_EXISTS Key already exists
+ * @retval BUNDLE_ERROR_OUT_OF_MEMORY Out of memory
+ */
+ int Add(const std::string& key, const std::vector<std::string>& val);
+
+ /**
+ * @brief Adds a string type key-value pair into a bundle.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @param[in] val The array of bytes
+ * @return The operation result
+ * @retval BUNDLE_ERROR_NONE Success
+ * @retval BUNDLE_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval BUNDLE_ERROR_KEY_EXISTS Key already exists
+ * @retval BUNDLE_ERROR_OUT_OF_MEMORY Out of memory
+ */
+ int Add(const std::string& key, const std::vector<unsigned char>& val);
+
+ /**
+ * @brief Deletes a key-value object with the given key.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @return The operation result
+ * @retval BUNDLE_ERROR_NONE Success
+ * @retval BUNDLE_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval BUNDLE_ERROR_KEY_NOT_AVAILABLE Key not available
+ */
+ int Delete(const std::string& key);
+
+ /**
+ * @brief Gets a string from the key.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @return The string
+ */
+ std::string GetString(const std::string& key) const;
+
+ /**
+ * @brief Gets strings from the key.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @return The array of strings
+ */
+ std::vector<std::string> GetStringArray(const std::string& key) const;
+
+ /**
+ * @brief Gets bytes from the key.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @return Bytes
+ */
+ std::vector<unsigned char> GetByte(const std::string& key) const;
+
+ /**
+ * @brief Converts this object to BundleRaw type.
+ * @since_tizen 5.5
+ * @return The object of BundleRaw
+ */
+ BundleRaw ToRaw();
+
+ /**
+ * @brief Gets the count of keys.
+ * @since_tizen 5.5
+ * @return The count
+ */
+ int GetCount() const;
+
+ /**
+ * @brief Gets the data type from the key.
+ * @since_tizen 5.5
+ * @param[in] key The string key
+ * @return The data type
+ */
+ bundle_type GetType(const std::string& key) const;
+
+ /**
+ * @brief Gets the handle for bundle APIs.
+ * @since_tizen 5.5
+ * @return The handle for bundle
+ */
+ bundle* GetHandle() const;
+
+ /**
+ * @brief Moves this object into the bundle handle.
+ * @since_tizen 5.5
+ * @return The handle for bundle
+ */
+ bundle* Detach();
+
+ private:
+ class Impl;
+ std::unique_ptr<Impl> impl_;
+};
+
+} // namespace tizen_base
+
+/**
+ * @}
+ */
+
+#endif // BUNDLE_CPP_H_
API int bundle_keyval_type_is_measurable(bundle_keyval_t *kv);
/**
+ * @brief Duplicate key-value pair.
+ * @since_tizen 5.5
+ * @param[in] kv A bundle_keyval_t object
+ * @return The bundle object
+ * @retval @c NULL - Failure
+ * @pre @a kv must be a valid bundle_keyval_t object.
+ */
+API bundle_keyval_t *bundle_keyval_dup(const bundle_keyval_t *kv);
+
+/**
* @brief Frees the encoded rawdata.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] r The rawdata
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(capi-base-common)
BuildRequires: pkgconfig(json-glib-1.0)
+BuildRequires: pkgconfig(gmock)
+
+%if 0%{?gcov:1}
+BuildRequires: lcov
+BuildRequires: zip
+%endif
+
%description
Simple string key-val dictionary ADT
%description devel
Simple string key-val dictionary ADT (devel)
+#################################################
+# unittests
+#################################################
+%package unittests
+Summary: GTest for bundle
+Group: Development/Libraries
+
+%description unittests
+GTest for bundle
+
+#################################################
+# gcov
+#################################################
+%if 0%{?gcov:1}
+%package gcov
+Summary: Simple string key-val dictionary ADT (gcov)
+Group: Application Framework/Testing
+
+%description gcov
+Simple string key-val dictionary ADT gcov objects
+%endif
%prep
%setup -q -n %{name}-%{version}
cp %{SOURCE1001} .
%build
+%if 0%{?gcov:1}
+export CFLAGS+=" -fprofile-arcs -ftest-coverage"
+export CXXFLAGS+=" -fprofile-arcs -ftest-coverage"
+export FFLAGS+=" -fprofile-arcs -ftest-coverage"
+export LDFLAGS+=" -lgcov"
+%endif
+
%cmake -DVERSION=%{version} .
%__make %{?_smp_mflags}
+%if 0%{?gcov:1}
+mkdir -p gcov-obj
+find . -name '*.gcno' -exec cp '{}' gcov-obj ';'
+%endif
+
%install
%make_install
+%if 0%{?gcov:1}
+mkdir -p %{buildroot}%{_datadir}/gcov/obj
+install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj
+%endif
+
+%check
+ctest --output-on-failure %{?_smp_mflags}
+%if 0%{?gcov:1}
+lcov -c --ignore-errors graph --no-external -q -d . -o bundle.info
+genhtml bundle.info -o bundle.out
+zip -r bundle.zip bundle.out
+install -m 0644 bundle.zip %{buildroot}%{_datadir}/gcov/
+%endif
+
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
+%post unittests
+%if 0%{?gcov:1}
+%{_bindir}/bundle_unittests
+%endif
%files
%manifest %{name}.manifest
%{_includedir}/*.h
%{_libdir}/pkgconfig/bundle.pc
%{_libdir}/libbundle.so
+
+#################################################
+# unittests
+#################################################
+%files unittests
+%{_bindir}/bundle_unittests
+
+#################################################
+# bundle-gcov
+#################################################
+%if 0%{?gcov:1}
+%files gcov
+%{_datadir}/gcov/*
+%endif
array_val, array_len, array_item_size);
}
+bundle_keyval_t *bundle_keyval_dup(const bundle_keyval_t *kv)
+{
+ bundle_keyval_t *ret_kv = NULL;
+ void *byte = NULL;
+ size_t byte_len;
+ size_t len;
+
+ if (!kv)
+ return NULL;
+
+ if (keyval_type_is_array(kv->type)) {
+ len = keyval_array_encode(
+ (keyval_array_t *)kv, &byte, &byte_len);
+ if (len == 0)
+ return NULL;
+ len = keyval_array_decode(byte,
+ (keyval_array_t **)&ret_kv, byte_len);
+ free(byte);
+ if (len == 0)
+ return NULL;
+ } else {
+ len = keyval_encode((keyval_t *)kv,
+ (unsigned char **)&byte, &byte_len);
+ if (len == 0)
+ return NULL;
+ len = keyval_decode(
+ (unsigned char *)byte, (keyval_t **)&ret_kv, byte_len);
+ free(byte);
+ if (len == 0)
+ return NULL;
+ }
+ return ret_kv;
+}
+
bundle *bundle_dup(bundle *b_from)
{
bundle *b_to;
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ *
+ * 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 <dlog.h>
+
+#include <memory>
+
+#include "bundle_cpp_implementation.h"
+#include "bundle_cpp.h"
+#include "bundle_internal.h"
+
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "BUNDLE"
+
+namespace tizen_base {
+Bundle::Impl::Impl(Bundle* parent, bool copy, bool own)
+ : copy_(copy), own_(own), parent_(parent) {
+}
+
+Bundle::Impl::Impl(Bundle* parent) : parent_(parent) {
+}
+
+Bundle::Impl::~Impl() = default;
+
+Bundle::Bundle()
+ : impl_(new Impl(this)) {
+ impl_->handle_ = bundle_create();
+}
+
+Bundle::Bundle(BundleRaw raw)
+ : impl_(new Impl(this)) {
+ impl_->handle_ = bundle_decode(raw.first.get(), raw.second);
+}
+
+Bundle::Bundle(const std::string& raw)
+ : impl_(new Impl(this)) {
+ impl_->handle_ = bundle_decode(reinterpret_cast<const bundle_raw*>(
+ raw.c_str()), raw.length());
+}
+
+Bundle::Bundle(bundle* b, bool copy, bool own)
+ : impl_(new Impl(this, copy, own)) {
+ if (!impl_->copy_)
+ impl_->handle_ = b;
+ else
+ impl_->handle_ = bundle_dup(b);
+}
+
+Bundle::~Bundle() {
+ if (impl_->handle_ && (impl_->own_ || impl_->copy_))
+ bundle_free(impl_->handle_);
+}
+
+Bundle::Bundle(const Bundle& b)
+ : impl_(new Impl(this)) {
+ impl_->handle_ = bundle_dup(b.impl_->handle_);
+}
+
+Bundle::KeyInfo::KeyInfo(const bundle_keyval_t* handle, std::string name)
+ : impl_(new Impl(this, handle, std::move(name))) {
+}
+
+Bundle::KeyInfo::KeyInfo()
+ : impl_(new Impl(this)) {
+}
+
+Bundle::KeyInfo::~KeyInfo() {
+}
+
+Bundle::KeyInfo::Impl::~Impl() = default;
+Bundle::KeyInfo::Impl::Impl(Bundle::KeyInfo* parent,
+ const bundle_keyval_t* handle,
+ std::string name)
+ : handle_(handle), name_(name), parent_(parent) {
+}
+
+Bundle::KeyInfo::Impl::Impl(Bundle::KeyInfo* parent) : parent_(parent) {
+}
+
+Bundle::KeyInfo::KeyInfo(const KeyInfo& k)
+ : impl_(new Impl(this)) {
+ impl_->handle_ = bundle_keyval_dup(k.impl_->handle_);
+ impl_->name_ = k.impl_->name_;
+}
+
+Bundle::KeyInfo& Bundle::KeyInfo::operator = (const Bundle::KeyInfo& k) {
+ if (this != &k) {
+ impl_->handle_ = bundle_keyval_dup(k.impl_->handle_);
+ impl_->name_ = k.impl_->name_;
+ }
+ return *this;
+}
+
+Bundle::KeyInfo::KeyInfo(Bundle::KeyInfo&& k) noexcept {
+ impl_ = std::unique_ptr<Impl>(new Impl(this));
+ impl_->handle_ = k.impl_->handle_;
+ impl_->name_ = k.impl_->name_;
+ k.impl_->handle_ = nullptr;
+ k.impl_->name_ = "";
+}
+
+Bundle::KeyInfo& Bundle::KeyInfo::operator = (Bundle::KeyInfo&& k) noexcept {
+ if (this != &k) {
+ impl_->handle_ = k.impl_->handle_;
+ impl_->name_ = k.impl_->name_;
+ k.impl_->handle_ = nullptr;
+ k.impl_->name_ = "";
+ }
+ return *this;
+}
+
+bundle_type Bundle::KeyInfo::GetType() const {
+ return static_cast<bundle_type>(
+ bundle_keyval_get_type(const_cast<bundle_keyval_t*>(impl_->handle_)));
+}
+
+bool Bundle::KeyInfo::IsArray() const {
+ return bundle_keyval_type_is_array(const_cast<bundle_keyval_t*>(
+ impl_->handle_));
+}
+
+const std::string& Bundle::KeyInfo::GetName() const {
+ return impl_->name_;
+}
+
+Bundle& Bundle::operator = (const Bundle& b) {
+ if (this != &b) {
+ impl_->handle_ = bundle_dup(b.impl_->handle_);
+ }
+ return *this;
+}
+
+Bundle::Bundle(Bundle&& b) noexcept {
+ impl_ = std::unique_ptr<Impl>(new Impl(this));
+ impl_->handle_ = b.impl_->handle_;
+ b.impl_->handle_ = nullptr;
+}
+
+Bundle& Bundle::operator = (Bundle&& b) noexcept {
+ if (this != &b) {
+ impl_->handle_ = b.impl_->handle_;
+ b.impl_->handle_ = nullptr;
+ }
+ return *this;
+}
+
+std::vector<Bundle::KeyInfo> Bundle::GetKeys() {
+ std::vector<Bundle::KeyInfo> v;
+
+ bundle_foreach(impl_->handle_, [](const char *key, const int type,
+ const bundle_keyval_t *kv, void *user_data) {
+ auto* v = static_cast<std::vector<KeyInfo>*>(user_data);
+ v->emplace_back(kv, key);
+ }, &v);
+
+ return v;
+}
+
+int Bundle::Add(const std::string& key, const std::string& val) {
+ return bundle_add_str(impl_->handle_, key.c_str(), val.c_str());
+}
+
+int Bundle::Add(const std::string& key, const std::vector<std::string>& val) {
+ std::vector<const char*> v;
+ for (auto& i : val) {
+ v.push_back(i.c_str());
+ }
+
+ return bundle_add_str_array(impl_->handle_, key.c_str(), v.data(), v.size());
+}
+
+int Bundle::Add(const std::string& key, const std::vector<unsigned char>& val) {
+ return bundle_add_byte(impl_->handle_, key.c_str(), val.data(), val.size());
+}
+
+int Bundle::Delete(const std::string& key) {
+ return bundle_del(impl_->handle_, key.c_str());
+}
+
+std::string Bundle::GetString(const std::string& key) const {
+ char* str = nullptr;
+ bundle_get_str(impl_->handle_, key.c_str(), &str);
+
+ if (!str)
+ return "";
+
+ return std::string(str);
+}
+
+std::vector<std::string> Bundle::GetStringArray(const std::string& key) const {
+ std::vector<std::string> v;
+
+ const char** str_array = nullptr;
+ int len = 0;
+
+ str_array = bundle_get_str_array(impl_->handle_, key.c_str(), &len);
+
+ for (int i = 0; i < len; i++) {
+ v.emplace_back(str_array[i]);
+ }
+
+ return v;
+}
+
+std::vector<unsigned char> Bundle::GetByte(const std::string& key) const {
+ size_t size;
+ unsigned char* bytes = nullptr;
+ bundle_get_byte(impl_->handle_, key.c_str(),
+ reinterpret_cast<void**>(&bytes), &size);
+ return std::vector<unsigned char>(bytes, bytes + size);
+}
+
+Bundle::BundleRaw Bundle::ToRaw() {
+ bundle_raw* raw = nullptr;
+ int len = 0;
+ bundle_encode(impl_->handle_, &raw, &len);
+
+ return BundleRaw(
+ std::unique_ptr<bundle_raw, decltype(std::free)*>(raw, std::free), len);
+}
+
+int Bundle::GetCount() const {
+ return bundle_get_count(impl_->handle_);
+}
+
+bundle_type Bundle::GetType(const std::string& key) const {
+ return static_cast<bundle_type>(bundle_get_type(impl_->handle_, key.c_str()));
+}
+
+bundle* Bundle::GetHandle() const {
+ return impl_->handle_;
+}
+
+bundle* Bundle::Detach() {
+ auto* h = impl_->handle_;
+ impl_->handle_ = nullptr;
+ return h;
+}
+
+} // namespace tizen_base
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ *
+ * 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 BUNDLE_CPP_IMPLEMENTATION_H_
+#define BUNDLE_CPP_IMPLEMENTATION_H_
+
+#include <string>
+#include <memory>
+#include <list>
+
+#include "bundle_cpp.h"
+
+namespace tizen_base {
+
+class Bundle::KeyInfo::Impl {
+ public:
+ virtual ~Impl();
+
+ private:
+ Impl(Bundle::KeyInfo* parent, const bundle_keyval_t* handle,
+ std::string name);
+ explicit Impl(Bundle::KeyInfo* parent);
+
+ private:
+ friend class Bundle::KeyInfo;
+
+ private:
+ const bundle_keyval_t* handle_;
+ std::string name_;
+ Bundle::KeyInfo* parent_;
+};
+
+class Bundle::Impl {
+ public:
+ virtual ~Impl();
+
+ private:
+ explicit Impl(Bundle* parent);
+ Impl(Bundle* parent, bool copy, bool own);
+
+ private:
+ friend class Bundle;
+
+ bundle* handle_;
+ bool copy_ = true;
+ bool own_ = true;
+ Bundle* parent_;
+};
+
+} // namespace tizen_base
+
+#endif // BUNDLE_CPP_IMPLEMENTATION_H_
#include <stddef.h>
+#ifdef __cplusplus
+extern "C" {
+# endif
+
/* ADT: object */
typedef struct keyval_t keyval_t;
int keyval_get_data(keyval_t *kv, int *type, void **val, size_t *size);
int keyval_get_type_from_encoded_byte(unsigned char *byte);
+#ifdef __cplusplus
+}
+#endif
+
#endif /* __KEYVAL_H__ */
#include "keyval.h"
+#ifdef __cplusplus
+extern "C" {
+# endif
+
typedef struct keyval_array_t {
struct keyval_t kv; /* Inherits keyval_t */
unsigned int len; /* length of array_val */
int idx, void *val, size_t size);
int keyval_array_is_idx_valid(keyval_array_t *kva, int idx);
+#ifdef __cplusplus
+}
+#endif
+
#endif /* __KEYVAL_ARRAY_H__ */
#include "bundle.h"
+#ifdef __cplusplus
+extern "C" {
+# endif
+
/* measure_size function type */
typedef size_t (*keyval_type_measure_size_func_t) (void *val);
size_t keyval_type_measure_size_str(void *val);
void keyval_type_init(void);
+#ifdef __cplusplus
+}
+#endif
+
#endif /* __KEYVAL_TYPE_H__ */
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(bundle_unittests C CXX)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(bundle_unittests REQUIRED
+ dlog
+ gmock
+ glib-2.0
+ json-glib-1.0
+ capi-base-common
+)
+
+FOREACH(flag ${bundle_unittests_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -Wall -Werror -Winline")
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++11")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src UNITTESTS_SOURCES)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../src BUNDLE_SOURCES)
+
+ADD_EXECUTABLE(${PROJECT_NAME}
+ ${BUNDLE_SOURCES}
+ ${UNITTESTS_SOURCES}
+)
+
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${EXTRA_CFLAGS}")
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${bundle_unittests_LDFLAGS})
+
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION /usr/bin/)
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <iostream>
+#include <stdexcept>
+
+#include "bundle_cpp.h"
+
+using ::testing::AtLeast;
+using namespace tizen_base;
+using namespace std;
+
+TEST(Bundle, CtorDtor) {
+ Bundle bundle;
+}
+
+TEST(Bundle, CopyCtor) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ Bundle b2(bundle);
+ EXPECT_EQ(b2.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, MoveCtor) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ Bundle b2(std::move(bundle));
+ EXPECT_EQ(b2.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, AddStringGetString) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, AddByteGetByte) {
+ Bundle bundle;
+ std::vector<unsigned char> v = { 0, 1, 2, 3};
+ bundle.Add("TestKey", v);
+ auto v2 = bundle.GetByte("TestKey");
+
+ EXPECT_EQ(v2.size(), 4);
+ EXPECT_EQ(v2[0], 0);
+ EXPECT_EQ(v2[1], 1);
+ EXPECT_EQ(v2[2], 2);
+ EXPECT_EQ(v2[3], 3);
+}
+
+TEST(Bundle, AddStringArrayGetStringArray) {
+ Bundle bundle;
+ bundle.Add("TestKey", { "TestVal1", "TestVal2", "TestVal3" });
+
+ auto v = bundle.GetStringArray("TestKey");
+
+ EXPECT_EQ(v.size(), 3);
+ EXPECT_EQ(v[0], "TestVal1");
+ EXPECT_EQ(v[1], "TestVal2");
+ EXPECT_EQ(v[2], "TestVal3");
+}
+
+TEST(Bundle, ToRaw) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ auto r = bundle.ToRaw();
+ Bundle b2(std::move(r));
+ EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, GetCount) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+
+ EXPECT_EQ(bundle.GetCount(), 2);
+}
+
+TEST(Bundle, Delete) {
+ Bundle bundle;
+ int r = bundle.Add("TestKey1", "TestVal1");
+ EXPECT_EQ(r, 0);
+
+ r = bundle.Delete("TestKey1");
+ EXPECT_EQ(r, 0);
+
+ EXPECT_EQ(bundle.GetString("TestKey1"), "");
+}
+
+TEST(Bundle, GetKeys) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+ bundle.Add("TestKey3", "TestVal3");
+
+ auto v = bundle.GetKeys();
+
+ EXPECT_EQ(bundle.GetCount(), 3);
+
+ for (auto& i : v) {
+ EXPECT_EQ(i.GetType(), BUNDLE_TYPE_STR);
+ }
+}
+
+TEST(Bundle, GetKeysCopy) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+ bundle.Add("TestKey3", "TestVal3");
+
+ auto v = bundle.GetKeys();
+
+ EXPECT_EQ(bundle.GetCount(), 3);
+
+ for (auto& i : v) {
+ Bundle::KeyInfo copied = i;
+ EXPECT_EQ(copied.GetType(), BUNDLE_TYPE_STR);
+ EXPECT_EQ(copied.GetName(), i.GetName());
+ }
+}
+
+TEST(Bundle, GetKeysMove) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+ bundle.Add("TestKey3", "TestVal3");
+
+ auto v = bundle.GetKeys();
+
+ EXPECT_EQ(bundle.GetCount(), 3);
+
+ for (auto& i : v) {
+ string name = i.GetName();
+ Bundle::KeyInfo copied = move(i);
+ EXPECT_EQ(copied.GetType(), BUNDLE_TYPE_STR);
+ EXPECT_EQ(copied.GetName(), name);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+int main(int argc, char** argv) {
+ testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
projects / platform / core / base / bundle.git / commitdiff