예제 #1
0
  /** Creates a {@link PluginPropertyField} based on the given field. */
  private PluginPropertyField createPluginProperty(Field field, TypeToken<?> resolvingType)
      throws UnsupportedTypeException {
    TypeToken<?> fieldType = resolvingType.resolveType(field.getGenericType());
    Class<?> rawType = fieldType.getRawType();

    Name nameAnnotation = field.getAnnotation(Name.class);
    Description descAnnotation = field.getAnnotation(Description.class);
    String name = nameAnnotation == null ? field.getName() : nameAnnotation.value();
    String description = descAnnotation == null ? "" : descAnnotation.value();

    if (rawType.isPrimitive()) {
      return new PluginPropertyField(name, description, rawType.getName(), true);
    }

    rawType = Primitives.unwrap(rawType);
    if (!rawType.isPrimitive() && !String.class.equals(rawType)) {
      throw new UnsupportedTypeException("Only primitive and String types are supported");
    }

    boolean required = true;
    for (Annotation annotation : field.getAnnotations()) {
      if (annotation.annotationType().getName().endsWith(".Nullable")) {
        required = false;
        break;
      }
    }

    return new PluginPropertyField(
        name, description, rawType.getSimpleName().toLowerCase(), required);
  }
예제 #2
0
 @Override
 public void serialize(TypeToken<?> type, Mute mute, ConfigurationNode node)
     throws ObjectMappingException {
   node.getNode("muted").setValue(TypeToken.of(UUID.class), mute.getMuted());
   node.getNode("muter").setValue(TypeToken.of(UUID.class), mute.getMuter());
   node.getNode("endtime").setValue(mute.getEndtime());
   node.getNode("starttime").setValue(mute.getStarttime());
   node.getNode("reason").setValue(TypeToken.of(Text.class), mute.getReason());
 }
예제 #3
0
 @Override
 public Mute deserialize(TypeToken<?> type, ConfigurationNode node)
     throws ObjectMappingException {
   UUID muted = node.getNode("muted").getValue(TypeToken.of(UUID.class));
   UUID muter = node.getNode("muter").getValue(TypeToken.of(UUID.class));
   Long endtime = node.getNode("endtime").getLong();
   Long starttime = node.getNode("starttime").getLong();
   Text reason = node.getNode("reason").getValue(TypeToken.of(Text.class));
   return new Mute(muted, muter, endtime, starttime, reason);
 }
예제 #4
0
  @Test
  public void testTypeToken()
      throws NoSuchMethodException, SecurityException, InvocationTargetException,
          IllegalAccessException {

    TypeToken<TypeTokenTest> token = TypeToken.of(TypeTokenTest.class);
    Invokable<TypeTokenTest, ?> invokable =
        token.method(TypeTokenTest.class.getMethod("helloWorld"));
    invokable.invoke(this);
  }
예제 #5
0
  public static <K, V> ThriftType map(ThriftType keyType, ThriftType valueType) {
    checkNotNull(keyType, "keyType is null");
    checkNotNull(valueType, "valueType is null");

    @SuppressWarnings("serial")
    Type javaType =
        new TypeToken<Map<K, V>>() {}.where(
                new TypeParameter<K>() {}, (TypeToken<K>) TypeToken.of(keyType.getJavaType()))
            .where(new TypeParameter<V>() {}, (TypeToken<V>) TypeToken.of(valueType.getJavaType()))
            .getType();
    return new ThriftType(ThriftProtocolType.MAP, javaType, keyType, valueType);
  }
예제 #6
0
  /**
   * Constructor.
   *
   * @param contentType the type of request this parser can handle
   */
  protected ParserSupport(String contentType) {
    this.contentType = contentType;

    TypeToken<O> typeToken = new TypeToken<O>(getClass()) {};

    if (typeToken.getType() instanceof Class) {
      @SuppressWarnings("unchecked")
      Class<O> rawType = (Class<O>) typeToken.getRawType();
      this.optsType = rawType;
    } else {
      throw new IllegalArgumentException("Type parameter O of ParserSupport must be a Class");
    }
  }
