/**
   * Method description
   *
   * @param ht_def_key
   * @param ht_dev_val
   * @param st_def_key
   * @param st_def_val
   * @param prop_key
   * @param prop_val_class
   * @param params
   * @param props
   * @param <T>
   */
  protected <T> void checkHighThroughputProperty(
      String ht_def_key,
      T ht_dev_val,
      String st_def_key,
      T st_def_val,
      String prop_key,
      Class<T> prop_val_class,
      Map<String, Object> params,
      Map<String, Object> props) {
    T tmp = st_def_val;
    String str_tmp = null;

    if (isHighThroughput()) {
      tmp = ht_dev_val;
      str_tmp = (String) params.get(ht_def_key);
    } else {
      tmp = st_def_val;
      str_tmp = (String) params.get(st_def_key);
    }
    if (prop_val_class.isAssignableFrom(Integer.class)) {
      tmp = prop_val_class.cast(DataTypes.parseNum(str_tmp, Integer.class, (Integer) tmp));
    }
    if (prop_val_class.isAssignableFrom(Long.class)) {
      tmp = prop_val_class.cast(DataTypes.parseNum(str_tmp, Long.class, (Long) tmp));
    }
    if (prop_val_class.isAssignableFrom(String.class)) {
      tmp = prop_val_class.cast(str_tmp);
    }
    props.put(prop_key, tmp);
  }
  /**
   * Adapts the source object to a view object.
   *
   * @param mapper An action that is invoked for each source object in the graph that is to be
   *     adapted. The action can influence how the source object is adapted via the provided {@link
   *     SourceObjectMapping}.
   */
  public <T, S> T adapt(
      Class<T> targetType, S sourceObject, Action<? super SourceObjectMapping> mapper) {
    if (sourceObject == null) {
      return null;
    }
    Class<? extends T> wrapperType = targetTypeProvider.getTargetType(targetType, sourceObject);
    DefaultSourceObjectMapping mapping =
        new DefaultSourceObjectMapping(sourceObject, targetType, wrapperType);
    mapper.execute(mapping);
    wrapperType = mapping.wrapperType.asSubclass(targetType);
    if (wrapperType.isInstance(sourceObject)) {
      return wrapperType.cast(sourceObject);
    }
    if (targetType.isEnum()) {
      return adaptToEnum(targetType, sourceObject);
    }

    MixInMethodInvoker mixInMethodInvoker = null;
    if (mapping.mixInType != null) {
      mixInMethodInvoker =
          new MixInMethodInvoker(
              mapping.mixInType, new AdaptingMethodInvoker(mapper, new ReflectionMethodInvoker()));
    }
    MethodInvoker overrideInvoker = chainInvokers(mixInMethodInvoker, mapping.overrideInvoker);
    Object proxy =
        Proxy.newProxyInstance(
            wrapperType.getClassLoader(),
            new Class<?>[] {wrapperType},
            new InvocationHandlerImpl(sourceObject, overrideInvoker, mapper));
    if (mixInMethodInvoker != null) {
      mixInMethodInvoker.setProxy(proxy);
    }
    return wrapperType.cast(proxy);
  }
Beispiel #3
0
 public <T> T unwrap(Class<T> clazz) {
   if (clazz.isInstance(this)) {
     return clazz.cast(this);
   }
   if (clazz.isInstance(OptiqSchema.this)) {
     return clazz.cast(OptiqSchema.this);
   }
   if (clazz.isInstance(OptiqSchema.this.schema)) {
     return clazz.cast(OptiqSchema.this.schema);
   }
   throw new ClassCastException("not a " + clazz);
 }
Beispiel #4
0
 public <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType) {
   T block = payloadType.cast(dirty.get(pos));
   if (block != null) {
     return block;
   }
   block = payloadType.cast(indexBlockCache.get(pos));
   if (block != null) {
     return block;
   }
   block = store.read(pos, payloadType);
   maybeCache(block);
   return block;
 }
