Java Code Examples for java.util.NoSuchElementException

@Override public Row next(){
  hasNext();
  final Row returnRow=row;
  row=null;
  if (returnRow == null) {
    throw new NoSuchElementException();
  }
  return returnRow;
}
 

/** 
 * Removes and returns the first element from this list.
 * @return the first element from this list.
 * @throws NoSuchElementException if this list is empty.
 */
public long removeFirst(){
  if (isEmpty()) {
    throw new NoSuchElementException();
  }
  Sequence rc=removeFirstSequence(1);
  return rc.first;
}
 

private ObjectName assertExists(ObjectName name){
  try {
    if (!server.queryNames(name,null).isEmpty()) {
      return name;
    }
  }
 catch (  IOException handled) {
  }
  throw new NoSuchElementException("No MBeans matching " + name);
}
 

@Override public Money next(){
  if (!hasNext()) {
    throw new NoSuchElementException("getEqualizedIterator");
  }
  return new Money(splitAmountCalculator.nextAmount(currentIndex++),inputMoney.getCurrency(),inputMoney.getRoundingMode());
}
 

@SuppressWarnings("unchecked") public E pop(){
  if (size <= 0) {
    throw new NoSuchElementException();
  }
  return (E)elements[--size];
}
 

@Override public BindingSet next() throws QueryEvaluationException {
  if (hasNext()) {
    BindingSet curr=next;
    next=null;
    return curr;
  }
 else   if (closed) {
    throw new RuntimeException("closed");
  }
 else {
    throw new NoSuchElementException();
  }
}
 

@Override public Class<?> next(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  Class<?> localClass=currentClass;
  currentClass=null;
  return localClass;
}
 

public HeaderElement nextElement() throws NoSuchElementException {
  if (this.currentElement == null) {
    parseNextElement();
  }
  if (this.currentElement == null) {
    throw new NoSuchElementException("No more header elements available");
  }
  HeaderElement element=this.currentElement;
  this.currentElement=null;
  return element;
}
 

/** 
 * Returns the element at the beginning of this list.
 */
public Object getFirst(){
  try {
    return _head.next().value();
  }
 catch (  NullPointerException e) {
    throw new NoSuchElementException();
  }
}
 

/** 
 * Return the next calendar in the iteration
 * @return Object calendar for the next date
 */
public Calendar next(){
  if (spot.equals(endFinal)) {
    throw new NoSuchElementException();
  }
  spot.add(Calendar.DATE,1);
  return (Calendar)spot.clone();
}
 

private static int indexOf(Object[] array,Object toFind){
  for (int i=0; i < array.length; i++) {
    if (toFind.equals(array[i])) {
      return i;
    }
  }
  throw new NoSuchElementException();
}
 

public final T next(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  state=State.NOT_READY;
  return next;
}
 

public PhoneNumberMatch next(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  PhoneNumberMatch result=lastMatch;
  lastMatch=null;
  state=State.NOT_READY;
  return result;
}
 

public E next(){
  if (cachedNext == null) {
    if (!hasNext()) {
      throw new NoSuchElementException("Call hasNext!");
    }
  }
  E tmp=cachedNext;
  cachedNext=null;
  return tmp;
}
 

@Override public T next(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  if (index == -1) {
    ++index;
    return first;
  }
  return others[offset + (index++)];
}
 

public static Vclock valueOf(Key key,Context context) throws IOException {
  Header clientId=context.removeHeader(Constants.CLIENT_ID);
  if (clientId == null) {
    throw new NoSuchElementException(Constants.CLIENT_ID);
  }
  return getOrCreate(key,context).update(clientId.getValue());
}
 

@Override public T next(){
  if (hasNext()) {
    return get(index++);
  }
 else {
    throw new NoSuchElementException();
  }
}
 

public E next(){
  if (hasNext()) {
    E result=next;
    next=null;
    return result;
  }
 else {
    throw new NoSuchElementException();
  }
}
 

public LinkedListTree next(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  index++;
  return (LinkedListTree)parent.getChild(index);
}
 

/** 
 * Moves to the next panel. I.e. increment its index, need not actually change any GUI itself.
 */
