commonMain.jetbrains.datalore.base.gcommon.collect.Ordering.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of lets-plot-common Show documentation

Lets-Plot JVM package without rendering part

There is a newer version: 4.5.3-alpha1

/*
 * Copyright (c) 2019 JetBrains s.r.o.
 * Use of this source code is governed by the MIT license that can be found in the LICENSE file.
 *
 * This file has been modified by JetBrains : Java code has been converted to Kotlin code.
 *
 * THE FOLLOWING IS THE COPYRIGHT OF THE ORIGINAL DOCUMENT:
 *
 * Copyright (C) 2007 The Guava Authors
 *
 * 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
 *
 * https://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 jetbrains.datalore.base.gcommon.collect

abstract class Ordering : Comparator {

    fun isOrdered(iterable: Iterable): Boolean {
        val it = iterable.iterator()
        if (it.hasNext()) {
            var prev: T = it.next()
            while (it.hasNext()) {
                val next = it.next()
                if (compare(prev, next) > 0) {
                    return false
                }
                prev = next
            }
        }
        return true
    }

    /**
     * @return immutable sorted list
     */
    fun  sortedCopy(elements: Iterable): List {
        return elements.sortedWith(object : Comparator {
            override fun compare(a: E, b: E): Int {
                return [email protected](a, b)
            }
        })
    }

    fun reverse(): Ordering {
        return ComparatorOrdering(reversed())
    }

    fun  min(a: E, b: E): E {
        return if (compare(a, b) <= 0) a else b
    }

    fun  min(iterable: Iterable): E {
        return min(iterable.iterator())
    }

    fun  min(iterator: Iterator): E {
        // input must not be empty
        var result = iterator.next()
        while (iterator.hasNext()) {
            result = min(result, iterator.next())
        }

        return result
    }


    fun  max(a: E, b: E): E {
        return if (compare(a, b) >= 0) a else b
    }

    fun  max(iterable: Iterable): E {
        return max(iterable.iterator())
    }

    fun  max(iterator: Iterator): E {
        // input must not be empty
        var result = iterator.next()
        while (iterator.hasNext()) {
            result = max(result, iterator.next())
        }

        return result
    }

    companion object {

        fun  from(comparator: Comparator): Ordering {
            return if (comparator is Ordering<*>)
                comparator as Ordering
            else
                ComparatorOrdering(comparator)
        }

        fun > natural(): Ordering {
            return ComparatorOrdering(naturalOrder())
        }
    }

}