cutflow.h

#ifndef CUTFLOW_H
#define CUTFLOW_H
 
#include <fstream>
#include <iostream>
#include <functional>
#include <string>
#include <vector>
#include <map>
#include <chrono>
 
#include "utilities.h"
 
enum Direction
{
    Left,
    Right
};
typedef std::vector<Direction> Directions;
 
class Cut
{
public:
    std::string name;
    Cut* parent;
    Cut* right;
    Cut* left;
    int n_pass;
    int n_fail;
    double n_pass_weighted;
    double n_fail_weighted;
    Utilities::RunningStat runtimes;
 
    Cut(std::string new_name);
 
    virtual ~Cut();
 
    virtual Cut* clone(std::string new_name);
 
    void print();
 
    virtual bool evaluate();
 
    bool getResult();
 
    virtual double weight();
    double getWeight();
};
 
class LambdaCut : public Cut
{
public:
    std::function<bool()> evaluate_lambda;
    std::function<double()> weight_lambda;
 
    LambdaCut(std::string new_name, std::function<bool()> new_evaluate_lambda);
 
    LambdaCut(std::string new_name, std::function<bool()> new_evaluate_lambda, 
              std::function<double()> new_weight_lambda);
 
    LambdaCut* clone(std::string new_name);
 
    bool evaluate();
 
    double weight();
};
 
class Cutflow
{
protected:
    Cut* root;
    std::map<std::string, Cut*> cut_record;
    std::function<void(Cut*)> debugger;
    bool debugger_is_set;
 
    Cut* getCut(std::string cut_name);
 
    bool recursiveSearchProgeny(Cut* cut, Cut* target_cut);
 
    Cut* recursiveFindTerminus(Cut* cut);
 
    void recursivePrint(std::string tabs, Cut* cut, Direction direction, bool show_timing = false);
 
    void recursiveWrite(Cut* cut, std::ofstream& ofstream, std::string output_cflow);
 
    void recursiveWriteCSV(std::string output_dir, Cut* cut, Direction direction, int csv_idx, 
                           Utilities::CSVFiles csv_files);
 
    void recursiveWriteMermaid(Cut* cut, std::ofstream& ofstream, std::string output_mmd);
 
    virtual bool recursiveEvaluate(Cut* cut);
 
    void recursiveDelete(Cut* cut);
 
public:
    std::string name;
    Utilities::Variables globals;
 
    Cutflow();
 
    Cutflow(std::string new_name);
 
    Cutflow(std::string new_name, Cut* new_root);
 
    ~Cutflow();
 
    void setRoot(Cut* new_root);
 
    void insert(std::string target_cut_name, Cut* new_cut, Direction direction);
 
    void insert(Cut* target_cut, Cut* new_cut, Direction direction);
 
    void replace(std::string target_cut_name, Cut* new_cut);
 
    void replace(Cut* target_cut, Cut* new_cut);
 
    void remove(std::string target_cut_name);
 
    void remove(Cut* target_cut);
 
    virtual bool run();
 
    bool run(Cut* target_cut);
 
    bool run(std::string target_cut_name);
 
    std::vector<bool> run(std::vector<Cut*> target_cuts);
 
    std::vector<bool> run(std::vector<std::string> target_cuts);
 
    bool isProgeny(std::string parent_cut_name, std::string target_cut_name, Direction direction);
 
    bool isProgeny(Cut* parent_cut, Cut* target_cut, Direction direction);
 
    Cut* findTerminus(std::string starting_cut_name);
 
    Cut* findTerminus(Cut* starting_cut);
 
    void print(bool show_timing = false);
 
    void write(std::string output_dir = "");
 
    void writeCSV(std::string output_dir = "");
 
    void writeMermaid(std::string output_dir = "", std::string orientation = "TD");
 
    void setDebugLambda(std::function<void(Cut*)> new_debugger);
};
 
#endif