@Override public void nextPanel(){
  if (!hasNext()) {
    throw new NoSuchElementException();
  }
  index++;
}
 

/** 
 * Read the next datum from the file.
 * @param reuse an instance to reuse.
 * @throws NoSuchElementException if no more remain in the file.
 */
public D next(D reuse) throws IOException {
  if (!hasNext())   throw new NoSuchElementException();
  D result=reader.read(reuse,datumIn);
  if (0 == --blockRemaining) {
    blockFinished();
  }
  return result;
}
 

@Override public T getSingle(){
  if (length == 1 && hasNext()) {
    return next();
  }
  throw new NoSuchElementException();
}
 

public E first(){
synchronized (lock) {
    if (storage.isEmpty()) {
      throw new NoSuchElementException();
    }
 else {
      return storage.get(0);
    }
  }
}
 

public final E next(){
  Node p=nextNode;
  if (p == null)   throw new NoSuchElementException();
  E e=nextItem;
  advance(p);
  return e;
}
 

public StackOverflowPost next(){
  if (hasNext()) {
    nextQueued=false;
    return post;
  }
 else {
    throw new NoSuchElementException();
  }
}
 

public T next() throws NoSuchElementException {
  if (hasNext()) {
    return this.array[this.pos++];
  }
 else {
    throw new NoSuchElementException();
  }
}
 

public E first(){
synchronized (lock) {
    if (storage.isEmpty()) {
      throw new NoSuchElementException();
    }
 else {
      return storage.get(0);
    }
  }
}
 

public static String firstNonEmpty(String... strings){
  for (  String s : strings) {
    if (!isEmpty(s)) {
      return s;
    }
  }
  throw new NoSuchElementException();
}
 

public String next(){
  String next=packageName;
  int pos=packageName.lastIndexOf('.');
  if (pos == -1) {
    throw new NoSuchElementException();
  }
  packageName=packageName.substring(0,pos);
  return next;
}
 

public Object next(){
  if (currentKey == null && !hasNext())   throw new NoSuchElementException();
  Object result=returnValueOfNext();
  lastReturned=entry;
  currentKey=currentValue=null;
  entry=entry.next;
  return result;
}
 

/** 
 * {@inheritDoc} 
 */
public Entry next(){
  int index=next.getIndex();
  if (index < 0) {
    throw new NoSuchElementException();
  }
  current.setIndex(index);
  advance(next);
  return current;
}
 

private JavaType getRecursiveClirrType(String className,JavaType[] typeSet){
  for (  JavaType jt : types) {
    if (jt.getName().equals(className)) {
      return jt;
    }
    return getRecursiveClirrType(className,jt.getInnerClasses());
  }
  throw new NoSuchElementException("No class named '" + className + "' could be found.");
}
 

public T next() throws NoSuchElementException {
  if (seq == null)   throw new NoSuchElementException();
  T ret=(T)RT.first(seq);
  seq=RT.next(seq);
  return ret;
}
 

public Object next() throws NoSuchElementException {
  if (seq == null)   throw new NoSuchElementException();
  Object ret=RT.first(seq);
  seq=RT.next(seq);
  return ret;
}
 

final Entry nextEntry(){
  if (modCount != expectedModCount)   throw new ConcurrentModificationException();
  Entry e=next;
  if (e == null)   throw new NoSuchElementException();
  if ((next=e.next) == null) {
    Entry[] t=table;
    while (index < t.length && (next=t[index++]) == null)     ;
  }
  current=e;
  return e;
}
 

public InputStream nextElement(){
  InputStream in=null;
  if (!hasMoreElements()) {
    throw new NoSuchElementException("No more files.");
  }
 else {
    String nextElement=m_listOfFiles[m_current++];
    try {
      in=new FileInputStream(nextElement);
    }
 catch (    FileNotFoundException e) {
      System.err.println("ListOfFiles: Can't open " + nextElement);
    }
  }
  return in;
}
 

/** 
 * Returns the next token from this string tokenizer. <p> The current position is set after the token returned.
 * @return the next token from this string tokenizer.
 * @throws NoSuchElementException if there are no more tokens in this tokenizer's string.
 * @since ostermillerutils 1.00.00
 */
