tools/aapt2/ValueVisitor.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_VALUE_VISITOR_H
#define AAPT_VALUE_VISITOR_H

#include "ResourceTable.h"
#include "ResourceValues.h"

namespace aapt {

/**
 * Visits a value and invokes the appropriate method based on its type. Does not
 * traverse
 * into compound types. Use ValueVisitor for that.
 */
struct RawValueVisitor {
  virtual ~RawValueVisitor() = default;

  virtual void visitItem(Item* value) {}
  virtual void visit(Reference* value) { visitItem(value); }
  virtual void visit(RawString* value) { visitItem(value); }
  virtual void visit(String* value) { visitItem(value); }
  virtual void visit(StyledString* value) { visitItem(value); }
  virtual void visit(FileReference* value) { visitItem(value); }
  virtual void visit(Id* value) { visitItem(value); }
  virtual void visit(BinaryPrimitive* value) { visitItem(value); }

  virtual void visit(Attribute* value) {}
  virtual void visit(Style* value) {}
  virtual void visit(Array* value) {}
  virtual void visit(Plural* value) {}
  virtual void visit(Styleable* value) {}
};

// NOLINT, do not add parentheses around T.
#define DECL_VISIT_COMPOUND_VALUE(T)          \
  virtual void visit(T* value) { /* NOLINT */ \
    visitSubValues(value);                    \
  }

/**
 * Visits values, and if they are compound values, visits the components as
 * well.
 */
struct ValueVisitor : public RawValueVisitor {
  // The compiler will think we're hiding an overload, when we actually intend
  // to call into RawValueVisitor. This will expose the visit methods in the
  // super
  // class so the compiler knows we are trying to call them.
  using RawValueVisitor::visit;

  void visitSubValues(Attribute* attribute) {
    for (Attribute::Symbol& symbol : attribute->symbols) {
      visit(&symbol.symbol);
    }
  }

  void visitSubValues(Style* style) {
    if (style->parent) {
      visit(&style->parent.value());
    }

    for (Style::Entry& entry : style->entries) {
      visit(&entry.key);
      entry.value->accept(this);
    }
  }

  void visitSubValues(Array* array) {
    for (std::unique_ptr<Item>& item : array->items) {
      item->accept(this);
    }
  }

  void visitSubValues(Plural* plural) {
    for (std::unique_ptr<Item>& item : plural->values) {
      if (item) {
        item->accept(this);
      }
    }
  }

  void visitSubValues(Styleable* styleable) {
    for (Reference& reference : styleable->entries) {
      visit(&reference);
    }
  }

  DECL_VISIT_COMPOUND_VALUE(Attribute);
  DECL_VISIT_COMPOUND_VALUE(Style);
  DECL_VISIT_COMPOUND_VALUE(Array);
  DECL_VISIT_COMPOUND_VALUE(Plural);
  DECL_VISIT_COMPOUND_VALUE(Styleable);
};

/**
 * Do not use directly. Helper struct for dyn_cast.
 */
template <typename T>
struct DynCastVisitor : public RawValueVisitor {
  T* value = nullptr;

  void visit(T* v) override { value = v; }
};

/**
 * Specialization that checks if the value is an Item.
 */
template <>
struct DynCastVisitor<Item> : public RawValueVisitor {
  Item* value = nullptr;

  void visitItem(Item* item) override { value = item; }
};

template <typename T>
const T* valueCast(const Value* value) {
  return valueCast<T>(const_cast<Value*>(value));
}

/**
 * Returns a valid pointer to T if the Value is of subtype T.
 * Otherwise, returns nullptr.
 */
template <typename T>
T* valueCast(Value* value) {
  if (!value) {
    return nullptr;
  }
  DynCastVisitor<T> visitor;
  value->accept(&visitor);
  return visitor.value;
}

inline void visitAllValuesInPackage(ResourceTablePackage* pkg,
                                    RawValueVisitor* visitor) {
  for (auto& type : pkg->types) {
    for (auto& entry : type->entries) {
      for (auto& configValue : entry->values) {
        configValue->value->accept(visitor);
      }
    }
  }
}

inline void visitAllValuesInTable(ResourceTable* table,
                                  RawValueVisitor* visitor) {
  for (auto& pkg : table->packages) {
    visitAllValuesInPackage(pkg.get(), visitor);
  }
}

}  // namespace aapt

#endif  // AAPT_VALUE_VISITOR_H