strutil.h

Go to the documentation of this file.

// Copyright (C) 2011-2022 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 STRUTIL_H
#define STRUTIL_H
 
#include <algorithm>
#include <cctype>
#include <stdint.h>
#include <string>
#include <iomanip>
#include <sstream>
#include <vector>
#include <exceptions/exceptions.h>
#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.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) {}
};
 
void normalizeSlash(std::string& name);
 
std::string trim(const std::string& instring);
 
template<typename Iterator>
Iterator
seekTrimmed(Iterator begin, Iterator end, uint8_t trim_val) {
    for ( ; end != begin && *(end - 1) == trim_val; --end);
    return(end);
}
 
std::vector<std::string> tokens(const std::string& text,
        const std::string& delim = std::string(" \t\n"),
        bool escape = false);
 
inline char toUpper(char chr) {
    return (static_cast<char>(std::toupper(static_cast<int>(chr))));
}
 
inline void uppercase(std::string& text) {
    std::transform(text.begin(), text.end(), text.begin(),
        isc::util::str::toUpper);
}
 
inline char toLower(char chr) {
    return (static_cast<char>(std::tolower(static_cast<int>(chr))));
}
 
inline void lowercase(std::string& text) {
    std::transform(text.begin(), text.end(), text.begin(),
        isc::util::str::toLower);
}
 
std::string format(const std::string& format,
    const std::vector<std::string>& args);
 
 
std::string getToken(std::istringstream& iss);
 
template <typename NumType, int BitSize>
NumType
tokenToNum(const std::string& num_token) {
    NumType num;
    try {
        num = boost::lexical_cast<NumType>(num_token);
    } catch (const boost::bad_lexical_cast&) {
        isc_throw(StringTokenError, "Invalid SRV numeric parameter: " <<
                  num_token);
    }
    if (num < 0 || num >= (static_cast<NumType>(1) << BitSize)) {
        isc_throw(StringTokenError, "Numeric SRV parameter out of range: " <<
                  num);
    }
    return (num);
}
 
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;
 
typedef boost::shared_ptr<StringSanitizerImpl> StringSanitizerImplPtr;
 
class StringSanitizer {
public:
 
    StringSanitizer(const std::string& char_set,
                    const std::string& char_replacement);
 
    ~StringSanitizer();
 
    std::string scrub(const std::string& original);
 
    static const uint32_t MAX_DATA_SIZE;
 
private:
    StringSanitizerImplPtr impl_;
};
 
typedef boost::shared_ptr<StringSanitizer> StringSanitizerPtr;
 
inline bool
isPrintable(const std::string& content) {
    for (const auto& ch : content) {
        if (isprint(static_cast<int>(ch)) == 0) {
            return (false);
        }
    }
    return (true);
}
 
inline bool
isPrintable(const std::vector<uint8_t>& content) {
    for (const auto& ch : content) {
        if (isprint(static_cast<int>(ch)) == 0) {
            return (false);
        }
    }
    return (true);
}
 
 
std::string dumpAsHex(const uint8_t* data, size_t length);
 
} // namespace str
} // namespace util
} // namespace isc
 
#endif // STRUTIL_H