private Entry _sibling(Entry current, N name) throws StaxNavException {
if (current != null) {
Entry element = current;
while (true) {
Entry next = element.next();
if (next != null && next.getElement().getDepth() >= current.getElement().getDepth()) {
if (next.getElement().getDepth() == current.getElement().getDepth()) {
if (name == null) {
current = next;
return current;
} else {
N siblingName = naming.getName(next.getElement().getName());
if (name.equals(siblingName)) {
current = next;
return current;
} else {
element = next;
}
}
} else {
element = next;
}
} else {
break;
}
}
}
return null;
}
private Entry _current(Entry current, N name) throws StaxNavException {
if (current != null) {
if (name == null || name.equals(naming.getName(current.getElement().getName()))) {
return current;
}
}
return null;
}
protected Entry next(int depth) throws StaxNavException {
Entry next = next();
if (next != null && next.getElement().getDepth() > depth) {
return next;
} else {
return null;
}
}
public Map<String, String> getAttributes()
throws NullPointerException, IllegalStateException, StaxNavException {
Map<String, String> attributes = current.getElement().getAttributes();
if (attributes.isEmpty()) {
return Collections.emptyMap();
} else {
return attributes;
}
}
public String getAttribute(String name)
throws NullPointerException, IllegalStateException, StaxNavException {
Map<String, String> attributes = current.getElement().getAttributes();
if (attributes.isEmpty()) {
return null;
} else {
return attributes.get(name);
}
}
public boolean find(N name) throws StaxNavException {
if (name == null) {
throw new NullPointerException("No null name accepted");
}
if (name.equals(naming.getName(current.getElement().getName()))) {
return true;
} else {
return navigate(Axis.FOLLOWING, name);
}
}
private int _descendant(N name) throws StaxNavException {
Entry element = current;
while (true) {
Entry next = element.next();
if (next != null && next.getElement().getDepth() >= current.getElement().getDepth()) {
N descendantName = naming.getName(next.getElement().getName());
if (name.equals(descendantName)) {
int diff = next.getElement().getDepth() - current.getElement().getDepth();
current = next;
return diff;
} else {
element = next;
}
} else {
break;
}
}
return -1;
}
@Override
public Entry<E> pollLastEntry() {
Iterator<Entry<E>> entryIterator = descendingEntryIterator();
if (entryIterator.hasNext()) {
Entry<E> result = entryIterator.next();
result = Multisets.immutableEntry(result.getElement(), result.getCount());
entryIterator.remove();
return result;
}
return null;
}
SerializedForm(Multiset<?> multiset) {
int distinct = multiset.entrySet().size();
elements = new Object[distinct];
counts = new int[distinct];
int i = 0;
for (Entry<?> entry : multiset.entrySet()) {
elements[i] = entry.getElement();
counts[i] = entry.getCount();
i++;
}
}
private Entry _next(Entry current, N name) throws StaxNavException {
if (current != null) {
Entry next = current.next(depth);
if (next != null
&& (name == null || name.equals(naming.getName(next.getElement().getName())))) {
current = next;
return current;
}
}
return null;
}
public <V> V parseContent(ValueType<V> valueType)
throws IllegalStateException, NullPointerException, StaxNavException {
if (valueType == null) {
throw new NullPointerException();
}
Entry element = current;
String content = element.getElement().getContent(true);
if (content == null) {
throw new IllegalStateException("No content available for parsing");
}
try {
return valueType.parse(content);
} catch (Exception e) {
if (e instanceof TypeConversionException) {
throw (TypeConversionException) e;
} else {
throw new TypeConversionException(
element.getElement().getLocation(), e, "Could not parse string value " + content);
}
}
}
/**
* Adds each element of {@code elements} to the {@code ImmutableMultiset}.
*
* @param elements the {@code Iterable} to add to the {@code ImmutableMultiset}
* @return this {@code Builder} object
* @throws NullPointerException if {@code elements} is null or contains a null element
*/
@Override
public Builder<E> addAll(Iterable<? extends E> elements) {
if (elements instanceof Multiset) {
Multiset<? extends E> multiset = Multisets.cast(elements);
for (Entry<? extends E> entry : multiset.entrySet()) {
addCopies(entry.getElement(), entry.getCount());
}
} else {
super.addAll(elements);
}
return this;
}
@Override
public boolean contains(Object o) {
if (o instanceof Entry) {
Entry<?> entry = (Entry<?>) o;
if (entry.getCount() <= 0) {
return false;
}
int count = multiset.count(entry.getElement());
return count == entry.getCount();
}
return false;
}
@SuppressWarnings("unchecked")
SerializedForm(SortedMultiset<E> multiset) {
this.comparator = multiset.comparator();
int n = multiset.entrySet().size();
elements = (E[]) new Object[n];
counts = new int[n];
int i = 0;
for (Entry<E> entry : multiset.entrySet()) {
elements[i] = entry.getElement();
counts[i] = entry.getCount();
i++;
}
}
public N next(Set<N> names) throws StaxNavException {
if (names == null) {
throw new NullPointerException();
}
Entry next = current.next(depth);
if (next != null) {
N name = naming.getName(next.getElement().getName());
if (names.contains(name)) {
current = next;
return name;
}
}
return null;
}
public String getAttribute(QName name)
throws NullPointerException, IllegalStateException, StaxNavException {
if (name == null) {
throw new NullPointerException("No null attribute name expected");
}
if (XMLConstants.NULL_NS_URI.equals(name.getNamespaceURI())) {
return getAttribute(name.getLocalPart());
} else {
Map<QName, String> qualifiedAttributes = current.getElement().getQualifiedAttributes();
if (qualifiedAttributes.isEmpty()) {
return null;
} else {
return qualifiedAttributes.get(name);
}
}
}
public Map<QName, String> getQualifiedAttributes()
throws NullPointerException, IllegalStateException, StaxNavException {
Map<QName, String> qualifiedAttributes = current.getElement().getQualifiedAttributes();
Map<String, String> attributes = getAttributes();
if (!attributes.isEmpty()) {
if (qualifiedAttributes.isEmpty()) {
qualifiedAttributes = new HashMap<QName, String>(qualifiedAttributes);
}
for (String key : attributes.keySet()) {
qualifiedAttributes.put(new QName(key), attributes.get(key));
}
}
if (qualifiedAttributes.isEmpty()) {
return Collections.emptyMap();
} else {
return qualifiedAttributes;
}
}
private Entry _following(Entry current, N name) throws StaxNavException {
if (name == null) {
throw new UnsupportedOperationException("todo");
}
if (current != null) {
Entry entry = current.next();
while (entry != null) {
N findName = naming.getName(entry.getElement().getName());
if (name.equals(findName)) {
current = entry;
return current;
} else {
entry = entry.next();
}
}
}
return null;
}
static <E> ImmutableMultiset<E> copyFromEntries(
Collection<? extends Entry<? extends E>> entries) {
long size = 0;
ImmutableMap.Builder<E, Integer> builder = ImmutableMap.builder();
for (Entry<? extends E> entry : entries) {
int count = entry.getCount();
if (count > 0) {
// Since ImmutableMap.Builder throws an NPE if an element is null, no
// other null checks are needed.
builder.put(entry.getElement(), count);
size += count;
}
}
if (size == 0) {
return of();
}
return new RegularImmutableMultiset<E>(builder.build(), Ints.saturatedCast(size));
}
private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries(
Comparator<? super E> comparator, Collection<Entry<E>> entries) {
if (entries.isEmpty()) {
return emptyMultiset(comparator);
}
ImmutableList.Builder<E> elementsBuilder = new ImmutableList.Builder<E>(entries.size());
long[] cumulativeCounts = new long[entries.size() + 1];
int i = 0;
for (Entry<E> entry : entries) {
elementsBuilder.add(entry.getElement());
cumulativeCounts[i + 1] = cumulativeCounts[i] + entry.getCount();
i++;
}
return new RegularImmutableSortedMultiset<E>(
new RegularImmutableSortedSet<E>(elementsBuilder.build(), comparator),
cumulativeCounts,
0,
entries.size());
}
@Override
public boolean equals(@Nullable Object object) {
if (object == this) {
return true;
}
if (object instanceof Multiset) {
Multiset<?> that = (Multiset<?>) object;
if (this.size() != that.size()) {
return false;
}
for (Entry<?> entry : that.entrySet()) {
if (count(entry.getElement()) != entry.getCount()) {
return false;
}
}
return true;
}
return false;
}
public String getContent() throws StaxNavException {
return current.getElement().getContent(trimContent);
}
public int getDepth() throws StaxNavException {
return current.getElement().getDepth();
}
public Location getLocation() throws StaxNavException {
return current.getElement().getLocation();
}
public QName getQName() throws StaxNavException {
return current.getElement().getName();
}
public String getLocalName() throws StaxNavException {
return current.getElement().getName().getLocalPart();
}
public N getName() throws StaxNavException {
return current.getElement().getName(naming);
}
private StaxNavigatorImpl(Naming<N> naming, Entry current, boolean trimContent) {
this.naming = naming;
this.current = current;
this.depth = current.getElement().getDepth();
this.trimContent = trimContent;
}
public String getNamespaceByPrefix(String prefix) throws NullPointerException, StaxNavException {
if (prefix == null) {
throw new NullPointerException();
}
return current.getElement().getNamespaceByPrefix(prefix);
}
