This method checks if this CounterMap has any values stored for a given first element

@param element
@return
191929
public boolean isEmpty(F element){
        if (isEmpty())
            return true;

        Counter<S> m = maps.get(element);
        if (m == null)
            return true;
        else
            return m.isEmpty();
    }
577934
public boolean isAfter(T element) {
    if (element == null) { return false; }
    return comparator.compare(element, min) < 0;
  }
99563
Long getCounterValueAsLong(final CounterMap counters, final String counterGroupName,
      final String counterName) {
    Counter c1 = counters.getCounter(counterGroupName, counterName);
    if (c1 != null) {
      return c1.getValue();
    } else {
      return 0L;
    }
  }
465484
public int getSortOrder(Element element) {
        String deepName = getDeepName(element);
        return elementNameSortOrderMap.get(deepName);
    }
1285524
private static Element getFirstNamedElement(Element element, String name) {
		NodeList list = element.getElementsByTagName(name);
		if (list.getLength() == 0) {
			return null;
		}

		return (Element) list.item(0);
	}
181035
public static boolean contains(Iterator<?> iterator, Object element) {
        if (iterator != null) {
            while (iterator.hasNext()) {
                Object candidate = iterator.next();
                if (ObjectUtils.nullSafeEquals(candidate, element)) {
                    return true;
                }
            }
        }
        return false;
    }
387058
public boolean isBefore(T element) {
    if (element == null) { return false; }
    return comparator.compare(element, max) > 0;
  }
320692
protected Element findAndReplaceSimpleElement(Counter counter, Element parent, String name, String text,
            String defaultValue)
   {
      if ((defaultValue != null) && (text != null) && defaultValue.equals(text))
      {
         Element element = parent.getChild(name, parent.getNamespace());
         // if exist and is default value or if doesn't exist.. just keep the
         // way it is..
         if (((element != null) && defaultValue.equals(element.getText())) || (element == null))
         {
            return element;
         }
      }

      boolean shouldExist = (text != null) && (text.trim().length() > 0);
      Element element = updateElement(counter, parent, name, shouldExist);
      if (shouldExist)
      {
         element.setText(text);
      }
      return element;
   }
1206254
public boolean isAfter(final T element) {
        if (element == null) {
            return false;
        }

        return lowerEndpoint.includes(element) == false;
    }
733372
@Override
    public boolean contains(long value, T element) {
    	if (root == null) return false;
    	if (value < first.value) return false;
    	if (value > last.value) return false;
    	if (value == first.value && ObjectUtil.equalsOrNull(element, first.element)) return true;
    	if (value == last.value && ObjectUtil.equalsOrNull(element, last.element)) return true;
    	return contains(root, value, element);
    }
254917
public T set(int index, T element)
    {
        if (index == 0)
        {
            T previousElement = this.element1;
            this.element1 = element;
            return previousElement;
        }
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + this.size());
    }
698205
protected boolean addElem(final T element) {
    // validate element
    if (element == null) {
      throw new IllegalArgumentException("Null element is not supported.");
    }
    // find hashCode & index
    final int hashCode = element.hashCode();
    final int index = getIndex(hashCode);
    // return false if already present
    if (containsElem(index, element, hashCode)) {
      return false;
    }

    modification++;
    size++;

    // update bucket linked list
    LinkedElement<T> le = new LinkedElement<T>(element, hashCode);
    le.next = entries[index];
    entries[index] = le;
    return true;
  }
1248326
@GuardedBy("elementsLock")
	@Override
	public boolean markChecked(CandidateElement element) {
		String generalString = element.getGeneralString();
		String uniqueString = element.getUniqueString();
		synchronized (elementsLock) {
			if (elements.contains(uniqueString)) {
				return false;
			} else {
				elements.add(generalString);
				elements.add(uniqueString);
				return true;
			}
		}
	}
827395
public boolean isEndedBy(T element) {
    if (element == null) { return false; }
    return comparator.compare(element, max) == 0;
  }
149498
@SuppressWarnings("unlikely-arg-type")
	@Pure
	public int indexOf(P element) {
		int idx = 0;
		for (final GridCellElement<P> e : this.elements) {
			if (e.isReferenceCell(this)) {
				if (e.equals(element)) {
					return idx;
				}
				++idx;
			}
		}
		return -1;
	}
817329
public static String getValue(Element element) {
        if (element != null) {
            Node dataNode = element.getFirstChild();
            if (dataNode != null) {
                return ((Text) dataNode).getData();
            }
        }
        return null;
    }
367897
public static <T> List<T> singletonList(T element) {
		if (element == null) {
			return Collections.emptyList();
		}
		return Collections.singletonList(element);
	}