CrowCpp / Crow / 525

Committed 07 Jan 2025 09:23PM UTC coverage: 87.528% (-0.1%) from 87.641%

Build # 525

Build Type

Pull #975

gh-actions

Committed by

web-flow

Commit Message

Merge 1199fbbe8 into 8dff896cc

Pull Request Pull Request #975: Refactor substr equals by find

Run Details

14 of 16 new or added lines in 4 files covered. (87.5%)

5 existing lines in 2 files now uncovered.

3965 of 4530 relevant lines covered (87.53%)

260.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.87

/include/crow/query_string.h

#pragma once

#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>
#include <memory>

namespace crow
{

// ----------------------------------------------------------------------------
// qs_parse (modified)
// https://github.com/bartgrantham/qs_parse
// ----------------------------------------------------------------------------
/*  Similar to strncmp, but handles URL-encoding for either string  */
int qs_strncmp(const char* s, const char* qs, size_t n);


/*  Finds the beginning of each key/value pair and stores a pointer in qs_kv.
 *  Also decodes the value portion of the k/v pair *in-place*.  In a future
 *  enhancement it will also have a compile-time option of sorting qs_kv
 *  alphabetically by key.  */
size_t qs_parse(char* qs, char* qs_kv[], size_t qs_kv_size, bool parse_url);


/*  Used by qs_parse to decode the value portion of a k/v pair  */
int qs_decode(char * qs);


/*  Looks up the value according to the key on a pre-processed query string
 *  A future enhancement will be a compile-time option to look up the key
 *  in a pre-sorted qs_kv array via a binary search.  */
//char * qs_k2v(const char * key, char * qs_kv[], int qs_kv_size);
 char * qs_k2v(const char * key, char * const * qs_kv, size_t qs_kv_size, int nth);


/*  Non-destructive lookup of value, based on key.  User provides the
 *  destinaton string and length.  */
char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len);

// TODO: implement sorting of the qs_kv array; for now ensure it's not compiled
#undef _qsSORTING

// isxdigit _is_ available in <ctype.h>, but let's avoid another header instead
#define CROW_QS_ISHEX(x)    ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0)
#define CROW_QS_HEX2DEC(x)  (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
#define CROW_QS_ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1)

inline int qs_strncmp(const char * s, const char * qs, size_t n)
{
    unsigned char u1, u2, unyb, lnyb;

    while(n-- > 0)
    {
        u1 = static_cast<unsigned char>(*s++);
        u2 = static_cast<unsigned char>(*qs++);

        if ( ! CROW_QS_ISQSCHR(u1) ) {  u1 = '\0';  }
        if ( ! CROW_QS_ISQSCHR(u2) ) {  u2 = '\0';  }

        if ( u1 == '+' ) {  u1 = ' ';  }
        if ( u1 == '%' ) // easier/safer than scanf
        {
            unyb = static_cast<unsigned char>(*s++);
            lnyb = static_cast<unsigned char>(*s++);
            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
                u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
            else
                u1 = '\0';
        }

        if ( u2 == '+' ) {  u2 = ' ';  }
        if ( u2 == '%' ) // easier/safer than scanf
        {
            unyb = static_cast<unsigned char>(*qs++);
            lnyb = static_cast<unsigned char>(*qs++);
            if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )
                u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);
            else
                u2 = '\0';
        }

        if ( u1 != u2 )
            return u1 - u2;
        if ( u1 == '\0' )
            return 0;
    }
    if ( CROW_QS_ISQSCHR(*qs) )
        return -1;
    else
        return 0;
}


