scip_constraint_handler.h

#ifndef SCIP_CONSTRAINT_HANDLER_H
#define SCIP_CONSTRAINT_HANDLER_H

#include<scip/objscip.h>
#include<scil/scil.h>

using namespace scip;

struct ConsData { // TODO kann ich es in den namespace tun?
  SCIL::sym_constraint* sc;
};



namespace SCIL {

  struct ILP_Problem_Data {
    SCIP* scipp;
    subproblem* MYSub;
    CONSHDLR* conshdlr;
    SCIPConsHandler* sconshdlr;
    LEDA::h_array<int,var> VM;
    LEDA::list<cons> CL;
    //LEDA::darray<cons_obj> CM;
    //LEDA::darray<sym_constraint* > SM;
  };

  struct Variable_Data {
    SCIP* scipp;
    VAR* varP;
  };

  struct Basic_Constraint_Data {
    SCIP* scipp;
    ROW* rowp;
  };

  class SCIPConsHandler : public ObjConshdlr {
    subproblem* MYSub;

  public:

  SCIPConsHandler(subproblem* MYSub_);

  virtual RETCODE scip_delete(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONSDATA**    consdata            
      );

  virtual RETCODE scip_trans(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS*         sourcecons,         
      CONS**        targetcons          
      );

  RETCODE scip_initlp(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS**        conss,              
      int           nconss              
      );

  virtual RETCODE scip_sepa(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS**        conss,              
      int           nconss,             
      int           nusefulconss,       
      RESULT*       result              
      );

  virtual RETCODE scip_enfolp(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS**        conss,              
      int           nconss,             
      int           nusefulconss,       
      RESULT*       result              
      );

  virtual RETCODE scip_enfops(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS**        conss,              
      int           nconss,             
      int           nusefulconss,       
      Bool          objinfeasible,      
      RESULT*       result              
      );

  virtual RETCODE scip_check(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS**        conss,              
      int           nconss,             
      SOL*          sol,                
      Bool          checkintegrality,   
      Bool          checklprows,        
      RESULT*       result              
      );

  virtual RETCODE scip_lock(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS*         cons,               
      int           nlockspos,          
      int           nlocksneg           
      );

  virtual RETCODE scip_unlock(
      SCIP*         scip,               
      CONSHDLR*     conshdlr,           
      CONS*         cons,               
      int           nlockspos,          
      int           nlocksneg           
      );


  void addCons(SCIP* scip, sym_constraint* sc);
  };

};

#endif

---