CommandFileParser Class Reference

This class parses a command file for the GatordMockService. More...

#include <CommandFileParser.hpp>

Public Member Functions
void	ParseFile (std::string CommandFile, GatordMockService &mockService)

Detailed Description

This class parses a command file for the GatordMockService.

The file contains one command per line. Valid commands are: SET and WAIT.

SET: Will construct and send a PeriodicCounterSelection packet to enable a set of counters. WAIT: Will pause for a set period of time to allow for data to be received.

Definition at line 22 of file CommandFileParser.hpp.

Member Function Documentation

ParseFile()

void ParseFile	(	std::string	CommandFile,
		GatordMockService &	mockService
	)

Definition at line 19 of file CommandFileParser.cpp.

References GatordMockService::ReceiveThreadRunning(), GatordMockService::SendActivateTimelinePacket(), GatordMockService::SendDeactivateTimelinePacket(), GatordMockService::SendPeriodicCounterSelectionList(), GatordMockService::SendRequestCounterDir(), and GatordMockService::WaitCommand().

Referenced by CreateMockService().

{
    std::ifstream infile(CommandFile);
    std::string line;

    std::cout << "Parsing command file: " << CommandFile << std::endl;

    while (mockService.ReceiveThreadRunning() && std::getline(infile, line))
    {
        std::istringstream iss(line);
        std::vector<std::string> tokens;

        std::copy(std::istream_iterator<std::string>(iss), std::istream_iterator<std::string>(),
                  std::back_inserter(tokens));
        if (tokens.size() > 0)
        {
            std::string command = tokens[0];
            if (command == "DISABLE")
            {
                // Send a deactivate timeline packet
                // Expected format for the ENABLE command
                //
                //      DISABLE
                //
                mockService.SendDeactivateTimelinePacket();
            }
            else if (command == "ENABLE")
            {
                // Send aa activate timeline packet
                // Expected format for the ENABLE command
                //
                //      ENABLE
                //
                mockService.SendActivateTimelinePacket();
            }
            else if (command == "LIST")
            {
                // Request the Counter Directory
                // Expected format for the LIST command
                //
                //      LIST
                //

                mockService.SendRequestCounterDir();
            }
            if (command == "SET")
            {
                // Send a periodic counter selection packet
                // Expected format for the SET command
                //
                //      SET 500000 1 2 5 10
                //
                // This breaks down to:
                // SET          command
                // 500000       polling period in micro seconds
                // 1 2 5 10     counter list

                if (tokens.size() > 2) // minimum of 3 tokens.
                {
                    uint32_t period = static_cast<uint32_t>(std::stoul(tokens[1]));

                    std::vector<uint16_t> counters;

                    std::transform(tokens.begin() + 2, tokens.end(), std::back_inserter(counters),
                                   [](const std::string& str)
                                       { return static_cast<uint16_t>(std::stoul(str)); });

                    mockService.SendPeriodicCounterSelectionList(period, counters);
                }
                else
                {
                    std::cerr << "Invalid SET command. Format is: SET <polling period> <id list>" << std::endl;
                }
            }
            else if (command == "WAIT")
            {
                // Wait for an interval of time in microseconds
                // Expected format for the WAIT command
                //
                //      WAIT 11000000
                //
                // This breaks down to:
                // WAIT         command
                // 11000000     timeout period in microseconds
                if (tokens.size() > 1) // minimum of 2 tokens.
                {
                    uint32_t timeout = static_cast<uint32_t>(std::stoul(tokens[1]));
                    mockService.WaitCommand(timeout);
                }
                else
                {
                    std::cerr << "Invalid WAIT command. Format is: WAIT <interval>" << std::endl;
                }
            }
        }
    }
}

---

The documentation for this class was generated from the following files:

• tests/profiling/gatordmock/CommandFileParser.hpp
• tests/profiling/gatordmock/CommandFileParser.cpp