* limitations under the License.
*/
+#include <algorithm>
#include <cstring>
+#include <utility>
+#include "include/bundle.h"
+
+#include "exception-internal.h"
#include "key-info-internal.h"
-#include "log-private.h"
namespace tizen_base {
namespace internal {
-KeyInfo::KeyInfo(int type, std::string key,
- std::vector<unsigned char> value)
- : type_(type),
- key_(std::move(key)) {
- SetValue(value);
+KeyInfo::KeyInfo(int type, std::string key, std::vector<unsigned char> value)
+ : type_(type), key_(std::move(key)) {
+ int ret = SetValue(value);
+ if (ret != BUNDLE_ERROR_NONE)
+ THROW(ret);
}
KeyInfo::KeyInfo(int type, std::string key,
std::vector<std::vector<unsigned char>> values)
- : type_(type),
- key_(std::move(key)) {
- SetValues(values);
+ : type_(type), key_(std::move(key)) {
+ int ret = SetValues(values);
+ if (ret != BUNDLE_ERROR_NONE)
+ THROW(ret);
}
KeyInfo::KeyInfo(std::vector<unsigned char> encoded_bytes) {
- Decode(encoded_bytes);
+ int ret = Decode(encoded_bytes);
+ if (ret != BUNDLE_ERROR_NONE)
+ THROW(ret);
}
-KeyInfo::~KeyInfo() = default;
-
KeyInfo::KeyInfo(const KeyInfo& key_info) {
+ values_.reserve(key_info.values_.size());
+ try {
+ for (unsigned int i = 0; i < key_info.values_.size(); ++i) {
+ auto new_value =
+ std::make_unique<unsigned char[]>(key_info.values_size_[i]);
+ std::copy(key_info.values_[i].get(),
+ key_info.values_[i].get() + key_info.values_size_[i],
+ new_value.get());
+ values_.push_back(std::move(new_value));
+ }
+ } catch (const std::bad_alloc& e) {
+ THROW(BUNDLE_ERROR_OUT_OF_MEMORY);
+ }
+
type_ = key_info.type_;
key_ = key_info.key_;
values_size_ = key_info.values_size_;
- for (unsigned int i = 0; i < key_info.values_.size(); ++i) {
- auto* new_value = new (std::nothrow) unsigned char[values_size_[i]];
- std::copy(key_info.values_[i].get(),
- key_info.values_[i].get() + values_size_[i], new_value);
- values_.emplace_back(new_value);
- }
+ uvalues_size_ = key_info.uvalues_size_;
}
-KeyInfo& KeyInfo::operator = (const KeyInfo& key_info) {
+KeyInfo& KeyInfo::operator=(const KeyInfo& key_info) {
if (this != &key_info) {
+ decltype(values_) new_values;
+ try {
+ for (unsigned int i = 0; i < key_info.values_.size(); ++i) {
+ auto new_value =
+ std::make_unique<unsigned char[]>(key_info.values_size_[i]);
+ std::copy(key_info.values_[i].get(),
+ key_info.values_[i].get() + key_info.values_size_[i],
+ new_value.get());
+ new_values.push_back(std::move(new_value));
+ }
+ } catch (const std::bad_alloc& e) {
+ THROW(BUNDLE_ERROR_OUT_OF_MEMORY);
+ }
+
type_ = key_info.type_;
key_ = key_info.key_;
values_size_ = key_info.values_size_;
- for (unsigned int i = 0; i < key_info.values_.size(); ++i) {
- auto* new_value = new (std::nothrow) unsigned char[values_size_[i]];
- std::copy(key_info.values_[i].get(),
- key_info.values_[i].get() + values_size_[i], new_value);
- values_.emplace_back(new_value);
- }
+ uvalues_size_ = key_info.uvalues_size_;
+ values_ = std::move(new_values);
}
+
return *this;
}
key_ = std::move(key_info.key_);
values_ = std::move(key_info.values_);
values_size_ = std::move(key_info.values_size_);
+ uvalues_size_ = std::move(key_info.uvalues_size_);
}
-KeyInfo& KeyInfo::operator = (KeyInfo&& key_info) noexcept {
+KeyInfo& KeyInfo::operator=(KeyInfo&& key_info) noexcept {
if (this != &key_info) {
type_ = key_info.type_;
key_info.type_ = 0;
key_ = std::move(key_info.key_);
values_ = std::move(key_info.values_);
values_size_ = std::move(key_info.values_size_);
+ uvalues_size_ = std::move(key_info.uvalues_size_);
}
return *this;
}
-bool KeyInfo::operator == (const KeyInfo& key_info) {
+bool KeyInfo::operator==(const KeyInfo& key_info) {
if (this == &key_info)
return true;
return false;
for (unsigned int i = 0; i < values_.size(); ++i) {
- if (values_size_[i] == key_info.values_size_[i])
+ if (values_size_[i] != key_info.values_size_[i])
return false;
int ret = std::memcmp(values_[i].get(), key_info.values_[i].get(),
values_size_[i]);
- if (ret == 0)
+ if (ret != 0)
return false;
}
}
bool KeyInfo::IsArray() const {
- if (values_.size() == 1)
+ if (type_ & BUNDLE_TYPE_ARRAY)
return true;
return false;
return values_size_;
}
-void KeyInfo::SetValue(const std::vector<unsigned char>& value) {
- auto* new_value = new (std::nothrow) unsigned char[value.size()];
- std::copy(value.begin(), value.end(), new_value);
- values_.emplace_back(new_value);
+const std::vector<unsigned int>& KeyInfo::GetUValuesSize() {
+ return uvalues_size_;
+}
+
+int KeyInfo::SetValue(const std::vector<unsigned char>& value) {
+ try {
+ auto new_value = std::make_unique<unsigned char[]>(value.size());
+ std::copy(value.begin(), value.end(), new_value.get());
+ values_.emplace_back(std::move(new_value));
+ } catch (const std::bad_alloc& e) {
+ return BUNDLE_ERROR_OUT_OF_MEMORY;
+ }
+
values_size_.push_back(value.size());
+ uvalues_size_.push_back(static_cast<unsigned int>(value.size()));
+ return BUNDLE_ERROR_NONE;
}
-void KeyInfo::SetValues(const std::vector<std::vector<unsigned char>>& values) {
- for (unsigned int i = 0; i< values.size(); ++i) {
- auto* new_value = new (std::nothrow) unsigned char[values[i].size()];
- std::copy(values[i].begin(), values[i].end(), new_value);
- values_.emplace_back(new_value);
- values_size_.push_back(values[i].size());
+int KeyInfo::SetValues(const std::vector<std::vector<unsigned char>>& values) {
+ try {
+ for (unsigned int i = 0; i < values.size(); ++i) {
+ auto new_value = std::make_unique<unsigned char[]>(values[i].size());
+ std::copy(values[i].begin(), values[i].end(), new_value.get());
+ values_.push_back(std::move(new_value));
+ values_size_.push_back(values[i].size());
+ uvalues_size_.push_back(values[i].size());
+ }
+ } catch (const std::bad_alloc& e) {
+ return BUNDLE_ERROR_OUT_OF_MEMORY;
}
+
+ return BUNDLE_ERROR_NONE;
}
std::vector<unsigned char> KeyInfo::Encode() {
// total size
unsigned char* p = reinterpret_cast<unsigned char*>(&encoded_size);
- std::copy(p, p + sizeof(encoded_size), std::back_inserter(bytes));
+ bytes.insert(bytes.end(), p, p + sizeof(encoded_size));
// type
p = reinterpret_cast<unsigned char*>(&type_);
- std::copy(p, p + sizeof(type_), std::back_inserter(bytes));
+ bytes.insert(bytes.end(), p, p + sizeof(type_));
// key size
std::size_t key_length = key_.length() + 1;
p = reinterpret_cast<unsigned char*>(&key_length);
- std::copy(p, p + sizeof(key_length), std::back_inserter(bytes));
+ bytes.insert(bytes.end(), p, p + sizeof(key_length));
// key
- std::copy(key_.begin(), key_.end() + 1, std::back_inserter(bytes));
+ bytes.insert(bytes.end(), key_.begin(), key_.end() + 1);
- // values size
- std::size_t values_size = values_.size();
- p = reinterpret_cast<unsigned char*>(&values_size);
- std::copy(p , p + sizeof(values_size), std::back_inserter(bytes));
+ if (type_ & BUNDLE_TYPE_ARRAY) {
+ // values size
+ std::size_t values_size = values_.size();
+ p = reinterpret_cast<unsigned char*>(&values_size);
+ bytes.insert(bytes.end(), p, p + sizeof(values_size));
+ }
// values
for (unsigned int i = 0; i < values_.size(); i++) {
std::size_t value_size = values_size_[i];
p = reinterpret_cast<unsigned char*>(&value_size);
- std::copy(p, p + sizeof(value_size), std::back_inserter(bytes));
+ bytes.insert(bytes.end(), p, p + sizeof(value_size));
- std::copy(values_[i].get(), values_[i].get() + value_size,
- std::back_inserter(bytes));
+ bytes.insert(bytes.end(), values_[i].get(), values_[i].get() + value_size);
}
return bytes;
encoded_size += key_.length() + 1;
- // values size
- if ((encoded_size + sizeof(std::size_t)) < encoded_size)
- return 0;
+ if (type_ & BUNDLE_TYPE_ARRAY) {
+ // values size
+ if ((encoded_size + sizeof(std::size_t)) < encoded_size)
+ return 0;
- encoded_size += sizeof(std::size_t);
+ encoded_size += sizeof(std::size_t);
+ }
// values
std::size_t values_size = 0;
return encoded_size;
}
-void KeyInfo::Decode(const std::vector<unsigned char>& bytes) {
+int KeyInfo::Decode(const std::vector<unsigned char>& bytes) {
unsigned int reader = 0;
// total size
std::size_t total_size = 0;
if ((reader + sizeof(total_size)) > bytes.size())
- return;
+ return BUNDLE_ERROR_INVALID_PARAMETER;
unsigned char* p = reinterpret_cast<unsigned char*>(&total_size);
std::copy(&bytes[reader], &bytes[reader] + sizeof(total_size), p);
// type
if ((reader + sizeof(type_)) > bytes.size())
- return;
+ return BUNDLE_ERROR_INVALID_PARAMETER;
p = reinterpret_cast<unsigned char*>(&type_);
- std::copy(&bytes[reader], &bytes[reader] + sizeof(type_), p);
+ std::copy(&bytes[reader], &bytes[reader] + sizeof(type_), p);
reader += sizeof(type_);
// key size
std::size_t key_size = 0;
if ((reader + sizeof(key_size)) > bytes.size())
- return;
+ return BUNDLE_ERROR_INVALID_PARAMETER;
p = reinterpret_cast<unsigned char*>(&key_size);
std::copy(&bytes[reader], &bytes[reader] + sizeof(key_size), p);
reader += sizeof(key_size);
if ((reader + key_size) > bytes.size())
- return;
+ return BUNDLE_ERROR_INVALID_PARAMETER;
// key
std::vector<unsigned char> key(&bytes[reader], &bytes[reader] + key_size);
key_ = std::string(reinterpret_cast<char*>(p));
reader += key_size;
- // values size
std::size_t values_size = 0;
- if ((reader + sizeof(values_size)) > bytes.size())
- return;
-
- p = reinterpret_cast<unsigned char*>(&values_size);
- std::copy(&bytes[reader], &bytes[reader] + sizeof(values_size), p);
- reader += sizeof(values_size);
+ if (type_ & BUNDLE_TYPE_ARRAY) {
+ // values size
+ if ((reader + sizeof(values_size)) > bytes.size())
+ return BUNDLE_ERROR_INVALID_PARAMETER;
+
+ p = reinterpret_cast<unsigned char*>(&values_size);
+ std::copy(&bytes[reader], &bytes[reader] + sizeof(values_size), p);
+ reader += sizeof(values_size);
+ } else {
+ values_size = 1;
+ }
// values
for (std::size_t i = 0; i < values_size; ++i) {
// value_size
std::size_t value_size = 0;
if ((reader + sizeof(value_size)) > bytes.size())
- return;
+ return BUNDLE_ERROR_INVALID_PARAMETER;
p = reinterpret_cast<unsigned char*>(&value_size);
std::copy(&bytes[reader], &bytes[reader] + sizeof(value_size), p);
// value
if ((reader + value_size) > bytes.size())
- return;
-
- auto* new_value = new unsigned char[value_size];
- std::copy(&bytes[reader], &bytes[reader] + value_size, new_value);
- reader += value_size;
-
- values_.emplace_back(new_value);
+ return BUNDLE_ERROR_INVALID_PARAMETER;
+
+ try {
+ auto new_value = std::make_unique<unsigned char[]>(value_size);
+ std::copy(&bytes[reader], &bytes[reader] + value_size, new_value.get());
+ reader += value_size;
+ values_.push_back(std::move(new_value));
+ } catch (const std::bad_alloc& e) {
+ return BUNDLE_ERROR_OUT_OF_MEMORY;
+ }
values_size_.push_back(value_size);
+ uvalues_size_.push_back(static_cast<unsigned int>(value_size));
}
+
+ return BUNDLE_ERROR_NONE;
}
-void KeyInfo::SetValue(int index, const std::vector<unsigned char>& value) {
- if (index > GetSize() && index < 0)
- return;
+int KeyInfo::SetValue(int index, const std::vector<unsigned char>& value) {
+ if (index > GetSize() || index < 0)
+ return BUNDLE_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS;
+
+ if (!IsArray())
+ return BUNDLE_ERROR_INVALID_PARAMETER;
+
+ try {
+ auto new_value = std::make_unique<unsigned char[]>(value.size());
+ if (value.size() != 0)
+ std::copy(value.begin(), value.end(), new_value.get());
+
+ values_[index] = std::move(new_value);
+ } catch (const std::bad_alloc& e) {
+ return BUNDLE_ERROR_OUT_OF_MEMORY;
+ }
- auto* new_value = new unsigned char[value.size()];
- std::copy(value.begin(), value.end(), new_value);
- values_[index].reset(new_value);
values_size_[index] = value.size();
+ uvalues_size_[index] = static_cast<unsigned int>(value.size());
+ return BUNDLE_ERROR_NONE;
}
int KeyInfo::GetSize() const {