congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
InjectableFactory
Code IndexAdd Tabnine to your IDE (free)

How to use
InjectableFactory
in
org.apache.wink.common.internal.registry

Best Java code snippets using org.apache.wink.common.internal.registry.InjectableFactory (Showing top 15 results out of 315)

origin: org.apache.tuscany.sca/tuscany-base-runtime

@Override
protected void initRegistries() {
  super.initRegistries();
  InjectableFactory.setInstance(new TuscanyInjectableFactory());
}
origin: org.apache.wink/wink-server

public void handleRequest(MessageContext context, HandlersChain chain) throws Throwable {
  SearchResult result = context.getAttribute(SearchResult.class);
  // create and save the invocation parameters for the found method
  List<Injectable> formal = result.getMethod().getMetadata().getFormalParameters();
  logger.trace("Formal Injectable parameters list is: {}", formal); //$NON-NLS-1$
  Object[] parameters = InjectableFactory.getInstance().instantiate(formal, context);
  if(logger.isTraceEnabled()) {
    if(parameters == null) {
      logger.trace("Actual parameters list to inject is: null"); //$NON-NLS-1$
    } else {
      logger.trace("Actual parameters list to inject is: {}", parameters); //$NON-NLS-1$
    }
  }
  result.setInvocationParameters(parameters);
  chain.doChain(context);
}
origin: org.apache.wink/wink-common

private void createFormalParameters() {
  formalParameters = new LinkedList<Injectable>();
  Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  Type[] paramTypes = method.getGenericParameterTypes();
  for (int pos = 0, limit = paramTypes.length; pos < limit; pos++) {
    Injectable fp =
      InjectableFactory.getInstance().create(paramTypes[pos],
                          parameterAnnotations[pos],
                          method,
                          false,
                          null);
    formalParameters.add(fp);
  }
}
origin: org.apache.wink/wink-common

