Removes request attributes which shouldn't be cached in flex cache entries from a map.<p>

@param attributeMap the map of attributes
767712
public void removeUncacheableAttributes(Map<String, Object> attributeMap) {

        for (String uncacheableAttribute : uncacheableAttributes) {
            attributeMap.remove(uncacheableAttribute);
        }
        attributeMap.remove(CmsFlexController.ATTRIBUTE_NAME);
        attributeMap.remove(CmsDetailPageResourceHandler.ATTR_DETAIL_CONTENT_RESOURCE);
        attributeMap.remove(CmsDetailPageResourceHandler.ATTR_DETAIL_FUNCTION_PAGE);
    }
613693
public void setAttributes(Map<String, ?> attributes) {
        if (attributes == null) {
            attributes = new HashMap<>();
        }

        this.attributes.clear();
        this.attributes.putAll(attributes);
    }
413473
public void clear() {

        if (m_flexRequestList != null) {
            m_flexRequestList.clear();
        }
        m_flexRequestList = null;
        if (m_flexResponseList != null) {
            m_flexResponseList.clear();
        }
        m_flexResponseList = null;
        if (m_req != null) {
            m_req.removeAttribute(ATTRIBUTE_NAME);
        }
        m_req = null;
        m_res = null;
        m_cmsObject = null;
        m_resource = null;
        m_cache = null;
        m_throwable = null;
    }
308239
public void removeAttribute(String name) {
        if (getAttributes() != null) {
            List<Attribute> toRemove = new ArrayList<Attribute>();
            for (Attribute attr : getAttributes()) {
                if (attr.getAttributeName().equals(name))
                    toRemove.add(attr);
            }
            for (Attribute attr : toRemove)
                getAttributes().remove(attr);
        }
    }
1225483
public void removeAttribute(String name) {
        if (!_iSess.isValid())
            throw new IllegalStateException();
        if (_iSess != null) {
            _iSess.removeAttribute(name);
        }
    }
1166016
@Override
    public void removeAttributes() {
        // TODO: there must be a direct way to clear the SO on the client side
        Set<String> names = getAttributeNames();
        for (String key : names) {
            SharedObjectEvent event = new SharedObjectEvent(Type.CLIENT_DELETE_DATA, key, null);
            ownerMessage.addEvent(event);
            syncEvents.add(event);
        }
        deleteStats.addAndGet(names.size());
        // clear data
        super.removeAttributes();
        // mark as modified
        modified.set(true);
        // broadcast 'modified' event
        notifyModified();
    }
1288000
@Override
    public boolean removeAttribute(String name) {
        boolean result = true;
        // Send confirmation to client
        final SharedObjectEvent event = new SharedObjectEvent(Type.CLIENT_DELETE_DATA, name, null);
        if (ownerMessage.addEvent(event)) {
            if (super.removeAttribute(name)) {
                modified.set(true);
                syncEvents.add(event);
                deleteStats.incrementAndGet();
            } else {
                result = false;
            }
            notifyModified();
        }
        return result;
    }
599850
public void clear()
    {
        super.clear();

        if (_jsMap != null)
            _jsMap.clear();

        id = null;
        style = null;
        styleClass = null;
    }
563453
public static void unmapByteBuffer(final MappedByteBuffer map) {
    if(map == null) {
      return;
    }
    map.force();
    try {
      if(Runtime.class.getDeclaredMethod("version") != null)
        return; // At later Java, the hack below will not work anymore.
    }
    catch(NoSuchMethodException e) {
      // This is an ugly hack, but all that Java <8 offers to help freeing
      // memory allocated using such buffers.
      // See also: http://bugs.sun.com/view_bug.do?bug_id=4724038
      AccessController.doPrivileged(new PrivilegedAction<Object>() {
        @Override
        public Object run() {
          try {
            Method getCleanerMethod = map.getClass().getMethod("cleaner", new Class[0]);
            if(getCleanerMethod == null) {
              return null;
            }
            getCleanerMethod.setAccessible(true);
            Object cleaner = getCleanerMethod.invoke(map, new Object[0]);
            Method cleanMethod = cleaner.getClass().getMethod("clean");
            if(cleanMethod == null) {
              return null;
            }
            cleanMethod.invoke(cleaner);
          }
          catch(Exception e) {
            LoggingUtil.exception(e);
          }
          return null;
        }
      });
    }
    catch(SecurityException e1) {
      // Ignore.
    }
  }
