Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.commons.configuration.attributes;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
AttributeSet is a container for Attributes. It is constructed by passing in a list of AttributeDefinitions. AttributeSets are initially unprotected, which means that the contained attributes can be modified. If the protect() method is invoked then only attributes which are not AttributeDefinition.isImmutable() can be modified from then on.

Author(s):
Tristan Tarrant
Since:
7.2
 
 public class AttributeSet implements AttributeListener<Object> {
    private static final Log log = LogFactory.getLog(AttributeSet.class);
    private final String name;
    private final Map<StringAttribute<? extends Object>> attributes;
    private boolean protect;
 
    @SafeVarargs
    public AttributeSet(Class<?> klass, AttributeDefinition<?>... attributeDefinitions) {
       this(klass.getSimpleName(), attributeDefinitions);
    }
 
    @SafeVarargs
    public AttributeSet(String name, AttributeDefinition<?>... attributeDefinitions) {
       this. = name;
       this. = new HashMap<>(attributeDefinitions.length);
       for (AttributeDefinition<?> def : attributeDefinitions) {
          if (.containsKey(def.name())) {
             throw .attributeSetDuplicateAttribute(def.name(), name);
          }
          Attribute<Objectattribute = (Attribute<Object>) def.toAttribute();
          if (!attribute.isImmutable())
             attribute.addListener(this);
          this..put(def.name(), attribute);
       }
    }
 
    @SafeVarargs
    public AttributeSet(Class<?> klassAttributeSet attributeSet, AttributeDefinition<?>... attributeDefinitions) {
       this(klass.getSimpleName(), attributeSetattributeDefinitions);
    }
 
    public AttributeSet(String nameAttributeSet attributeSet, AttributeDefinition<?>[] attributeDefinitions) {
       this. = name;
       this. = new HashMap<>(attributeDefinitions.length + attributeSet.attributes.size());
       for (Attribute<? extends Objectattribute : attributeSet.attributes.values()) {
          this..put(attribute.name(), attribute.getAttributeDefinition().toAttribute());
       }
       for (AttributeDefinition<?> def : attributeDefinitions) {
          Attribute<Objectattribute = (Attribute<Object>) def.toAttribute();
          if (!attribute.isImmutable())
             attribute.addListener(this);
          this..put(def.name(), attribute);
       }
    }
 
    public String getName() {
       return ;
    }
 
    public boolean contains(String name) {
       return .containsKey(name);
    }
 
    public <T> boolean contains(AttributeDefinition<T> def) {
       return contains(def.name());
    }
 
    @SuppressWarnings("unchecked")
    public <T> Attribute<T> attribute(String name) {
       return (Attribute<T>) this..get(name);
    }
 
    public <T> Attribute<T> attribute(AttributeDefinition<T> def) {
       Attribute<T> attribute = attribute(def.name());
       if (attribute != null)
          return attribute;
       else
          throw .noSuchAttribute(def.name(), );
    }
 
    public void read(AttributeSet other) {
 
       for (Iterator<Attribute<? extends Object>> iterator = .values().iterator(); iterator.hasNext();) {
          Attribute<Objectattribute = (Attribute<Object>) iterator.next();
 
          Attribute<Objecta = other.attribute(attribute.name());
          if (a.isModified()) {
             attribute.read(a);
          }
       }
    }

   
Returns a new ValueSet where immutable Attributes are write-protected

Returns:
   public AttributeSet protect() {
      AttributeDefinition<?> attrDefs[] = new AttributeDefinition[.size()];
      int i = 0;
      for (Attribute<?> attribute : .values()) {
         attrDefs[i++] = attribute.getAttributeDefinition();
      }
      AttributeSet protectedSet = new AttributeSet(attrDefs);
      for (Attribute<?> attribute : protectedSet.attributes.values()) {
         Attribute<?> localAttr = this..get(attribute.name());
         attribute.read((Attribute)localAttr);
         attribute.protect();
      }
      protectedSet.protect = true;
      return protectedSet;
   }
   public boolean isProtected() {
      return ;
   }
   public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + (( == null) ? 0 : .hashCode());
      return result;
   }
   public boolean equals(Object obj) {
      if (this == obj)
         return true;
      if (obj == null)
         return false;
      if (getClass() != obj.getClass())
         return false;
      AttributeSet other = (AttributeSetobj;
      if ( == null) {
         if (other.attributes != null)
            return false;
      } else if (!.equals(other.attributes))
         return false;
      return true;
   }
   public String toString() {
      return toString(null);
   }
   public String toString(String name) {
      StringBuilder sb = new StringBuilder();
      if (name != null) {
         sb.append(name);
         sb.append(" = ");
      }
      sb.append("[");
      boolean comma = false;
      for (Attribute<?> value : .values()) {
         if (comma) {
            sb.append(", ");
         } else {
            comma = true;
         }
         sb.append(value.toString());
      }
      sb.append("]");
      return sb.toString();
   }
   public AttributeSet checkProtection() {
      if (!) {
         throw .unprotectedAttributeSet();
      }
      return this;
   }
   public void reset() {
      if () {
         throw .protectedAttributeSet();
      }
      for (Iterator<Attribute<? extends Object>> iterator = .values().iterator(); iterator.hasNext();) {
         iterator.next().reset();
      }
   }
   public void attributeChanged(Attribute<ObjectattributeObject oldValue) {
      // TODO
   }
New to GrepCode? Check out our FAQ X