FQName.cpp - platform/system/libvintf - Git at Google

 /*
  * Copyright (C) 2023 The Android Open Source Project
  *
  * 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 <vintf/FQName.h>

 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/strings.h>
 #include <iostream>
 #include <sstream>

 namespace android::vintf::details {

 FQName::FQName() : mIsIdentifier(false) {}

 bool FQName::parse(const std::string& s, FQName* into) {
     return into->setTo(s);
 }

 FQName::FQName(const std::string& package, const std::string& version, const std::string& name) {
     size_t majorVer, minorVer;
     CHECK(parseVersion(version, &majorVer, &minorVer));
     CHECK(setTo(package, majorVer, minorVer, name)) << string();
 }

 bool FQName::setTo(const std::string& package, size_t majorVer, size_t minorVer,
                    const std::string& name) {
     mPackage = package;
     mMajor = majorVer;
     mMinor = minorVer;
     mName = name;

     FQName other;
     if (!parse(string(), &other)) return false;
     if ((*this) != other) return false;
     mIsIdentifier = other.isIdentifier();
     return true;
 }

 bool FQName::isIdentifier() const {
     return mIsIdentifier;
 }

 bool FQName::isInterfaceName() const {
     return !mName.empty() && mName[0] == 'I' && mName.find('.') == std::string::npos;
 }

 static inline bool isIdentStart(char a) {
     return ('a' <= a && a <= 'z') || ('A' <= a && a <= 'Z') || a == '_';
 }
 static inline bool isLeadingDigit(char a) {
     return '1' <= a && a <= '9';
 }
 static inline bool isDigit(char a) {
     return '0' <= a && a <= '9';
 }
 static inline bool isIdentBody(char a) {
     return isIdentStart(a) || isDigit(a);
 }

 // returns pointer to end of [a-zA-Z_][a-zA-Z0-9_]*
 static const char* eatIdent(const char* l, const char* end) {
     if (!(l < end && isIdentStart(*l++))) return nullptr;
     while (l < end && isIdentBody(*l)) l++;
     return l;
 }

 // returns pointer to end of <ident>(\.<ident>)*
 static const char* eatPackage(const char* l, const char* end) {
     if ((l = eatIdent(l, end)) == nullptr) return nullptr;

     while (l < end && *l == '.') {
         l++;
         if ((l = eatIdent(l, end)) == nullptr) return nullptr;
     }
     return l;
 }

 // returns pointer to end of [1-9][0-9]*|0
 static const char* eatNumber(const char* l, const char* end) {
     if (!(l < end)) return nullptr;
     if (*l == '0') return l + 1;
     if (!isLeadingDigit(*l++)) return nullptr;
     while (l < end && isDigit(*l)) l++;
     return l;
 }

 bool FQName::setTo(const std::string& s) {
     clear();

     if (s.empty()) return false;

     const char* l = s.c_str();
     const char* end = l + s.size();
     // android.hardware.foo@10.12::IFoo.Type
     // S                   ES ES E S        E
     //
     // S - start pointer
     // E - end pointer

     struct StartEnd {
         const char* start = nullptr;
         const char* end = nullptr;

         std::string string() {
             if (start == nullptr) return std::string();
             return std::string(start, end - start);
         }
     };
     StartEnd package, major, minor, name;

     if (l < end && isIdentStart(*l)) {
         package.start = l;
         if ((package.end = l = eatPackage(l, end)) == nullptr) return false;
     }
     if (l < end && *l == '@') {
         l++;

         major.start = l;
         if ((major.end = l = eatNumber(l, end)) == nullptr) return false;

         if (!(l < end && *l++ == '.')) return false;

         minor.start = l;
         if ((minor.end = l = eatNumber(l, end)) == nullptr) return false;
     }
     if (l < end && *l == ':') {
         l++;
         if (l < end && *l == ':') {
             l++;
             name.start = l;
             if ((name.end = l = eatPackage(l, end)) == nullptr) return false;
         } else {
             return false;
         }
     }

     if (l < end) return false;

     CHECK((major.start == nullptr) == (minor.start == nullptr));

     // if we only parse a package, consider this to be a name
     if (name.start == nullptr && major.start == nullptr) {
         name.start = package.start;
         name.end = package.end;
         package.start = package.end = nullptr;
     }

     // failures after this goto fail to clear
     mName = name.string();
     mPackage = package.string();

     if (major.start != nullptr) {
         if (!parseVersion(major.string(), minor.string(), &mMajor, &mMinor)) goto fail;
     } else if (mPackage.empty() && name.end == eatIdent(name.start, name.end)) {
         // major.start == nullptr
         mIsIdentifier = true;
     }

     if (!mPackage.empty() && version().empty()) goto fail;

     return true;
 fail:
     clear();
     return false;
 }

 const std::string& FQName::package() const {
     return mPackage;
 }

 std::string FQName::version() const {
     if (!hasVersion()) {
         return "";
     }
     return std::to_string(mMajor) + "." + std::to_string(mMinor);
 }

 std::string FQName::atVersion() const {
     std::string v = version();
     return v.empty() ? "" : ("@" + v);
 }

 void FQName::clear() {
     mIsIdentifier = false;
     mPackage.clear();
     clearVersion();
     mName.clear();
 }

 void FQName::clearVersion(size_t* majorVer, size_t* minorVer) {
     *majorVer = *minorVer = 0;
 }

 bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr,
                           size_t* majorVer, size_t* minorVer) {
     bool versionParseSuccess = ::android::base::ParseUint(majorStr, majorVer) &&
                                ::android::base::ParseUint(minorStr, minorVer);
     if (!versionParseSuccess) {
         LOG(ERROR) << "numbers in " << majorStr << "." << minorStr << " are out of range.";
     }
     return versionParseSuccess;
 }

 bool FQName::parseVersion(const std::string& v, size_t* majorVer, size_t* minorVer) {
     if (v.empty()) {
         clearVersion(majorVer, minorVer);
         return true;
     }

     std::vector<std::string> vs = base::Split(v, ".");
     if (vs.size() != 2) return false;
     return parseVersion(vs[0], vs[1], majorVer, minorVer);
 }

 bool FQName::setVersion(const std::string& v) {
     return parseVersion(v, &mMajor, &mMinor);
 }

 void FQName::clearVersion() {
     clearVersion(&mMajor, &mMinor);
 }

 bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr) {
     return parseVersion(majorStr, minorStr, &mMajor, &mMinor);
 }

 const std::string& FQName::name() const {
     return mName;
 }

 std::string FQName::string() const {
     std::string out;
     out.append(mPackage);
     out.append(atVersion());
     if (!mName.empty()) {
         if (!mPackage.empty() || !version().empty()) {
             out.append("::");
         }
         out.append(mName);
     }

     return out;
 }

 bool FQName::operator<(const FQName& other) const {
     return string() < other.string();
 }

 bool FQName::operator==(const FQName& other) const {
     return string() == other.string();
 }

 bool FQName::operator!=(const FQName& other) const {
     return !(*this == other);
 }

 const std::string& FQName::getInterfaceName() const {
     CHECK(isInterfaceName()) << mName;

     return mName;
 }

 FQName FQName::getPackageAndVersion() const {
     return FQName(package(), version(), "");
 }

 std::vector<std::string> FQName::getPackageComponents() const {
     return base::Split(package(), ".");
 }

 bool FQName::hasVersion() const {
     return mMajor > 0;
 }

 std::pair<size_t, size_t> FQName::getVersion() const {
     return {mMajor, mMinor};
 }

 size_t FQName::getPackageMajorVersion() const {
     CHECK(hasVersion()) << "FQName: No version exists at getPackageMajorVersion(). "
                         << "Did you check hasVersion()?";
     return mMajor;
 }

 size_t FQName::getPackageMinorVersion() const {
     CHECK(hasVersion()) << "FQName: No version exists at getPackageMinorVersion(). "
                         << "Did you check hasVersion()?";
     return mMinor;
 }

 bool FQName::inPackage(const std::string& package) const {
     std::vector<std::string> components = getPackageComponents();
     std::vector<std::string> inComponents = base::Split(package, ".");

     if (inComponents.size() > components.size()) {
         return false;
     }

     for (size_t i = 0; i < inComponents.size(); i++) {
         if (inComponents[i] != components[i]) {
             return false;
         }
     }

     return true;
 }

 }  // namespace android::vintf::details
	/*
	* Copyright (C) 2023 The Android Open Source Project
	*
	* 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 <vintf/FQName.h>

	#include <android-base/logging.h>
	#include <android-base/parseint.h>
	#include <android-base/strings.h>
	#include <iostream>
	#include <sstream>

	namespace android::vintf::details {

	FQName::FQName() : mIsIdentifier(false) {}

	bool FQName::parse(const std::string& s, FQName* into) {
	return into->setTo(s);
	}

	FQName::FQName(const std::string& package, const std::string& version, const std::string& name) {
	size_t majorVer, minorVer;
	CHECK(parseVersion(version, &majorVer, &minorVer));
	CHECK(setTo(package, majorVer, minorVer, name)) << string();
	}

	bool FQName::setTo(const std::string& package, size_t majorVer, size_t minorVer,
	const std::string& name) {
	mPackage = package;
	mMajor = majorVer;
	mMinor = minorVer;
	mName = name;

	FQName other;
	if (!parse(string(), &other)) return false;
	if ((*this) != other) return false;
	mIsIdentifier = other.isIdentifier();
	return true;
	}

	bool FQName::isIdentifier() const {
	return mIsIdentifier;
	}

	bool FQName::isInterfaceName() const {
	return !mName.empty() && mName[0] == 'I' && mName.find('.') == std::string::npos;
	}

	static inline bool isIdentStart(char a) {
	return ('a' <= a && a <= 'z') \|\| ('A' <= a && a <= 'Z') \|\| a == '_';
	}
	static inline bool isLeadingDigit(char a) {
	return '1' <= a && a <= '9';
	}
	static inline bool isDigit(char a) {
	return '0' <= a && a <= '9';
	}
	static inline bool isIdentBody(char a) {
	return isIdentStart(a) \|\| isDigit(a);
	}

	// returns pointer to end of [a-zA-Z_][a-zA-Z0-9_]*
	static const char* eatIdent(const char* l, const char* end) {
	if (!(l < end && isIdentStart(*l++))) return nullptr;
	while (l < end && isIdentBody(*l)) l++;
	return l;
	}

	// returns pointer to end of <ident>(\.<ident>)*
	static const char* eatPackage(const char* l, const char* end) {
	if ((l = eatIdent(l, end)) == nullptr) return nullptr;

	while (l < end && *l == '.') {
	l++;
	if ((l = eatIdent(l, end)) == nullptr) return nullptr;
	}
	return l;
	}

	// returns pointer to end of [1-9][0-9]*\|0
	static const char* eatNumber(const char* l, const char* end) {
	if (!(l < end)) return nullptr;
	if (*l == '0') return l + 1;
	if (!isLeadingDigit(*l++)) return nullptr;
	while (l < end && isDigit(*l)) l++;
	return l;
	}

	bool FQName::setTo(const std::string& s) {
	clear();

	if (s.empty()) return false;

	const char* l = s.c_str();
	const char* end = l + s.size();
	// android.hardware.foo@10.12::IFoo.Type
	// S ES ES E S E
	//
	// S - start pointer
	// E - end pointer

	struct StartEnd {
	const char* start = nullptr;
	const char* end = nullptr;

	std::string string() {
	if (start == nullptr) return std::string();
	return std::string(start, end - start);
	}
	};
	StartEnd package, major, minor, name;

	if (l < end && isIdentStart(*l)) {
	package.start = l;
	if ((package.end = l = eatPackage(l, end)) == nullptr) return false;
	}
	if (l < end && *l == '@') {
	l++;

	major.start = l;
	if ((major.end = l = eatNumber(l, end)) == nullptr) return false;

	if (!(l < end && *l++ == '.')) return false;

	minor.start = l;
	if ((minor.end = l = eatNumber(l, end)) == nullptr) return false;
	}
	if (l < end && *l == ':') {
	l++;
	if (l < end && *l == ':') {
	l++;
	name.start = l;
	if ((name.end = l = eatPackage(l, end)) == nullptr) return false;
	} else {
	return false;
	}
	}

	if (l < end) return false;

	CHECK((major.start == nullptr) == (minor.start == nullptr));

	// if we only parse a package, consider this to be a name
	if (name.start == nullptr && major.start == nullptr) {
	name.start = package.start;
	name.end = package.end;
	package.start = package.end = nullptr;
	}

	// failures after this goto fail to clear
	mName = name.string();
	mPackage = package.string();

	if (major.start != nullptr) {
	if (!parseVersion(major.string(), minor.string(), &mMajor, &mMinor)) goto fail;
	} else if (mPackage.empty() && name.end == eatIdent(name.start, name.end)) {
	// major.start == nullptr
	mIsIdentifier = true;
	}

	if (!mPackage.empty() && version().empty()) goto fail;

	return true;
	fail:
	clear();
	return false;
	}

	const std::string& FQName::package() const {
	return mPackage;
	}

	std::string FQName::version() const {
	if (!hasVersion()) {
	return "";
	}
	return std::to_string(mMajor) + "." + std::to_string(mMinor);
	}

	std::string FQName::atVersion() const {
	std::string v = version();
	return v.empty() ? "" : ("@" + v);
	}

	void FQName::clear() {
	mIsIdentifier = false;
	mPackage.clear();
	clearVersion();
	mName.clear();
	}

	void FQName::clearVersion(size_t* majorVer, size_t* minorVer) {
	majorVer = minorVer = 0;
	}

	bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr,
	size_t* majorVer, size_t* minorVer) {
	bool versionParseSuccess = ::android::base::ParseUint(majorStr, majorVer) &&
	::android::base::ParseUint(minorStr, minorVer);
	if (!versionParseSuccess) {
	LOG(ERROR) << "numbers in " << majorStr << "." << minorStr << " are out of range.";
	}
	return versionParseSuccess;
	}

	bool FQName::parseVersion(const std::string& v, size_t* majorVer, size_t* minorVer) {
	if (v.empty()) {
	clearVersion(majorVer, minorVer);
	return true;
	}

	std::vector<std::string> vs = base::Split(v, ".");
	if (vs.size() != 2) return false;
	return parseVersion(vs[0], vs[1], majorVer, minorVer);
	}

	bool FQName::setVersion(const std::string& v) {
	return parseVersion(v, &mMajor, &mMinor);
	}

	void FQName::clearVersion() {
	clearVersion(&mMajor, &mMinor);
	}

	bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr) {
	return parseVersion(majorStr, minorStr, &mMajor, &mMinor);
	}

	const std::string& FQName::name() const {
	return mName;
	}

	std::string FQName::string() const {
	std::string out;
	out.append(mPackage);
	out.append(atVersion());
	if (!mName.empty()) {
	if (!mPackage.empty() \|\| !version().empty()) {
	out.append("::");
	}
	out.append(mName);
	}

	return out;
	}

	bool FQName::operator<(const FQName& other) const {
	return string() < other.string();
	}

	bool FQName::operator==(const FQName& other) const {
	return string() == other.string();
	}

	bool FQName::operator!=(const FQName& other) const {
	return !(*this == other);
	}

	const std::string& FQName::getInterfaceName() const {
	CHECK(isInterfaceName()) << mName;

	return mName;
	}

	FQName FQName::getPackageAndVersion() const {
	return FQName(package(), version(), "");
	}

	std::vector<std::string> FQName::getPackageComponents() const {
	return base::Split(package(), ".");
	}

	bool FQName::hasVersion() const {
	return mMajor > 0;
	}

	std::pair<size_t, size_t> FQName::getVersion() const {
	return {mMajor, mMinor};
	}

	size_t FQName::getPackageMajorVersion() const {
	CHECK(hasVersion()) << "FQName: No version exists at getPackageMajorVersion(). "
	<< "Did you check hasVersion()?";
	return mMajor;
	}

	size_t FQName::getPackageMinorVersion() const {
	CHECK(hasVersion()) << "FQName: No version exists at getPackageMinorVersion(). "
	<< "Did you check hasVersion()?";
	return mMinor;
	}

	bool FQName::inPackage(const std::string& package) const {
	std::vector<std::string> components = getPackageComponents();
	std::vector<std::string> inComponents = base::Split(package, ".");

	if (inComponents.size() > components.size()) {
	return false;
	}

	for (size_t i = 0; i < inComponents.size(); i++) {
	if (inComponents[i] != components[i]) {
	return false;
	}
	}

	return true;
	}

	} // namespace android::vintf::details