Algorithm.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <algorithm>
#include <iterator>
 
namespace CeresEngine {
 
    template<typename Container, typename Value> void erase(Container& container, const Value& value) {
        container.erase(std::remove(container.begin(), container.end(), value), container.end());
    }
 
    template<typename Container, typename Predicate> void eraseIf(Container& container, Predicate&& predicate) {
        container.erase(std::remove_if(container.begin(), container.end(), predicate), container.end());
    }
 
    template<typename Container> void eraseDuplicates(Container& container) {
        container.erase(std::unique(container.begin(), container.end()), container.end());
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Container, typename Value> decltype(std::declval<Container>().begin()) findContainer(Container& container, const Value& value) {
        return std::find(container.begin(), container.end(), value);
    }
 
    template<typename Container, typename Predicate> decltype(std::declval<Container>().begin()) findIf(Container& container, Predicate&& predicate) {
        return std::find_if(container.begin(), container.end(), predicate);
    }
 
    template<typename Container, typename Predicate> decltype(std::declval<Container>().begin()) findIfNot(Container& container, Predicate&& predicate) {
        return std::find_if_not(container.begin(), container.end(), predicate);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Container> void sort(Container& container) { std::sort(container.begin(), container.end()); }
 
    template<typename Container, typename Compare> void sort(Container& container, Compare&& compare) {
        std::sort(container.begin(), container.end(), compare);
    }
 
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Container, typename Transformation> void transformInPlace(Container& container, Transformation&& transformation) {
        std::transform(container.begin(), container.end(), container.begin(), transformation);
    }
 
    template<typename InContainer, typename OutContainer, typename Transformation>
    void transformTo(const InContainer& inContainer, OutContainer& outContainer, Transformation&& transformation) {
        std::transform(inContainer.begin(), inContainer.end(), std::inserter(outContainer, outContainer.end()), transformation);
    }
 
    template<typename Container, typename Transformation>
    Vector<decltype(std::declval<Transformation>()(*std::declval<Container>().begin()))> transformTo(const Container& container, Transformation&& transformation) {
        Vector<decltype(transformation(*container.begin()))> output;
        std::transform(container.begin(), container.end(), std::back_inserter(output), transformation);
        return output;
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Container, typename Range> Container toContainer(Range& range) { return Container(range.begin(), range.end()); }
 
    template<typename Container, typename Range> Container toContainer(const Range& range) { return Container(range.begin(), range.end()); }
 
} // namespace CeresEngine