Gets the.

@param _accessType the access type
@param _instances the instances
@return the access
773367
public static Access get(final AccessType _accessType, final Collection<Instance> _instances)
    {
        return new Access(_accessType, _instances);
    }
649779
public static Group groupsGet(String access_token){
		HttpUriRequest httpUriRequest = RequestBuilder.post()
				.setUri(BASE_URI+"/cgi-bin/groups/get")
				.addParameter(PARAM_ACCESS_TOKEN, API.accessToken(access_token))
				.build();
		return LocalHttpClient.executeJsonResult(httpUriRequest,Group.class);
	}
1198243
function getType(instance) {
    return instance.static.type === consts_1.DEFAULT_TYPE
        ? getProp(instance, instance.static.typeAttribute)
        : instance.static.type;
}
232516
public function getAccessToken($access_token)
    {
        $token = $this->getObjectByType('access_token_table',$access_token);

        return is_null($token) ? false : $token;
    }
571969
protected function getCacheIdentifier($accessType, $filterEntities = [])
    {
        $filter = $accessType . ':';
        foreach ($filterEntities as $pae) {
            $filter .= $pae->getAccessEntityID() . ':';
        }
        $filter = trim($filter, ':');
        $paID = $this->getPermissionAccessID();
        $class = strtolower(get_class($this->pk));

        return sprintf('permission/access/list_items/%s/%s/%s', $paID, $filter, $class);
    }
167637
def superclasses(access_type = nil)
      QueryResult.new(
        [
          NodeCache.find_children_of_type(self, "Base").select do |base|
            access_type.nil? ? true : base.send("#{access_type}?")
          end
        ].flatten.map {|base| base.cpp_type }
      )
    end
119867
public java.util.List<? extends com.google.appengine.v1.InstanceOrBuilder> 
      getInstancesOrBuilderList() {
    return instances_;
  }
1274486
public static final AccessClassLoader get(Class<?> typeToBeExtended) {

		ClassLoader loader = typeToBeExtended.getClassLoader();
		return get(loader == null ? ClassLoader.getSystemClassLoader() : loader);
	}
460789
public static MetaClassRegistry getInstance(int includeExtension) {
        if (includeExtension != DONT_LOAD_DEFAULT) {
            if (instanceInclude == null) {
                instanceInclude = new MetaClassRegistryImpl();
            }
            return instanceInclude;
        } else {
            if (instanceExclude == null) {
                instanceExclude = new MetaClassRegistryImpl(DONT_LOAD_DEFAULT);
            }
            return instanceExclude;
        }
    }
83333
private static Map<String, PropertyAccessor> _getAccessors(
                    final Class<?> clazz
                    )
    {
        Map<String, PropertyAccessor>  accessors = null;

        synchronized (_ACCESSORS_REG_) {
            accessors = _ACCESSORS_REG_.get( clazz );
            if (accessors == null) {
                accessors = PropertyAccessor.findAll( clazz );
                _ACCESSORS_REG_.put( clazz, accessors );
            }
        }

        return accessors;
    }
1278527
public <R> R accessContext(ContextAccess<C,R> access)
    {
        contextLock.lock();
        try
        {
            return access.access(context);
        }
        finally
        {
            contextLock.unlock();
        }
    }
432942
public java.lang.String getAccesskey() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.accesskey);

    }
756404
private function getAccess($accessType, $userId)
    {
        if (!isset($this->permissionsById[$userId]))
        {
            return false;
        }
        if (!isset($this->permissionsById[$userId][$accessType]))
        {
            return false;
        }

        return $this->permissionsById[$userId][$accessType];
    }
458879
public function getAccessListItems($accessType = PermissionKey::ACCESS_TYPE_INCLUDE, $filterEntities = [], $checkCache = true)
    {
        $app = Application::getFacadeApplication();
        if ($checkCache) {
            $cache = $app->make('cache/request');
            $item = $cache->getItem($this->getCacheIdentifier($accessType, $filterEntities));
            if (!$item->isMiss()) {
                return $item->get();
            }
            $item->lock();
        }
        $db = $app->make(Connection::class);
        $list = parent::getAccessListItems($accessType, $filterEntities, false);
        $pobj = $this->getPermissionObjectToCheck();
        foreach ($list as $l) {
            $pe = $l->getAccessEntityObject();
            if ($pobj instanceof Page) {
                $permission = $db->fetchColumn('select permission from BlockTypePermissionBlockTypeAccessList where paID = ?', [$l->getPermissionAccessID()]);
            } else {
                $permission = $db->fetchColumn('select permission from AreaPermissionBlockTypeAccessList where peID = ? and paID = ?', [$pe->getAccessEntityID(), $l->getPermissionAccessID()]);
            }
            if ($permission != 'N' && $permission != 'C') {
                $permission = 'A';
            }
            $l->setBlockTypesAllowedPermission($permission);
            if ($permission == 'C') {
                if ($pobj instanceof Area) {
                    $rs = $db->executeQuery('select btID from AreaPermissionBlockTypeAccessListCustom where peID = ? and paID = ?', [$pe->getAccessEntityID(), $l->getPermissionAccessID()]);
                } else {
                    $rs = $db->executeQuery('select btID from BlockTypePermissionBlockTypeAccessListCustom where paID = ?', [$l->getPermissionAccessID()]);
                }
                $btIDs = [];
                while (($btID = $rs->fetchColumn()) !== false) {
                    $btIDs[] = (int) $btID;
                }
                $l->setBlockTypesAllowedArray($btIDs);
            }
        }

        if ($checkCache) {
            $cache->save($item->set($list));
        }

        return $list;
    }
55453
public static AccessType getAccessType(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, AccessType> cache = InfinispanCache.get().<UUID, AccessType>getCache(AccessType.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            AccessType.getAccessTypeFromDB(AccessType.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
566600
static public Accessor[] getAccessors(Class<?> type, FieldFilter filter) {
		Class<?> nextClass = type;
		HashMap<String, Accessor> map = new HashMap<String, Accessor>();
		if (filter == null)
			filter = BasicFiledFilter.SINGLETON;
		while (nextClass != Object.class) {
			Field[] declaredFields = nextClass.getDeclaredFields();

			for (Field field : declaredFields) {
				String fn = field.getName();
				if (map.containsKey(fn))
					continue;
				Accessor acc = new Accessor(nextClass, field, filter);
				if (!acc.isUsable())
					continue;
				map.put(fn, acc);
			}
			nextClass = nextClass.getSuperclass();
		}
		return map.values().toArray(new Accessor[map.size()]);
	}
1062899
protected EObject getAccessibleType(IEObjectDescription description, String fragment, ResourceSet resourceSet) throws UnknownNestedTypeException {
		EObject typeProxy = description.getEObjectOrProxy();
		if (typeProxy.eIsProxy()) {
			typeProxy = EcoreUtil.resolve(typeProxy, resourceSet);
		}
		if (!typeProxy.eIsProxy() && typeProxy instanceof JvmType) {
			if (fragment != null) {
				EObject result = resolveJavaObject((JvmType) typeProxy, fragment);
				if (result != null)
					return result;
			} else
				return typeProxy;
		}
		return null;
	}