Attempt to read the Jandex index.

If Jandex is not enabled, immediately answer null.

If no Jandex index is available, or if it cannot be read, answer null.

@return The read Jandex index.
6258
protected Index getJandexIndex() {
    	String methodName = "getJandexIndex";

        boolean doLog = tc.isDebugEnabled();
        boolean doJandexLog = JandexLogger.doLog();

        boolean useJandex = getUseJandex();

        if ( !useJandex ) {
        	// Figuring out if there is a Jandex index is mildly expensive,
        	// and is to be avoided when logging is disabled.

        	if ( doLog || doJandexLog ) {
        		boolean haveJandex = basicHasJandexIndex();

        		String msg;
        		if ( haveJandex ) {
        			msg = MessageFormat.format(
        				"[ {0} ] Jandex disabled; Jandex index [ {1} ] found",
        				getHashText(), getJandexIndexPath());
        		} else {
        			msg = MessageFormat.format(
        				"[ {0} ] Jandex disabled; Jandex index [ {1} ] not found",
        				getHashText(), getJandexIndexPath());

        		}
        		if ( doLog ) {
        		    Tr.debug(tc, msg);
        		}
        		if ( doJandexLog ) {
        		    JandexLogger.log(CLASS_NAME,  methodName, msg);
        		}
        	}

        	return null;

        } else {
        	Index jandexIndex = basicGetJandexIndex();

        	if ( doLog || doJandexLog ) {
        		String msg;
        		if ( jandexIndex != null ) {
        			msg = MessageFormat.format(
        				"[ {0} ] Jandex enabled; Jandex index [ {1} ] found",
        				getHashText(), getJandexIndexPath());
        		} else {
        			msg = MessageFormat.format(
        				"[ {0} ] Jandex enabled; Jandex index [ {1} ] not found",
        				getHashText(), getJandexIndexPath());
        		}
        		if ( doLog ) {
        	        Tr.debug(tc, msg);
        		}
        		if ( doJandexLog ) {
        			JandexLogger.log(CLASS_NAME,  methodName, msg);
        		}
        	}

        	return jandexIndex;
        }
    }
920109
Index getIndex(String indexName) {

        Index[] indexes = indexList;
        int     i       = getIndexIndex(indexName);

        return i == -1 ? null
                       : indexes[i];
    }
196310
public int read() throws IOException {
    if (chunk == null || pos + 1 == chunk.length) {
      if (!fetchChunk()) {
        return -1;
      }
    }
    return chunk[pos++] & 0xff;
  }
357814
@CheckForSigned
  private int _getReadIndex (final int key)
  {
    int idx = MapHelper.phiMix (key) & m_nMask;
    if (m_aKeys[idx] == key)
    {
      // we check FREE prior to this call
      return idx;
    }
    if (m_aKeys[idx] == FREE_KEY)
    {
      // end of chain already
      return -1;
    }
    final int startIdx = idx;
    while ((idx = _getNextIndex (idx)) != startIdx)
    {
      if (m_aKeys[idx] == FREE_KEY)
        return -1;
      if (m_aKeys[idx] == key)
        return idx;
    }
    return -1;
  }
11232
public boolean get(long index) {
    if (!(index < size))
      throw new IndexOutOfBoundsException();
    return (bytes.readLong(offset(index)) & (1l << (position(index)))) != 0;
  }
1116786
public final M get(final int index)
    {
        if ((index >= 0) && (index < size()))
        {
            return m_jso.get(index);
        }
        return null;
    }
1245973
public final CharSequence[] getSelectedEntries() {
        List<Integer> indices = indicesOf(values);
        Collections.sort(indices);

        if (!indices.isEmpty()) {
            CharSequence[] selectedEntries = new CharSequence[indices.size()];
            int currentIndex = 0;

            for (int index : indices) {
                selectedEntries[currentIndex] = getEntries()[index];
                currentIndex++;
            }

            return selectedEntries;
        }

        return null;
    }
1123654
public SubscriptionIndex getSubscriptionIndex()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getSubscriptionIndex");
            SibTr.exit(tc, "getSubscriptionIndex", _subscriptionIndex);
        }
        return _subscriptionIndex;
    }
53137
public int read() throws java.io.IOException {
    checkClosed();
    try {
      if (limit > 0 && apos >= limit) {
        return -1;
      }
      if (buffer == null || bpos >= buffer.length) {
        buffer = lo.read(bsize);
        bpos = 0;
      }

      // Handle EOF
      if (bpos >= buffer.length) {
        return -1;
      }

      int ret = (buffer[bpos] & 0x7F);
      if ((buffer[bpos] & 0x80) == 0x80) {
        ret |= 0x80;
      }

      bpos++;
      apos++;

      return ret;
    } catch (SQLException se) {
      throw new IOException(se.toString());
    }
  }
154857
public TransactionGeomIndex getGeometryIndex() {
		if (index == null) {
			index = new TransactionGeomIndex();
			index.setExteriorRing(true);
			index.setGeometryIndex(0);
			index.setCoordinateIndex(0);
			index.setFeatureIndex(0);
		}
		return index;
	}
1243199
public XEvent get(int index) {
		try {
			XEvent event = events.get(index);
			return event;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}
164566
public List<ESIndice> getIndexes() throws ElasticSearchException{
		 String data = this.client.executeHttp("_cat/indices?v",HTTP_GET);
         logger.debug(data);

         if(SimpleStringUtil.isNotEmpty(data)){
			try {
				List<ESIndice> indices = extractIndice(data);
				 return indices;
			} catch (IOException e) {
				throw new ElasticSearchException(e);
			}
        	
         }
         return null;
	 }
183191
public String getNextIndex() {
        String newIndex;

        do {
            newIndex = "tsx" + String.valueOf(lastIndexIndex);
            lastIndexIndex++;
        }
        while (exists(newIndex) == true);

        addIndex(newIndex);

        return newIndex;
    }
744130
@Override
  public int read () throws IOException
  {
    _ensureOpen ();
    while (true)
    {
      if (m_nNextCharIndex >= m_nChars)
      {
        _fill ();
        if (m_nNextCharIndex >= m_nChars)
          return -1;
      }
      if (m_bSkipLF)
      {
        m_bSkipLF = false;
        if (m_aBuf[m_nNextCharIndex] == '\n')
        {
          m_nNextCharIndex++;
          continue;
        }
      }
      return m_aBuf[m_nNextCharIndex++];
    }
  }
422133
public int read() throws IOException {
    while (true) {
      lockR.lock();
      try {
        if (availableCount.get() > 0) {
          // as long as there is available data
          // serve it even if closed
          int b = bytes[readCursor] & 0xFF;
          incReadCursor(1);
          availableCount.decrementAndGet();
          totalRead++;
          return b;
        } else if (closed){
          // when no bytes are left and buffer is closed
          // return -1
          return -1;
        }
      } finally {
        lockR.unlock();
      }
      sleep(1);
    }
  }
198712
public IndexModel index() {
		checkReadOnly();
		IndexModel index = new IndexModel();
		index.setTableModel(this);
		getIndexConsts().add(index);
		return index;
	}
1102033
public long next() {
        try {
            ByteBufferUtil.readWithShortLength(input);

            final long offset = input.readLong();

            // TODO: Because this is version ic > ia promotedIndex is true and we need to handle it. See C* Descriptor
            skipPromotedIndex(input);

            return offset;
        } catch (IOException e) {
            throw new IOError(e);
        }
    }