Beispiel #5
0
  @Override
  @Nullable
  protected <T extends VcsExtension> T getVcsCustomExtension(
      @NotNull final Class<T> extensionClass) {
    if (ChangesInfoBuilder.class.equals(extensionClass)) {
      return extensionClass.cast(getCollectChangesPolicy());
    }

    if (myExtensions != null) {
      for (GitServerExtension e : myExtensions) {
        if (extensionClass.isInstance(e)) return extensionClass.cast(e);
      }
    }
    return super.getVcsCustomExtension(extensionClass);
  }
 public <T> T getAs(final String key, final Class<T> clazz) {
   if (!this.is(key, clazz)) {
     throw new IllegalArgumentException();
   } else {
     return clazz.cast(this.contentMap.get(key));
   }
 }
 public static <T extends CommandInterceptor> T findInterceptor(
     Cache<?, ?> cache, Class<T> interceptorToFind) {
   for (CommandInterceptor i : cache.getAdvancedCache().getInterceptorChain()) {
     if (interceptorToFind.isInstance(i)) return interceptorToFind.cast(i);
   }
   return null;
 }
  /**
   * Returns the property names <code>name</code> which is still wrapped into the annotation
   * instance.
   *
   * @param name the name of the property
   * @param propertyClass the class of the property
   * @return the wrapper around property
   * @throws PropertyException if there is no such property
   */
  public S4PropWrapper getProperty(String name, Class<?> propertyClass) throws PropertyException {
    if (!propValues.containsKey(name))
      throw new InternalConfigurationException(
          getInstanceName(),
          name,
          "Unknown property '" + name + "' ! Make sure that you've annotated it.");

    S4PropWrapper s4PropWrapper = registeredProperties.get(name);

    if (s4PropWrapper == null) {
      throw new InternalConfigurationException(
          getInstanceName(),
          name,
          "Property is not an annotated property of " + getConfigurableClass());
    }

    try {
      propertyClass.cast(s4PropWrapper.getAnnotation());
    } catch (ClassCastException e) {
      throw new InternalConfigurationException(
          e,
          getInstanceName(),
          name,
          "Property annotation "
              + s4PropWrapper.getAnnotation()
              + " doesn't match the required type "
              + propertyClass.getName());
    }

    return s4PropWrapper;
  }
  public <T> T unwrap(Class<T> clazz) {
    if (!clazz.isAssignableFrom(nativeImpl.getClass()))
      throw new IllegalArgumentException(
          "HazelcastStore can't be unwrapped into " + clazz.getCanonicalName() + " instance");

    return clazz.cast(nativeImpl);
  }
  public <T extends Item> T getItem(Class<T> c) {
    for (int i = 0; i < items.length; i++) {
      if (c.isInstance(items[i])) return c.cast(items[i]);
    }

    return null;
  }
Beispiel #11
0
 public final boolean assertInstanceOf(String $label, Class<?> $klass, Object $obj) {
   if ($obj == null) {
     $unitFailures++;
     $log.warn(
         messageFail(
             $label, "null is never an instance of anything, and certainly not " + $klass + "."),
         new AssertionFailed());
     return false;
   }
   try {
     $klass.cast($obj);
     $log.debug(
         messagePass(
             $label,
             "\""
                 + $obj.getClass().getCanonicalName()
                 + "\" is an instance of \""
                 + $klass.getCanonicalName()
                 + "\""));
     return true;
   } catch (ClassCastException $e) {
     $unitFailures++;
     $log.warn(messageFail($label, $e.getMessage() + "."), new AssertionFailed());
     return false;
   }
 }
Beispiel #12
0
 @Deprecated
 public <T extends Widget> T findchild(Class<T> cl) {
   for (Widget wdg = child; wdg != null; wdg = wdg.next) {
     if (cl.isInstance(wdg)) return (cl.cast(wdg));
     T ret = wdg.findchild(cl);
     if (ret != null) return (ret);
   }
   return (null);
 }
 protected E1 getParentOf(E2 child) {
   Collection<? extends RefObject> c = super.query(false, child);
   assert (c.size() <= 1);
   if (c.isEmpty()) {
     return null;
   } else {
     return end1GenericClass.cast(c.iterator().next());
   }
 }
