Merge "aconfig: c++ read api to return an android::base::Result and cargo fmt" into main (6c63da3c) · Commits · e / os / android_build

tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp

+35 −51

Original line number	Diff line number	Diff line
		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/result.h>
		#include <protos/aconfig_storage_metadata.pb.h>

		#include <sys/mman.h>
		@@ -97,40 +96,21 @@ static Result<MappedStorageFile> map_storage_file(std::string const& file) {
		namespace private_internal_api {

		/// Get mapped file implementation.
		MappedStorageFileQuery get_mapped_file_impl(
		Result<MappedStorageFile> get_mapped_file_impl(
		std::string const& pb_file,
		std::string const& container,
		StorageFileType file_type) {
		auto query = MappedStorageFileQuery();

		auto file_result = find_storage_file(pb_file, container, file_type);
		if (!file_result.ok()) {
		query.query_success = false;
		query.error_message = file_result.error().message();
		query.mapped_file.file_ptr = nullptr;
		query.mapped_file.file_size = 0;
		return query;
		}

		auto mapped_file_result = map_storage_file(*file_result);
		if (!mapped_file_result.ok()) {
		query.query_success = false;
		query.error_message = mapped_file_result.error().message();
		query.mapped_file.file_ptr = nullptr;
		query.mapped_file.file_size = 0;
		} else {
		query.query_success = true;
		query.error_message = "";
		query.mapped_file = *mapped_file_result;
		return Error() << file_result.error();
		}

		return query;
		return map_storage_file(*file_result);
		}

		} // namespace private internal api

		/// Get mapped storage file
		MappedStorageFileQuery get_mapped_file(
		Result<MappedStorageFile> get_mapped_file(
		std::string const& container,
		StorageFileType file_type) {
		return private_internal_api::get_mapped_file_impl(
		@@ -138,61 +118,65 @@ MappedStorageFileQuery get_mapped_file(
		}

		/// Get storage file version number
		VersionNumberQuery get_storage_file_version(
		Result<uint32_t> get_storage_file_version(
		std::string const& file_path) {
		auto version_cxx = get_storage_file_version_cxx(
		rust::Str(file_path.c_str()));
		auto version = VersionNumberQuery();
		version.query_success = version_cxx.query_success;
		version.error_message = std::string(version_cxx.error_message.c_str());
		version.version_number = version_cxx.version_number;
		return version;
		if (version_cxx.query_success) {
		return version_cxx.version_number;
		} else {
		return Error() << version_cxx.error_message;
		}
		}

		/// Get package offset
		PackageOffsetQuery get_package_offset(
		Result<PackageOffset> get_package_offset(
		MappedStorageFile const& file,
		std::string const& package) {
		auto content = rust::Slice<const uint8_t>(
		static_cast<uint8_t*>(file.file_ptr), file.file_size);
		auto offset_cxx = get_package_offset_cxx(content, rust::Str(package.c_str()));
		auto offset = PackageOffsetQuery();
		offset.query_success = offset_cxx.query_success;
		offset.error_message = std::string(offset_cxx.error_message.c_str());
		if (offset_cxx.query_success) {
		auto offset = PackageOffset();
		offset.package_exists = offset_cxx.package_exists;
		offset.package_id = offset_cxx.package_id;
		offset.boolean_offset = offset_cxx.boolean_offset;
		return offset;
		} else {
		return Error() << offset_cxx.error_message;
		}
		}

		/// Get flag offset
		FlagOffsetQuery get_flag_offset(
		Result<FlagOffset> get_flag_offset(
		MappedStorageFile const& file,
		uint32_t package_id,
		std::string const& flag_name){
		auto content = rust::Slice<const uint8_t>(
		static_cast<uint8_t*>(file.file_ptr), file.file_size);
		auto offset_cxx = get_flag_offset_cxx(content, package_id, rust::Str(flag_name.c_str()));
		auto offset = FlagOffsetQuery();
		offset.query_success = offset_cxx.query_success;
		offset.error_message = std::string(offset_cxx.error_message.c_str());
		if (offset_cxx.query_success) {
		auto offset = FlagOffset();
		offset.flag_exists = offset_cxx.flag_exists;
		offset.flag_offset = offset_cxx.flag_offset;
		return offset;
		} else {
		return Error() << offset_cxx.error_message;
		}
		}

		/// Get boolean flag value
		BooleanFlagValueQuery get_boolean_flag_value(
		Result<bool> get_boolean_flag_value(
		MappedStorageFile const& file,
		uint32_t offset) {
		auto content = rust::Slice<const uint8_t>(
		static_cast<uint8_t*>(file.file_ptr), file.file_size);
		auto value_cxx = get_boolean_flag_value_cxx(content, offset);
		auto value = BooleanFlagValueQuery();
		value.query_success = value_cxx.query_success;
		value.error_message = std::string(value_cxx.error_message.c_str());
		value.flag_value = value_cxx.flag_value;
		return value;
		if (value_cxx.query_success) {
		return value_cxx.flag_value;
		} else {
		return Error() << value_cxx.error_message;
		}
		}

		} // namespace aconfig_storage

tools/aconfig/aconfig_storage_read_api/include/aconfig_storage/aconfig_storage_read_api.hpp

+21 −45

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@

		#include <stdint.h>
		#include <string>
		#include <android-base/result.h>

		namespace aconfig_storage {

		@@ -18,73 +19,48 @@ struct MappedStorageFile {
		size_t file_size;
		};

		/// Mapped storage file query
		struct MappedStorageFileQuery {
		bool query_success;
		std::string error_message;
		MappedStorageFile mapped_file;
		};

		/// DO NOT USE APIS IN THE FOLLOWING NAMESPACE DIRECTLY
		namespace private_internal_api {

		MappedStorageFileQuery get_mapped_file_impl(
		std::string const& pb_file,
		std::string const& container,
		StorageFileType file_type);

		} // namespace private_internal_api

		/// Storage version number query result
		struct VersionNumberQuery {
		bool query_success;
		std::string error_message;
		uint32_t version_number;
		};

		/// Package offset query result
		struct PackageOffsetQuery {
		bool query_success;
		std::string error_message;
		struct PackageOffset {
		bool package_exists;
		uint32_t package_id;
		uint32_t boolean_offset;
		};

		/// Flag offset query result
		struct FlagOffsetQuery {
		bool query_success;
		std::string error_message;
		struct FlagOffset {
		bool flag_exists;
		uint16_t flag_offset;
		};

		/// Boolean flag value query result
		struct BooleanFlagValueQuery {
		bool query_success;
		std::string error_message;
		bool flag_value;
		};
		/// DO NOT USE APIS IN THE FOLLOWING NAMESPACE DIRECTLY
		namespace private_internal_api {

		android::base::Result<MappedStorageFile> get_mapped_file_impl(
		std::string const& pb_file,
		std::string const& container,
		StorageFileType file_type);

		} // namespace private_internal_api

		/// Get mapped storage file
		/// \input container: stoarge container name
		/// \input file_type: storage file type enum
		/// \returns a MappedStorageFileQuery
		MappedStorageFileQuery get_mapped_file(
		android::base::Result<MappedStorageFile> get_mapped_file(
		std::string const& container,
		StorageFileType file_type);

		/// Get storage file version number
		/// \input file_path: the path to the storage file
		/// \returns a VersionNumberQuery
		VersionNumberQuery get_storage_file_version(
		/// \returns the storage file version
		android::base::Result<uint32_t> get_storage_file_version(
		std::string const& file_path);

		/// Get package offset
		/// \input file: mapped storage file
		/// \input package: the flag package name
		/// \returns a PackageOffsetQuery
		PackageOffsetQuery get_package_offset(
		/// \returns a package offset
		android::base::Result<PackageOffset> get_package_offset(
		MappedStorageFile const& file,
		std::string const& package);

		@@ -92,8 +68,8 @@ PackageOffsetQuery get_package_offset(
		/// \input file: mapped storage file
		/// \input package_id: the flag package id obtained from package offset query
		/// \input flag_name: flag name
		/// \returns a FlagOffsetQuery
		FlagOffsetQuery get_flag_offset(
		/// \returns the flag offset
		android::base::Result<FlagOffset> get_flag_offset(
		MappedStorageFile const& file,
		uint32_t package_id,
		std::string const& flag_name);
		@@ -101,8 +77,8 @@ FlagOffsetQuery get_flag_offset(
		/// Get boolean flag value
		/// \input file: mapped storage file
		/// \input offset: the boolean flag value byte offset in the file
		/// \returns a BooleanFlagValueQuery
		BooleanFlagValueQuery get_boolean_flag_value(
		/// \returns the boolean flag value
		android::base::Result<bool> get_boolean_flag_value(
		MappedStorageFile const& file,
		uint32_t offset);

tools/aconfig/aconfig_storage_read_api/src/flag_table_query.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -65,7 +65,7 @@ pub fn find_flag_offset(
		#[cfg(test)]
		mod tests {
		use super::*;
		use aconfig_storage_file::{StorageFileType, FlagTable};
		use aconfig_storage_file::{FlagTable, StorageFileType};

		// create test baseline, syntactic sugar
		fn new_expected_node(

tools/aconfig/aconfig_storage_read_api/src/flag_value_query.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -48,7 +48,7 @@ pub fn find_boolean_flag_value(buf: &[u8], flag_offset: u32) -> Result<bool, Aco
		#[cfg(test)]
		mod tests {
		use super::*;
		use aconfig_storage_file::{StorageFileType, FlagValueList};
		use aconfig_storage_file::{FlagValueList, StorageFileType};

		pub fn create_test_flag_value_list() -> FlagValueList {
		let header = FlagValueHeader {

tools/aconfig/aconfig_storage_read_api/src/lib.rs

+4 −13

Original line number	Diff line number	Diff line
		@@ -183,14 +183,9 @@ mod ffi {

		pub fn get_package_offset_cxx(file: &[u8], package: &str) -> PackageOffsetQueryCXX;

		pub fn get_flag_offset_cxx(
		file: &[u8],
		package_id: u32,
		flag: &str,
		) -> FlagOffsetQueryCXX;
		pub fn get_flag_offset_cxx(file: &[u8], package_id: u32, flag: &str) -> FlagOffsetQueryCXX;

		pub fn get_boolean_flag_value_cxx(file: &[u8], offset: u32)
		-> BooleanFlagValueQueryCXX;
		pub fn get_boolean_flag_value_cxx(file: &[u8], offset: u32) -> BooleanFlagValueQueryCXX;
		}
		}

		@@ -294,11 +289,7 @@ pub fn get_package_offset_cxx(file: &[u8], package: &str) -> ffi::PackageOffsetQ
		}

		/// Get flag start offset cc interlop
		pub fn get_flag_offset_cxx(
		file: &[u8],
		package_id: u32,
		flag: &str,
		) -> ffi::FlagOffsetQueryCXX {
		pub fn get_flag_offset_cxx(file: &[u8], package_id: u32, flag: &str) -> ffi::FlagOffsetQueryCXX {
		ffi::FlagOffsetQueryCXX::new(find_flag_offset(file, package_id, flag))
		}