public String nextToken(){
  int workingPosition=position;
  boolean workingEmptyReturned=emptyReturned;
  boolean onToken=advancePosition();
  while (position != workingPosition || emptyReturned != workingEmptyReturned) {
    if (onToken) {
      tokenCount--;
      return (emptyReturned ? "" : text.substring(workingPosition,(position != -1) ? position : strLength));
    }
    workingPosition=position;
    workingEmptyReturned=emptyReturned;
    onToken=advancePosition();
  }
  throw new NoSuchElementException();
}
 

/** 
 * Create a IOIO instance. This specific implementation creates a IOIO instance which works with the actual IOIO board connected via a TCP connection (typically over a wired USB connection).
 * @return The IOIO instance.
 */
public static IOIO create(){
  Collection<IOIOConnectionFactory> factories=IOIOConnectionRegistry.getConnectionFactories();
  try {
    return create(factories.iterator().next().createConnection());
  }
 catch (  NoSuchElementException e) {
    Log.e(TAG,"No connection is available. This shouldn't happen.");
    throw e;
  }
}
 

@Test public void testNext(){
  for (  String v : source) {
    assertEquals(v,ci.next());
  }
  try {
    ci.next();
    fail("Failed to get NoSuchElementException");
  }
 catch (  NoSuchElementException e) {
  }
catch (  Exception e) {
    fail("Failed to get NoSuchElementException");
  }
}
 

public static SmartPoster parse(NdefRecord[] recordsRaw){
  try {
    Iterable<ParsedNdefRecord> records=NdefMessageParser.getRecords(recordsRaw);
    UriRecord uri=Iterables.getOnlyElement(Iterables.filter(records,UriRecord.class));
    TextRecord title=getFirstIfExists(records,TextRecord.class);
    ImageRecord image=getFirstIfExists(records,ImageRecord.class);
    RecommendedAction action=parseRecommendedAction(recordsRaw);
    String type=parseType(recordsRaw);
    return new SmartPoster(uri,title,image,action,type);
  }
 catch (  NoSuchElementException e) {
    throw new IllegalArgumentException(e);
  }
}
 

public String readLine() throws IOException {
  String line;
  try {
    line=scanner.next();
  }
 catch (  IllegalStateException e) {
    if (scanner.ioException() != null) {
      throw scanner.ioException();
    }
 else {
      throw new IOException("No more lines available: " + e.getMessage());
    }
  }
catch (  NoSuchElementException e) {
    if (scanner.ioException() != null) {
      throw scanner.ioException();
    }
 else {
      throw new IOException("No more lines available: " + e.getMessage());
    }
  }
  if (trace != null) {
    trace.received(line);
  }
  return line;
}
 

@Override public void addSample(long sample){
  if (!latencies.offer(sample)) {
    try {
      latencies.remove();
    }
 catch (    NoSuchElementException e) {
    }
    latencies.offer(sample);
  }
}
 

/** 
 * {@link CalendarDate}???????????????????????????@link CalendarDate}????° ???????????@link CalendarDate}????????????????? <p>????°?????????????????????????????????????????????????????????????????? ???????????????  {@link Iterator#next()} ?????????????????</p>
 * @param calendarDays ??????????
 * @return ????????????????
 * @throws IllegalArgumentException ?????@code null}?????????
 * @since 1.0
 */
public Iterator<CalendarDate> businessDaysOnly(final Iterator<CalendarDate> calendarDays){
  Validate.notNull(calendarDays);
  return new ImmutableIterator<CalendarDate>(){
    CalendarDate lookAhead=null;
{
      lookAhead=nextBusinessDate();
    }
    @Override public boolean hasNext(){
      return lookAhead != null;
    }
    @Override public CalendarDate next(){
      if (hasNext() == false) {
        throw new NoSuchElementException();
      }
      CalendarDate next=lookAhead;
      lookAhead=nextBusinessDate();
      return next;
    }
    private CalendarDate nextBusinessDate(){
      CalendarDate result=null;
      do {
        result=calendarDays.hasNext() ? (CalendarDate)calendarDays.next() : null;
      }
 while ((result == null || isBusinessDay(result)) == false);
      return result;
    }
  }
;
}
 