251659
public void removeAttribute(String n)
    {
        attributes.remove(n);
        if (n.endsWith(".*"))
            prefixes.remove(n.substring(0,n.length()-2));
    }
125606
public synchronized void removeAll() {
        for (final AttributeCache cache : attributeCacheMap.values()) {
            cache.stopRefresh();
        }
        attributeCacheMap.clear();
        extTrigAttributeCacheMap.clear();
        for (final CommandCache cache : commandCacheMap.values()) {
            cache.stopRefresh();
        }
        commandCacheMap.clear();
        extTrigCommandCacheMap.clear();
        if (stateCache != null) {
            stateCache.stopRefresh();
            stateCache = null;
        }
        if (statusCache != null) {
            statusCache.stopRefresh();
            statusCache = null;
        }
        cacheList.remove(deviceName);
    }
739363
public Attribute removeAttributeWithPrefix(CharSequence prefix, CharSequence name) {
		for (Iterator<Attribute> it = event.attributes.iterator(); it.hasNext(); ) {
			Attribute attr = it.next();
			if (attr.localName.equals(name) && attr.namespacePrefix.equals(prefix)) {
				it.remove();
				return attr;
			}
		}
		return null;
	}
28316
protected Map<String, AttributeValue> untransformAttributes(Class<?> clazz, Map<String, AttributeValue> attributeValues) {
        Method hashKeyGetter = reflector.getHashKeyGetter(clazz);
        String hashKeyName = reflector.getAttributeName(hashKeyGetter);
        Method rangeKeyGetter = reflector.getRangeKeyGetter(clazz);
        String rangeKeyName = rangeKeyGetter == null ? null : reflector.getAttributeName(rangeKeyGetter);
        return untransformAttributes(hashKeyName, rangeKeyName, attributeValues);
    }
767206
protected void clearCaches(CmsEvent event) {

        // synchronization of this method is not required as the individual maps are all synchronized maps anyway,
        // and setExportnames() is doing it's own synchronization

        // flush all caches
        m_cacheOnlineLinks.clear();
        m_cacheExportUris.clear();
        m_cacheSecureLinks.clear();
        m_cacheExportLinks.clear();
        m_exportnameResources = null;
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLUSHED_CACHES_1, new Integer(event.getType())));
        }
    }
875971
public void removeAttributePolling(final String attributeName) throws DevFailed {
        // jive sends value with lower case, so manage it
        final AttributeImpl attribute = AttributeGetterSetter.getAttribute(attributeName, attributeList);
        attribute.resetPolling();
        cacheManager.removeAttributePolling(attribute);
        pollAttributes.remove(attributeName.toLowerCase(Locale.ENGLISH));
        if (attribute.getName().equals(DeviceImpl.STATE_NAME) || attribute.getName().equals(DeviceImpl.STATUS_NAME)) {
            // command is also set as polled
            final CommandImpl cmd = CommandGetter.getCommand(attribute.getName(), commandList);
            cmd.resetPolling();
            cacheManager.removeCommandPolling(cmd);
        }
        savePollingConfig();
    }
182039
public synchronized void clearSSLConfigMap() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "clearSSLConfigMap");

        sslConfigMap.clear();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "clearSSLConfigMap");
    }
161
public void clearKSMap() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "Clearing keystore maps");
        synchronized (keyStoreMap) {
            keyStoreMap.clear();
        }
    }