protected ViewNavigator getNavigator() {
   final Map<String, Object> requestScope = getRequestScope();
   final String key = "viewnav-" + this.toString();
   if (!requestScope.containsKey(key)) {
     requestScope.put(key, getNewNavigator());
   }
   nav_ = (ViewNavigator) requestScope.get(key);
   return nav_;
 }
 @SuppressWarnings("unchecked")
 private Map<Integer, E> getCache() {
   Map<String, Object> cacheScope =
       FrameworkUtils.isFaces() ? FrameworkUtils.getRequestScope() : internalCacheScope_;
   String key = toString() + "_entrycache";
   if (!cacheScope.containsKey(key)) {
     cacheScope.put(key, new HashMap<Integer, E>());
   }
   return (Map<Integer, E>) cacheScope.get(key);
 }
  public final void clearCache() {
    getCache().clear();
    getView().refresh();
    size_ = -1;

    final Map<String, Object> requestScope = getRequestScope();
    String thisToString = this.toString();
    requestScope.remove("viewnav-" + thisToString);
    requestScope.remove("viewentries-" + thisToString);
    requestScope.remove("lastFetchedIndex-" + thisToString);
  }
  protected ViewEntryCollection getEntries() {
    final Map<String, Object> requestScope = getRequestScope();
    final String key = "viewentries-" + this.toString();
    if (!requestScope.containsKey(key)) {
      View view = getView();
      if (StringUtil.isNotEmpty(searchQuery_)) {
        if (getResortColumn() != null) {
          view.FTSearchSorted(
              searchQuery_, 0, getResortColumn(), isAscending(), false, false, false);
        } else {
          view.FTSearch(searchQuery_);
        }
      }

      if (category_ != null) {
        requestScope.put(key, view.getAllEntriesByKey(category_));
      } else {
        requestScope.put(key, view.getAllEntries());
      }
    }
    return (ViewEntryCollection) requestScope.get(key);
  }
  /* **********************************************************************
   * List methods
   ************************************************************************/
  @Override
  @SuppressWarnings("deprecation")
  public E get(final int index) {
    if (invalid_) {
      return null;
    }

    Map<Integer, E> cache = getCache();
    if (!cache.containsKey(index)) {
      try {
        if (searchQuery_ == null || searchQuery_.isEmpty()) {
          ViewNavigator nav = getNavigator();

          // getNth is top-level only, so let's skip to what we need
          int lastFetchedIndex = 0;
          Map<String, Object> requestScope = getRequestScope();
          String key = "lastFetchedIndex-" + toString();
          if (requestScope.containsKey(key)) {
            lastFetchedIndex = (Integer) requestScope.get(key);
          }
          nav.skip(index - lastFetchedIndex);

          requestScope.put(key, index);

          try {
            // Try to get the current one, which may be null due to an as-yet-unsolved
            // "object has been removed or recycled" error. Check for that and switch to
            // our exception handler to retry
            ViewEntry entry = nav.getCurrent();
            if (entry == null) {
              throw new NullPointerException();
            }
            cache.put(index, createFromViewEntry(entry, columnInfo_));
          } catch (NullPointerException npe) {
            // Then we've probably hit an "Object has been removed or recycled" on the nav

            if (reset_ < 10) {
              reset_++;
              clearCache();
              return get(index);
            }

            System.out.println("=============================== NPE in DominoModelList");
            System.out.println(
                "=============================== Current class: " + getClass().getName());
            System.out.println("=============================== Type: " + getClazz().getName());
            System.out.println("=============================== Desired index: " + index);
            System.out.println("=============================== Current cache: " + cache);
            System.out.println("=============================== Current reported size: " + size());
            throw npe;
          } catch (RuntimeException re) {
            if (String.valueOf(re.getCause()).contains("Argument has been removed or recycled")) {
              if (reset_ < 10) {
                reset_++;
                clearCache();
                return get(index);
              }
            }
            // Otherwise, throw it up
            throw re;
          }
        } else {
          ViewEntryCollection vec = getEntries();
          cache.put(index, createFromViewEntry(vec.getNthEntry(index + 1), columnInfo_));
        }
      } catch (Exception e) {
        throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
      }
    }
    return cache.get(index);
  }