str.h

Go to the documentation of this file.

// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef KEA_UTIL_STR_H
#define KEA_UTIL_STR_H
 
#include <exceptions/exceptions.h>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include <boost/lexical_cast.hpp>
 
namespace isc {
namespace util {
namespace str {
 
 
class StringTokenError : public Exception {
public:
    StringTokenError(const char* file, size_t line, const char* what)
        : isc::Exception(file, line, what) {
    }
};
 
std::string
trim(const std::string& input);
 
template <typename Iterator>
Iterator
seekTrimmed(Iterator const& begin, Iterator end, uint8_t const trim_val) {
    while (end != begin && *(end - 1) == trim_val) {
        --end;
    }
 
    return (end);
}
 
std::vector<std::string>
tokens(const std::string& text, const std::string& delim = " \t\n", bool escape = false);
 
char
toUpper(char const chr);
 
void
uppercase(std::string& text);
 
char
toLower(char const chr);
 
void
lowercase(std::string& text);
 
std::vector<uint8_t>
quotedStringToBinary(const std::string& quoted_string);
 
void
decodeSeparatedHexString(const std::string& hex_string,
                         const std::string& sep,
                         std::vector<uint8_t>& binary);
 
void
decodeColonSeparatedHexString(const std::string& hex_string, std::vector<uint8_t>& binary);
 
void
decodeFormattedHexString(const std::string& hex_string, std::vector<uint8_t>& binary);
 
class StringSanitizerImpl;
 
using StringSanitizerImplPtr = std::shared_ptr<StringSanitizerImpl>;
 
class StringSanitizer {
public:
    StringSanitizer(const std::string& char_set, const std::string& char_replacement);
 
    std::string scrub(const std::string& original);
 
    static const uint32_t MAX_DATA_SIZE;
 
private:
    StringSanitizerImplPtr impl_;
};
 
using StringSanitizerPtr = std::unique_ptr<StringSanitizer>;
 
bool
isPrintable(const std::string& content);
 
bool
isPrintable(const std::vector<uint8_t>& content);
 
std::string
dumpAsHex(const uint8_t* data, size_t length);
 
std::string dumpDouble(double val, size_t precision = 5);
 
}  // namespace str
}  // namespace util
}  // namespace isc
 
#endif  // KEA_UTIL_STR_H