inline size_t qs_parse(char* qs, char* qs_kv[], size_t qs_kv_size, bool parse_url = true)
{
    size_t i, j;
    char * substr_ptr;

    for(i=0; i<qs_kv_size; i++)  qs_kv[i] = NULL;

    // find the beginning of the k/v substrings or the fragment
    substr_ptr = parse_url ? qs + strcspn(qs, "?#") : qs;
    if (parse_url)
    {
        if (substr_ptr[0] != '\0')
            substr_ptr++;
        else
            return 0; // no query or fragment
    }

    i=0;
    while(i<qs_kv_size)
    {
        qs_kv[i] = substr_ptr;
        j = strcspn(substr_ptr, "&");
        if ( substr_ptr[j] == '\0' ) { i++; break;  } // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
        substr_ptr += j + 1;
        i++;
    }

    // we only decode the values in place, the keys could have '='s in them
    // which will hose our ability to distinguish keys from values later
    for(j=0; j<i; j++)
    {
        substr_ptr = qs_kv[j] + strcspn(qs_kv[j], "=&#");
        if ( substr_ptr[0] == '&' || substr_ptr[0] == '\0')  // blank value: skip decoding
            substr_ptr[0] = '\0';
        else
            qs_decode(++substr_ptr);
    }

#ifdef _qsSORTING
// TODO: qsort qs_kv, using qs_strncmp() for the comparison
#endif

    return i;
}


inline int qs_decode(char * qs)
{
    int i=0, j=0;

    while( CROW_QS_ISQSCHR(qs[j]) )
    {
        if ( qs[j] == '+' ) {  qs[i] = ' ';  }
        else if ( qs[j] == '%' ) // easier/safer than scanf
        {
            if ( ! CROW_QS_ISHEX(qs[j+1]) || ! CROW_QS_ISHEX(qs[j+2]) )
            {
                qs[i] = '\0';
                return i;
            }
            qs[i] = (CROW_QS_HEX2DEC(qs[j+1]) * 16) + CROW_QS_HEX2DEC(qs[j+2]);
            j+=2;
        }
        else
        {
            qs[i] = qs[j];
        }
        i++;  j++;
    }
    qs[i] = '\0';

    return i;
}


inline char * qs_k2v(const char * key, char * const * qs_kv, size_t qs_kv_size, int nth = 0)
{
    size_t i;
    size_t key_len, skip;

    key_len = strlen(key);

#ifdef _qsSORTING
// TODO: binary search for key in the sorted qs_kv
#else  // _qsSORTING
    for(i=0; i<qs_kv_size; i++)
    {
        // we rely on the unambiguous '=' to find the value in our k/v pair
        if ( qs_strncmp(key, qs_kv[i], key_len) == 0 )
        {
            skip = strcspn(qs_kv[i], "=");
            if ( qs_kv[i][skip] == '=' )
                skip++;
            // return (zero-char value) ? ptr to trailing '\0' : ptr to value
            if(nth == 0)
                return qs_kv[i] + skip;
            else
                --nth;
        }
    }
#endif  // _qsSORTING

    return nullptr;
}

inline std::unique_ptr<std::pair<std::string, std::string>> qs_dict_name2kv(const char * dict_name, char * const * qs_kv, size_t qs_kv_size, int nth = 0)
{
    size_t i;
    size_t name_len, skip_to_eq, skip_to_brace_open, skip_to_brace_close;

    name_len = strlen(dict_name);

#ifdef _qsSORTING
// TODO: binary search for key in the sorted qs_kv
#else  // _qsSORTING
    for(i=0; i<qs_kv_size; i++)
    {
        if ( strncmp(dict_name, qs_kv[i], name_len) == 0 )
        {
            skip_to_eq = strcspn(qs_kv[i], "=");
            if ( qs_kv[i][skip_to_eq] == '=' )
                skip_to_eq++;
            skip_to_brace_open = strcspn(qs_kv[i], "[");
            if ( qs_kv[i][skip_to_brace_open] == '[' )
                skip_to_brace_open++;
            skip_to_brace_close = strcspn(qs_kv[i], "]");

            if ( skip_to_brace_open <= skip_to_brace_close &&
                 skip_to_brace_open > 0 &&
                 skip_to_brace_close > 0 &&
                 nth == 0 )
            {
                auto key = std::string(qs_kv[i] + skip_to_brace_open, skip_to_brace_close - skip_to_brace_open);
                auto value = std::string(qs_kv[i] + skip_to_eq);
                return std::unique_ptr<std::pair<std::string, std::string>>(new std::pair<std::string, std::string>(key, value));
            }
            else
            {
                --nth;
            }
        }
    }
#endif  // _qsSORTING

    return nullptr;
}


inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
{
    size_t i, key_len;
    const char * tmp;

    // find the beginning of the k/v substrings
    if ( (tmp = strchr(qs, '?')) != NULL )
        qs = tmp + 1;

    key_len = strlen(key);
    while(qs[0] != '#' && qs[0] != '\0')
    {
        if ( qs_strncmp(key, qs, key_len) == 0 )
            break;
        qs += strcspn(qs, "&") + 1;
    }

    if ( qs[0] == '\0' ) return NULL;

    qs += strcspn(qs, "=&#");
    if ( qs[0] == '=' )
    {
        qs++;
        i = strcspn(qs, "&=#");
#ifdef _MSC_VER
        strncpy_s(val, val_len, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1));
#else
        strncpy(val, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1));
#endif
                qs_decode(val);
    }
    else
    {
        if ( val_len > 0 )
            val[0] = '\0';
    }

    return val;
}
}
// ----------------------------------------------------------------------------


namespace crow
{
    struct request;
    /// A class to represent any data coming after the `?` in the request URL into key-value pairs.
    class query_string
    {
    public:
        static const int MAX_KEY_VALUE_PAIRS_COUNT = 256;

        query_string() = default;

        query_string(const query_string& qs):
          url_(qs.url_)
        {
            for (auto p : qs.key_value_pairs_)
            {
                key_value_pairs_.push_back((char*)(p - qs.url_.c_str() + url_.c_str()));
            }
        }

        query_string& operator=(const query_string& qs)
        {
            url_ = qs.url_;
            key_value_pairs_.clear();
            for (auto p : qs.key_value_pairs_)
            {
                key_value_pairs_.push_back((char*)(p - qs.url_.c_str() + url_.c_str()));
            }
            return *this;
        }

        query_string& operator=(query_string&& qs) noexcept
        {
            key_value_pairs_ = std::move(qs.key_value_pairs_);
            char* old_data = (char*)qs.url_.c_str();
            url_ = std::move(qs.url_);
            for (auto& p : key_value_pairs_)
            {
                p += (char*)url_.c_str() - old_data;
            }
            return *this;
        }


        query_string(std::string params, bool url = true):
          url_(std::move(params))
        {
            if (url_.empty())
                return;

            key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT);
            size_t count = qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT, url);

