---

Tools.h

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// (Coded@ReallySoft.de)
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#ifndef TOOLS_H
#define TOOLS_H

#ifndef RSDEF_H
#include "rsdef.h"
#endif
#ifndef GENERIC_ALGO_H
#include "generic_algo.h"
#endif


namespace rs {

    namespace internal {
        inline int diff(size_t v1, size_t v2) {
            return v1<v2 ? -int(v2-v1) : int(v1-v2);
        }
    }

    namespace str {

        std::string vstrf(const char *format, va_list argPtr);

        std::string strf(const char *format, ...);

        inline std::string cropString(const std::string& s) {
            size_t start = s.find_first_not_of(' ');
            size_t end = s.find_last_not_of(' ');
            return (start==std::string::npos || end==std::string::npos)
                ? ""
                : std::string(s, start, end-start+1);
        }

        inline char *strdup(const std::string& s) {
            char *buf       = (char*)std::malloc(s.length()+1);
            memcpy(buf, s.data(), s.length());
            buf[s.length()] = 0;
            return buf;
        }

        // ---------------------------------------- strncmp

        inline int strncmp(const std::string& s1, const char *s2, size_t maxcmp) {
            size_t l1 = s1.length();
            if (l1<maxcmp) {
                int cmp = std::strncmp(s1.data(), s2, l1);
                return cmp ? cmp : (s2[l1]==0 ? 0 : -1);
            }
            return std::strncmp(s1.data(), s2, maxcmp);
        }
        inline int strncmp(const char* s1, const std::string& s2, size_t maxcmp) {
            return -strncmp(s2, s1, maxcmp);
        }

        inline int strncmp(const std::string& s1, const std::string& s2, size_t maxcmp) {
            size_t Len1 = s1.length();
            size_t Len2 = s2.length();

            if (Len1<maxcmp || Len2<maxcmp) { // one string is shorter than maxcmp
                int cmp = std::strncmp(s1.data(), s2.data(), gen_algo::min(Len1, Len2));
                return cmp ? cmp : internal::diff(Len1, Len2);
            }
            return std::strncmp(s1.data(), s2.data(), maxcmp);
        }


        // ---------------------------------------- strnicmp

        inline int strnicmp(const char *s1, const char *s2, size_t maxcmp) {
            int cmp = 0;
            size_t idx = 0;
            while (!cmp && maxcmp--) {
                if (!s1[idx]) return s2[idx] ? -1 : 0;
                if (!s2[idx]) return 1;
                cmp = tolower(s1[idx]) - tolower(s2[idx]);
                ++idx;
            }
            return cmp;
        }

        inline int strnicmp(const std::string& s1, const char *s2, size_t maxcmp) {
            size_t l1 = s1.length();
            if (l1<maxcmp) {
                int cmp = strnicmp(s1.data(), s2, l1);
                return cmp ? cmp : (s2[l1]==0 ? 0 : -1);
            }
            return strnicmp(s1.data(), s2, maxcmp);
        }
        inline int strnicmp(const char* s1, const std::string& s2, size_t maxcmp) {
            return -strnicmp(s2, s1, maxcmp);
        }

        inline int strnicmp(const std::string& s1, const std::string& s2, size_t maxcmp) {
            size_t Len1 = s1.length();
            size_t Len2 = s2.length();

            if (Len1<maxcmp || Len2<maxcmp) { // one string is shorter than maxcmp
                int cmp = strnicmp(s1.data(), s2.data(), gen_algo::min(Len1, Len2));
                return cmp ? cmp : internal::diff(Len1, Len2);
            }
            return strnicmp(s1.data(), s2.data(), maxcmp);
        }


        // ---------------------------------------- stricmp

        inline int stricmp(const char *s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            while (!cmp) {
                if (!s1[idx]) return s2[idx] ? -1 : 0;
                if (!s2[idx]) return 1;
                cmp = tolower(s1[idx]) - tolower(s2[idx]);
                ++idx;
            }
            return cmp;
        }

        inline int stricmp(const std::string& s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            size_t Len1 = s1.length();
            std::string::const_iterator iter1 = s1.begin();
            while (!cmp) {
                if (Len1==idx) return s2[idx] ? -1 : 0;
                if (!s2[idx]) return 1;
                cmp = tolower(*iter1) - tolower(s2[idx]);
                ++idx;
                ++iter1;
            }
            return cmp;
        }
        inline int stricmp(const char *s1, const std::string& s2) {
            return -stricmp(s2, s1);
        }
        inline int stricmp(const std::string& s1, const std::string& s2) {
            size_t Len1 = s1.length();
            size_t Len2 = s2.length();
            int cmp = strnicmp(s1, s2, gen_algo::min(Len1, Len2));
            return cmp ? cmp : internal::diff(Len1, Len2);
        }


