#include "dynamic_depth/item.h"
|
|
#include "android-base/logging.h"
|
#include "dynamic_depth/const.h"
|
|
using ::dynamic_depth::xmpmeta::xml::Deserializer;
|
using ::dynamic_depth::xmpmeta::xml::Serializer;
|
|
namespace dynamic_depth {
|
namespace {
|
|
constexpr char kNamespaceHref[] = "http://ns.google.com/photos/dd/1.0/item/";
|
|
constexpr char kMime[] = "Mime";
|
constexpr char kLength[] = "Length";
|
constexpr char kPadding[] = "Padding";
|
constexpr char kDataUri[] = "DataURI";
|
|
} // namespace
|
|
// Private constructor.
|
Item::Item(const ItemParams& params) : params_(params) {}
|
|
// Private instantiator.
|
|
std::unique_ptr<Item> Item::FromDataInternal(const ItemParams& params,
|
bool check_filepath) {
|
if (check_filepath && params.length != params.payload_to_serialize.size()) {
|
LOG(ERROR) << "Length does not match payload's size";
|
return nullptr;
|
}
|
|
if (params.mime.empty()) {
|
LOG(ERROR) << "Mime is empty";
|
return nullptr;
|
}
|
|
if (params.length < 0) {
|
LOG(ERROR) << "Item length must be non-negative";
|
return nullptr;
|
}
|
|
if (params.padding > 0 &&
|
static_cast<int>(params.length - params.padding) <= 0) {
|
LOG(ERROR) << "Item length must be larger than padding; found padding="
|
<< params.padding << ", length=" << params.length;
|
return nullptr;
|
}
|
|
// TODO(miraleung): Check for only supported mime types?
|
|
return std::unique_ptr<Item>(new Item(params)); // NOLINT
|
}
|
|
void Item::GetNamespaces(std::unordered_map<string, string>* ns_name_href_map) {
|
if (ns_name_href_map == nullptr) {
|
LOG(ERROR) << "Namespace list or own namespace is null";
|
return;
|
}
|
|
ns_name_href_map->emplace(DynamicDepthConst::Item(), kNamespaceHref);
|
}
|
|
std::unique_ptr<Item> Item::FromData(const ItemParams& params) {
|
return FromDataInternal(params, true);
|
}
|
|
std::unique_ptr<Item> Item::FromDeserializer(
|
const Deserializer& parent_deserializer) {
|
std::unique_ptr<Deserializer> deserializer =
|
parent_deserializer.CreateDeserializer(
|
DynamicDepthConst::Namespace(DynamicDepthConst::Item()),
|
DynamicDepthConst::Item());
|
if (deserializer == nullptr) {
|
return nullptr;
|
}
|
|
string mime;
|
int length;
|
int padding = 0;
|
string data_uri;
|
|
if (!deserializer->ParseString(DynamicDepthConst::Item(), kMime, &mime) ||
|
!deserializer->ParseInt(DynamicDepthConst::Item(), kLength, &length)) {
|
return nullptr;
|
}
|
|
deserializer->ParseInt(DynamicDepthConst::Item(), kPadding, &padding);
|
deserializer->ParseString(DynamicDepthConst::Item(), kDataUri, &data_uri);
|
|
ItemParams params(mime, length);
|
if (!data_uri.empty()) {
|
params.data_uri = data_uri;
|
}
|
if (padding > 0) {
|
params.padding = padding;
|
}
|
|
return Item::FromDataInternal(params, false);
|
}
|
|
// Getters.
|
const string& Item::GetMime() const { return params_.mime; }
|
unsigned int Item::GetLength() const { return params_.length; }
|
const string& Item::GetDataUri() const { return params_.data_uri; }
|
unsigned int Item::GetPadding() const { return params_.padding; }
|
const string& Item::GetPayloadToSerialize() const {
|
return params_.payload_to_serialize;
|
}
|
|
bool Item::Serialize(Serializer* serializer) const {
|
if (serializer == nullptr) {
|
LOG(ERROR) << "Serializer is null";
|
return false;
|
}
|
|
// No error-checking for the mime or length here, since it's assumed to be
|
// taken care of in the instantiator.
|
bool success = serializer->WriteProperty(DynamicDepthConst::Item(), kMime,
|
params_.mime) &&
|
serializer->WriteProperty(DynamicDepthConst::Item(), kLength,
|
std::to_string(params_.length));
|
if (!params_.data_uri.empty()) {
|
success &= serializer->WriteProperty(DynamicDepthConst::Item(), kDataUri,
|
params_.data_uri);
|
}
|
|
if (params_.padding > 0) {
|
success &= serializer->WriteProperty(DynamicDepthConst::Item(), kPadding,
|
std::to_string(params_.padding));
|
}
|
|
return success;
|
}
|
|
} // namespace dynamic_depth
|
