common/lib/util.h

#ifndef BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_
#define BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_
 
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <optional>
#include <ostream>
#include <string>
#include <vector>
 
#include <boost/random/mersenne_twister.hpp>
 
#include "ir/ir.h"
 
namespace P4::P4Tools {
 
class Utils {
    /* =========================================================================================
     *  Seeds, timestamps, randomness.
     * ========================================================================================= */
 private:
    static boost::random::mt19937 rng;
 
    static std::optional<uint32_t> currentSeed;
 
 public:
    static std::string getTimeStamp();
 
    static void setRandomSeed(int seed);
 
    static std::optional<uint32_t> getCurrentSeed();
 
    static uint64_t getRandInt(uint64_t max);
 
    static int64_t getRandInt(int64_t min, int64_t max);
 
    static int64_t getRandInt(const std::vector<int64_t> &percent);
 
    static big_int getRandBigInt(const big_int &max);
 
    static big_int getRandBigInt(const big_int &min, const big_int &max);
 
    static const IR::Constant *getRandConstantForWidth(int bitWidth);
 
    static const IR::Constant *getRandConstantForType(const IR::Type_Bits *type);
 
    /* =========================================================================================
     *  Other.
     * ========================================================================================= */
 public:
    static const IR::MethodCallExpression *generateInternalMethodCall(
        std::string_view methodName, const std::vector<const IR::Expression *> &argVector,
        const IR::Type *returnType = IR::Type_Void::get(),
        const IR::ParameterList *paramList = new IR::ParameterList());
 
    template <typename T>
    static void shuffle(T *inp) {
        std::shuffle(inp->begin(), inp->end(), rng);
    }
 
    template <typename Iter>
    static Iter pickRandom(Iter start, Iter end) {
        int random = getRandInt(std::distance(start, end) - 1);
        std::advance(start, random);
        return start;
    }
 
    template <typename ContainerType>
    static std::string containerToString(const ContainerType &container) {
        std::stringstream stringStream;
 
        stringStream << '[';
        auto val = container.cbegin();
        if (val != container.cend()) {
            stringStream << *val++;
            while (val != container.cend()) {
                stringStream << ", " << *val++;
            }
        }
        stringStream << ']';
        return stringStream.str();
    }
};
 
std::vector<const IR::Type_Declaration *> argumentsToTypeDeclarations(
    const IR::IGeneralNamespace *ns, const IR::Vector<IR::Argument> *inputArgs);
 
const IR::IDeclaration *findProgramDecl(const IR::IGeneralNamespace *ns, const IR::Path *path);
 
const IR::IDeclaration *findProgramDecl(const IR::IGeneralNamespace *ns,
                                        const IR::PathExpression *pathExpr);
 
const IR::Type_Declaration *resolveProgramType(const IR::IGeneralNamespace *ns,
                                               const IR::Type_Name *type);
 
}  // namespace P4::P4Tools
 
#endif /* BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_ */