        // ---------------------------------------- strscmp

        inline int strscmp(const char *s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            while (!cmp) {
                if (!s1[idx] || !s2[idx]) break;
                cmp = s1[idx]-s2[idx];
                ++idx;
            }
            return cmp;
        }

        inline int strscmp(const std::string& s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            size_t Len1 = s1.length();
            std::string::const_iterator iter1 = s1.begin();
            while (!cmp) {
                if (idx==Len1 || !s2[idx]) break;
                cmp = *iter1-s2[idx];
                ++idx;
                ++iter1;
            }
            return cmp;
        }
        inline int strscmp(const char *s1, const std::string& s2) {
            return -strscmp(s2, s1);
        }

        inline int strscmp(const std::string& s1, const std::string& s2) {
            return strncmp(s1, s2, gen_algo::min(s1.length(), s2.length()));
        }


        // ---------------------------------------- strsicmp

        inline int strsicmp(const char *s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            while (!cmp) {
                if (!s1[idx] || !s2[idx]) break;
                cmp = tolower(s1[idx])-tolower(s2[idx]);
                ++idx;
            }
            return cmp;
        }

        inline int strsicmp(const std::string& s1, const char *s2) {
            int cmp = 0;
            size_t idx = 0;
            size_t Len1 = s1.length();
            std::string::const_iterator iter1 = s1.begin();
            while (!cmp) {
                if (idx==Len1 || !s2[idx]) break;
                cmp = tolower(*iter1)-tolower(s2[idx]);
                ++idx;
                ++iter1;
            }
            return cmp;
        }
        inline int strsicmp(const char *s1, const std::string& s2) {
            return -strsicmp(s2, s1);
        }

        inline int strsicmp(const std::string& s1, const std::string& s2) {
            return strnicmp(s1, s2, gen_algo::min(s1.length(), s2.length()));
        }


        // ---------------------------------------- strichr

        inline const char *strichr(const char *haystack, char needle) {
            needle = tolower(needle);
            while (1) {
                char c = tolower(*haystack++);
                if (c==needle) return haystack-1;
                if (!c) break;
            }
            return 0;
        }
        inline char *strichr(char *haystack, char needle) {
            return const_cast<char*>(strichr(const_cast<const char *>(haystack), needle));
        }


        // ---------------------------------------- stristr

        inline const char *stristr(const char *haystack, const char *needle) {
            const char *first = haystack;
            size_t len = strlen(needle);
            while (1) {
                first = strichr(first, needle[0]);
                if (!first) break;
                if (strnicmp(first, needle, len)==0) return first;
                ++first;
            }
            return 0;
        }
        inline char *stristr(char *haystack, const char* needle) {
            return const_cast<char*>(stristr(const_cast<const char *>(haystack), needle));
        }


        // ---------------------------------------- strlwr/strupr

        inline void strlwr(char *s) {
            size_t i = 0;
            while (1) {
                if ((s[i]=tolower(s[i]))==0) break;
                ++i;
            }
        }
        inline void strlwr(std::string& s) {
            size_t len = s.length();
            std::string::iterator iter = s.begin();
            while (len--) {
                *iter = tolower(*iter);
                ++iter;
            }
        }
        inline void strupr(char *s) {
            size_t i = 0;
            while (1) {
                if ((s[i]=toupper(s[i]))==0) break;
                ++i;
            }
        }

        inline void strupr(std::string& s) {
            size_t len = s.length();
            std::string::iterator iter = s.begin();
            while (len--) {
                *iter = toupper(*iter);
                ++iter;
            }
        }

    };

    namespace output {

        void outf(std::ostream& out, const char *format, ...);

//         /** @brief output with fixed width

//             breaks long lines

//             @param out output stream
//             @param s string to print
//             @param width width of output in columns
//         */
//         void fixed_width_output(std::ostream& out, const std::string& s, size_t width);

        void printIndented(std::ostream& out, unsigned indent, unsigned border, unsigned width, const std::string& s);

        void printIndented(std::ostream& out, unsigned width, const std::string& left, const std::string& right);

    };
};

#endif //TOOLS_H

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002