/** * Return an iterator over the elements in this collection. Duplicates will show up the number of * times it has occurrences. */ @Override public Iterator iterator() { return new StructBagIterator(fieldValuesIterator()); }
/** Remove the field values from a struct of the correct type */ @Override public boolean removeFieldValues(Object[] fieldValues) { if (this.hasLimitIterator) { // Asif : Get the field value Iterator Iterator fieldItr = this.fieldValuesIterator(); while (fieldItr.hasNext()) { if (Arrays.equals((Object[]) fieldItr.next(), fieldValues)) { fieldItr.remove(); return true; } } return false; } else { return super.remove(fieldValues); } }
/** * Does this set contain a Struct of the correct type with the specified values? */ @Override public boolean containsFieldValues(Object[] fieldValues) { // Asif: The fieldValues can never be null . If the Struc contained // null , then the the getFieldValues would have returned // a zero size Object array. So we need not bother about null here if (this.hasLimitIterator) { Iterator fieldItr = this.fieldValuesIterator(); while (fieldItr.hasNext()) { if (Arrays.equals((Object[]) fieldItr.next(), fieldValues)) { return true; } } return false; } else { return super.contains(fieldValues); } }
@Override public int occurrences(Object element) { if (!(element instanceof Struct)) { return 0; } Struct s = (Struct) element; if (!this.elementType.equals(StructTypeImpl.typeFromStruct(s))) { return 0; } if (this.hasLimitIterator) { int count = 0; boolean encounteredObject = false; Object[] fields = s.getFieldValues(); for (Iterator itr = this.fieldValuesIterator(); itr.hasNext();) { Object[] structFields = (Object[]) itr.next(); if (Arrays.equals(fields, structFields)) { count++; encounteredObject = true; } else if (encounteredObject) { // Asif: No possibility of its occurrence again break; } } return count; } else { return this.map.get(s.getFieldValues()); // returns 0 if not found } }
public boolean retainAll(StructFields ss) { if (!this.elementType.equals(ss.getCollectionType().getElementType())) { if (isEmpty()) { return false; // nothing modified } else { clear(); return true; // nothing retained in receiver collection } } boolean changed = false; int size = size(); Iterator it; it = fieldValuesIterator(); while (size-- > 0) { Object[] vals = (Object[]) it.next(); if (!ss.containsFieldValues(vals)) { it.remove(); changed = true; } } return changed; }
/** * Creates a StructSet directly from a StructBag; (internal use) * * @since GemFire 5.1 */ StructSet(StructBag bag) { this.contents = new ObjectOpenCustomHashSet(new ObjectArrayHashingStrategy()); this.structType = (StructType) bag.elementType; if (bag.hasLimitIterator) { // Asif: Since the number of unique keys which // will be returned by Bag with limit in place // cannot be more than the size of the bag ( i.e // the limit) , we can safely assume HashMap size // to equal to bag's size Iterator itr = bag.fieldValuesIterator(); while (itr.hasNext()) { addFieldValues((Object[]) itr.next()); } } else { Set keys = bag.map.keySet(); for (Object key : keys) { addFieldValues((Object[]) key); } } }