Implements java.util.ResourceBundle.handleGetObject; inherits javadoc specification.
9177
public final Object handleGetObject(String key) {
        // lazily load the lookup hashtable.
        if (lookup == null) {
            loadLookup();
        }
        if (key == null) {
            throw new NullPointerException();
        }
        return lookup.get(key); // this class ignores locales
    }
957226
private Object handleGetObjectImpl(String aKey, UResourceBundle requested) {
        Object obj = resolveObject(aKey, requested);
        if (obj == null) {
            UResourceBundle parentBundle = getParent();
            if (parentBundle != null) {
                obj = parentBundle.handleGetObjectImpl(aKey, requested);
            }
            if (obj == null)
                throw new MissingResourceException(
                    "Can't find resource for bundle "
                    + this.getClass().getName() + ", key " + aKey,
                    this.getClass().getName(), aKey);
        }
        return obj;
    }
1129207
private <T> Observable<DocumentFragment<Lookup>> getIn(final String id, final LookupSpec spec,
        final Class<T> fragmentType, long timeout, TimeUnit timeUnit) {
        return Observable.defer(new Func0<Observable<DocumentFragment<Lookup>>>() {
            @Override
            public Observable<DocumentFragment<Lookup>> call() {
                final SubGetRequest request = new SubGetRequest(id, spec.path(), bucketName);
                request.xattr(spec.xattr());
                request.accessDeleted(accessDeleted);
                addRequestSpan(environment, request, "subdoc_get");
                return deferAndWatch(new Func1<Subscriber, Observable<SimpleSubdocResponse>>() {
                    @Override
                    public Observable<SimpleSubdocResponse> call(Subscriber s) {
                        request.subscriber(s);
                        return core.send(request);
                    }
                }).map(new Func1<SimpleSubdocResponse, DocumentFragment<Lookup>>() {
                    @Override
                    public DocumentFragment<Lookup> call(SimpleSubdocResponse response) {
                        try {
                            if (response.status().isSuccess()) {
                                try {
                                    byte[] raw = null;
                                    if (isIncludeRaw()) {
                                        TranscoderUtils.ByteBufToArray rawData = TranscoderUtils.byteBufToByteArray(response.content());
                                        raw = Arrays.copyOfRange(rawData.byteArray, rawData.offset, rawData.offset + rawData.length);
                                    }

                                    Scope decodeScope = null;
                                    if (environment.operationTracingEnabled()) {
                                        decodeScope = environment.tracer()
                                            .buildSpan("response_decoding")
                                            .asChildOf(response.request().span())
                                            .startActive(true);
                                    }

                                    T content = subdocumentTranscoder.decodeWithMessage(response.content(), fragmentType,
                                        "Couldn't decode subget fragment for " + id + "/" + spec.path());

                                    if (environment.operationTracingEnabled() && decodeScope != null) {
                                        decodeScope.close();
                                        if (decodeScope.span() instanceof ThresholdLogSpan) {
                                            decodeScope.span().setBaggageItem(ThresholdLogReporter.KEY_DECODE_MICROS,
                                                Long.toString(((ThresholdLogSpan) decodeScope.span()).durationMicros())
                                            );
                                        }
                                    }

                                    SubdocOperationResult<Lookup> single = SubdocOperationResult
                                        .createResult(spec.path(), Lookup.GET, response.status(), content, raw);
                                    return new DocumentFragment<Lookup>(id, response.cas(), response.mutationToken(),
                                        Collections.singletonList(single));
                                } finally {
                                    if (response.content() != null) {
                                        response.content().release();
                                    }
                                }
                            } else {
                                if (response.content() != null && response.content().refCnt() > 0) {
                                    response.content().release();
                                }

                                if (response.status() == ResponseStatus.SUBDOC_PATH_NOT_FOUND) {
                                    SubdocOperationResult<Lookup> single = SubdocOperationResult
                                        .createResult(spec.path(), Lookup.GET, response.status(), null);
                                    return new DocumentFragment<Lookup>(id, response.cas(), response.mutationToken(), Collections.singletonList(single));
                                } else {
                                    throw SubdocHelper.commonSubdocErrors(response.status(), id, spec.path());
                                }
                            }
                        } finally {
                            if (environment.operationTracingEnabled()) {
                                environment.tracer().scopeManager()
                                    .activate(response.request().span(), true)
                                    .close();
                            }
                        }
                    }
                });
            }
        });
    }
638722
@Override
	public Response handle(JsonPath jsonPath, QueryAdapter queryAdapter, RepositoryMethodParameterProvider parameterProvider, Document requestBody) {
		String resourceName = jsonPath.getElementName();
		PathIds resourceIds = jsonPath.getIds();
		RegistryEntry registryEntry = resourceRegistry.getEntry(resourceName);
		if (registryEntry == null) {
			throw new ResourceNotFoundException(resourceName);
		}
		String id = resourceIds.getIds().get(0);

		@SuppressWarnings("unchecked")
		Class<? extends Serializable> idClass = (Class<? extends Serializable>) registryEntry.getResourceInformation().getIdField().getType();
		Serializable castedId = typeParser.parse(id, idClass);
		ResourceRepositoryAdapter resourceRepository = registryEntry.getResourceRepository(parameterProvider);
		JsonApiResponse entities = resourceRepository.findOne(castedId, queryAdapter);
		
		Document responseDocument = documentMapper.toDocument(entities, queryAdapter);
		
		// return explicit { data : null } if values found
		if(!responseDocument.getData().isPresent()){
			responseDocument.setData(Nullable.nullValue());
		}

		return new Response(responseDocument, 200);
	}
