com.epam.deltix.util.collections.ChainedIterator Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of timebase-collections Show documentation
Timebase Common utilities and collections
The newest version!
/*
 * Copyright 2021 EPAM Systems, Inc
 *
 * See the NOTICE file distributed with this work for additional information
 * regarding copyright ownership. Licensed 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 com.epam.deltix.util.collections;

import java.util.Iterator;

/**
 *  Chains several iterators into one.
 */
public class ChainedIterator  implements Iterator  {
    private final Iterator >     metaIterator;
    private boolean                                     firstTime = true;
    private Iterator                       nextIter = null;
    private Iterator                       lastIter = null;

    public ChainedIterator (Iterator > metaIterator) {
        this.metaIterator = metaIterator;
    }

    @SafeVarargs
    public ChainedIterator (Iterator  ... chain) {
        this (new ArrayIterator <> (chain));
    }
    
    @SafeVarargs @SuppressWarnings ("unchecked")
    public ChainedIterator (Iterable  ... chain) {
        this (new IterableToIteratorTransformer (new ArrayIterator <> (chain)));
    }
    
    @Override
    public boolean                              hasNext () {
        if (firstTime) {
            firstTime = false;
            
            do {
                if (!metaIterator.hasNext ()) {
                    nextIter = null;
                    break;
                }
                                    
                nextIter = metaIterator.next ();                                
            } while (!nextIter.hasNext ());
        }
        
        return (nextIter != null);
    }

    @Override
    public T                                    next () {
        lastIter = nextIter;
        
        T                       ret = nextIter.next ();
        
        while (!nextIter.hasNext ()) {
            if (!metaIterator.hasNext ()) {
                nextIter = null;
                break;
            }
            
            nextIter = metaIterator.next ();            
        }
        
        return (ret);
    }

    @Override
    public void                                 remove () {
        if (lastIter == null)
            throw new IllegalStateException ("next () was not called");
        
        lastIter.remove ();
    }        
}