/*
 * Copyright (c) 2015, University of Kaiserslautern
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors:
 *    Janik Schlemminger
 *    Robert Gernhardt
 *    Matthias Jung
 */

#include "Command.h"
#include <systemc.h>


std::string commandToString(Command command)
{
    switch (command) {
    case Command::Read:
        return "RD";
        break;
    case Command::ReadA:
        return "RDA";
        break;
    case Command::Write:
        return "WR";
        break;
    case Command::WriteA:
        return "WRA";
        break;
    case Command::PreB:
        return "PREB";
        break;
    case Command::Precharge:
        return "PRE";
        break;
    case Command::ActB:
        return "ACTB";
        break;
    case Command::Activate:
        return "ACT";
        break;
    case Command::PrechargeAll:
        return "PRE_ALL";
        break;
    case Command::AutoRefresh:
        return "REF";
        break;

    case Command::PDNA:
        return "PDNA";
        break;
    case Command::PDNAX:
        return "PDNAX";
        break;
    case Command::PDNP:
        return "PDNP";
        break;
    case Command::PDNPX:
        return "PDNPX";
        break;
    case Command::SREF:
        return "SREF";
        break;
    case Command::SREFX:
        return "SREFX";
        break;

    case Command::NOP:
        return "NOP";
        break;

    default:
        SC_REPORT_FATAL("command", "commandToString was called with unknown command");
        break;
    }

    return "";
}

const std::vector<Command> &getAllCommands()
{
    static std::vector<Command> allCommands( { Command::PreB,
                                               Command::Precharge,
                                               Command::PrechargeAll,
                                               Command::ActB,
                                               Command::Activate,
                                               Command::Read,
                                               Command::Write,
                                               Command::ReadA,
                                               Command::WriteA,
                                               Command::AutoRefresh,
                                               Command::PDNA,
                                               Command::PDNAX,
                                               Command::PDNP,
                                               Command::PDNPX,
                                               Command::SREF,
                                               Command::SREFX
                                             });
    return allCommands;
}

bool commandIsIn(Command command, std::vector<Command> commands)
{
    for (Command c : commands) {
        if (c == command)
            return true;
    }
    return false;
}
