Implement the general getAccessor method
424084
public int getAccessor(JMFSchema schema) {
    for (Accessor acc = accessor; acc != null; acc = acc.next)
      if (schema == acc.schema)
        return acc.accessor;
    return -1;
  }
532695
@SuppressWarnings("unchecked")
    public static PropertyAccessor getPropertyAccessor(Class<?> clazz)
    {
        PropertyAccessor<?> accessor;
        if (clazz.isEnum())
        {
            accessor = new EnumAccessor();
        }
        else
        {
            accessor = map.get(clazz);
        }

        // allow fall-back to Object streamer.
        if (null == accessor)
        {
            if (Enum.class.isAssignableFrom(clazz))
            {
                accessor = map.get(Enum.class);
            }
            else
            {
                accessor = map.get(Object.class);
            }

        }
        return accessor;
    }
602795
function( obj ) {
    var accessor = this._getAccessor( obj );
    var seen = {};
    for( var i = 0; i < this.form.elements.length; i++) {
      this.serializeField( this.form.elements[i], accessor, seen);
    }
    return accessor.target;
  }
1347494
public static Method getGenericAccessor(Class<?> clazz, String field) {
        LOG.trace( "getGenericAccessor({}, {})", clazz, field );

        String accessorQualifiedName = new StringBuilder(clazz.getCanonicalName())
			.append(".").append(field).toString();

        return accessorCache.computeIfAbsent(accessorQualifiedName, key ->
        	Stream.of( clazz.getMethods() )
            .filter( m -> Optional.ofNullable( m.getAnnotation( FEELProperty.class ) )
                    .map( ann -> ann.value().equals( field ) )
                    .orElse( false )
            )
            .findFirst()
            .orElse( getAccessor( clazz, field ) ));
    }
424185
public static Object callGetter(View view, String methodName) {
        try {
            Method method = view.getClass().getMethod(methodName);
            return method.invoke(view);
        } catch (SecurityException ex) {
            throw new AttributeAccessException(ex);
        } catch (NoSuchMethodException ex) {
            throw new AttributeAccessException("No such attribute", ex);
        } catch (IllegalAccessException ex) {
            throw new AttributeAccessException(ex);
        } catch (InvocationTargetException ex) {
            throw new AttributeAccessException(ex);
        }
    }
689584
function(type){
    return function(prop){
        var accessor = this.getAccessor(prop, type),
            accessorName = this._accessorName;

        /**
         * Prevent recursive get calls by checking if it's currently accessing
         * and if the accessor name is the same as the property arg. If all positive,
         * then return the value from _data/_previousData, otherwise return from 
         * the accessor function. Fallback to returning from the _data/_previousData
         * if an accessor function does not exist.
         */
        if (accessor && accessorName != prop) {
            return accessor();
        }

        return this.parent(prop);
    }.overloadGetter();
}
1084653
Symbol accessMethod(Symbol sym,
                  DiagnosticPosition pos,
                  Symbol location,
                  Type site,
                  Name name,
                  boolean qualified,
                  List<Type> argtypes,
                  List<Type> typeargtypes) {
        return accessInternal(sym, pos, location, site, name, qualified, argtypes, typeargtypes, methodLogResolveHelper);
    }
1205982
public T get(Object source) {
		try {
			if (!method.isAccessible()) {
				method.setAccessible(true);
			}
			@SuppressWarnings("unchecked")
			T value=(T) method.invoke(source);
			return value;
		} catch (IllegalAccessException illegalAccessException) {
			return null;
		} catch (IllegalArgumentException illegalArgumentException) {
			return null;
		} catch (InvocationTargetException invocationTargetException) {
			return null;
		}
	}
1361513
public Map<String, Accessor> getAccessors() {
    if (accessors == null)
      synchronized (this) {
        if (accessors == null)
          accessors = PropertyInfoSetResolver.resolveAccessors(source, type, configuration);
      }

    return accessors;
  }
1293984
@Override
	public OUT get() {
		ACC accumulator = getInternal();
		return accumulator != null ? aggregateTransformation.aggFunction.getResult(accumulator) : null;
	}
695926
public static Accessor getAccessorForProperty(final Class<?> clazz, final String propertyName)
    {
        int splitPoint = propertyName.indexOf('.');
        if (splitPoint > 0)
        {
            String firstPart = propertyName.substring(0, splitPoint);
            String secondPart = propertyName.substring(splitPoint + 1);
            return new NestedAccessor(clazz, firstPart, secondPart);
        }
        return new SimpleAccessor(clazz, propertyName);
    }