@Override
protected Injectable parseAccessibleObject(AccessibleObject field, Type fieldType) {
  Context context = field.getAnnotation(Context.class);
  if (context != null) {
    return InjectableFactory.getInstance().createContextParam(GenericsUtils
                                   .getClassType(fieldType, ((Member) field).getDeclaringClass()),
                                 field.getAnnotations(),
                                 (Member)field);
  }
  return null;
}
origin: org.apache.wink/wink-common

    createMatrixParam(matrix.value(), classType, genericType, annotations, member);
} else if (path != null) {
  injectable = createPathParam(path.value(), classType, genericType, annotations, member);
} else if (query != null) {
  injectable =
    createQueryParam(query.value(), classType, genericType, annotations, member);
} else if (header != null) {
  injectable =
    createHeaderParam(header.value(), classType, genericType, annotations, member);
} else if (cookie != null) {
  injectable =
    createCookieParam(cookie.value(), classType, genericType, annotations, member);
} else if (form != null) {
  injectable = createFormParam(form.value(), classType, genericType, annotations, member);
} else if (context != null) {
  injectable = createContextParam(classType, annotations, member);
} else {
  injectable = createEntityParam(classType, genericType, annotations, member);
origin: org.apache.wink/wink-common

  InjectableFactory.getInstance().instantiate(method.getFormalParameters(), context);
try {
origin: org.apache.wink/wink-common

@Override
protected final Injectable parseAccessibleObject(AccessibleObject field, Type fieldType) {
  logger.trace("parseAccessibleObject({}, {})", field, fieldType);
  Injectable injectable =
    InjectableFactory.getInstance().create(fieldType,
                        field.getAnnotations(),
                        (Member)field,
                        getMetadata().isEncoded(),
                        null);
  logger.trace("Injectable is {}", injectable);
  if (injectable.getParamType() == Injectable.ParamType.ENTITY) {
    // EntityParam should be ignored for fields (see JSR-311 3.2)
    logger.trace("parseAccessibleObject() returning null");
    return null;
  }
  logger.trace("parseAccessibleObject() returning {}", injectable);
  return injectable;
}
origin: org.apache.tuscany.sca/tuscany-wink

@Override
protected void initRegistries() {
  super.initRegistries();
  InjectableFactory.setInstance(new TuscanyInjectableFactory());
}
origin: org.apache.wink/wink-common

/**
 * creates object (StaticResource or Provider) based on its ClassMetadata
 * 
 * @param metadata
 * @param runtimeContext
 * @return created object
 */
static Object createObject(ClassMetadata metadata, RuntimeContext runtimeContext) {
  try {
    // use constructor to create a prototype
    ConstructorMetadata constructorMetadata = metadata.getConstructor();
    Constructor<?> constructor = constructorMetadata.getConstructor();
    List<Injectable> formalParameters = constructorMetadata.getFormalParameters();
    Object[] params =
      InjectableFactory.getInstance().instantiate(formalParameters, runtimeContext);
    Object object = constructor.newInstance(params);
    injectFields(object, metadata, runtimeContext);
    return object;
  } catch (RuntimeException e) {
    throw e;
  } catch (InvocationTargetException e) {
    Throwable targetException = e.getTargetException();
    if (targetException instanceof RuntimeException) {
      throw (RuntimeException)targetException;
    }
    throw new ObjectCreationException(targetException);
  } catch (Exception e) {
    throw new ObjectCreationException(e);
  }
}
origin: org.apache.wink/wink-common

@Override
protected final Injectable parseAccessibleObject(AccessibleObject field, Type fieldType) {
  Injectable injectable =
    InjectableFactory.getInstance().create(fieldType,
                        field.getAnnotations(),
                        (Member)field,
                        getMetadata().isEncoded(),
                        null);
  if (injectable.getParamType() == Injectable.ParamType.ENTITY) {
    // EntityParam should be ignored for fields (see JSR-311 3.2)
    return null;
  }
  return injectable;
}
origin: org.apache.wink/wink-server

/**
 * Initializes registries. Usually there should be no need to override this
 * method. When creating Resources or Providers registry, ensure that they
 * use the same instance of the ApplicationValidator.
 */
protected void initRegistries() {
  InjectableFactory.setInstance(new ServerInjectableFactory());
  if (ofFactoryRegistry == null) {
    ofFactoryRegistry = new LifecycleManagersRegistry();
    ofFactoryRegistry.addFactoryFactory(new ScopeLifecycleManager<Object>());
    ofFactoryRegistry.addFactoryFactory(new JSR250LifecycleManager<Object>());
  }
  ApplicationValidator applicationValidator = new ApplicationValidator();
  providersRegistry = new ProvidersRegistry(ofFactoryRegistry, applicationValidator);
  resourceRegistry =
    new ResourceRegistry(ofFactoryRegistry, applicationValidator, properties);
}
origin: org.apache.wink/wink-common

  InjectableFactory.getInstance().instantiate(method.getFormalParameters(), context);
try {
origin: org.apache.wink/wink-common

private void mergeFormalParameterMetadata(MethodMetadata metadata, Method method) {
  logger.trace("mergeFormalParameterMetadata({})", new Object[] {metadata, method});
  Type[] parameterTypes = method.getGenericParameterTypes();
  List<Injectable> currentParameters =
    new ArrayList<Injectable>(metadata.getFormalParameters());
  metadata.getFormalParameters().clear();
  int i = 0;
  for (Injectable injectable : currentParameters) {
    Injectable fp =
      InjectableFactory.getInstance().create(parameterTypes[i],
                          injectable.getAnnotations(),
                          method,
                          getMetadata().isEncoded() || metadata
                            .isEncoded(),
                          metadata.getDefaultValue());
    metadata.getFormalParameters().add(fp);
    ++i;
  }
  logger.trace("mergeFormalParameterMetadata exit");
}
origin: org.apache.wink/wink-common

private void parseMethodParameters(Method method, MethodMetadata methodMetadata) {
  logger.trace("parseMethodParameters({}, {}), entry", method, methodMetadata);
  Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  Type[] paramTypes = getParamTypesFilterByXmlElementAnnotation(method);
  boolean entityParamExists = false;
  for (int pos = 0, limit = paramTypes.length; pos < limit; pos++) {
    Injectable fp =
      InjectableFactory.getInstance().create(paramTypes[pos],
                          parameterAnnotations[pos],
                          method,
                          getMetadata().isEncoded() || methodMetadata
                            .isEncoded(),
                          methodMetadata.getDefaultValue());
    if (fp.getParamType() == Injectable.ParamType.ENTITY) {
      if (entityParamExists) {
        // we are allowed to have only one entity parameter
        String methodName =
          method.getDeclaringClass().getName() + "." + method.getName(); //$NON-NLS-1$
        throw new IllegalStateException(Messages
          .getMessage("resourceMethodMoreThanOneEntityParam", methodName)); //$NON-NLS-1$
      }
      entityParamExists = true;
    }
    methodMetadata.getFormalParameters().add(fp);
    logger.trace("Adding formal parameter {}", fp);
  }
  logger.trace("parseMethodParameters(), exit");
}
origin: org.apache.wink/wink-common

InjectableFactory.getInstance()
  .create(paramTypes[pos],
      parameterAnnotations[pos],
      constructor,
org.apache.wink.common.internal.registryInjectableFactory

Most used methods

  • setInstance
  • getInstance
  • instantiate
    Instantiates a list of formal parameters into an Object array
  • create
  • createContextParam
  • createCookieParam
  • createEntityParam
  • createFormParam
  • createHeaderParam
  • createMatrixParam
  • createPathParam
  • createQueryParam
  • createPathParam,
  • createQueryParam

Popular in Java

  • Start an intent from android
  • setScale (BigDecimal)
  • requestLocationUpdates (LocationManager)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • RandomAccessFile (java.io)
    Allows reading from and writing to a file in a random-access manner. This is different from the uni-
  • ServerSocket (java.net)
    This class represents a server-side socket that waits for incoming client connections. A ServerSocke
  • SocketTimeoutException (java.net)
    This exception is thrown when a timeout expired on a socket read or accept operation.
  • BitSet (java.util)
    The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
  • Base64 (org.apache.commons.codec.binary)
    Provides Base64 encoding and decoding as defined by RFC 2045.This class implements section 6.8. Base
  • Loader (org.hibernate.loader)
    Abstract superclass of object loading (and querying) strategies. This class implements useful common
  • Sublime Text for Python
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now