Retrieve the map token of the render map from the previous request.

Returns the value of _saveRenderFlashMapTokenForNextRequest() from
the previous request.
@param externalContext
@return
425240
private String _getRenderFlashMapTokenFromPreviousRequest(FacesContext facesContext)
    {
        ExternalContext externalContext = facesContext.getExternalContext();
        String tokenValue = null;
        ClientWindow clientWindow = externalContext.getClientWindow();
        if (clientWindow != null)
        {
            if (facesContext.getApplication().getStateManager().isSavingStateInClient(facesContext))
            {
                Map<String, Object> sessionMap = externalContext.getSessionMap();
                tokenValue = (String) sessionMap.get(FLASH_RENDER_MAP_TOKEN+
                        SEPARATOR_CHAR+clientWindow.getId());                
            }
            else
            {
                FlashClientWindowTokenCollection lruMap = getFlashClientWindowTokenCollection(externalContext, false);
                if (lruMap != null)
                {
                    tokenValue = (String) lruMap.get(clientWindow.getId());
                }
            }
        }
        else
        {
            HttpServletResponse httpResponse = ExternalContextUtils.getHttpServletResponse(externalContext);
            if (httpResponse != null)
            {
                //Use a cookie
                Cookie cookie = (Cookie) externalContext.getRequestCookieMap().get(FLASH_RENDER_MAP_TOKEN);
                if (cookie != null)
                {
                    tokenValue = cookie.getValue();
                }
            }
            else
            {
                //Use HttpSession or PortletSession object
                Map<String, Object> sessionMap = externalContext.getSessionMap();
                tokenValue = (String) sessionMap.get(FLASH_RENDER_MAP_TOKEN);
            }
        }
        return tokenValue;
    }
912674
public Map<String, TemplateTokenInfo> getTokensAsMap() {
        HashMap<String, TemplateTokenInfo> tokens = new HashMap<String, TemplateTokenInfo>();
        for (TemplateTokenInfo tokenInfo : tokenInfos)
            tokens.put(tokenInfo.getName(), tokenInfo);
        return Collections.unmodifiableMap(tokens);
    }
1047184
CompletedCheckpointStats.DiscardCallback reportCompletedCheckpoint(String externalPointer) {
		CompletedCheckpointStats completed = new CompletedCheckpointStats(
			checkpointId,
			triggerTimestamp,
			props,
			numberOfSubtasks,
			new HashMap<>(taskStats),
			currentNumAcknowledgedSubtasks,
			currentStateSize,
			currentAlignmentBuffered,
			latestAcknowledgedSubtask,
				externalPointer);

		trackerCallback.reportCompletedCheckpoint(completed);

		return completed.getDiscardCallback();
	}
65855
@SuppressWarnings("unchecked")
    private Map<String, Object> _getExecuteFlashMap(FacesContext context)
    {
        // Note that we don't have to synchronize here, because it is no problem
        // if we create more SubKeyMaps with the same subkey, because they are
        // totally equal and point to the same entries in the SessionMap.
        
        Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
        Map<String, Object> map = (Map<String, Object>) requestMap.get(FLASH_EXECUTE_MAP);
        if (map == null)
        {
            String token = (String) requestMap.get(FLASH_EXECUTE_MAP_TOKEN);
            String fullToken = FLASH_SESSION_MAP_SUBKEY_PREFIX + SEPARATOR_CHAR + token + SEPARATOR_CHAR;
            map = _createSubKeyMap(context, fullToken);
            requestMap.put(FLASH_EXECUTE_MAP, map);
        }
        return map;
    }
852102
protected void addAuthnContextClassContext(ProfileRequestContext<?, ?> context, AuthnContextClassContext authnContextClassContext)
      throws ExternalAutenticationErrorCodeException {
    AuthenticationContext authnContext = authenticationContextLookupStrategy.apply(context);
    if (authnContext == null) {
      log.error("No AuthenticationContext available [{}]", this.getLogString(context));
      throw new ExternalAutenticationErrorCodeException(AuthnEventIds.INVALID_AUTHN_CTX, "Missing AuthenticationContext");
    }
    authnContext.addSubcontext(authnContextClassContext, true);
  }
127998
private static Map<Integer, AdvancedExternalizer<?>> getExternalizersFromProps(StoreProperties props) {
      Map<Integer, AdvancedExternalizer<?>> map = new HashMap<>();
      String externalizers = props.get(MARSHALLER, EXTERNALIZERS);
      if (externalizers != null) {
         for (String ext : externalizers.split(",")) {
            String[] extArray = ext.split(":");
            String className = extArray.length > 1 ? extArray[1] : extArray[0];
            AdvancedExternalizer<?> instance = Util.getInstance(className, SerializationConfigUtil.class.getClassLoader());
            int id = extArray.length > 1 ? new Integer(extArray[0]) : instance.getId();
            map.put(id, instance);
         }
      }
      return map;
   }