public synchronized boolean connect(String target){
  disconnect();
  try {
    receiveSocket=new Socket();
    receiveSocket.setSoTimeout(5000);
    receiveSocket.connect(new InetSocketAddress(target,TaskServer.PORT));
    InputStream inStream=receiveSocket.getInputStream();
    Scanner inScanner=new Scanner(inStream);
    String line=inScanner.nextLine().trim();
    if ("None".equals(line)) {
      receiveSocket.close();
      receiveSocket=null;
      return false;
    }
    if (line.matches("^Lines\\s+[0-9]+$")) {
      int lineCount=Integer.parseInt(line.split("\\s+")[1]);
      String inLines="";
      for (int i=0; i < lineCount; i++) {
        inLines+=inScanner.nextLine().replaceAll("[\n\r]","") + "\n";
      }
      connectionParameters=new TaskParameters(inLines);
      socketOutStream=receiveSocket.getOutputStream();
      return true;
    }
    return false;
  }
 catch (  NoSuchElementException e) {
    e.printStackTrace();
  }
catch (  IOException e) {
    e.printStackTrace();
  }
  disconnect();
  return false;
}
 

public static void purgeAction(TransactionImpl act,Thread t,boolean unregister) throws NoSuchElementException {
  if ((act != null) && (unregister)) {
    act.removeChildThread(ThreadUtil.getThreadId(t));
  }
  Stack txs=(Stack)_threadList.get();
  if (txs != null) {
    txs.removeElement(act);
    if (txs.size() == 0) {
      _threadList.set(null);
    }
  }
}
 

@Override @SuppressWarnings({"unchecked","rawtypes"}) public Enumeration getParameterNames(){
  final Enumeration<String> requestParamNames=super.getParameterNames();
  return new Enumeration<String>(){
    final Iterator<String> matchResultParamNames=new ArrayList<String>(parameters.keySet()).iterator();
    @Override public boolean hasMoreElements(){
      return matchResultParamNames.hasNext() || requestParamNames.hasMoreElements();
    }
    @Override public String nextElement(){
      if (matchResultParamNames.hasNext()) {
        return matchResultParamNames.next();
      }
      if (requestParamNames.hasMoreElements()) {
        return requestParamNames.nextElement();
      }
      throw new NoSuchElementException();
    }
  }
;
}
 

/** 
 * Create a new VersionImpl.
 * @param version the version as a string
 * @throws IllegalArgumentException for a null version or invalid format
 */
private Version(String version){
  if (version == null)   throw new IllegalArgumentException("Null version");
  int major;
  int minor=0;
  int micro=0;
  String qualifier="";
  try {
    StringTokenizer st=new StringTokenizer(version,SEPARATOR,true);
    major=Integer.parseInt(st.nextToken().trim());
    if (st.hasMoreTokens()) {
      st.nextToken();
      minor=Integer.parseInt(st.nextToken().trim());
      if (st.hasMoreTokens()) {
        st.nextToken();
        micro=Integer.parseInt(st.nextToken().trim());
        if (st.hasMoreTokens()) {
          st.nextToken();
          qualifier=st.nextToken().trim();
          if (st.hasMoreTokens()) {
            throw new IllegalArgumentException("Invalid version format, too many seperators: " + version);
          }
        }
      }
    }
  }
 catch (  NoSuchElementException e) {
    throw new IllegalArgumentException("Invalid version format: " + version);
  }
catch (  NumberFormatException e) {
    throw new IllegalArgumentException("Invalid version format: " + version,e);
  }
  this.major=major;
  this.minor=minor;
  this.micro=micro;
  this.qualifier=qualifier;
  validate();
}
 

/** 
 * Convert a space delimited color tuple string to a color. <p> Converts a string value like "255 255 0" to a color constant, in this case, yellow.
 * @param key the name of the property
 * @return a Color object equivalent to the provided string contents. Returns white if the string is null or can't be converted.
 */
public static Color getColorProperty(Properties properties,Object key){
  String string=(String)properties.get(key);
  if (string == null) {
    System.err.println("WARN: couldn't find color tuplet under '" + key + "'");
    return Color.white;
  }
  StringTokenizer st=new StringTokenizer(string," ");
  Color c;
  try {
    c=new Color(Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()));
  }
 catch (  NoSuchElementException e) {
    c=Color.white;
    System.err.println("WARN: invalid color spec '" + string + "' in property file");
  }
  return c;
}
 

