Algorithms.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_SBUF_ALGORITHMS_H
#define SQUID_SRC_SBUF_ALGORITHMS_H
 
#include "sbuf/SBuf.h"
 
#include <algorithm>
#include <numeric>
 
class SBufEqual
{
public:
    explicit SBufEqual(const SBuf &reference, SBufCaseSensitive sensitivity = caseSensitive) :
        reference_(reference), sensitivity_(sensitivity) {}
    bool operator() (const SBuf & checking) { return checking.compare(reference_,sensitivity_) == 0; }
private:
    SBuf reference_;
    SBufCaseSensitive sensitivity_;
};
 
class SBufStartsWith
{
public:
    explicit SBufStartsWith(const SBuf &prefix, SBufCaseSensitive sensitivity = caseSensitive) :
        prefix_(prefix), sensitivity_(sensitivity) {}
    bool operator() (const SBuf & checking) { return checking.startsWith(prefix_,sensitivity_); }
private:
    SBuf prefix_;
    SBufCaseSensitive sensitivity_;
};
 
class SBufAddLength
{
public:
    explicit SBufAddLength(const SBuf &separator) :
        separatorLen_(separator.length()) {}
    SBuf::size_type operator()(const SBuf::size_type sz, const SBuf & item) {
        return sz + item.length() + separatorLen_;
    }
private:
    SBuf::size_type separatorLen_;
};
 
template <class ContainerIterator>
SBuf&
JoinContainerIntoSBuf(SBuf &dest, const ContainerIterator &begin,
                      const ContainerIterator &end, const SBuf& separator,
                      const SBuf& prefix = SBuf(), const SBuf& suffix = SBuf())
{
    if (begin == end) {
        dest.append(prefix).append(suffix);
        return dest;
    }
 
    // optimization: pre-calculate needed storage
    const SBuf::size_type totalContainerSize =
        std::accumulate(begin, end, 0, SBufAddLength(separator)) +
        dest.length() + prefix.length() + suffix.length();
    SBufReservationRequirements req;
    req.minSpace = totalContainerSize;
    dest.reserve(req);
 
    auto i = begin;
    dest.append(prefix);
    dest.append(*i);
    ++i;
    for (; i != end; ++i)
        dest.append(separator).append(*i);
    dest.append(suffix);
    return dest;
}
 
template <class ContainerIterator>
SBuf
JoinContainerToSBuf(const ContainerIterator &begin,
                    const ContainerIterator &end, const SBuf& separator,
                    const SBuf& prefix = SBuf(), const SBuf& suffix = SBuf())
{
    SBuf rv;
    return JoinContainerIntoSBuf(rv, begin, end, separator, prefix, suffix);
}
 
namespace std {
template <>
struct hash<SBuf>
{
    size_t operator()(const SBuf &) const noexcept;
};
}
 
class CaseInsensitiveSBufHash
{
public:
    std::size_t operator()(const SBuf &) const noexcept;
};
 
class CaseInsensitiveSBufEqual
{
public:
    bool operator()(const SBuf &lhs, const SBuf &rhs) const
    {
        // Optimization: Do not iterate strings of different lengths.
        return lhs.length() == rhs.length() && (lhs.compare(rhs, caseInsensitive) == 0);
    }
};
 
#endif /* SQUID_SRC_SBUF_ALGORITHMS_H */