829311
@VisibleForTesting
    static Method getMethod(Class<?> cls, String name, Class<?>... params) {
        Method m;
        try {
            m = cls.getDeclaredMethod(name, params);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        m.setAccessible(true);
        return m;
    }
427002
function getAccessor (accessor, bufferViews) {
  if (accessor._data) return accessor

  const numberOfComponents = GLTF_ACCESSOR_TYPE_COMPONENTS_NUMBER[accessor.type]
  if (accessor.byteOffset === undefined) accessor.byteOffset = 0

  accessor._bufferView = bufferViews[accessor.bufferView]

  const TypedArrayConstructor = WEBGL_TYPED_ARRAY_BY_COMPONENT_TYPES[accessor.componentType]
  const byteSize = GLTF_ACCESSOR_COMPONENT_TYPE_SIZE[accessor.componentType]

  const data = new TypedArrayConstructor(accessor._bufferView._data.slice(
    accessor.byteOffset,
    accessor.byteOffset + accessor.count * numberOfComponents * byteSize
  ))
  accessor._data = data

  // Sparse accessors
  // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/accessor.sparse.schema.json
  if (accessor.sparse !== undefined) {
    const TypedArrayIndicesConstructor =
      WEBGL_TYPED_ARRAY_BY_COMPONENT_TYPES[accessor.sparse.indices.componentType]

    // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/accessor.sparse.indices.schema.json
    const sparseIndices = new TypedArrayIndicesConstructor(
      bufferViews[accessor.sparse.indices.bufferView]._data,
      accessor.sparse.indices.byteOffset || 0,
      accessor.sparse.count
    )

    // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/accessor.sparse.values.schema.json
    const sparseValues = new TypedArrayConstructor(
      bufferViews[accessor.sparse.values.bufferView]._data,
      accessor.sparse.values.byteOffset || 0,
      accessor.sparse.count * numberOfComponents
    )

    if (accessor._data !== null) {
      accessor._data = accessor._data.slice()
    }

    let valuesIndex = 0
    for (let indicesIndex = 0; indicesIndex < sparseIndices.length; indicesIndex++) {
      let dataIndex = sparseIndices[indicesIndex] * numberOfComponents
      for (let componentIndex = 0; componentIndex < numberOfComponents; componentIndex++) {
        accessor._data[dataIndex++] = sparseValues[valuesIndex++]
      }
    }
  }

  return accessor
}
117361
public static AccessType getAccessType(final String _name)
        throws CacheReloadException
    {
        final Cache<String, AccessType> cache = InfinispanCache.get()
                        .<String, AccessType>getCache(AccessType.NAMECACHE);
        if (!cache.containsKey(_name)) {
            AccessType.getAccessTypeFromDB(AccessType.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
431446
public static Method getAccessibleMethodByName(final Object target, final String name) {
		for (Class<?> searchType = target.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
			Method[] methods = searchType.getDeclaredMethods();
			for (Method method : methods) {
				if (method.getName().equals(name)) {
					makeAccessible(method);
					return method;
				}
			}
		}
		return null;
	}
607300
function readCall(walker, defaultArgs) {
    walker.goUntil();
    var result = readAccessor(walker);

    var args;
    if (walker.goUntil(40)) { // (
        args = [];

        while (!walker.goUntil(41)) { // )
            args.push(readTertiaryExpr(walker));
            walker.goUntil(44); // ,
        }
    }
    else if (defaultArgs) {
        args = defaultArgs;
    }

    if (args) {
        result = {
            type: ExprType.CALL,
            name: result,
            args: args
        };
    }

    return result;
}
532593
private static IAccessRule[] getAccessRules(IPath[] accessibleFiles, IPath[] nonAccessibleFiles) {
        final int accessibleFilesLength = accessibleFiles == null ? 0 : accessibleFiles.length;
        final int nonAccessibleFilesLength = nonAccessibleFiles == null ? 0 : nonAccessibleFiles.length;
        final int length = accessibleFilesLength + nonAccessibleFilesLength;
        if (length == 0) {
            return null;
        }
        final IAccessRule[] accessRules = new IAccessRule[length];
        if (accessibleFiles != null) {
	        for (int i = 0; i < accessibleFilesLength; i++) {
	            accessRules[i] = JavaCore.newAccessRule(accessibleFiles[i], IAccessRule.K_ACCESSIBLE);
	        }
        }
        if (nonAccessibleFiles != null) {
	        for (int i = 0; i < nonAccessibleFilesLength; i++) {
	            accessRules[accessibleFilesLength + i] = JavaCore.newAccessRule(nonAccessibleFiles[i], IAccessRule.K_NON_ACCESSIBLE);
	        }
        }
        return accessRules;
    }