Function split

Source/Utils/json.hpp:12274–12334

! @brief split the string input to reference tokens @note This function is only called by the json_pointer constructor. All exceptions below are documented there. @throw parse_error.107 if the pointer is not empty or begins with '/' @throw parse_error.108 if character '~' is not followed by '0' or '1' */

        @throw parse_error.108  if character '~' is not followed by '0' or '1'
        */
        static std::vector<std::string> split(const std::string& reference_string)
        {
            std::vector<std::string> result;

            // special case: empty reference string -> no reference tokens
            if (reference_string.empty())
            {
                return result;
            }

            // check if nonempty reference string begins with slash
            if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
            {
                JSON_THROW(detail::parse_error::create(107, 1,
                    "JSON pointer must be empty or begin with '/' - was: '" +
                    reference_string + "'"));
            }

            // extract the reference tokens:
            // - slash: position of the last read slash (or end of string)
            // - start: position after the previous slash
            for (
                // search for the first slash after the first character
                std::size_t slash = reference_string.find_first_of('/', 1),
                // set the beginning of the first reference token
                start = 1;
                // we can stop if start == 0 (if slash == std::string::npos)
                start != 0;
                // set the beginning of the next reference token
                // (will eventually be 0 if slash == std::string::npos)
                start = (slash == std::string::npos) ? 0 : slash + 1,
                // find next slash
                slash = reference_string.find_first_of('/', start))
            {
                // use the text between the beginning of the reference token
                // (start) and the last slash (slash).
                auto reference_token = reference_string.substr(start, slash - start);

                // check reference tokens are properly escaped
                for (std::size_t pos = reference_token.find_first_of('~');
                    pos != std::string::npos;
                    pos = reference_token.find_first_of('~', pos + 1))
                {
                    JSON_ASSERT(reference_token[pos] == '~');

                    // ~ must be followed by 0 or 1
                    if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
                        (reference_token[pos + 1] != '0' &&
                            reference_token[pos + 1] != '1')))
                    {
                        JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
                    }
                }

                // finally, store the reference token
                unescape(reference_token);
                result.push_back(reference_token);
            }