1340010
void handleGet(Object value, 
                   MatchSpaceKey msg, 
                   EvalCache cache,
                   Object contextValue,
                   SearchResults result) 
      throws MatchingException, BadMessageFormatMatchingException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(this,
               cclass, 
               "handleGet", 
               new Object[] {value,msg,cache,contextValue,result});
    // Call the handleGet() method in the parent class but 
    // provide a context and we may need to call it multiple times
    if (value != null && value instanceof SetValEvaluationContext)
    {
      // The "value" we get back is a list of wrapped string values and
      // DOM nodes that we need to process individually
      
      SetValEvaluationContext xpContext = (SetValEvaluationContext)value;
      ArrayList nodeList = xpContext.getWrappedNodeList();
      
      // Iterate over the nodes that were passed into us
      Iterator iter = nodeList.iterator();

      while(iter.hasNext())
      {
        WrappedNodeResults wrappedNode = (WrappedNodeResults)iter.next();
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          tc.debug(this,cclass, "handleGet", "Processing node: " + wrappedNode); 
        
        // Need to be careful here, we propagate the string value of
        // the attribute or element that we have retrieved, but the
        // context for subsequent operations is the parent node.
        ArrayList stringList = wrappedNode.getStringList(id.getName());
        if(stringList != null)
        {
          Iterator iterString = stringList.iterator();
          
          while(iterString.hasNext())
          {
            String strValue = (String)iterString.next();

            // Need to pass in an XPathEvaluationContext
            SetValEvaluationContext xpEval = new SetValEvaluationContext(wrappedNode);
      
            super.handleGet(strValue, msg, cache, xpEval, result);
          } // eof while             
        } // eof if integerList not null               
      } // eof iterating over the nodes
    } // eof value not null 
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "handleGet");        
  }
258847
@Override
    public Object getObject( final String    key )
        throws
            UtilException
    {
        return formatObject( key, getRequiredPropValue( key ) );
    }
767776
public Object fetchValue()
    {
        try
        {
            return m_propertyMetadata.getGetMethod().invoke(m_proxyObject.getObject());
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
461396
void handleGet(Object value, 
                   MatchSpaceKey msg, 
                   EvalCache cache,
                   Object contextValue,
                   SearchResults result) 
      throws MatchingException, BadMessageFormatMatchingException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(this,
               cclass, 
               "handleGet", 
               new Object[] {value,msg,cache,contextValue,result});
    if (value != null)
    {
      if (child != null)
      {
          child.get(null, msg, cache, value, result);
      }
    }       
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "handleGet");       
  }
40757
public static Object get(Object obj, String property) throws Throwable {
        return getGetterMethod(obj.getClass(), property).invoke(obj);
    }
1148081
@Override
    public Object getE(int intKey) throws PageException {
	Iterator it = valueIterator();// getMap().keySet().iterator();
	int count = 0;
	Object o;
	while (it.hasNext()) {
	    o = it.next();
	    if ((++count) == intKey) {
		return o;// super.get(o.toString());
	    }
	}
	throw new ExpressionException("invalid index [" + intKey + "] for argument scope");
    }
303333
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        mRequestHandler =  new DownloadRequestHandler(this);
    }
125960
private void readObject(ObjectInputStream in) throws ClassNotFoundException, NoSuchMethodException, IOException {
        type = ClassRef.read(in);
        name = in.readUTF();
        val = in.readObject();
    }
337298
@Override
	public Object getObject(final int columnIndex) throws SQLException {
		String columnLabel = getWrapped().getMetaData().getColumnLabel(columnIndex);

		return getObject(columnLabel);
	}
1292137
@SuppressWarnings("unchecked")
    @Override
    public <T> T get(EntityGetOperation<T> getter) throws ServiceException {
        getter.setProxyData(createProxyData());
        Object rawResponse = getResource(getter).get(getter.getResponseClass());
        Object processedResponse = getter.processResponse(rawResponse);
        return (T) processedResponse;
    }
957348
public static Object callGetter(Object obj, String prop) throws PageException {
	try {
	    return getGetter(obj.getClass(), prop).invoke(obj);
	}
	catch (InvocationTargetException e) {
	    Throwable target = e.getTargetException();
	    if (target instanceof PageException) throw (PageException) target;
	    throw Caster.toPageException(e.getTargetException());
	}
	catch (Exception e) {
	    throw Caster.toPageException(e);
	}
    }
92754
public static <T> T invokeGetter(Object obj, String propertyName) {
		Method method = getGetterMethod(obj.getClass(), propertyName);
		if (method == null) {
			throw new IllegalArgumentException(
					"Could not find getter method [" + propertyName + "] on target [" + obj + ']');
		}
		return invokeMethod(obj, method);
	}
1303519
private void collectStaticGettersResults(@NonNull Class<?> someClass, @NonNull JSONObject container) throws JSONException {
        final Method[] methods = someClass.getMethods();
        for (final Method method : methods) {
            if (method.getParameterTypes().length == 0
                    && (method.getName().startsWith("get") || method.getName().startsWith("is"))
                    && !"getClass".equals(method.getName())) {
                try {
                    container.put(method.getName(), method.invoke(null, (Object[]) null));
                } catch (@NonNull IllegalArgumentException ignored) {
                    // NOOP
                } catch (@NonNull InvocationTargetException ignored) {
                    // NOOP
                } catch (@NonNull IllegalAccessException ignored) {
                    // NOOP
                }
            }
        }
    }