Beispiel #14
0
 /**
  * Removes the property of the given type.
  *
  * @return The property that was just removed.
  * @since 1.279
  */
 public <T extends JobProperty> T removeProperty(Class<T> clazz) throws IOException {
   for (JobProperty<? super JobT> p : properties) {
     if (clazz.isInstance(p)) {
       removeProperty(p);
       return clazz.cast(p);
     }
   }
   return null;
 }
 protected E2 getChildOf(E1 parent) {
   Collection<? extends RefObject> c = super.query(true, parent);
   assert (c.size() <= 1);
   if (c.isEmpty()) {
     return null;
   } else {
     return end2GenericClass.cast(c.iterator().next());
   }
 }
  @Override
  public void onMessage(final String message) {
    try {
      AbstractMessage msg = (AbstractMessage) (new XMLBuilder().fromXML(message));
      final int requestID = msg.getId();
      String messageType = msg.getType();
      final String destination = msg.getEndpoint();
      switch (messageType) {
        case "request":
          {
            if (DEBUG) System.out.println("Receiving the request: \n" + message);
            final Request request = (Request) msg;
            executors.submit(
                new Callable<Object>() {

                  @Override
                  public Object call() throws Exception {
                    try {

                      Object result = invokeOperation(request.getOpName(), request.getParams());

                      if (result instanceof OperationAborted) return null;
                      sendResponse(requestID, result, destination);

                    } catch (Exception e) {
                      e.printStackTrace();
                    }

                    return null;
                  }
                });
            break;
          }
        case "response":
          {
            if (DEBUG) System.out.println("Receiving the response: \n" + message);
            Response response = (Response) msg;
            if (response.getReturnType() != null) {
              Class<?> type = (Class<?>) response.getReturnType();
              results.put(response.getRequestID(), type.cast(response.getReturnValue()));
            } else {
              results.put(response.getRequestID(), NullObject);
            }
            synchronized (this) {
              this.notifyAll();
            }
            break;
          }
        default:
          break;
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Beispiel #17
0
 public <T> T nodeByTypeElement(Class<T> baseType) {
   int len = children.size();
   for (int i = 0; i < len; i++) {
     Child child = children.get(i);
     if (child instanceof NodeChild) {
       NodeChild nc = (NodeChild) child;
       if (model.elements.containsKey(nc.name)) continue; // match with named
       if (baseType.isAssignableFrom(nc.dom.getImplementationClass()))
         return baseType.cast(nc.dom.get());
     }
   }
   return null;
 }
  /**
   * Constructs new instance of the specified class.
   *
   * @param exp Expected class for the new instance.
   * @param clsName Class name to create new instance for.
   * @param <T> Expected class type for the new instance.
   * @return New instance of specified class.
   * @throws GridClientException If loading failed.
   */
  private static <T> T newInstance(Class<T> exp, String clsName) throws GridClientException {
    Object obj;

    try {
      obj = Class.forName(clsName).newInstance();
    }
    // Catch all for convenience.
    catch (Exception e) {
      throw new GridClientException("Failed to create class instance: " + clsName, e);
    }

    return exp.cast(obj);
  }
Beispiel #19
0
  public synchronized <T> Iterable<T> getPlugins(Class<T> wantedType) {

    //
    Iterable<CRaSHPlugin<?>> plugins = getPlugins();

    //
    List<T> tmp = Collections.emptyList();

    //
    for (CRaSHPlugin<?> plugin : plugins) {
      Class<?> pluginType = plugin.getType();
      if (wantedType.isAssignableFrom(pluginType)) {

        switch (plugin.status) {
          default:
          case CRaSHPlugin.FAILED:
          case CRaSHPlugin.INITIALIZED:
            // Do nothing
            break;
          case CRaSHPlugin.CONSTRUCTED:
            int status = CRaSHPlugin.FAILED;
            try {
              plugin.status = CRaSHPlugin.INITIALIZING;
              plugin.init();
              log.info("Initialized plugin " + plugin);
              status = CRaSHPlugin.INITIALIZED;
            } catch (Exception e) {
              log.error("Could not initialize plugin " + plugin, e);
            } finally {
              plugin.status = status;
            }
            break;
          case CRaSHPlugin.INITIALIZING:
            throw new RuntimeException("Circular dependency");
        }

        //
        if (plugin.status == CRaSHPlugin.INITIALIZED) {
          if (tmp.isEmpty()) {
            tmp = new ArrayList<T>();
          }
          T t = wantedType.cast(plugin);
          tmp.add(t);
        }
      }
    }

    //
    return tmp;
  }
 @NotNull
 private static <T extends Configurable> T findConfigurable(
     ConfigurableEP<Configurable>[] extensions, Class<T> configurableClass) {
   for (ConfigurableEP<Configurable> extension : extensions) {
     if (extension.providerClass != null
         || extension.instanceClass != null
         || extension.implementationClass != null) {
       final Configurable configurable = extension.createConfigurable();
       if (configurableClass.isInstance(configurable)) {
         return configurableClass.cast(configurable);
       }
     }
   }
   throw new IllegalArgumentException("Cannot find configurable of " + configurableClass);
 }
 public <T> T generateRandom(Class<T> objectClass) {
   Random r = new Random();
   if (objectClass.isInstance(String.class)) {
     String s = "";
     for (int i = 0; i < 10; i++) {
       char c = (char) (r.nextInt() / ('Z' - 'A') + 'A');
       s = s + c;
     }
     return objectClass.cast(s);
   } else if (objectClass.isInstance(Integer.class)) {
     Integer s = r.nextInt();
     return objectClass.cast(s);
   } else if (objectClass.isInstance(Long.class)) {
     Long s = r.nextLong();
     return objectClass.cast(s);
   } else if (objectClass.isInstance(java.util.Date.class)) {
     java.util.Calendar c = java.util.Calendar.getInstance();
     c.set(java.util.Calendar.MONTH, r.nextInt() / 12);
     c.set(java.util.Calendar.DAY_OF_MONTH, r.nextInt() / 30);
     c.setLenient(false);
     return objectClass.cast(c.getTime());
   }
   return null;
 }
Beispiel #22
0
 @Override
 public <DS> DS getDatastoreSession(Class<DS> sessionType) {
   DatastoreSession<
           EntityId,
           Entity,
           EntityMetadata,
           EntityDiscriminator,
           RelationId,
           Relation,
           RelationMetadata,
           RelationDiscriminator,
           PropertyMetadata>
       datastoreSession = sessionContext.getDatastoreSession();
   return sessionType.cast(datastoreSession);
 }
  /**
   * Return the first fetch response item of the given class for the given message number.
   *
   * @param r the responses
   * @param msgno the message number
   * @param c the class
   * @param	<T> the type of fetch item
   * @return the fetch item
   */
  public static <T extends Item> T getItem(Response[] r, int msgno, Class<T> c) {
    if (r == null) return null;

    for (int i = 0; i < r.length; i++) {

      if (r[i] == null
          || !(r[i] instanceof FetchResponse)
          || ((FetchResponse) r[i]).getNumber() != msgno) continue;

      FetchResponse f = (FetchResponse) r[i];
      for (int j = 0; j < f.items.length; j++) {
        if (c.isInstance(f.items[j])) return c.cast(f.items[j]);
      }
    }

    return null;
  }
 @Nullable
 public static <T> T cast(@NotNull Class<T> type, UnnamedConfigurable configurable) {
   if (configurable instanceof ConfigurableWrapper) {
     ConfigurableWrapper wrapper = (ConfigurableWrapper) configurable;
     if (wrapper.myConfigurable == null) {
       Class<?> configurableType = wrapper.getExtensionPoint().getConfigurableType();
       if (configurableType != null) {
         if (!type.isAssignableFrom(configurableType)) {
           return null; // do not create configurable that cannot be cast to the specified type
         }
       } else if (type == Configurable.Assistant.class || type == OptionalConfigurable.class) {
         return null; // do not create configurable from ConfigurableProvider which replaces
                      // OptionalConfigurable
       }
     }
     configurable = wrapper.getConfigurable();
   }
   return type.isInstance(configurable) ? type.cast(configurable) : null;
 }
  /**
   * Return all fetch response items of the given class for the given message number.
   *
   * @param r the responses
   * @param msgno the message number
   * @param c the class
   * @param	<T> the type of fetch items
   * @return the list of fetch items
   * @since JavaMail 1.5.2
   */
  public static <T extends Item> List<T> getItems(Response[] r, int msgno, Class<T> c) {
    List<T> items = new ArrayList<T>();

    if (r == null) return items;

    for (int i = 0; i < r.length; i++) {

      if (r[i] == null
          || !(r[i] instanceof FetchResponse)
          || ((FetchResponse) r[i]).getNumber() != msgno) continue;

      FetchResponse f = (FetchResponse) r[i];
      for (int j = 0; j < f.items.length; j++) {
        if (c.isInstance(f.items[j])) items.add(c.cast(f.items[j]));
      }
    }

    return items;
  }
  public static <T extends ClientBehavior> T findClientBehavior(
      Class<T> behaviorClass, String eventName, UIComponent component) {
    if (!(component instanceof ClientBehaviorHolder)) return null;

    T foundBehavior = null;

    Map<String, List<ClientBehavior>> behaviorsMap =
        ((ClientBehaviorHolder) component).getClientBehaviors();
    if (behaviorsMap != null && behaviorsMap.size() > 0) {
      List<ClientBehavior> behaviors = behaviorsMap.get(eventName);
      if (behaviors != null)
        for (ClientBehavior behavior : behaviors) {
          if (behaviorClass.isInstance(behavior)) {
            foundBehavior = behaviorClass.cast(behavior);
            break;
          }
        }
    }

    return foundBehavior;
  }
 private static <T, S> T adaptToEnum(Class<T> targetType, S sourceObject) {
   try {
     String literal;
     if (sourceObject instanceof Enum) {
       literal = ((Enum<?>) sourceObject).name();
     } else if (sourceObject instanceof String) {
       literal = (String) sourceObject;
     } else {
       literal = sourceObject.toString();
     }
     NotationParser<String, T> parser =
         new NotationConverterToNotationParserAdapter<String, T>(
             new EnumFromCharSequenceNotationParser(targetType));
     T parsedLiteral = parser.parseNotation(literal);
     return targetType.cast(parsedLiteral);
   } catch (TypeConversionException e) {
     throw new IllegalArgumentException(
         String.format(
             "Can't convert '%s' to enum type '%s'", sourceObject, targetType.getSimpleName()),
         e);
   }
 }
Beispiel #28
0
 public <T> T unwrap(Class<T> iface) throws SQLException {
   if (iface.isInstance(this)) {
     return iface.cast(this);
   }
   throw statement.connection.helper.createException("does not implement '" + iface + "'");
 }
Beispiel #29
0
 /**
  * Returns the first provider in the registry for the specified category, using the specified map
  * of hints (if any). This method may {@linkplain #scanForPlugins scan for plugins} the first time
  * it is invoked. Except as a result of this scan, no new provider instance is created by the
  * default implementation of this method. The {@link FactoryCreator} class change this behavior
  * however.
  *
  * @param  <T> The class represented by the {@code category} argument.
  * @param category The category to look for. Must be one of the categories declared to the
  *     constructor. Usually an interface class (not the actual implementation class).
  * @param filter An optional filter, or {@code null} if none. This is used for example in order to
  *     select the first factory for some {@linkplain
  *     org.opengis.referencing.AuthorityFactory#getAuthority authority}.
  * @param hints A {@linkplain Hints map of hints}, or {@code null} if none.
  * @param key The key to use for looking for a user-provided instance in the hints, or {@code
  *     null} if none.
  * @return A factory {@linkplain OptionalFactory#isAvailable available} for use for the specified
  *     category and hints. The returns type is {@code Object} instead of {@link Factory} because
  *     the factory implementation doesn't need to be a Geotools one.
  * @throws FactoryNotFoundException if no factory was found for the specified category, filter and
  *     hints.
  * @throws FactoryRegistryException if a factory can't be returned for some other reason.
  * @see #getServiceProviders(Class, Filter, Hints)
  * @see FactoryCreator#getServiceProvider
  */
 public <T> T getServiceProvider(
     final Class<T> category, final Filter filter, Hints hints, final Hints.Key key)
     throws FactoryRegistryException {
   synchronizeIteratorProviders();
   final boolean debug = LOGGER.isLoggable(DEBUG_LEVEL);
   if (debug) {
     /*
      * We are not required to insert the method name ("GetServiceProvider") in the
      * message because it is part of the informations already stored by LogRecord,
      * and formatted by the default java.util.logging.SimpleFormatter.
      *
      * Conventions for the message part according java.util.logging.Logger javadoc:
      * - "ENTRY"  at the begining of a method.
      * - "RETURN" at the end of a method, if successful.
      * - "THROW"  in case of failure.
      * - "CHECK"  ... is our own addition to Sun's convention for this method ...
      */
     debug("ENTRY", category, key, null, null);
   }
   Class<?> implementation = null;
   if (key != null) {
     /*
      * Sanity check: make sure that the key class is appropriate for the category.
      */
     final Class<?> valueClass = key.getValueClass();
     if (!category.isAssignableFrom(valueClass)) {
       if (debug) {
         debug("THROW", category, key, "unexpected type:", valueClass);
       }
       throw new IllegalArgumentException(Errors.format(ErrorKeys.ILLEGAL_KEY_$1, key));
     }
     if (hints != null) {
       final Object hint = hints.get(key);
       if (hint != null) {
         if (debug) {
           debug("CHECK", category, key, "user provided a", hint.getClass());
         }
         if (category.isInstance(hint)) {
           /*
            * The factory implementation was given explicitly by the user.
            * Nothing to do; we are done.
            */
           if (debug) {
             debug("RETURN", category, key, "return hint as provided.", null);
           }
           return category.cast(hint);
         }
         /*
          * Before to pass the hints to the private 'getServiceImplementation' method,
          * remove the hint for the user-supplied key.  This is because this hint has
          * been processed by this public 'getServiceProvider' method, and the policy
          * is to remove the processed hints before to pass them to child dependencies
          * (see the "Check recursively in factory dependencies" comment elswhere in
          * this class).
          *
          * Use case: DefaultDataSourceTest invokes indirectly 'getServiceProvider'
          * with a "CRS_AUTHORITY_FACTORY = ThreadedEpsgFactory.class" hint. However
          * ThreadedEpsgFactory (in the org.geotools.referencing.factory.epsg package)
          * is a wrapper around DirectEpsgFactory, and defines this dependency through
          * a "CRS_AUTHORITY_FACTORY = DirectEpsgFactory.class" hint. There is no way
          * to match this hint for both factories in same time. Since we must choose
          * one, we assume that the user is interrested in the most top level one and
          * discart this particular hint for the dependencies.
          */
         hints = new Hints(hints);
         if (hints.remove(key) != hint) {
           // Should never happen except on concurrent modification in an other thread.
           throw new AssertionError(key);
         }
         /*
          * If the user accepts many implementation classes, then try all of them in
          * the preference order given by the user. The last class (or the singleton
          * if the hint was not an array) will be tried using the "normal" path
          * (oustide the loop) in order to get the error message in case of failure.
          */
         if (hint instanceof Class<?>[]) {
           final Class<?>[] types = (Class<?>[]) hint;
           final int length = types.length;
           for (int i = 0; i < length - 1; i++) {
             final Class<?> type = types[i];
             if (debug) {
               debug("CHECK", category, key, "consider hint[" + i + ']', type);
             }
             final T candidate = getServiceImplementation(category, type, filter, hints);
             if (candidate != null) {
               if (debug) {
                 debug("RETURN", category, key, "found implementation", candidate.getClass());
               }
               return candidate;
             }
           }
           if (length != 0) {
             implementation = types[length - 1]; // Last try to be done below.
           }
         } else {
           implementation = (Class<?>) hint;
         }
       }
     }
   }
   if (debug && implementation != null) {
     debug("CHECK", category, key, "consider hint[last]", implementation);
   }
   final T candidate = getServiceImplementation(category, implementation, filter, hints);
   if (candidate != null) {
     if (debug) {
       debug("RETURN", category, key, "found implementation", candidate.getClass());
     }
     return candidate;
   }
   if (debug) {
     debug("THROW", category, key, "could not find implementation.", null);
   }
   throw new FactoryNotFoundException(
       Errors.format(
           ErrorKeys.FACTORY_NOT_FOUND_$1, implementation != null ? implementation : category));
 }
Beispiel #30
0
 public <T extends Widget> T getparent(Class<T> cl) {
   for (Widget w = this; w != null; w = w.parent) {
     if (cl.isInstance(w)) return (cl.cast(w));
   }
   return (null);
 }