public Iterator<Tuple> createIterator(final IndexTuple current,final Iterator<IndexTuple> values){
  return new Iterator<Tuple>(){
    IndexTuple value=current;
    @Override public boolean hasNext(){
      return value != null;
    }
    @Override public Tuple next(){
      if (value == null && !values.hasNext())       throw new NoSuchElementException();
      Tuple result=value.getTuple();
      if (values.hasNext())       value=(IndexTuple)values.next();
 else       value=null;
      return result;
    }
    @Override public void remove(){
    }
  }
;
}
 

/** 
 * Create a new VersionImpl.
 * @param version the version as a string
 * @throws IllegalArgumentException for a null version or invalid format
 */
private ModuleVersion(String version){
  if (version == null)   throw new IllegalArgumentException("Null version");
  int major;
  int minor=0;
  int micro=0;
  String qualifier="";
  try {
    StringTokenizer st=new StringTokenizer(version,SEPARATOR,true);
    major=Integer.parseInt(st.nextToken().trim());
    if (st.hasMoreTokens()) {
      st.nextToken();
      minor=Integer.parseInt(st.nextToken().trim());
      if (st.hasMoreTokens()) {
        st.nextToken();
        micro=Integer.parseInt(st.nextToken().trim());
        if (st.hasMoreTokens()) {
          st.nextToken();
          qualifier=st.nextToken().trim();
          if (st.hasMoreTokens()) {
            throw new IllegalArgumentException("Invalid version format, too many seperators: " + version);
          }
        }
      }
    }
  }
 catch (  NoSuchElementException e) {
    throw new IllegalArgumentException("Invalid version format: " + version);
  }
catch (  NumberFormatException e) {
    throw new IllegalArgumentException("Invalid version format: " + version,e);
  }
  this.major=major;
  this.minor=minor;
  this.micro=micro;
  this.qualifier=qualifier;
  validate();
}
 

public void testSocketTee() throws Exception {
  Configuration conf=new Configuration();
  conf.set("chukwaCollector.pipeline",SocketTeeWriter.class.getCanonicalName());
  conf.set("chukwaCollector.writerClass",PipelineStageWriter.class.getCanonicalName());
  PipelineStageWriter psw=new PipelineStageWriter();
  psw.init(conf);
  SocketDataLoader sdl=new SocketDataLoader("all");
  System.out.println("pipeline established; now pushing a chunk");
  ArrayList<Chunk> l=new ArrayList<Chunk>();
  l.add(new ChunkImpl("dt","name",1,new byte[]{'a'},null));
  psw.add(l);
  try {
    Collection<Chunk> clist=sdl.read();
    for (    Chunk c : clist) {
      if (c != null && c.getData() != null) {
        assertTrue("a".equals(new String(c.getData())));
      }
    }
  }
 catch (  NoSuchElementException e) {
  }
}
 

public boolean reschedule(Algorithm algorithm,Calendar newTime){
  ServiceReference reference=this.algorithmSchedulerTask.getServiceReference(algorithm);
  boolean canReschedule=false;
  try {
    AlgorithmState algorithmState=this.algorithmSchedulerTask.getAlgorithmState(algorithm);
    if (algorithmState.equals(AlgorithmState.RUNNING)) {
      canReschedule=false;
    }
 else     if (algorithmState.equals(AlgorithmState.STOPPED)) {
      this.algorithmSchedulerTask.purgeFinished();
      this.algorithmSchedulerTask.schedule(algorithm,reference,newTime);
      canReschedule=true;
    }
 else     if (algorithmState.equals(AlgorithmState.NEW)) {
      this.algorithmSchedulerTask.cancel(algorithm);
      this.algorithmSchedulerTask.schedule(algorithm,reference,newTime);
    }
 else {
      throw new IllegalStateException("Encountered an invalid state: " + algorithmState);
    }
  }
 catch (  NoSuchElementException e) {
    this.algorithmSchedulerTask.schedule(algorithm,reference,newTime);
    canReschedule=true;
  }
  return canReschedule;
}