Handle unmapped attribute.

@param attributesToRelease the attributes to release
@param attributeName       the attribute name
@param attributeValue      the attribute value
175599
protected void handleUnmappedAttribute(final Map<String, List<Object>> attributesToRelease, final String attributeName, final Object attributeValue) {
        LOGGER.debug("Found attribute [{}] that is not defined in pattern definitions", attributeName);
        if (excludeUnmappedAttributes) {
            LOGGER.debug("Excluding attribute [{}] given unmatched attributes are to be excluded", attributeName);
        } else {
            LOGGER.debug("Added unmatched attribute [{}] with value(s) [{}]", attributeName, attributeValue);
            attributesToRelease.put(attributeName, CollectionUtils.toCollection(attributeValue, ArrayList.class));
        }
    }
1099633
protected void fireAttributeRemovedEvent(String name, AttributeValue oldValue) {
		if (this.listeners != null && isEventFirable()) {
			final AttributeChangeEvent event = new AttributeChangeEvent(
					//source
					this,
					//type
					Type.REMOVAL,
					//old name
					name,
					//old value
					oldValue,
					//current name
					name,
					//current value
					oldValue);
			for (final AttributeChangeListener listener : this.listeners) {
				listener.onAttributeChangeEvent(event);
			}
		}
	}
1350139
public void setAttribute(String pName, Object pValue) {
        crossoverCheck("setAttribute");
        if (pName != null && pValue == null)
            removeAttribute(pName);
        else
            putSessionValue(pName, pValue, false);
    }
725543
public void addAttribute(String attributeName, String attributeValue) throws XmlModelException {
        String name = attributeName.trim();
        String value = attributeValue.trim();
        if(attributesMap.containsKey(name)) {
            throw new XmlModelException("Duplicate attribute: " + name);
        }
        attributeNames.add(name);
        attributesMap.put(name, new Attribute(name, value));
    }
1322914
protected BaseBo removeAttribute(String attrName, boolean triggerChange) {
        Lock lock = lockForWrite();
        try {
            attributes.remove(attrName);
            if (triggerChange) {
                triggerChange(attrName);
            }
            markDirty();
            return this;
        } finally {
            lock.unlock();
        }
    }
263009
protected synchronized void fireAttributeRemovedEvent(String name, AttributeValue oldValue) {
		if (this.listenerList != null && isEventFirable()) {
			final AttributeChangeListener[] list = new AttributeChangeListener[this.listenerList.size()];
			this.listenerList.toArray(list);
			final AttributeChangeEvent event = new AttributeChangeEvent(
					this,
					Type.REMOVAL,
					name,
					oldValue,
					name,
					oldValue);
			for (final AttributeChangeListener listener : list) {
				listener.onAttributeChangeEvent(event);
			}
		}
	}
841254
public void sessionAttributeRemoved(ISession session, Object name, Object value, Boolean oldIsBindingListener) {
        HttpSessionAttributeListener listener = null;
        HttpSessionBindingEvent event = null;
        HttpSession httpsession = (HttpSession) _adapter.adapt(session);

        event = new HttpSessionBindingEvent(httpsession, (String) name, value);
        // if (value instanceof HttpSessionBindingListener) {
        if (value != null && oldIsBindingListener.booleanValue()) {
            ((HttpSessionBindingListener) value).valueUnbound(event);
        }
        for (int i = 0; i < _sessionAttributeListeners.size(); i++) {
            listener = (HttpSessionAttributeListener) _sessionAttributeListeners.get(i);
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "sessionAttributeRemoved", "SessionManager calling attributeRemoved on listener:" + listener);
            }
            listener.attributeRemoved(event);
        }

    }
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);
    }
144219
protected String extractAttribute(String stringContainingAttributes, String attributeName) {

    String attributeValue = "";

    stringContainingAttributes = stringContainingAttributes.replaceAll("<", "").replaceAll(">", "");

    String[] keyValues = stringContainingAttributes.split(" ");
    for (int i = 0; i < keyValues.length; i++) {
      String keyValue = keyValues[i].trim();
      String[] keyAndValue = keyValue.split("=");
      if (keyAndValue[0].equalsIgnoreCase(attributeName)) {
        return keyAndValue[1].substring(1, keyAndValue[1].length() - 1);
      }
    }

    return attributeValue;
  }
1146389
public void pushAttributeValueEvent(final String deviceName, final String attributeName) throws DevFailed {
        xlogger.entry();
        for (final EventType eventType : EventType.getEventAttrValueTypeList()) {
            pushAttributeValueEventIdlLoop(deviceName, attributeName, eventType);
        }
        xlogger.exit();
    }
44268
public static String requireSingleAttribute(final XMLStreamReader reader, final String attributeName)
            throws XMLStreamException {
        final int count = reader.getAttributeCount();
        if (count == 0) {
            throw missingRequired(reader, Collections.singleton(attributeName));
        }
        requireNoNamespaceAttribute(reader, 0);
        if (!attributeName.equals(reader.getAttributeLocalName(0))) {
            throw unexpectedAttribute(reader, 0);
        }
        if (count > 1) {
            throw unexpectedAttribute(reader, 1);
        }
        return reader.getAttributeValue(0);
    }
126790
public void writeAttribute(String attributeName, String value) throws IOException {
		this.attribute(null, attributeName, value);

	}
240342
public void setUnmappedAttributes(java.util.Collection<UnmappedAttribute> unmappedAttributes) {
        if (unmappedAttributes == null) {
            this.unmappedAttributes = null;
            return;
        }

        this.unmappedAttributes = new java.util.ArrayList<UnmappedAttribute>(unmappedAttributes);
    }
208508
public boolean unlink(Object source, String attributeName, Object target)
    {
        return linkOrUnlink(false, source, attributeName, false);
    }
28705
@Pure
	protected AttributeValue getStoredAttributeValue(String name, AttributeType expectedType) {
		Object val = this.heap.get(name);
		if (val != null) {
			final AttributeType currentType = AttributeType.fromValue(val);
			val = unprotectNull(val);
			final AttributeValue attr = new AttributeValueImpl(name);
			if (expectedType == null) {
				attr.castAndSet(currentType, val);
			} else {
				attr.castAndSet(expectedType, val);
			}
			return attr;
		}
		return null;
	}
1006476
public static boolean getAttributeAsBoolean(XmlPullParser parser, String attributeName, boolean defaultValue) throws Exception {
		// parser.getText()
		String value = parser.getAttributeValue(null, attributeName);

		if (!StringUtils.hasText(value)) {
			return defaultValue;
		}

		return Boolean.parseBoolean(value);
	}
253893
@Pure
	protected Attribute getStoredAttribute(String name, AttributeType expectedType) {
		Object val = this.heap.get(name);
		if (val != null) {
			final AttributeType currentType = AttributeType.fromValue(val);
			val = unprotectNull(val);
			final Attribute attr = new AttributeImpl(name);
			if (expectedType == null) {
				attr.castAndSet(currentType, val);
			} else {
				attr.castAndSet(expectedType, val);
			}
			return attr;
		}
		return null;
	}