public class BlobStoreViewMBeanFactory implements ViewMBeanFactory<BlobStoreContext> {

  private static final TypeToken<BlobStoreContext> TYPE = TypeToken.of(BlobStoreContext.class);

  /**
   * Creates a {@link org.jclouds.management.ManagedBean} for the Context.
   *
   * @param view
   * @return
   */
  @Override
  public ViewMBean<BlobStoreContext> create(BlobStoreContext view) {
    return new BlobStoreManagement(view);
  }

  /**
   * Returns the {@link com.google.common.reflect.TypeToken} of the {@link org.jclouds.View}.
   *
   * @return
   */
  @Override
  public TypeToken<BlobStoreContext> getViewType() {
    return TYPE;
  }
}
예제 #8
0
 @Override
 public boolean isWriteable(
     Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
   return List.class.isAssignableFrom(type)
       && TypeToken.of(genericType).resolveType(LIST_GENERIC_TOKEN).getRawType().equals(Page.class)
       && mediaType.isCompatible(PRESTO_PAGES_TYPE);
 }
  @SuppressWarnings("unchecked")
  @Override
  public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    if (typeToken.getRawType() != ImmutableMap.class || !(type instanceof ParameterizedType)) {
      return null;
    }

    com.google.common.reflect.TypeToken<ImmutableMap<?, ?>> betterToken =
        (com.google.common.reflect.TypeToken<ImmutableMap<?, ?>>)
            com.google.common.reflect.TypeToken.of(typeToken.getType());
    final TypeAdapter<HashMap<?, ?>> hashMapAdapter =
        (TypeAdapter<HashMap<?, ?>>)
            gson.getAdapter(
                TypeToken.get(
                    betterToken.getSupertype(Map.class).getSubtype(HashMap.class).getType()));
    return new TypeAdapter<T>() {
      @Override
      public void write(JsonWriter out, T value) throws IOException {
        HashMap<?, ?> hashMap = Maps.newHashMap((Map<?, ?>) value);
        hashMapAdapter.write(out, hashMap);
      }

      @Override
      public T read(JsonReader in) throws IOException {
        HashMap<?, ?> hashMap = hashMapAdapter.read(in);
        return (T) ImmutableMap.copyOf(hashMap);
      }
    };
  }
 @SuppressWarnings(
     "RedundantTypeArguments") // <Class<?>> is actually needed to compile
 @Override
 public ImmutableSet<Class<?>> load(Class<?> concreteClass) {
   return ImmutableSet.<Class<?>>copyOf(
       TypeToken.of(concreteClass).getTypes().rawTypes());
 }
예제 #11
0
/**
 * Known keys for metadata
 *
 * @author Adrian Cole
 */
public enum Metadata {
  ROOT_AUTHORIZED_KEYS(TypeToken.of(String.class).getType()),
  /**
   * If the dataset you create a machine from is set to generate passwords for you, the
   * username/password pairs will be returned in the metadata response as a nested object, like:
   *
   * <pre>
   * "credentials": {
   *     "root": "s8v9kuht5e",
   *     "admin": "mf4bteqhpy"
   *   }
   * </pre>
   */
  CREDENTIALS(
      new TypeToken<Map<String, String>>() {
        private static final long serialVersionUID = -433136967305618708L;
      }.getType());

  private final Type valueType;

  Metadata(Type valueType) {
    this.valueType = valueType;
  }

  public String key() {
    return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_UNDERSCORE, name());
  }

  /** type of the value; */
  public Type type() {
    return valueType;
  }
}
예제 #12
0
 @Override
 public boolean equals(Object obj) {
   if (this == obj) return true;
   if (obj == null) return false;
   if (getClass() != obj.getClass()) return false;
   AdapterKey<?> other = (AdapterKey<?>) obj;
   return key.equals(other.getKey()) && role.equals(other.role);
 }
예제 #13
0
 @Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + ((key == null) ? 0 : key.hashCode());
   result = prime * result + ((role == null) ? 0 : role.hashCode());
   return result;
 }
