.. _program_listing_file_src_partition_refine_engine_MoveApplier.h:

Program Listing for File MoveApplier.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_partition_refine_engine_MoveApplier.h>` (``src/partition/refine/engine/MoveApplier.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef PARTITION_REFINE_ENGINE_MOVEAPPLIER_H_
   #define PARTITION_REFINE_ENGINE_MOVEAPPLIER_H_
   
   #include "refine/bucket/MoveBucket.h"
   #include "refine/core/RefineTypes.h"
   
   
   class IMoveConstraintChecker {
    public:
     virtual ~IMoveConstraintChecker() = default;
   
     virtual bool canMove(
         const graph &finest, vector<VectorXi> &occupied_resources,
         vector<int> &parts, int node_id, int to_part, const fpga &fpgas,
         const std::function<bool(const vector<VectorXi> &, const node &, int)>
             &check_balance) const = 0;
   };
   
   class CompositeConstraintChecker : public IMoveConstraintChecker {
    public:
     bool canMove(const graph &finest, vector<VectorXi> &occupied_resources,
                  vector<int> &parts, int node_id, int to_part, const fpga &fpgas,
                  const std::function<bool(const vector<VectorXi> &, const node &,
                                           int)> &check_balance) const override;
   };
   
   struct MoveApplierContext {
     int large_net_threshold;               
     vector<vector<int>> &cut_weights;      
     const fpga &fpgas;                     
     const TimingRefineConfig &timing_cfg;  
   };
   
   class MoveStateApplierCore {
    public:
     static void takeMove(const MoveApplierContext &ctx, const graph &finest,
                          vector<VectorXi> &occupied_resources, vector<int> &parts,
                          vector<NetPartition> &partition, int node, int best_p,
                          HSFullTiming::HSTimingDelta *delta,
                          bool update_timing_edge = true);
   
     static void applyMoveToState(const MoveApplierContext &ctx,
                                  const Gain &gain_cell, const graph &finest,
                                  vector<int> &parts,
                                  vector<VectorXi> &occupied_resources,
                                  vector<NetPartition> &partition);
   
     static void acceptMove(const MoveApplierContext &ctx, const Gain &gain_cell,
                            PerPartBucketSet &buckets, vector<Gain> &moves_trace,
                            double &total_delta_gain,
                            vector<bool> &visited_vertices_flag,
                            const graph &finest, vector<int> &parts,
                            vector<VectorXi> &occupied_resources,
                            vector<NetPartition> &partition);
   
     static void cancelMove(const MoveApplierContext &ctx, const Gain &gain_cell,
                            const graph &finest,
                            vector<bool> &visited_vertices_flag,
                            vector<int> &parts,
                            vector<VectorXi> &occupied_resources,
                            vector<NetPartition> &partition);
   };
   
   class ConstraintCheckerCore {
    public:
     static bool checkBalance(const fpga &fpgas,
                              const vector<VectorXi> &occupied_resources,
                              const node &vertex, int from);
   
     static bool checkMove(
         const fpga &fpgas, const graph &finest,
         vector<VectorXi> &occupied_resources, vector<int> &parts, int node_id,
         int toPart,
         const std::function<bool(const vector<VectorXi> &, const node &, int)>
             &check_balance_fn);
   };
   
   #endif