/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.exoplatform.services.jcr.impl.core.query.lucene;
import org.exoplatform.services.jcr.impl.core.NodeImpl;
import org.exoplatform.services.jcr.impl.core.SessionDataManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.NoSuchElementException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
/**
* Implements a {@link javax.jcr.NodeIterator} returned by
* {@link javax.jcr.query.QueryResult#getNodes()}.
*/
class NodeIteratorImpl implements TwoWayRangeIterator, NodeIterator
{
/** Logger instance for this class */
private static final Logger log = LoggerFactory.getLogger("exo.jcr.component.core.NodeIteratorImpl");
/** The node ids of the nodes in the result set with their score value */
protected final ScoreNodeIterator scoreNodes;
/** The index for the default selector withing {@link #scoreNodes} */
private final int selectorIndex;
/** ItemManager to turn UUIDs into Node instances */
protected final SessionDataManager itemMgr;
/** Number of invalid nodes */
protected int invalid = 0;
/** Reference to the next node instance */
private NodeImpl next;
/**
* Whether this iterator had been initialized.
*/
private boolean initialized;
/**
* Creates a new <code>NodeIteratorImpl</code> instance.
*
* @param itemMgr the <code>ItemManager</code> to turn UUIDs into
* <code>Node</code> instances.
* @param scoreNodes iterator over score nodes.
* @param selectorIndex the index for the default selector within
* <code>scoreNodes</code>.
*/
NodeIteratorImpl(SessionDataManager itemMgr, ScoreNodeIterator scoreNodes, int selectorIndex)
{
this.itemMgr = itemMgr;
this.scoreNodes = scoreNodes;
this.selectorIndex = selectorIndex;
}
/**
* Returns the current position in this <code>NodeIterator</code>.
* @return the current position in this <code>NodeIterator</code>.
*/
public long getPosition()
{
initialize();
long position = scoreNodes.getPosition() - invalid;
// scoreNode.getPosition() is one ahead
// if there is a prefetched node
if (next != null)
{
position--;
}
return position;
}
/**
* Returns the number of nodes in this iterator.
* </p>
* Note: The number returned by this method may differ from the number
* of nodes actually returned by calls to hasNext() / getNextNode()! This
* is because this iterator works on a lazy instantiation basis and while
* iterating over the nodes some of them might have been deleted in the
* meantime. Those will not be returned by getNextNode(). As soon as an
* invalid node is detected, the size of this iterator is adjusted.
*
* @return the number of node in this iterator.
*/
public long getSize()
{
long size = scoreNodes.getSize();
if (size == -1)
{
return size;
}
else
{
return size - invalid;
}
}
/**
* Returns <code>true</code> if there is another <code>Node</code>
* available; <code>false</code> otherwise.
* @return <code>true</code> if there is another <code>Node</code>
* available; <code>false</code> otherwise.
*/
public boolean hasNext()
{
initialize();
return next != null;
}
/**
* Returns the next <code>Node</code> in the result set.
* @return the next <code>Node</code> in the result set.
* @throws NoSuchElementException if iteration has no more
* <code>Node</code>s.
*/
public Object next() throws NoSuchElementException
{
initialize();
return nextNode();
}
/**
* Returns the next <code>Node</code> in the result set.
* @return the next <code>Node</code> in the result set.
* @throws NoSuchElementException if iteration has no more
* <code>Node</code>s.
*/
public Node nextNode() throws NoSuchElementException
{
initialize();
if (next == null)
{
throw new NoSuchElementException();
}
NodeImpl n = next;
fetchNext();
return n;
}
/**
* @throws UnsupportedOperationException always.
*/
public void remove()
{
throw new UnsupportedOperationException("remove");
}
/**
* Skip a number of <code>Node</code>s in this iterator.
* @param skipNum the non-negative number of <code>Node</code>s to skip
* @throws NoSuchElementException
* if skipped past the last <code>Node</code> in this iterator.
*/
public void skip(long skipNum) throws NoSuchElementException
{
initialize();
if (skipNum > 0)
{
scoreNodes.skip(skipNum - 1);
fetchNext();
}
}
public void skipBack(long skipNum)
{
initialize();
if (skipNum < 0)
{
throw new IllegalArgumentException("skipNum must not be negative");
}
scoreNodes.skipBack(skipNum + 1);
fetchNext();
}
/**
* Clears {@link #next} and tries to fetch the next Node instance.
* When this method returns {@link #next} refers to the next available
* node instance in this iterator. If {@link #next} is null when this
* method returns, then there are no more valid element in this iterator.
*/
protected void fetchNext()
{
// reset
next = null;
while (next == null && scoreNodes.hasNext())
{
ScoreNode[] sn = scoreNodes.nextScoreNodes();
try
{
next = (NodeImpl)itemMgr.getItemByIdentifier(sn[selectorIndex].getNodeId(), true);
if (next == null)
{
invalid++;
}
}
catch (RepositoryException e)
{
log.warn("Exception retrieving Node with UUID: " + sn[selectorIndex].getNodeId() + ": " + e.toString());
// try next
invalid++;
}
}
}
protected void initialize()
{
if (!initialized)
{
fetchNext();
initialized = true;
}
}
}