예제 #14
0
 /**
  * Creates a new {@link AdapterKey} for the given key and role.
  *
  * @param <T> The adapter type.
  * @param key The key to use for the newly created {@link AdapterKey}. May not be <code>null
  *     </code>.
  * @param role The role to use for the newly created {@link AdapterKey}. May not be <code>null
  *     </code>.
  * @return A new {@link AdapterKey} for the given key and role.
  */
 public static <T> AdapterKey<T> get(Class<T> key, String role) {
   if (key == null) {
     throw new NullPointerException("Key may not be null.");
   }
   if (role == null) {
     throw new NullPointerException("Role may not be null.");
   }
   return new AdapterKey<T>(TypeToken.of(key), role);
 }
  public static void main(String[] args) {
    ApplicationContext appContext = new AnnotationConfigApplicationContext(FieldsCheckerMain.class);
    FieldsChecker fieldsChecker = appContext.getBean(FieldsChecker.class);
    fieldsChecker.checkTableFields();

    boolean resolved = false;
    TypeToken mapOfString = TypeTokens.mapOf(String.class, String.class);
    Type type = mapOfString.getType();
    if (type instanceof ParameterizedType) {
      ParameterizedType pType = (ParameterizedType) type;
      Type[] types = pType.getActualTypeArguments();
      if (types.length == 2) {
        TypeToken valueType = TypeToken.of(types[1]);
        resolved = valueType.getRawType().equals(String.class);
      }
    }

    System.out.println(resolved);
  }
예제 #16
0
 /**
  * Creates a new optioninfo.
  *
  * @param name Name of the option.
  * @param help Help string.
  * @param prefix Prefix scope for the option.
  * @param type Concrete option target type.
  * @param <T> Option type.
  * @return A new optioninfo.
  */
 public static <T> OptionInfo<T> create(String name, String help, String prefix, Class<T> type) {
   return new OptionInfo<T>(
       checkValidName(name),
       help,
       Arg.<T>create(),
       TypeToken.of(type),
       prefix,
       ImmutableList.<Annotation>of(),
       null);
 }
  @Test
  public void shouldDownloadBundle() {
    client.downloadBundle(ANY_RESOURCE_ID);

    String expectedUri =
        ARTIFACTS_BUNDLE_URI + ARTIFACTS_BUNDLE_DOWNLOAD_URI + "/" + ANY_RESOURCE_ID;
    Request expectedRequest = new Request(HttpMethod.GET, expectedUri);

    then(baseClient).should().executeRequest(expectedRequest, TypeToken.of(String.class).getType());
  }
예제 #18
0
  public static <E> ThriftType list(ThriftType valueType) {
    checkNotNull(valueType, "valueType is null");

    @SuppressWarnings("serial")
    Type javaType =
        new TypeToken<List<E>>() {}.where(
                new TypeParameter<E>() {}, (TypeToken<E>) TypeToken.of(valueType.getJavaType()))
            .getType();
    return new ThriftType(ThriftProtocolType.LIST, javaType, null, valueType);
  }
예제 #19
0
/**
 * 模拟委托的接口,对应C#中的委托Action(void -> void)
 *
 * @author Zhang Yifan
 */
@ParametersAreNonnullByDefault
public interface Action0 extends IDelegate {
  /** */
  void DoAction();

  /** */
  public static final TypeToken<Action0> ACTION0_TYPETOKEN = TypeToken.of(Action0.class);

  /** A Method object that represents the only method in Action0 interface. */
  public static final Invokable<Action0, Void> ACTION0_METHOD =
      Methods.TryGetFirstMethod(TypeToken.of(Action0.class), "DoAction")
          .get()
          .returning(void.class);

  // public static final Method ACTION0_METHOD = Methods.TryGetFirstMethod(Action0.class,
  // "DoAction").get();

  // public static final Invokable<Action0, Void> ACTION0_INVOKABLE =
  // ACTION0_TYPETOKEN.method(ACTION0_METHOD).returning(Void.class);
}
  @Test
  public void shouldGetSasLogicalInterconnectGroupById() {
    client.getById(ANY_RESOURCE_ID);

    String expectedUri = SAS_LOGICAL_INTERCONNECT_GROUP_URI + "/" + ANY_RESOURCE_ID;
    Request expectedRequest = new Request(HttpMethod.GET, expectedUri);

    then(baseClient)
        .should()
        .executeRequest(expectedRequest, TypeToken.of(SasLogicalInterconnectGroup.class).getType());
  }
예제 #21
0
  /**
   * Inspects the plugin config class and build up a map for {@link PluginPropertyField}.
   *
   * @param configType type of the config class
   * @param result map for storing the result
   * @throws UnsupportedTypeException if a field type in the config class is not supported
   */
  private void inspectConfigField(TypeToken<?> configType, Map<String, PluginPropertyField> result)
      throws UnsupportedTypeException {
    for (TypeToken<?> type : configType.getTypes().classes()) {
      if (PluginConfig.class.equals(type.getRawType())) {
        break;
      }

      for (Field field : type.getRawType().getDeclaredFields()) {
        PluginPropertyField property = createPluginProperty(field, type);
        if (result.containsKey(property.getName())) {
          throw new IllegalArgumentException(
              "Plugin config with name "
                  + property.getName()
                  + " already defined in "
                  + configType.getRawType());
        }
        result.put(property.getName(), property);
      }
    }
  }
  @Test
  public void shouldGetArtifactsBundle() {
    client.getById(ANY_RESOURCE_ID);

    String expectedUri = ARTIFACTS_BUNDLE_URI + "/" + ANY_RESOURCE_ID;
    Request expectedRequest = new Request(HttpMethod.GET, expectedUri);

    then(baseClient)
        .should()
        .executeRequest(expectedRequest, TypeToken.of(ArtifactsBundle.class).getType());
  }
예제 #23
0
 private <T> List<T> deserializeAsArray(
     JsonElement json,
     JsonDeserializationContext context,
     TypeToken<T> typeToken,
     Type listOfT) {
   if (json.isJsonPrimitive()) {
     List<T> list = new ArrayList<T>();
     list.add((T) context.deserialize(json, typeToken.getType()));
     return list;
   } else {
     return context.deserialize(json, listOfT);
   }
 }
예제 #24
0
 /** Constructor with hit for handling type. */
 public ConfigureAdapterStage(
     CConfiguration cConf,
     Id.Namespace namespace,
     String adapterName,
     Location templateJarLocation,
     PluginRepository pluginRepository) {
   super(TypeToken.of(AdapterDeploymentInfo.class));
   this.cConf = cConf;
   this.namespace = namespace;
   this.adapterName = adapterName;
   this.templateJarLocation = templateJarLocation;
   this.pluginRepository = pluginRepository;
 }
예제 #25
0
  private List<ApplicationClass> inspectApplications(File artifactFile)
      throws IOException, InvalidArtifactException {
    List<ApplicationClass> apps = Lists.newArrayList();

    Location artifactLocation = Locations.toLocation(artifactFile);
    Manifest manifest = BundleJarUtil.getManifest(artifactLocation);
    if (manifest == null) {
      return apps;
    }
    Attributes manifestAttributes = manifest.getMainAttributes();
    if (manifestAttributes == null) {
      return apps;
    }

    // right now we force users to include the application main class as an attribute in their
    // manifest,
    // which forces them to have a single application class.
    // in the future, we may want to let users do this or maybe specify a list of classes or
    // a package that will be searched for applications, to allow multiple applications in a single
    // artifact.
    String mainClassName = manifestAttributes.getValue(ManifestFields.MAIN_CLASS);
    if (mainClassName != null) {
      try (CloseableClassLoader artifactClassLoader =
          artifactClassLoaderFactory.createClassLoader(Locations.toLocation(artifactFile))) {

        Object appMain = artifactClassLoader.loadClass(mainClassName).newInstance();
        if (!(appMain instanceof Application)) {
          throw new InvalidArtifactException(
              String.format(
                  "Application main class is of invalid type: %s", appMain.getClass().getName()));
        }

        Application app = (Application) appMain;

        TypeToken typeToken = TypeToken.of(app.getClass());
        TypeToken<?> resultToken = typeToken.resolveType(Application.class.getTypeParameters()[0]);
        Type configType;
        // if the user parameterized their template, like 'xyz extends ApplicationTemplate<T>',
        // we can deserialize the config into that object. Otherwise it'll just be a Config
        if (resultToken.getType() instanceof Class) {
          configType = resultToken.getType();
        } else {
          configType = Config.class;
        }
        apps.add(new ApplicationClass(mainClassName, "", schemaGenerator.generate(configType)));
      } catch (ClassNotFoundException e) {
        throw new InvalidArtifactException(
            String.format("Could not find Application main class %s.", mainClassName));
      } catch (UnsupportedTypeException e) {
        throw new InvalidArtifactException(
            String.format("Config for Application %s has an unsupported schema.", mainClassName));
      } catch (InstantiationException | IllegalAccessException e) {
        throw new InvalidArtifactException(
            String.format("Could not instantiate Application class %s.", mainClassName), e);
      }
    }
    return apps;
  }
예제 #26
0
  @Override
  public void onInitialize() throws CraftBookException {
    super.onInitialize();

    try {
      List<String> blockBagList = config.getNode("blockbags").getList(TypeToken.of(String.class));
      blockBags = new BlockBag[blockBagList.size()];
      for (int i = 0; i < blockBagList.size(); i++) {
        blockBags[i] = BlockBag.createFromString(blockBagList.get(i));
      }
    } catch (ObjectMappingException e) {
      CraftBookPlugin.spongeInst().getLogger().error("Failed to map object.", e);
    }
  }
  @Test
  public void shouldStopBundleCreation() {
    TaskUri taskUri = new TaskUri();

    taskUri.setTaskUri(ANY_TASK_URI);

    client.stopBundleCreation(ANY_RESOURCE_ID, taskUri);

    String expectedUri =
        ARTIFACTS_BUNDLE_URI + "/" + ANY_RESOURCE_ID + ARTIFACTS_BUNDLE_STOP_ARTIFACT_CREATE_URI;
    Request expectedRequest = new Request(HttpMethod.PUT, expectedUri, taskUri);

    then(baseClient).should().executeRequest(expectedRequest, TypeToken.of(String.class).getType());
  }
 protected Builder(Class<?> client, Class<?> asyncClient) {
   super(client, asyncClient);
   id("chef")
       .name("Opscode Platform Api")
       .identityName("User")
       .credentialName("Certificate")
       .version(ChefAsyncClient.VERSION)
       .documentation(URI.create("http://help.opscode.com/kb/api"))
       .defaultEndpoint("https://api.opscode.com")
       .defaultProperties(OpscodePlatformApiMetadata.defaultProperties())
       .context(TypeToken.of(OpscodePlatformContext.class))
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>of(
               OpscodePlatformRestClientModule.class, JMXOhaiModule.class));
 }
 protected Builder() {
   super(CloudSigmaClient.class, CloudSigmaAsyncClient.class);
   id("cloudsigma")
       .name("CloudSigma API")
       .identityName("Email")
       .credentialName("Password")
       .documentation(URI.create("http://cloudsigma.com/en/platform-details/the-api"))
       .version("1.0")
       .defaultEndpoint("https://api.cloudsigma.com")
       .defaultProperties(CloudSigmaApiMetadata.defaultProperties())
       .view(TypeToken.of(ComputeServiceContext.class))
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>of(
               CloudSigmaRestClientModule.class, CloudSigmaComputeServiceContextModule.class));
 }
예제 #30
0
 protected Builder() {
   super(AtmosClient.class, AtmosAsyncClient.class);
   id("atmos")
       .name("EMC's Atmos API")
       .identityName("Subtenant ID (UID)")
       .credentialName("Shared Secret")
       .documentation(URI.create("https://community.emc.com/docs/DOC-10508"))
       .version("1.4.0")
       .defaultEndpoint("https://accesspoint.atmosonline.com")
       .defaultProperties(AtmosApiMetadata.defaultProperties())
       .view(TypeToken.of(BlobStoreContext.class))
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>of(
               AtmosRestClientModule.class, AtmosBlobStoreContextModule.class));
 }