ProcessWorklist.h File Reference

#include "include/core/SkSpan.h"
#include <functional>
#include <string>

Go to the source code of this file.

Enumerations
enum class	ResultCode {   kSuccess = 0 , kCompileError = 1 , kInputError = 2 , kOutputError = 3 ,   kConfigurationError = 4 }

Functions
ResultCode	ProcessWorklist (const char *worklistPath, const std::function< ResultCode(SkSpan< std::string > args)> &processCommandFn)

Enumeration Type Documentation

ResultCode

enum class ResultCode

strong

Enumerator
kSuccess
kCompileError
kInputError
kOutputError
kConfigurationError

Definition at line 16 of file ProcessWorklist.h.

                      {
    kSuccess = 0,
    kCompileError = 1,
    kInputError = 2,
    kOutputError = 3,
    kConfigurationError = 4,
};

Function Documentation

ProcessWorklist()

ResultCode ProcessWorklist	(	const char *	worklistPath,
		const std::function< ResultCode(SkSpan< std::string > args)> &	processCommandFn
	)

Processes multiple inputs in a single invocation by reading a worklist file. The processCommand is invoked with a set of arguments, read from the worklist. A blank line is used to separate one group of arguments from the next group.

Definition at line 15 of file ProcessWorklist.cpp.

                                                                                 {
    std::string inputPath(worklistPath);
    if (!skstd::ends_with(inputPath, ".worklist")) {
        printf("expected .worklist file, found: %s\n\n", worklistPath);
        return ResultCode::kConfigurationError;
    }
 
    // The worklist contains one line per argument to pass. When a blank line is reached, those
    // arguments will be passed to `processCommandFn`.
    auto resultCode = ResultCode::kSuccess;
    std::vector<std::string> args = {"sksl"};
    std::ifstream in(worklistPath);
    for (std::string line; std::getline(in, line); ) {
        if (in.rdstate()) {
            printf("error reading '%s'\n", worklistPath);
            return ResultCode::kInputError;
        }
 
        if (!line.empty()) {
            // We found an argument. Remember it.
            args.push_back(std::move(line));
        } else {
            // We found a blank line. If we have any arguments stored up, process them as a command.
            if (!args.empty()) {
                ResultCode outcome = processCommandFn(args);
                resultCode = std::max(resultCode, outcome);
 
                // Clear every argument except the first.
                args.resize(1);
            }
        }
    }
 
    // If the worklist ended with a list of arguments but no blank line, process those now.
    if (args.size() > 1) {
        ResultCode outcome = processCommandFn(args);
        resultCode = std::max(resultCode, outcome);
    }
 
    // Return the "worst" status we encountered. For our purposes, compilation errors are the least
    // serious, because they are expected to occur in unit tests. Other types of errors are not
    // expected at all during a build.
    return resultCode;
}