tools/aapt2/util/Util.h

/*
 * Copyright (C) 2015 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.
 */

#ifndef AAPT_UTIL_H
#define AAPT_UTIL_H

#include <functional>
#include <memory>
#include <ostream>
#include <string>
#include <vector>

#include "androidfw/ResourceTypes.h"
#include "androidfw/StringPiece.h"
#include "utils/ByteOrder.h"

#include "util/BigBuffer.h"
#include "util/Maybe.h"

#ifdef _WIN32
// TODO(adamlesinski): remove once http://b/32447322 is resolved.
// utils/ByteOrder.h includes winsock2.h on WIN32,
// which will pull in the ERROR definition. This conflicts
// with android-base/logging.h, which takes care of undefining
// ERROR, but it gets included too early (before winsock2.h).
#ifdef ERROR
#undef ERROR
#endif
#endif

namespace aapt {
namespace util {

template <typename T>
struct Range {
  T start;
  T end;
};

std::vector<std::string> Split(const android::StringPiece& str, char sep);
std::vector<std::string> SplitAndLowercase(const android::StringPiece& str, char sep);

// Returns true if the string starts with prefix.
bool StartsWith(const android::StringPiece& str, const android::StringPiece& prefix);

// Returns true if the string ends with suffix.
bool EndsWith(const android::StringPiece& str, const android::StringPiece& suffix);

// Creates a new StringPiece16 that points to a substring of the original string without leading or
// trailing whitespace.
android::StringPiece TrimWhitespace(const android::StringPiece& str);

// Tests that the string is a valid Java class name.
bool IsJavaClassName(const android::StringPiece& str);

// Tests that the string is a valid Java package name.
bool IsJavaPackageName(const android::StringPiece& str);

// Tests that the string is a valid Android package name. More strict than a Java package name.
// - First character of each component (separated by '.') must be an ASCII letter.
// - Subsequent characters of a component can be ASCII alphanumeric or an underscore.
// - Package must contain at least two components, unless it is 'android'.
bool IsAndroidPackageName(const android::StringPiece& str);

// Tests that the string is a valid Android split name.
// - First character of each component (separated by '.') must be an ASCII letter.
// - Subsequent characters of a component can be ASCII alphanumeric or an underscore.
bool IsAndroidSplitName(const android::StringPiece& str);

// Converts the class name to a fully qualified class name from the given
// `package`. Ex:
//
// asdf         --> package.asdf
// .asdf        --> package.asdf
// .a.b         --> package.a.b
// asdf.adsf    --> asdf.adsf
Maybe<std::string> GetFullyQualifiedClassName(const android::StringPiece& package,
                                              const android::StringPiece& class_name);

template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, int>::type compare(const T& a, const T& b) {
  if (a < b) {
    return -1;
  } else if (a > b) {
    return 1;
  }
  return 0;
}

// Makes a std::unique_ptr<> with the template parameter inferred by the compiler.
// This will be present in C++14 and can be removed then.
template <typename T, class... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
  return std::unique_ptr<T>(new T{std::forward<Args>(args)...});
}

// Writes a set of items to the std::ostream, joining the times with the provided separator.
template <typename Container>
::std::function<::std::ostream&(::std::ostream&)> Joiner(const Container& container,
                                                         const char* sep) {
  using std::begin;
  using std::end;
  const auto begin_iter = begin(container);
  const auto end_iter = end(container);
  return [begin_iter, end_iter, sep](::std::ostream& out) -> ::std::ostream& {
    for (auto iter = begin_iter; iter != end_iter; ++iter) {
      if (iter != begin_iter) {
        out << sep;
      }
      out << *iter;
    }
    return out;
  };
}

// Helper method to extract a UTF-16 string from a StringPool. If the string is stored as UTF-8,
// the conversion to UTF-16 happens within ResStringPool.
android::StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx);

// Helper method to extract a UTF-8 string from a StringPool. If the string is stored as UTF-16,
// the conversion from UTF-16 to UTF-8 does not happen in ResStringPool and is done by this method,
// which maintains no state or cache. This means we must return an std::string copy.
std::string GetString(const android::ResStringPool& pool, size_t idx);