            key_value_pairs_.resize(count);
            key_value_pairs_.shrink_to_fit();
        }

        void clear()
        {
            key_value_pairs_.clear();
            url_.clear();
        }

        friend std::ostream& operator<<(std::ostream& os, const query_string& qs)
        {
            os << "[ ";
            for (size_t i = 0; i < qs.key_value_pairs_.size(); ++i)
            {
                if (i)
                    os << ", ";
                os << qs.key_value_pairs_[i];
            }
            os << " ]";
            return os;
        }

        /// Get a value from a name, used for `?name=value`.

        ///
        /// Note: this method returns the value of the first occurrence of the key only, to return all occurrences, see \ref get_list().
        char* get(const std::string& name) const
        {
            char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());
            return ret;
        }

        /// Works similar to \ref get() except it removes the item from the query string.
        char* pop(const std::string& name)
        {
            char* ret = get(name);
            if (ret != nullptr)
            {
                const std::string key_name = name + '=';
                for (unsigned int i = 0; i < key_value_pairs_.size(); i++)
                {
                    std::string str_item(key_value_pairs_[i]);
                    if (str_item.find(key_name)==0)
                    {
                        key_value_pairs_.erase(key_value_pairs_.begin() + i);
                        break;
                    }
                }
            }
            return ret;
        }

        /// Returns a list of values, passed as `?name[]=value1&name[]=value2&...name[]=valuen` with n being the size of the list.

        ///
        /// Note: Square brackets in the above example are controlled by `use_brackets` boolean (true by default). If set to false, the example becomes `?name=value1,name=value2...name=valuen`
        std::vector<char*> get_list(const std::string& name, bool use_brackets = true) const
        {
            std::vector<char*> ret;
            std::string plus = name + (use_brackets ? "[]" : "");
            char* element = nullptr;

            int count = 0;
            while (1)
            {
                element = qs_k2v(plus.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++);
                if (!element)
                    break;
                ret.push_back(element);
            }
            return ret;
        }

        /// Similar to \ref get_list() but it removes the
        std::vector<char*> pop_list(const std::string& name, bool use_brackets = true)
        {
            std::vector<char*> ret = get_list(name, use_brackets);
            const size_t name_len = name.length();
            if (!ret.empty())
            {
                for (unsigned int i = 0; i < key_value_pairs_.size(); i++)
                {
                    std::string str_item(key_value_pairs_[i]);
                    if (str_item.find(name)==0) {
                      if (use_brackets && str_item.find("[]=",name_len)==name_len) {
                        key_value_pairs_.erase(key_value_pairs_.begin() + i--);
                      } else if (!use_brackets && str_item.find('=',name_len)==name_len ) {
                           key_value_pairs_.erase(key_value_pairs_.begin() + i--);
                       }
                    }
                }
            }
            return ret;
        }

        /// Works similar to \ref get_list() except the brackets are mandatory must not be empty.

        ///
        /// For example calling `get_dict(yourname)` on `?yourname[sub1]=42&yourname[sub2]=84` would give a map containing `{sub1 : 42, sub2 : 84}`.
        ///
        /// if your query string has both empty brackets and ones with a key inside, use pop_list() to get all the values without a key before running this method.
        std::unordered_map<std::string, std::string> get_dict(const std::string& name) const
        {
            std::unordered_map<std::string, std::string> ret;

            int count = 0;
            while (1)
            {
                if (auto element = qs_dict_name2kv(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++))
                    ret.insert(*element);
                else
                    break;
            }
            return ret;
        }

        /// Works the same as \ref get_dict() but removes the values from the query string.
        std::unordered_map<std::string, std::string> pop_dict(const std::string& name)
        {
            const std::string name_value = name +'[';
            std::unordered_map<std::string, std::string> ret = get_dict(name);
            if (!ret.empty())
            {
                for (unsigned int i = 0; i < key_value_pairs_.size(); i++)
                {
                    std::string str_item(key_value_pairs_[i]);
                    if (str_item.find(name_value)==0)
                    {
                        key_value_pairs_.erase(key_value_pairs_.begin() + i--);
                    }
                }
            }
            return ret;
        }

        std::vector<std::string> keys() const
        {
            std::vector<std::string> keys;
            keys.reserve(key_value_pairs_.size());

            for (const char* const element : key_value_pairs_)
            {
                const char* delimiter = strchr(element, '=');
                if (delimiter)
                    keys.emplace_back(element, delimiter);
                else
                    keys.emplace_back(element);
            }

            return keys;
        }

    private:
        std::string url_;
        std::vector<char*> key_value_pairs_;
    };

} // namespace crow

