org.osgl.util.SequenceBase Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of osgl-tool Show documentation
A simple Java toolkit
The newest version!
package org.osgl.util;

/*-
 * #%L
 * Java Tool
 * %%
 * Copyright (C) 2014 - 2017 OSGL (Open Source General Library)
 * %%
 * 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.
 * #L%
 */

import org.osgl.$;

import java.util.EnumSet;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * Provide default implementation to some {@link C.Sequence} interface.
 *
 * The most of the method of this implementation is lazy without
 * regarding to the {@link C.Feature#LAZY} setting of this
 * sequence instance
 */
public abstract class SequenceBase
extends TraversableBase implements C.Sequence {

    // utilities
    protected final boolean isLazy() {
        return is(C.Feature.LAZY);
    }

    protected final boolean isImmutable() {
        return is(C.Feature.IMMUTABLE);
    }

    protected final boolean isReadOnly() {
        return is(C.Feature.READONLY);
    }

    protected final boolean isMutable() {
        return !isImmutable() && !isReadOnly();
    }

    protected final boolean isLimited() {
        return is(C.Feature.LIMITED);
    }

    @Override
    public C.Sequence lazy() {
        return (C.Sequence)super.lazy();
    }

    @Override
    public C.Sequence eager() {
        return (C.Sequence)super.eager();
    }

    @Override
    public C.Sequence parallel() {
        return (C.Sequence)super.parallel();
    }

    @Override
    public C.Sequence sequential() {
        return (C.Sequence)super.sequential();
    }

    @Override
    protected EnumSet initFeatures() {
        return EnumSet.of(C.Feature.LAZY, C.Feature.READONLY);
    }

    @Override
    public C.List asList() {
        return C.list(this);
    }

    @Override
    public SequenceBase accept($.Visitor visitor) {
        C.forEach(this, visitor);
        return this;
    }

    @Override
    public SequenceBase forEach($.Visitor visitor) {
        return accept(visitor);
    }

    @Override
    public C.Sequence each($.Visitor visitor) {
        return accept(visitor);
    }

    protected void forEachLeft($.Visitor visitor) {
        forEach(visitor);
    }

    @Override
    public T first() throws NoSuchElementException {
        return iterator().next();
    }

    @Override
    public final T head() throws NoSuchElementException {
        return first();
    }

    @Override
    @SuppressWarnings("unchecked")
    public C.Sequence acceptLeft($.Visitor visitor) {
        forEachLeft(visitor);
        return this;
    }

    /**
     * Delegate to {@link TraversableBase#reduce(Object, org.osgl.Lang.Func2)}
     * @param identity {@inheritDoc}
     * @param accumulator {@inheritDoc}
     * @param  {@inheritDoc}
     * @return {@inheritDoc}
     */
    @Override
    public  R reduceLeft(R identity, $.Func2 accumulator) {
        return reduce(identity, accumulator);
    }

    /**
     * Delegate to {@link TraversableBase#reduce(org.osgl.Lang.Func2)}
     * @param accumulator {@inheritDoc}
     * @return {@inheritDoc}
     */
    @Override
    public $.Option reduceLeft($.Func2 accumulator) {
        return reduce(accumulator);
    }

    /**
     * Delegate to {@link TraversableBase#findOne(org.osgl.Lang.Function)}
     * @param predicate the function map the element to Boolean
     * @return {@inheritDoc}
     */
    @Override
    public $.Option findFirst($.Function predicate) {
        return findOne(predicate);
    }

    @Override
    public C.Sequence head(int n) {
        if (n == 0) {
            return Nil.seq();
        } else if (n < 0) {
            if (isLimited()) {
                return drop(size() + n);
            } else {
                throw new UnsupportedOperationException();
            }
        } else {
            if (isLimited() && n >= size()) {
                return this;
            }
            return IndexFilteredSeq.of(this, $.F.lessThan(n));
        }
    }

    @Override
    public C.Sequence tail() throws UnsupportedOperationException {
        return IndexFilteredSeq.of(this, $.F.greaterThan(0));
    }

    @Override
    public C.Sequence take(int n) {
        return head(n);
    }

    @Override
    public C.Sequence takeWhile($.Function predicate) {
        return FilteredSeq.of(this, predicate, FilteredIterator.Type.WHILE);
    }

    @Override
    public C.Sequence drop(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IndexOutOfBoundsException();
        }
        if (n == 0) {
            return this;
        }
        return IndexFilteredSeq.of(this, $.F.gte(n));
    }

    @Override
    public C.Sequence dropWhile($.Function predicate) {
        return FilteredSeq.of(this, $.F.negate(predicate), FilteredIterator.Type.UNTIL);
    }

    @Override
    public C.Sequence append(Iterable iterable) {
        return append(C.seq(iterable));
    }

    @Override
    public C.Sequence append(C.Sequence seq) {
        if (seq.isEmpty()) {
            return this;
        }
        return CompositeSeq.of(this, seq);
    }

    @Override
    public C.Sequence append(Iterator iterator) {
        if (!iterator.hasNext()) {
            return this;
        }
        return CompositeSeq.of(this, C.seq(iterator));
    }

    @Override
    public C.Sequence append(Enumeration enumeration) {
        if (!enumeration.hasMoreElements()) {
            return this;
        }
        return CompositeSeq.of(this, C.seq(enumeration));
    }

    @Override
    public C.Sequence append(T t) {
        return CompositeSeq.of(this, $.val(t));
    }

    @Override
    public C.Sequence prepend(Iterable iterable) {
        if (!iterable.iterator().hasNext()) {
            return this;
        }
        return prepend(C.seq(iterable));
    }

    @Override
    public C.Sequence prepend(Iterator iterator) {
        if (!iterator.hasNext()) {
            return this;
        }
        return prepend(C.seq(iterator));
    }

    @Override
    public C.Sequence prepend(Enumeration enumeration) {
        if (!enumeration.hasMoreElements()) {
            return this;
        }
        return prepend(C.seq(enumeration));
    }

    @Override
    public C.Sequence prepend(C.Sequence seq) {
        if (seq.isEmpty()) {
            return this;
        }
        C.Sequence casted = $.cast(seq);
        return casted.append(this);
    }

    @Override
    public C.Sequence prepend(T t) {
        return CompositeSeq.of(C.singletonList(t), this);
    }

    @Override
    public C.Sequence filter($.Function predicate) {
        return FilteredSeq.of(this, predicate);
    }

    @Override
    public  C.Sequence map($.Function mapper) {
        return MappedSeq.of(this, mapper);
    }

    @Override
    public  C.Sequence flatMap($.Function> mapper
    ) {
        return FlatMappedSeq.of(this, mapper);
    }

    @Override
    public  C.Sequence collect(String path) {
        return CollectorSeq.of(this, path);
    }

    @Override
    public  C.Sequence<$.Binary> zip(Iterable iterable) {
        return new ZippedSeq(this, iterable);
    }

    @Override
    public  C.Sequence<$.Binary> zipAll(Iterable iterable, T def1, T2 def2) {
        return new ZippedSeq<>(this, iterable, def1, def2);
    }

    @Override
    public C.Sequence<$.Binary> zipWithIndex() {
        return new ZippedSeq<>(this, new IndexIterable(this));
    }

    @Override
    public int count(T t) {
        return count(this, t);
    }

    public static  int count(C.Sequence sequence, T element) {
        int n = 0;
        for (T t : sequence) {
            if ($.eq(t, element)) {
                n++;
            }
        }
        return n;
    }
}