tools/aapt2/java/ClassDefinition.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_JAVA_CLASSDEFINITION_H
#define AAPT_JAVA_CLASSDEFINITION_H

#include "Resource.h"
#include "java/AnnotationProcessor.h"
#include "util/StringPiece.h"
#include "util/Util.h"

#include <android-base/macros.h>
#include <sstream>
#include <string>

namespace aapt {

// The number of attributes to emit per line in a Styleable array.
constexpr static size_t kAttribsPerLine = 4;
constexpr static const char* kIndent = "  ";

class ClassMember {
 public:
  virtual ~ClassMember() = default;

  AnnotationProcessor* getCommentBuilder() { return &mProcessor; }

  virtual bool empty() const = 0;

  virtual void writeToStream(const StringPiece& prefix, bool final,
                             std::ostream* out) const {
    mProcessor.writeToStream(out, prefix);
  }

 private:
  AnnotationProcessor mProcessor;
};

template <typename T>
class PrimitiveMember : public ClassMember {
 public:
  PrimitiveMember(const StringPiece& name, const T& val)
      : mName(name.toString()), mVal(val) {}

  bool empty() const override { return false; }

  void writeToStream(const StringPiece& prefix, bool final,
                     std::ostream* out) const override {
    ClassMember::writeToStream(prefix, final, out);

    *out << prefix << "public static " << (final ? "final " : "") << "int "
         << mName << "=" << mVal << ";";
  }

 private:
  std::string mName;
  T mVal;

  DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
};

/**
 * Specialization for strings so they get the right type and are quoted with "".
 */
template <>
class PrimitiveMember<std::string> : public ClassMember {
 public:
  PrimitiveMember(const StringPiece& name, const std::string& val)
      : mName(name.toString()), mVal(val) {}

  bool empty() const override { return false; }

  void writeToStream(const StringPiece& prefix, bool final,
                     std::ostream* out) const override {
    ClassMember::writeToStream(prefix, final, out);

    *out << prefix << "public static " << (final ? "final " : "") << "String "
         << mName << "=\"" << mVal << "\";";
  }

 private:
  std::string mName;
  std::string mVal;

  DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
};

using IntMember = PrimitiveMember<uint32_t>;
using ResourceMember = PrimitiveMember<ResourceId>;
using StringMember = PrimitiveMember<std::string>;

template <typename T>
class PrimitiveArrayMember : public ClassMember {
 public:
  explicit PrimitiveArrayMember(const StringPiece& name)
      : mName(name.toString()) {}

  void addElement(const T& val) { mElements.push_back(val); }

  bool empty() const override { return false; }

  void writeToStream(const StringPiece& prefix, bool final,
                     std::ostream* out) const override {
    ClassMember::writeToStream(prefix, final, out);

    *out << prefix << "public static final int[] " << mName << "={";

    const auto begin = mElements.begin();
    const auto end = mElements.end();
    for (auto current = begin; current != end; ++current) {
      if (std::distance(begin, current) % kAttribsPerLine == 0) {
        *out << "\n" << prefix << kIndent << kIndent;
      }

      *out << *current;
      if (std::distance(current, end) > 1) {
        *out << ", ";
      }
    }
    *out << "\n" << prefix << kIndent << "};";
  }

 private:
  std::string mName;
  std::vector<T> mElements;

  DISALLOW_COPY_AND_ASSIGN(PrimitiveArrayMember);
};

using ResourceArrayMember = PrimitiveArrayMember<ResourceId>;

enum class ClassQualifier { None, Static };

class ClassDefinition : public ClassMember {
 public:
  static bool writeJavaFile(const ClassDefinition* def,
                            const StringPiece& package, bool final,
                            std::ostream* out);

  ClassDefinition(const StringPiece& name, ClassQualifier qualifier,
                  bool createIfEmpty)
      : mName(name.toString()),
        mQualifier(qualifier),
        mCreateIfEmpty(createIfEmpty) {}

  void addMember(std::unique_ptr<ClassMember> member) {
    mMembers.push_back(std::move(member));
  }

  bool empty() const override;
  void writeToStream(const StringPiece& prefix, bool final,
                     std::ostream* out) const override;

 private:
  std::string mName;
  ClassQualifier mQualifier;
  bool mCreateIfEmpty;
  std::vector<std::unique_ptr<ClassMember>> mMembers;

  DISALLOW_COPY_AND_ASSIGN(ClassDefinition);
};

}  // namespace aapt

#endif /* AAPT_JAVA_CLASSDEFINITION_H */