1	#pragma once
2
3	#include <stdio.h>
4	#include <string.h>
5	#include <string>
6	#include <vector>
7	#include <unordered_map>
8	#include <iostream>
9	#include <memory>
10
11	namespace crow
12	{
13
14	// ----------------------------------------------------------------------------
15	// qs_parse (modified)
16	// https://github.com/bartgrantham/qs_parse
17	// ----------------------------------------------------------------------------
18	/* Similar to strncmp, but handles URL-encoding for either string */
19	int qs_strncmp(const char* s, const char* qs, size_t n);
20
21
22	/* Finds the beginning of each key/value pair and stores a pointer in qs_kv.
23	* Also decodes the value portion of the k/v pair in-place. In a future
24	* enhancement it will also have a compile-time option of sorting qs_kv
25	* alphabetically by key. */
26	size_t qs_parse(char* qs, char* qs_kv[], size_t qs_kv_size, bool parse_url);
27
28
29	/* Used by qs_parse to decode the value portion of a k/v pair */
30	int qs_decode(char * qs);
31
32
33	/* Looks up the value according to the key on a pre-processed query string
34	* A future enhancement will be a compile-time option to look up the key
35	* in a pre-sorted qs_kv array via a binary search. */
36	//char * qs_k2v(const char * key, char * qs_kv[], int qs_kv_size);
37	char * qs_k2v(const char * key, char * const * qs_kv, size_t qs_kv_size, int nth);
38
39
40	/* Non-destructive lookup of value, based on key. User provides the
41	* destinaton string and length. */
42	char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len);
43
44	// TODO: implement sorting of the qs_kv array; for now ensure it's not compiled
45	#undef _qsSORTING
46
47	// isxdigit _is_ available in <ctype.h>, but let's avoid another header instead
48	#define CROW_QS_ISHEX(x) ((((x)>='0'&&(x)<='9') \|\| ((x)>='A'&&(x)<='F') \|\| ((x)>='a'&&(x)<='f')) ? 1 : 0)
49	#define CROW_QS_HEX2DEC(x) (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0)
50	#define CROW_QS_ISQSCHR(x) ((((x)=='=')\|\|((x)=='#')\|\|((x)=='&')\|\|((x)=='\0')) ? 0 : 1)
51
52	inline int qs_strncmp(const char * s, const char * qs, size_t n)	166✔
53	{
54	unsigned char u1, u2, unyb, lnyb;
55
56	while(n-- > 0)	890✔
57	{
58	u1 = static_cast<unsigned char>(*s++);	760✔
59	u2 = static_cast<unsigned char>(*qs++);	760✔
60
61	if ( ! CROW_QS_ISQSCHR(u1) ) { u1 = '\0'; }	760✔
62	if ( ! CROW_QS_ISQSCHR(u2) ) { u2 = '\0'; }	760✔
63
64	if ( u1 == '+' ) { u1 = ' '; }	760✔
65	if ( u1 == '%' ) // easier/safer than scanf	760✔
66	{
67	unyb = static_cast<unsigned char>(*s++);	×
68	lnyb = static_cast<unsigned char>(*s++);	×
69	if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )	×
70	u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);	×
71	else
72	u1 = '\0';	×
73	}
74
75	if ( u2 == '+' ) { u2 = ' '; }	760✔
76	if ( u2 == '%' ) // easier/safer than scanf	760✔
77	{
78	unyb = static_cast<unsigned char>(*qs++);	×
79	lnyb = static_cast<unsigned char>(*qs++);	×
80	if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) )	×
81	u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb);	×
82	else
83	u2 = '\0';	×
84	}
85
86	if ( u1 != u2 )	760✔
87	return u1 - u2;	36✔
88	if ( u1 == '\0' )	724✔
89	return 0;	×
90	}
91	if ( CROW_QS_ISQSCHR(*qs) )	130✔
92	return -1;	2✔
93	else
94	return 0;	128✔
95	}
96
97
98	inline size_t qs_parse(char* qs, char* qs_kv[], size_t qs_kv_size, bool parse_url = true)	156✔
99	{
100	size_t i, j;
101	char * substr_ptr;
102
103	for(i=0; i<qs_kv_size; i++) qs_kv[i] = NULL;	40,092✔
104
105	// find the beginning of the k/v substrings or the fragment
106	substr_ptr = parse_url ? qs + strcspn(qs, "?#") : qs;	156✔
107	if (parse_url)	156✔
108	{
109	if (substr_ptr[0] != '\0')	156✔
110	substr_ptr++;	22✔
111	else
112	return 0; // no query or fragment	134✔
113	}
114
115	i=0;	22✔
116	while(i<qs_kv_size)	54✔
117	{
118	qs_kv[i] = substr_ptr;	54✔
119	j = strcspn(substr_ptr, "&");	54✔
120	if ( substr_ptr[j] == '\0' ) { i++; break; } // x &'s -> means x iterations of this loop -> means x+1 k/v pairs	54✔
121	substr_ptr += j + 1;	32✔
122	i++;	32✔
123	}
124
125	// we only decode the values in place, the keys could have '='s in them
126	// which will hose our ability to distinguish keys from values later
127	for(j=0; j<i; j++)	76✔
128	{
129	substr_ptr = qs_kv[j] + strcspn(qs_kv[j], "=&#");	54✔
130	if ( substr_ptr[0] == '&' \|\| substr_ptr[0] == '\0') // blank value: skip decoding	54✔
131	substr_ptr[0] = '\0';	8✔
132	else
133	qs_decode(++substr_ptr);	46✔
134	}
135
136	#ifdef _qsSORTING
137	// TODO: qsort qs_kv, using qs_strncmp() for the comparison
138	#endif
139
140	return i;	22✔
141	}
142
143
144	inline int qs_decode(char * qs)	46✔
145	{
146	int i=0, j=0;	46✔
147
148	while( CROW_QS_ISQSCHR(qs[j]) )	264✔
149	{
150	if ( qs[j] == '+' ) { qs[i] = ' '; }	218✔
151	else if ( qs[j] == '%' ) // easier/safer than scanf	218✔
152	{
153	if ( ! CROW_QS_ISHEX(qs[j+1]) \|\| ! CROW_QS_ISHEX(qs[j+2]) )	×
154	{
155	qs[i] = '\0';	×
156	return i;	×
157	}
158	qs[i] = (CROW_QS_HEX2DEC(qs[j+1]) * 16) + CROW_QS_HEX2DEC(qs[j+2]);	×
159	j+=2;	×
160	}
161	else
162	{
163	qs[i] = qs[j];	218✔
164	}
165	i++; j++;	218✔
166	}
167	qs[i] = '\0';	46✔
168
169	return i;	46✔
170	}
171
172
173	inline char * qs_k2v(const char * key, char * const * qs_kv, size_t qs_kv_size, int nth = 0)	90✔
174	{
175	size_t i;
176	size_t key_len, skip;
177
178	key_len = strlen(key);	90✔
179
180	#ifdef _qsSORTING
181	// TODO: binary search for key in the sorted qs_kv
182	#else // _qsSORTING
183	for(i=0; i<qs_kv_size; i++)	192✔
184	{
185	// we rely on the unambiguous '=' to find the value in our k/v pair
186	if ( qs_strncmp(key, qs_kv[i], key_len) == 0 )	166✔
187	{
188	skip = strcspn(qs_kv[i], "=");	128✔
189	if ( qs_kv[i][skip] == '=' )	128✔
190	skip++;	120✔
191	// return (zero-char value) ? ptr to trailing '\0' : ptr to value
192	if(nth == 0)	128✔
193	return qs_kv[i] + skip;	64✔
194	else
195	--nth;	64✔
196	}
197	}
198	#endif // _qsSORTING
199
200	return nullptr;	26✔
201	}
202
203	inline std::unique_ptr<std::pair<std::string, std::string>> qs_dict_name2kv(const char * dict_name, char * const * qs_kv, size_t qs_kv_size, int nth = 0)	42✔
204	{
205	size_t i;
206	size_t name_len, skip_to_eq, skip_to_brace_open, skip_to_brace_close;
207
208	name_len = strlen(dict_name);	42✔
209
210	#ifdef _qsSORTING
211	// TODO: binary search for key in the sorted qs_kv
212	#else // _qsSORTING
213	for(i=0; i<qs_kv_size; i++)	102✔
214	{
215	if ( strncmp(dict_name, qs_kv[i], name_len) == 0 )	90✔
216	{
217	skip_to_eq = strcspn(qs_kv[i], "=");	90✔
218	if ( qs_kv[i][skip_to_eq] == '=' )	90✔
219	skip_to_eq++;	90✔
220	skip_to_brace_open = strcspn(qs_kv[i], "[");	90✔
221	if ( qs_kv[i][skip_to_brace_open] == '[' )	90✔
222	skip_to_brace_open++;	90✔
223	skip_to_brace_close = strcspn(qs_kv[i], "]");	90✔
224
225	if ( skip_to_brace_open <= skip_to_brace_close &&	90✔
226	skip_to_brace_open > 0 &&	90✔
227	skip_to_brace_close > 0 &&	90✔
228	nth == 0 )
229	{
230	auto key = std::string(qs_kv[i] + skip_to_brace_open, skip_to_brace_close - skip_to_brace_open);	60✔
231	auto value = std::string(qs_kv[i] + skip_to_eq);	30✔
232	return std::unique_ptr<std::pair<std::string, std::string>>(new std::pair<std::string, std::string>(key, value));	30✔
233	}	30✔
234	else
235	{
236	--nth;	60✔
237	}
238	}
239	}
240	#endif // _qsSORTING
241
242	return nullptr;	12✔
243	}
244
245
246	inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len)
247	{
248	size_t i, key_len;
249	const char * tmp;
250
251	// find the beginning of the k/v substrings
252	if ( (tmp = strchr(qs, '?')) != NULL )
253	qs = tmp + 1;
254
255	key_len = strlen(key);
256	while(qs[0] != '#' && qs[0] != '\0')
257	{
258	if ( qs_strncmp(key, qs, key_len) == 0 )
259	break;
260	qs += strcspn(qs, "&") + 1;
261	}
262
263	if ( qs[0] == '\0' ) return NULL;
264
265	qs += strcspn(qs, "=&#");
266	if ( qs[0] == '=' )
267	{
268	qs++;
269	i = strcspn(qs, "&=#");
270	#ifdef _MSC_VER
271	strncpy_s(val, val_len, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1));
272	#else
273	strncpy(val, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1));
274	#endif
275	qs_decode(val);
276	}
277	else
278	{
279	if ( val_len > 0 )
280	val[0] = '\0';
281	}
282
283	return val;
284	}
285	}
286	// ----------------------------------------------------------------------------
287
288
289	namespace crow
290	{
291	struct request;
292	/// A class to represent any data coming after the `?` in the request URL into key-value pairs.
293	class query_string
294	{
295	public:
296	static const int MAX_KEY_VALUE_PAIRS_COUNT = 256;
297
298	query_string() = default;	740✔
299
300	query_string(const query_string& qs):	2✔
301	url_(qs.url_)	2✔
302	{
303	for (auto p : qs.key_value_pairs_)	8✔
304	{
305	key_value_pairs_.push_back((char*)(p - qs.url_.c_str() + url_.c_str()));	6✔
306	}
307	}	2✔
308
309	query_string& operator=(const query_string& qs)	18✔
310	{
311	url_ = qs.url_;	18✔
312	key_value_pairs_.clear();	18✔
313	for (auto p : qs.key_value_pairs_)	54✔
314	{
315	key_value_pairs_.push_back((char*)(p - qs.url_.c_str() + url_.c_str()));	36✔
316	}
317	return *this;	18✔
318	}
319
320	query_string& operator=(query_string&& qs) noexcept	406✔
321	{
322	key_value_pairs_ = std::move(qs.key_value_pairs_);	406✔
323	char* old_data = (char*)qs.url_.c_str();	406✔
324	url_ = std::move(qs.url_);	406✔
325	for (auto& p : key_value_pairs_)	448✔
326	{
327	p += (char*)url_.c_str() - old_data;	42✔
328	}
329	return *this;	406✔
330	}
331
332
333	query_string(std::string params, bool url = true):	158✔
334	url_(std::move(params))	158✔
335	{
336	if (url_.empty())	158✔
337	return;	2✔
338
339	key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT);	156✔
340	size_t count = qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT, url);	156✔
341
342	key_value_pairs_.resize(count);	156✔
343	key_value_pairs_.shrink_to_fit();	156✔
344	}	×
345
346	void clear()
347	{
348	key_value_pairs_.clear();
349	url_.clear();
350	}
351
352	friend std::ostream& operator<<(std::ostream& os, const query_string& qs)	2✔
353	{
354	os << "[ ";	2✔
355	for (size_t i = 0; i < qs.key_value_pairs_.size(); ++i)	2✔
356	{
357	if (i)	×
358	os << ", ";	×
359	os << qs.key_value_pairs_[i];	×
360	}
361	os << " ]";	2✔
362	return os;	2✔
363	}
364
365	/// Get a value from a name, used for `?name=value`.
366
367	///
368	/// Note: this method returns the value of the first occurrence of the key only, to return all occurrences, see \ref get_list().
369	char* get(const std::string& name) const	38✔
370	{
371	char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());	38✔
372	return ret;	38✔
373	}
374
375	/// Works similar to \ref get() except it removes the item from the query string.
376	char* pop(const std::string& name)	2✔
377	{
378	char* ret = get(name);	2✔
379	if (ret != nullptr)	2✔
380	{
381	const std::string key_name = name + '=';	2✔
382	for (unsigned int i = 0; i < key_value_pairs_.size(); i++)	4✔
383	{
384	std::string str_item(key_value_pairs_[i]);	4✔
385	if (str_item.find(key_name)==0)	4✔
386	{
387	key_value_pairs_.erase(key_value_pairs_.begin() + i);	2✔
388	break;	2✔
389	}
390	}	4✔
391	}	2✔
392	return ret;	2✔
393	}
394
395	/// Returns a list of values, passed as `?name[]=value1&name[]=value2&...name[]=valuen` with n being the size of the list.
396
397	///
398	/// Note: Square brackets in the above example are controlled by `use_brackets` boolean (true by default). If set to false, the example becomes `?name=value1,name=value2...name=valuen`
399	std::vector<char*> get_list(const std::string& name, bool use_brackets = true) const	18✔
400	{
401	std::vector<char*> ret;	18✔
402	std::string plus = name + (use_brackets ? "[]" : "");	18✔
403	char* element = nullptr;	18✔
404
405	int count = 0;	18✔
406	while (1)
407	{
408	element = qs_k2v(plus.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++);	52✔
409	if (!element)	52✔
410	break;	18✔
411	ret.push_back(element);	34✔
412	}
413	return ret;	36✔
414	}	18✔
415
416	/// Similar to \ref get_list() but it removes the
417	std::vector<char*> pop_list(const std::string& name, bool use_brackets = true)	2✔
418	{
419	std::vector<char*> ret = get_list(name, use_brackets);	2✔
420	const size_t name_len = name.length();	2✔
421	if (!ret.empty())	2✔
422	{
423	for (unsigned int i = 0; i < key_value_pairs_.size(); i++)	8✔
424	{
425	std::string str_item(key_value_pairs_[i]);	6✔
426	if (str_item.find(name)==0) {	6✔
427	if (use_brackets && str_item.find("[]=",name_len)==name_len) {	6✔
428	key_value_pairs_.erase(key_value_pairs_.begin() + i--);	6✔
NEW 429	} else if (!use_brackets && str_item.find('=',name_len)==name_len ) {	×
NEW 430	key_value_pairs_.erase(key_value_pairs_.begin() + i--);	×
431	}
432	}
433	}	6✔
434	}
435	return ret;	2✔
436	}	×
437
438	/// Works similar to \ref get_list() except the brackets are mandatory must not be empty.
439
440	///
441	/// For example calling `get_dict(yourname)` on `?yourname[sub1]=42&yourname[sub2]=84` would give a map containing `{sub1 : 42, sub2 : 84}`.
442	///
443	/// if your query string has both empty brackets and ones with a key inside, use pop_list() to get all the values without a key before running this method.
444	std::unordered_map<std::string, std::string> get_dict(const std::string& name) const	12✔
445	{
446	std::unordered_map<std::string, std::string> ret;	12✔
447
448	int count = 0;	12✔
449	while (1)
450	{
451	if (auto element = qs_dict_name2kv(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++))	42✔
452	ret.insert(*element);	30✔
453	else
454	break;	42✔
455	}	30✔
456	return ret;	12✔
457	}	×
458
459	/// Works the same as \ref get_dict() but removes the values from the query string.
460	std::unordered_map<std::string, std::string> pop_dict(const std::string& name)	2✔
461	{
462	const std::string name_value = name +'[';	2✔
463	std::unordered_map<std::string, std::string> ret = get_dict(name);	2✔
464	if (!ret.empty())	2✔
465	{
466	for (unsigned int i = 0; i < key_value_pairs_.size(); i++)	8✔
467	{
468	std::string str_item(key_value_pairs_[i]);	6✔
469	if (str_item.find(name_value)==0)	6✔
470	{
471	key_value_pairs_.erase(key_value_pairs_.begin() + i--);	6✔
472	}
473	}	6✔
474	}
475	return ret;	4✔
476	}	2✔
477
478	std::vector<std::string> keys() const	4✔
479	{
480	std::vector<std::string> keys;	4✔
481	keys.reserve(key_value_pairs_.size());	4✔
482
483	for (const char* const element : key_value_pairs_)	16✔
484	{
485	const char* delimiter = strchr(element, '=');	12✔
486	if (delimiter)	12✔
487	keys.emplace_back(element, delimiter);	12✔
488	else
489	keys.emplace_back(element);	×
490	}
491
492	return keys;	4✔
493	}	×
494
495	private:
496	std::string url_;
497	std::vector<char*> key_value_pairs_;
498	};
499
500	} // namespace crow

CrowCpp / Crow / 525

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous