If not already created, a new <code>async-method</code> element will be created and returned.
Otherwise, the first existing <code>async-method</code> element will be returned.
@return the instance defined for the element <code>async-method</code>
180981
public AsyncMethodType<SessionBeanType<T>> getOrCreateAsyncMethod()
   {
      List<Node> nodeList = childNode.get("async-method");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new AsyncMethodTypeImpl<SessionBeanType<T>>(this, "async-method", childNode, nodeList.get(0));
      }
      return createAsyncMethod();
   }
295132
@Override
    public java.util.concurrent.Future<DescribeReservedCacheNodesOfferingsResult> describeReservedCacheNodesOfferingsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReservedCacheNodesOfferingsRequest, DescribeReservedCacheNodesOfferingsResult> asyncHandler) {

        return describeReservedCacheNodesOfferingsAsync(new DescribeReservedCacheNodesOfferingsRequest(), asyncHandler);
    }
598911
@Override
    public java.util.concurrent.Future<DescribeReservedNodeOfferingsResult> describeReservedNodeOfferingsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReservedNodeOfferingsRequest, DescribeReservedNodeOfferingsResult> asyncHandler) {

        return describeReservedNodeOfferingsAsync(new DescribeReservedNodeOfferingsRequest(), asyncHandler);
    }
149194
public Object previous() {
        Object element = null;
        if (previousElement != null) {
            element = previousElement;
            previousElement = null;
        } else {
            element = getPreviousElement();
            if (element == null) {
                throw new java.util.NoSuchElementException();
            }
        }
        return element;
    }
727014
public Object get() {
		Object result = null;
		if (over)
			return eventResult;
		try {
			boolean runOk = (Boolean) futureTask.get(timeoutforeturnResult, TimeUnit.MILLISECONDS);
			if (runOk) {
				result = this.eventResult;
			}
			over = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
423804
public Versioned<E> previous() {
        if(hasPrevious()) {
            E resultValue = _previousNode.getValue().getValue();
            _lastId = _previousNode.getValue().getId();
            _lastCall = LastCall.PREVIOUS;
            _nextNode = _previousNode;
            _isNextSet = true;
            _isPreviousSet = false;
            return new Versioned<E>(resultValue, _previousNode.getVersion());
        } else {
            throw new NoSuchElementException();
        }
    }
655856
@Override
    public java.util.concurrent.Future<DescribeReservedInstancesListingsResult> describeReservedInstancesListingsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReservedInstancesListingsRequest, DescribeReservedInstancesListingsResult> asyncHandler) {

        return describeReservedInstancesListingsAsync(new DescribeReservedInstancesListingsRequest(), asyncHandler);
    }
1111241
@Override
	public Method createJavaMethod() {
		Class<?> clazz = rtype.getClazz();
		String name = methodMember.getName();
		String methodDescriptor = methodMember.getDescriptor();

		ClassLoader classLoader = rtype.getTypeRegistry().getClassLoader();
		try {
			Class<?>[] params = Utils.toParamClasses(methodDescriptor, classLoader);
			Class<?> returnType = Utils.toClass(Type.getReturnType(methodDescriptor), classLoader);
			Class<?>[] exceptions = Utils.slashedNamesToClasses(methodMember.getExceptions(), classLoader);
			return JVM.newMethod(clazz, name, params, returnType, exceptions, methodMember.getModifiers(),
					methodMember.getGenericSignature());
		}
		catch (ClassNotFoundException e) {
			throw new IllegalStateException("Couldn't create j.l.r.Method for " + clazz.getName() + "."
					+ methodDescriptor, e);
		}
	}
896830
public Step<JobXMLDescriptor> getOrCreateStep()
   {
      List<Node> nodeList = model.get("step");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new StepImpl<JobXMLDescriptor>(this, "step", model, nodeList.get(0));
      }
      return createStep();
   }
1002285
protected <S> MethodVault<S> newMethod(Method method)
  {
    if (! Modifier.isAbstract(method.getModifiers())) {
      throw new IllegalStateException(String.valueOf(method));
    }
    else if (method.getName().startsWith("create")) {
      Method target = assetMethod(method);

      if (target != null) {
        return newCreateMethod(target);
      }
      else {
        return newCreateMethodDTO(method);
      }
    }
    else if (method.getName().startsWith("delete")) {
      Method target = assetMethod(method);

      if (target != null) {
        return newDeleteMethod(target);
      }
      else {
        return newDeleteMethodDTO(method);
      }
    }
    else {
      return new MethodVaultNull<>(method.getName() + " " + getClass().getName());
    }
  }
508006
public T requestInstance() {
		T a;
		if( unused.size() > 0 ) {
			a = unused.pop();
		} else {
			a = createInstance();
		}
		return a;
	}
1197324
public static Executors getInstance() {
        if (instance == null) {
            synchronized (Executors.class) {
                if (instance == null) instance = new Executors();
            }
        }
        return instance;
    }
1164156
public T next() {
        if (entry == null) return null;
        entry = entry.next;
        return entry.element;
    }
1314087
synchronized public E get() {
		if (this.isClosed())
			throw new NoSuchElementException();

		while (this.elements.isEmpty()) {
			try {
				this.wait();
			} catch (final InterruptedException e) {
				Thread.currentThread().interrupt();
				throw new RuntimeException(e);
			}
		}
		return this.elements.remove();
	}
72254
public OrderingType<WebFragmentDescriptor> getOrCreateOrdering()
   {
      List<Node> nodeList = model.get("ordering");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new OrderingTypeImpl<WebFragmentDescriptor>(this, "ordering", model, nodeList.get(0));
      }
      return createOrdering();
   }
536891
public ElementType<AnnotationType<T>> getOrCreateElement()
   {
      List<Node> nodeList = childNode.get("element");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ElementTypeImpl<AnnotationType<T>>(this, "element", childNode, nodeList.get(0));
      }
      return createElement();
   }
1188225
private Object getPreviousElement() {
        Object element = null;
        while (currentIndex >= startIndex && element == null) {
            currentIndex--;
            element = getElement();
        }
        return element;
    }