public OrderedMergeIterator(IteratorRegistry registry, CloseableIterator<LLEntry>[] iterators) {
   this.registry = registry;
   if (registry != null) {
     registry.registerIterator(this);
   }
   // init values
   currentValues = new ArrayList<LLEntry>();
   for (int i = 0; i < iterators.length; i++) {
     CloseableIterator<LLEntry> iter = iterators[i];
     if (iter.hasNext()) {
       this.iterators.add(iter);
       currentValues.add(iter.next());
     }
   }
   // find smallest value
   if (!currentValues.isEmpty()) {
     int currentPos = 0;
     current = currentValues.get(0);
     for (int i = 1; i < currentValues.size(); i++) {
       if (current.getKey() > currentValues.get(i).getKey()) {
         currentPos = i;
         current = currentValues.get(i);
       }
     }
     // refill
     getNext(currentPos);
   }
 }
 @Override
 public void close() {
   for (CloseableIterator<?> i : iterators) {
     i.close();
   }
   if (registry != null) {
     registry.deregisterIterator(this);
   }
 }
 private void getNext(int currentPos) {
   CloseableIterator<LLEntry> iter = iterators.get(currentPos);
   if (iter.hasNext()) {
     currentValues.set(currentPos, iter.next());
   } else {
     iter.close();
     iterators.remove(currentPos);
     currentValues.remove(currentPos);
   }
 }
Example #4
0
 @Override
 public boolean inIndex(String identifier) {
   CloseableIterator<JdbcEntry> i = getSqlCursor(getFindSql(identifier));
   boolean result = i.hasNext();
   try {
     i.close();
   } catch (IOException ex) {
     log.warn(ex);
   }
   return result;
 }
Example #5
0
  public Iterator<T> iterator() {
    _broker.assertNontransactionalRead();
    CloseableIterator citr = null;
    try {
      // create an iterator chain; add pnew objects if transactional
      CloseableIteratorChain chain = new CloseableIteratorChain();
      boolean trans = !_ignore && _broker.isActive();
      if (trans) chain.addIterator(new FilterNewIterator());

      // add database iterators for each implementing class
      MetaDataRepository repos = _broker.getConfiguration().getMetaDataRepositoryInstance();
      ClassMetaData meta = repos.getMetaData(_type, _broker.getClassLoader(), false);

      ClassMetaData[] metas;
      if (meta != null
          && (!_subs || !meta.isManagedInterface())
          && (meta.isMapped() || (_subs && meta.getMappedPCSubclassMetaDatas().length > 0)))
        metas = new ClassMetaData[] {meta};
      else if (_subs && (meta == null || meta.isManagedInterface()))
        metas = repos.getImplementorMetaDatas(_type, _broker.getClassLoader(), false);
      else metas = EMPTY_METAS;

      ResultObjectProvider rop;
      for (int i = 0; i < metas.length; i++) {
        rop = _broker.getStoreManager().executeExtent(metas[i], _subs, _fc);
        if (rop != null) chain.addIterator(new ResultObjectProviderIterator(rop));
      }

      // filter deleted objects if transactional
      if (trans) citr = new FilterDeletedIterator(chain);
      else citr = chain;
      citr.setRemoveOnClose(this);
    } catch (OpenJPAException ke) {
      throw ke;
    } catch (RuntimeException re) {
      throw new GeneralException(re);
    }

    lock();
    try {
      if (_openItrs == null) _openItrs = new ReferenceHashSet(ReferenceHashSet.WEAK);
      _openItrs.add(citr);
    } finally {
      unlock();
    }
    return citr;
  }
Example #6
0
  public void closeAll() {
    if (_openItrs == null) return;

    lock();
    try {
      CloseableIterator citr;
      for (Iterator itr = _openItrs.iterator(); itr.hasNext(); ) {
        citr = (CloseableIterator) itr.next();
        citr.setRemoveOnClose(null);
        try {
          citr.close();
        } catch (Exception e) {
        }
      }
      _openItrs.clear();
    } catch (OpenJPAException ke) {
      throw ke;
    } catch (RuntimeException re) {
      throw new GeneralException(re);
    } finally {
      unlock();
    }
  }
Example #7
0
 /**
  * Calls close() on all elements of <code>objs</code> that implement Closeable
  *
  * @param objs A list of potentially closeable objects
  *     <p>NOTE: This method must take a List<? extends Object>, not List<Object>, otherwise the
  *     overload above will be selected if the argument is not exactly List<Object>.
  */
 public static void close(List<? extends Object> objs) {
   for (Object o : objs) {
     if (o instanceof Closeable) {
       try {
         ((Closeable) o).close();
       } catch (IOException ioe) {
         // Do nothing
       }
     } else if (o instanceof CloseableIterator) {
       ((CloseableIterator) o).close();
     } else {
       try {
         java.lang.reflect.Method m = o.getClass().getMethod("close");
         m.invoke(o);
       } catch (Exception e) {
         /** Ignore */
       }
     }
   }
 }
 @Override
 public void refresh() {
   for (CloseableIterator<?> it : iterators) {
     it.refresh();
   }
 }