コード例 #1
0
ファイル: Mute.java プロジェクト: Bammerbom/UltimateCore
 @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());
 }
コード例 #2
0
ファイル: Mute.java プロジェクト: Bammerbom/UltimateCore
 @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);
 }
コード例 #3
0
ファイル: ThriftType.java プロジェクト: hgschmie/swift
  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);
  }
コード例 #4
0
ファイル: Metadata.java プロジェクト: normanmaurer/jclouds
/**
 * 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;
  }
}
コード例 #5
0
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;
  }
}
コード例 #6
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);
 }
コード例 #7
0
 @SuppressWarnings(
     "RedundantTypeArguments") // <Class<?>> is actually needed to compile
 @Override
 public ImmutableSet<Class<?>> load(Class<?> concreteClass) {
   return ImmutableSet.<Class<?>>copyOf(
       TypeToken.of(concreteClass).getTypes().rawTypes());
 }
コード例 #8
0
  @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);
      }
    };
  }
コード例 #9
0
ファイル: ArtifactInspector.java プロジェクト: domarps/cdap
  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;
  }
コード例 #10
0
ファイル: AdapterKey.java プロジェクト: BrPasha/gef4
 /**
  * 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);
 }
コード例 #11
0
  @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());
  }
コード例 #12
0
ファイル: ThriftType.java プロジェクト: hgschmie/swift
  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);
  }
コード例 #13
0
ファイル: OptionInfo.java プロジェクト: nsanch/commons
 /**
  * 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);
 }
コード例 #14
0
ファイル: TypeTokenTest.java プロジェクト: nrvivek23/knives
  @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);
  }
コード例 #15
0
ファイル: Action0.java プロジェクト: njusegzyf/ZYF-Base
/**
 * 模拟委托的接口,对应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());
  }
コード例 #17
0
  @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());
  }
コード例 #18
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;
 }
コード例 #19
0
  @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());
  }
コード例 #20
0
ファイル: BlockBagManager.java プロジェクト: sk89q/CraftBook
  @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);
    }
  }
コード例 #21
0
 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));
 }
コード例 #22
0
 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));
 }
コード例 #23
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));
 }
コード例 #24
0
 protected Builder() {
   super(GleSYSApi.class, GleSYSAsyncApi.class);
   id("glesys")
       .name("GleSYS API")
       .identityName("Username")
       .credentialName("API Key")
       .documentation(URI.create("https://customer.glesys.com/api.php"))
       .version("1")
       .buildVersion("3.5.0")
       .defaultEndpoint("https://api.glesys.com")
       .defaultProperties(GleSYSApiMetadata.defaultProperties())
       .view(TypeToken.of(ComputeServiceContext.class))
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>of(
               GleSYSComputeServiceContextModule.class, GleSYSRestClientModule.class));
 }
コード例 #25
0
ファイル: ArtifactInspector.java プロジェクト: domarps/cdap
 /**
  * Gets all config properties for the given plugin.
  *
  * @return the name of the config field in the plugin class or {@code null} if the plugin doesn't
  *     have a config field
  */
 @Nullable
 private String getProperties(TypeToken<?> pluginType, Map<String, PluginPropertyField> result)
     throws UnsupportedTypeException {
   // Get the config field
   for (TypeToken<?> type : pluginType.getTypes().classes()) {
     for (Field field : type.getRawType().getDeclaredFields()) {
       TypeToken<?> fieldType = TypeToken.of(field.getGenericType());
       if (PluginConfig.class.isAssignableFrom(fieldType.getRawType())) {
         // Pick up all config properties
         inspectConfigField(fieldType, result);
         return field.getName();
       }
     }
   }
   return null;
 }
コード例 #26
0
  @Test
  public void builder_forSimpleType() {
    // Given(SetUp)

    // When(Exercise)
    final TypedDefaultMutableTreeNodeBuilder<String> builder =
        TypedDefaultMutableTreeNodeBuilder.newBuilder(TypeToken.of(String.class));

    final String data1 = "1";
    final String data2 = "2";

    final TypedDefaultMutableTreeNode<String> node = builder.build(data1);

    // Then(Verify)
    TypedDefaultMutableTreeNodeTest.compareAndSetUserObject(node, data1, data2);
    Assert.assertEquals(node.getUserObject(), data2);
  }