775411
@NotNull
    @Override
    public ExternalSetQueryContext<E, ?> queryContext(E key) {
        //noinspection unchecked
        return (ExternalSetQueryContext<E, ?>) m.queryContext(key);
    }
647283
public static function get_available_in_context_returns() {
        return new external_single_structure(
            array(
                'filters' => new external_multiple_structure(
                    new external_single_structure(
                        array(
                            'contextlevel' => new external_value(PARAM_ALPHA, 'The context level where the filters are:
                                (coursecat, course, module).'),
                            'instanceid' => new external_value(PARAM_INT, 'The instance id of item associated with the context.'),
                            'contextid' => new external_value(PARAM_INT, 'The context id.'),
                            'filter'  => new external_value(PARAM_PLUGIN, 'Filter plugin name.'),
                            'localstate' => new external_value(PARAM_INT, 'Filter state: 1 for on, -1 for off, 0 if inherit.'),
                            'inheritedstate' => new external_value(PARAM_INT, '1 or 0 to use when localstate is set to inherit.'),
                        )
                    ),
                    'Available filters'
                ),
                'warnings' => new external_warnings(),
            )
        );
    }
894586
public static String getPasswordResetToken(final RequestContext requestContext) {
        val flowScope = requestContext.getFlowScope();
        return flowScope.getString(FLOWSCOPE_PARAMETER_NAME_TOKEN);
    }
1306205
@SuppressWarnings("unchecked")
    private Map<Contextual<?>, Object> getComponentInstanceMap() {
        ConcurrentHashMap<Contextual<?>, Object> map = (ConcurrentHashMap<Contextual<?>, Object>) getCurrentRenderContext()
                .get(COMPONENT_MAP_NAME);

        if (map == null) {
            map = new ConcurrentHashMap<Contextual<?>, Object>();
            getCurrentRenderContext().put(COMPONENT_MAP_NAME, map);
        }

        return map;
    }
615611
Map<Object, Object> createOrRestoreMap(FacesContext context, String prefix,
        boolean create)
    {
        ExternalContext external = context.getExternalContext();
        Map<String, Object> sessionMap = external.getSessionMap();

        Map<Object, Object> map = (Map<Object, Object>) sessionMap.get(prefix);
        if (map == null && create)
        {
            map = new ConcurrentHashMap<Object, Object>();
            sessionMap.put(prefix, map);
        }
        return map;
    }
1055234
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.String> getExternalValues() {
    return getExternalValuesMap();
  }
176741
protected ProfileRequestContext<?, ?> getProfileRequestContext(HttpServletRequest httpRequest) throws ExternalAuthenticationException {
    return ExternalAuthentication.getProfileRequestContext(this.getExternalAuthenticationKey(httpRequest), httpRequest);
  }
584438
public static Map<String, Object> getExternalProperties(String pu, Map<String, Object> externalProperties,
            String... persistenceUnits)
    {
        Map<String, Object> puProperty;
        if (persistenceUnits != null && persistenceUnits.length > 1 && externalProperties != null)
        {
            puProperty = (Map<String, Object>) externalProperties.get(pu);

            // if property found then return it, if it is null by pass it, else
            // throw invalidConfiguration.
            if (puProperty != null)
            {
                return fetchPropertyMap(puProperty);
            }
            return null;
        }
        return externalProperties;
    }
780038
@Override
	protected void afterPaint(final RenderContext renderContext) {
		super.afterPaint(renderContext);

		final int size = getChildCount();

		for (int i = 0; i < size; i++) {
			WComponent child = getChildAt(i);
			child.reset();
		}
	}
622642
public GVRTexture getSplashTexture(GVRContext gvrContext) {
        Bitmap bitmap = BitmapFactory.decodeResource( //
                gvrContext.getContext().getResources(), //
                R.drawable.__default_splash_screen__);
        GVRTexture tex = new GVRTexture(gvrContext);
        tex.setImage(new GVRBitmapImage(gvrContext, bitmap));
        return tex;
    }
486946
private void _saveRedirectValue(FacesContext facesContext)
    {
        ExternalContext externalContext = facesContext.getExternalContext();
        
        // This request contains a redirect. This condition is in general 
        // triggered by a NavigationHandler. After a redirect all request scope
        // values get lost, so in order to preserve this value we need to
        // pass it between request. One strategy is use a cookie that is never sent
        // to the client. Other alternative is use the session map.
        // See _restoreRedirectValue() for restoring this value.
        HttpServletResponse httpResponse = ExternalContextUtils
                .getHttpServletResponse(externalContext);
        if (httpResponse != null)
        {
            Cookie cookie = _createFlashCookie(FLASH_REDIRECT, "true", externalContext);
            httpResponse.addCookie(cookie);
        }
        else
        {
            externalContext.getSessionMap().put(FLASH_REDIRECT, true);
        }
    }