com.google.web.bindery.requestfactory.apt.ClientToDomainMapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gwt-servlet Show documentation
There is a newer version: 2.7.0.vaadin7
/*
 * Copyright 2011 Google Inc.
 *
 * 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.
 */
package com.google.web.bindery.requestfactory.apt;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import javax.lang.model.type.WildcardType;

/**
 * Uses information in a State object to convert client types to their domain
 * equivalents. This types assumes that any incoming type has already been
 * determined to be a transportable type.
 */
class ClientToDomainMapper extends TypeVisitorBase {
  public static class UnmappedTypeException extends RuntimeException {
    private final TypeMirror clientType;

    public UnmappedTypeException() {
      super();
      clientType = null;
    }

    public UnmappedTypeException(TypeMirror clientType) {
      super("No domain type resolved for " + clientType.toString());
      this.clientType = clientType;
    }

    public TypeMirror getClientType() {
      return clientType;
    }
  }

  @Override
  public TypeMirror visitDeclared(DeclaredType x, State state) {
    if (x.asElement().getKind().equals(ElementKind.ENUM)) {
      // Enums map to enums
      return x;
    }
    if (state.types.isAssignable(x, state.entityProxyType)
        || state.types.isAssignable(x, state.valueProxyType)) {
      // FooProxy -> FooDomain
      /*
       * TODO(bobv): This if statement should be widened to baseProxy to support
       * heterogenous collections of any proxy type. The BaseProxy interface
       * would also need to be annotated with an @ProxyFor mapping. This can be
       * done once RFIV is removed, since it only allows homogenous collections.
       */
      TypeElement domainType =
          (TypeElement) state.getClientToDomainMap().get(state.types.asElement(x));
      if (domainType == null) {
        return defaultAction(x, state);
      }
      return domainType.asType();
    }
    if (state.types.isAssignable(x, state.entityProxyIdType)) {
      // EntityProxyId -> FooDomain
      return convertSingleParamType(x, state.entityProxyIdType, 0, state);
    }
    if (state.types.isAssignable(x, state.requestType)) {
      // Request -> FooDomain
      return convertSingleParamType(x, state.requestType, 0, state);
    }
    if (state.types.isAssignable(x, state.instanceRequestType)) {
      // InstanceRequest -> FooDomain
      return convertSingleParamType(x, state.instanceRequestType, 1, state);
    }
    for (DeclaredType valueType : getValueTypes(state)) {
      if (state.types.isAssignable(x, valueType)) {
        // Value types map straight through
        return x;
      }
    }
    if (state.types.isAssignable(x, state.findType(List.class))
        || state.types.isAssignable(x, state.findType(Set.class))) {
      // Convert Set,List to Set,List
      TypeMirror param = convertSingleParamType(x, state.findType(Collection.class), 0, state);
      return state.types.getDeclaredType((TypeElement) state.types.asElement(x), param);
    }
    final DeclaredType mapType = state.findType(Map.class);
    if (state.types.isAssignable(x, mapType)) {
      // Convert Map to Map
      TypeMirror keyParam = convertSingleParamType(x, mapType, 0, state);
      TypeMirror valueParam = convertSingleParamType(x, mapType, 1, state);
      return state.types.getDeclaredType((TypeElement) state.types.asElement(x), keyParam, valueParam);
    }
    return defaultAction(x, state);
  }

  @Override
  public TypeMirror visitNoType(NoType x, State state) {
    if (x.getKind().equals(TypeKind.VOID)) {
      // Pass void through
      return x;
    }
    // Here, x would be NONE or PACKAGE, neither of which make sense
    return defaultAction(x, state);
  }

  @Override
  public TypeMirror visitPrimitive(PrimitiveType x, State state) {
    // Primitives pass through
    return x;
  }

  @Override
  public TypeMirror visitTypeVariable(TypeVariable x, State state) {
    // Convert  to FooDomain
    return x.getUpperBound().accept(this, state);
  }

  @Override
  public TypeMirror visitWildcard(WildcardType x, State state) {
    // Convert  to FooDomain
    return state.types.erasure(x).accept(this, state);
  }

  /**
   * Utility method to convert a {@code Foo -> BarDomain}. The
   * {@code param} parameter specifies the index of the type paramater to
   * extract.
   */
  protected TypeMirror convertSingleParamType(DeclaredType x, DeclaredType convertTo, int param,
      State state) {
    DeclaredType converted = (DeclaredType) State.viewAs(convertTo, x, state);
    if (converted == null) {
      return state.types.getNoType(TypeKind.NONE);
    }
    if (converted.getTypeArguments().isEmpty()) {
      return defaultAction(x, state);
    }
    return converted.getTypeArguments().get(param).accept(this, state);
  }

  @Override
  protected TypeMirror defaultAction(TypeMirror x, State state) {
    throw new UnmappedTypeException(x);
  }
}