コード例 #27
0
ファイル: ArtifactInspector.java プロジェクト: domarps/cdap
  /** Inspects the plugin file and extracts plugin classes information. */
  private List<PluginClass> inspectPlugins(
      Id.Artifact artifactId, File artifactFile, PluginInstantiator pluginInstantiator)
      throws IOException {

    List<PluginClass> pluginClasses = Lists.newArrayList();

    // See if there are export packages. Plugins should be in those packages
    Set<String> exportPackages = getExportPackages(artifactFile);
    if (exportPackages.isEmpty()) {
      return pluginClasses;
    }

    // Load the plugin class and inspect the config field.
    ArtifactDescriptor artifactDescriptor =
        new ArtifactDescriptor(
            artifactId.getName(),
            artifactId.getVersion(),
            Constants.SYSTEM_NAMESPACE_ID.equals(artifactId.getNamespace()),
            Locations.toLocation(artifactFile));

    ClassLoader pluginClassLoader = pluginInstantiator.getArtifactClassLoader(artifactDescriptor);
    for (Class<?> cls : getPluginClasses(exportPackages, pluginClassLoader)) {
      Plugin pluginAnnotation = cls.getAnnotation(Plugin.class);
      if (pluginAnnotation == null) {
        continue;
      }
      Map<String, PluginPropertyField> pluginProperties = Maps.newHashMap();
      try {
        String configField = getProperties(TypeToken.of(cls), pluginProperties);
        PluginClass pluginClass =
            new PluginClass(
                pluginAnnotation.type(),
                getPluginName(cls),
                getPluginDescription(cls),
                cls.getName(),
                configField,
                pluginProperties);
        pluginClasses.add(pluginClass);
      } catch (UnsupportedTypeException e) {
        LOG.warn("Plugin configuration type not supported. Plugin ignored. {}", cls, e);
      }
    }

    return pluginClasses;
  }
コード例 #28
0
 protected Builder(Class<?> syncClient, Class<?> asyncClient) {
   super(syncClient, asyncClient);
   id("swift")
       .name("OpenStack Swift with SwiftAuth")
       .identityName("tenantId:user")
       .credentialName("password")
       .documentation(URI.create("http://api.openstack.org/"))
       .version("1.0")
       .defaultProperties(SwiftApiMetadata.defaultProperties())
       .view(TypeToken.of(BlobStoreContext.class))
       .context(CONTEXT_TOKEN)
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>builder()
               .add(StorageEndpointModule.class)
               .add(SwiftRestClientModule.class)
               .add(SwiftBlobStoreContextModule.class)
               .add(SwiftTemporaryUrlExtensionModule.class)
               .build());
 }
コード例 #29
0
  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);
  }
コード例 #30
0
 protected Builder() {
   super(CloudLoadBalancersApi.class, CloudLoadBalancersAsyncApi.class);
   id("rackspace-cloudloadbalancers")
       .name("Rackspace Cloud Load Balancers API")
       .identityName("Username")
       .credentialName("API Key")
       .documentation(
           URI.create(
               "http://docs.rackspace.com/loadbalancers/api/clb-devguide-latest/index.html"))
       .version("1.0")
       .defaultEndpoint("https://identity.api.rackspacecloud.com/v2.0/")
       .defaultProperties(CloudLoadBalancersApiMetadata.defaultProperties())
       .view(TypeToken.of(LoadBalancerServiceContext.class))
       .defaultModules(
           ImmutableSet.<Class<? extends Module>>of(
               CloudIdentityAuthenticationModule.class,
               ZoneModule.class,
               CloudLoadBalancersRestClientModule.class,
               CloudLoadBalancersLoadBalancerContextModule.class));
 }