// Checks that the Java string format contains no non-positional arguments (arguments without
// explicitly specifying an index) when there are more than one argument. This is an error
// because translations may rearrange the order of the arguments in the string, which will
// break the string interpolation.
bool VerifyJavaStringFormat(const android::StringPiece& str);

class StringBuilder {
 public:
  explicit StringBuilder(bool preserve_spaces = false);

  StringBuilder& Append(const android::StringPiece& str);
  const std::string& ToString() const;
  const std::string& Error() const;
  bool IsEmpty() const;

  // When building StyledStrings, we need UTF-16 indices into the string,
  // which is what the Java layer expects when dealing with java
  // String.charAt().
  size_t Utf16Len() const;

  explicit operator bool() const;

 private:
  bool preserve_spaces_;
  std::string str_;
  size_t utf16_len_ = 0;
  bool quote_ = false;
  bool trailing_space_ = false;
  bool last_char_was_escape_ = false;
  std::string error_;
};

inline const std::string& StringBuilder::ToString() const {
  return str_;
}

inline const std::string& StringBuilder::Error() const {
  return error_;
}

inline bool StringBuilder::IsEmpty() const {
  return str_.empty();
}

inline size_t StringBuilder::Utf16Len() const {
  return utf16_len_;
}

inline StringBuilder::operator bool() const {
  return error_.empty();
}

// Converts a UTF8 string to a UTF16 string.
std::u16string Utf8ToUtf16(const android::StringPiece& utf8);
std::string Utf16ToUtf8(const android::StringPiece16& utf16);

// Writes the entire BigBuffer to the output stream.
bool WriteAll(std::ostream& out, const BigBuffer& buffer);

// Copies the entire BigBuffer into a single buffer.
std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer);

// A Tokenizer implemented as an iterable collection. It does not allocate any memory on the heap
// nor use standard containers.
class Tokenizer {
 public:
  class iterator {
   public:
    using reference = android::StringPiece&;
    using value_type = android::StringPiece;
    using difference_type = size_t;
    using pointer = android::StringPiece*;
    using iterator_category = std::forward_iterator_tag;

    iterator(const iterator&) = default;
    iterator& operator=(const iterator&) = default;

    iterator& operator++();

    android::StringPiece operator*() { return token_; }
    bool operator==(const iterator& rhs) const;
    bool operator!=(const iterator& rhs) const;

   private:
    friend class Tokenizer;

    iterator(const android::StringPiece& s, char sep, const android::StringPiece& tok, bool end);

    android::StringPiece str_;
    char separator_;
    android::StringPiece token_;
    bool end_;
  };

  Tokenizer(const android::StringPiece& str, char sep);

  iterator begin() const {
    return begin_;
  }

  iterator end() const {
    return end_;
  }

 private:
  const iterator begin_;
  const iterator end_;
};

inline Tokenizer Tokenize(const android::StringPiece& str, char sep) {
  return Tokenizer(str, sep);
}

inline uint16_t HostToDevice16(uint16_t value) {
  return htods(value);
}

inline uint32_t HostToDevice32(uint32_t value) {
  return htodl(value);
}

inline uint16_t DeviceToHost16(uint16_t value) {
  return dtohs(value);
}

inline uint32_t DeviceToHost32(uint32_t value) {
  return dtohl(value);
}

// Given a path like: res/xml-sw600dp/foo.xml
//
// Extracts "res/xml-sw600dp/" into outPrefix.
// Extracts "foo" into outEntry.
// Extracts ".xml" into outSuffix.
//
// Returns true if successful.
bool ExtractResFilePathParts(const android::StringPiece& path, android::StringPiece* out_prefix,
                             android::StringPiece* out_entry, android::StringPiece* out_suffix);

}  // namespace util

// Stream operator for functions. Calls the function with the stream as an argument.
// In the aapt namespace for lookup.
inline ::std::ostream& operator<<(::std::ostream& out,
                                  const ::std::function<::std::ostream&(::std::ostream&)>& f) {
  return f(out);
}

}  // namespace aapt

#endif  // AAPT_UTIL_H