Home | History | Annotate | Download | only in proto 
      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 #include "proto/ProtoHelpers.h"
     18 
     19 namespace aapt {
     20 
     21 void SerializeStringPoolToPb(const StringPool& pool,
     22                              pb::StringPool* out_pb_pool) {
     23   BigBuffer buffer(1024);
     24   StringPool::FlattenUtf8(&buffer, pool);
     25 
     26   std::string* data = out_pb_pool->mutable_data();
     27   data->reserve(buffer.size());
     28 
     29   size_t offset = 0;
     30   for (const BigBuffer::Block& block : buffer) {
     31     data->insert(data->begin() + offset, block.buffer.get(),
     32                  block.buffer.get() + block.size);
     33     offset += block.size;
     34   }
     35 }
     36 
     37 void SerializeSourceToPb(const Source& source, StringPool* src_pool,
     38                          pb::Source* out_pb_source) {
     39   StringPool::Ref ref = src_pool->MakeRef(source.path);
     40   out_pb_source->set_path_idx(static_cast<uint32_t>(ref.index()));
     41   if (source.line) {
     42     out_pb_source->set_line_no(static_cast<uint32_t>(source.line.value()));
     43   }
     44 }
     45 
     46 void DeserializeSourceFromPb(const pb::Source& pb_source,
     47                              const android::ResStringPool& src_pool,
     48                              Source* out_source) {
     49   if (pb_source.has_path_idx()) {
     50     out_source->path = util::GetString(src_pool, pb_source.path_idx());
     51   }
     52 
     53   if (pb_source.has_line_no()) {
     54     out_source->line = static_cast<size_t>(pb_source.line_no());
     55   }
     56 }
     57 
     58 pb::SymbolStatus_Visibility SerializeVisibilityToPb(SymbolState state) {
     59   switch (state) {
     60     case SymbolState::kPrivate:
     61       return pb::SymbolStatus_Visibility_Private;
     62     case SymbolState::kPublic:
     63       return pb::SymbolStatus_Visibility_Public;
     64     default:
     65       break;
     66   }
     67   return pb::SymbolStatus_Visibility_Unknown;
     68 }
     69 
     70 SymbolState DeserializeVisibilityFromPb(
     71     pb::SymbolStatus_Visibility pb_visibility) {
     72   switch (pb_visibility) {
     73     case pb::SymbolStatus_Visibility_Private:
     74       return SymbolState::kPrivate;
     75     case pb::SymbolStatus_Visibility_Public:
     76       return SymbolState::kPublic;
     77     default:
     78       break;
     79   }
     80   return SymbolState::kUndefined;
     81 }
     82 
     83 void SerializeConfig(const ConfigDescription& config,
     84                      pb::ConfigDescription* out_pb_config) {
     85   android::ResTable_config flat_config = config;
     86   flat_config.size = sizeof(flat_config);
     87   flat_config.swapHtoD();
     88   out_pb_config->set_data(&flat_config, sizeof(flat_config));
     89 }
     90 
     91 bool DeserializeConfigDescriptionFromPb(const pb::ConfigDescription& pb_config,
     92                                         ConfigDescription* out_config) {
     93   if (!pb_config.has_data()) {
     94     return false;
     95   }
     96 
     97   const android::ResTable_config* config;
     98   if (pb_config.data().size() > sizeof(*config)) {
     99     return false;
    100   }
    101 
    102   config = reinterpret_cast<const android::ResTable_config*>(
    103       pb_config.data().data());
    104   out_config->copyFromDtoH(*config);
    105   return true;
    106 }
    107 
    108 pb::Reference_Type SerializeReferenceTypeToPb(Reference::Type type) {
    109   switch (type) {
    110     case Reference::Type::kResource:
    111       return pb::Reference_Type_Ref;
    112     case Reference::Type::kAttribute:
    113       return pb::Reference_Type_Attr;
    114     default:
    115       break;
    116   }
    117   return pb::Reference_Type_Ref;
    118 }
    119 
    120 Reference::Type DeserializeReferenceTypeFromPb(pb::Reference_Type pb_type) {
    121   switch (pb_type) {
    122     case pb::Reference_Type_Ref:
    123       return Reference::Type::kResource;
    124     case pb::Reference_Type_Attr:
    125       return Reference::Type::kAttribute;
    126     default:
    127       break;
    128   }
    129   return Reference::Type::kResource;
    130 }
    131 
    132 pb::Plural_Arity SerializePluralEnumToPb(size_t plural_idx) {
    133   switch (plural_idx) {
    134     case Plural::Zero:
    135       return pb::Plural_Arity_Zero;
    136     case Plural::One:
    137       return pb::Plural_Arity_One;
    138     case Plural::Two:
    139       return pb::Plural_Arity_Two;
    140     case Plural::Few:
    141       return pb::Plural_Arity_Few;
    142     case Plural::Many:
    143       return pb::Plural_Arity_Many;
    144     default:
    145       break;
    146   }
    147   return pb::Plural_Arity_Other;
    148 }
    149 
    150 size_t DeserializePluralEnumFromPb(pb::Plural_Arity arity) {
    151   switch (arity) {
    152     case pb::Plural_Arity_Zero:
    153       return Plural::Zero;
    154     case pb::Plural_Arity_One:
    155       return Plural::One;
    156     case pb::Plural_Arity_Two:
    157       return Plural::Two;
    158     case pb::Plural_Arity_Few:
    159       return Plural::Few;
    160     case pb::Plural_Arity_Many:
    161       return Plural::Many;
    162     default:
    163       break;
    164   }
    165   return Plural::Other;
    166 }
    167 
    168 }  // namespace aapt
    169