Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.drools.impl.adapters;
  
 import  org.kie.api.event.kiebase.AfterFunctionRemovedEvent;
 import  org.kie.api.event.kiebase.AfterKieBaseLockedEvent;
 import  org.kie.api.event.kiebase.AfterKieBaseUnlockedEvent;
 import  org.kie.api.event.kiebase.AfterKiePackageAddedEvent;
 import  org.kie.api.event.kiebase.AfterKiePackageRemovedEvent;
 import  org.kie.api.event.kiebase.AfterProcessAddedEvent;
 import  org.kie.api.event.kiebase.AfterProcessRemovedEvent;
 import  org.kie.api.event.kiebase.AfterRuleAddedEvent;
 import  org.kie.api.event.kiebase.AfterRuleRemovedEvent;
 import  org.kie.api.event.kiebase.BeforeFunctionRemovedEvent;
 import  org.kie.api.event.kiebase.BeforeKieBaseLockedEvent;
 import  org.kie.api.event.kiebase.BeforeKieBaseUnlockedEvent;
 import  org.kie.api.event.kiebase.BeforeKiePackageAddedEvent;
 import  org.kie.api.event.kiebase.BeforeKiePackageRemovedEvent;
 import  org.kie.api.event.kiebase.BeforeProcessAddedEvent;
 import  org.kie.api.event.kiebase.BeforeProcessRemovedEvent;
 import  org.kie.api.event.kiebase.BeforeRuleAddedEvent;
 import  org.kie.api.event.kiebase.BeforeRuleRemovedEvent;
 import  org.kie.api.event.kiebase.KieBaseEventListener;
 
 public class KnowledgeBaseEventListenerAdapter implements KieBaseEventListener {
 
     private final KnowledgeBaseEventListener delegate;
 
         this. = delegate;
     }
 
     public void beforeKiePackageAdded(final BeforeKiePackageAddedEvent event) {
             public KnowledgePackage getKnowledgePackage() {
                 return new KnowledgePackageAdapter((org.kie.internal.definition.KnowledgePackage)event.getKiePackage());
             }
 
             public KnowledgeBase getKnowledgeBase() {
                 return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase)event.getKieBase());
             }
         });
     }
 
     public void afterKiePackageAdded(final AfterKiePackageAddedEvent event) {
             public KnowledgePackage getKnowledgePackage() {
                 return new KnowledgePackageAdapter((org.kie.internal.definition.KnowledgePackage) event.getKiePackage());
             }
 
             public KnowledgeBase getKnowledgeBase() {
                 return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
             }
         });
     }
 
     public void beforeKiePackageRemoved(final BeforeKiePackageRemovedEvent event) {
             public KnowledgePackage getKnowledgePackage() {
                 return new KnowledgePackageAdapter((org.kie.internal.definition.KnowledgePackage) event.getKiePackage());
             }
 
             public KnowledgeBase getKnowledgeBase() {
                 return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
             }
         });
     }
 
     public void afterKiePackageRemoved(final AfterKiePackageRemovedEvent event) {
             public KnowledgePackage getKnowledgePackage() {
                 return new KnowledgePackageAdapter((org.kie.internal.definition.KnowledgePackage) event.getKiePackage());
             }
 
             public KnowledgeBase getKnowledgeBase() {
                 return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
             }
         });
     }
 
     public void beforeKieBaseLocked(final BeforeKieBaseLockedEvent event) {
             public KnowledgeBase getKnowledgeBase() {
                 return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
             }
         });
     }
 
    public void afterKieBaseLocked(final AfterKieBaseLockedEvent event) {
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
            public Rule getRule() {
                return new RuleAdapter(event.getRule());
            }
        });
    }
    public void beforeKieBaseUnlocked(final BeforeKieBaseUnlockedEvent event) {
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterKieBaseUnlocked(final AfterKieBaseUnlockedEvent event) {
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void beforeRuleAdded(final BeforeRuleAddedEvent event) {
            public Rule getRule() {
                return new RuleAdapter(event.getRule());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterRuleAdded(final AfterRuleAddedEvent event) {
            public Rule getRule() {
                return new RuleAdapter(event.getRule());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void beforeRuleRemoved(final BeforeRuleRemovedEvent event) {
            public Rule getRule() {
                return new RuleAdapter(event.getRule());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterRuleRemoved(final AfterRuleRemovedEvent event) {
            public Rule getRule() {
                return new RuleAdapter(event.getRule());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void beforeFunctionRemoved(final BeforeFunctionRemovedEvent event) {
            public String getFunction() {
                return event.getFunction();
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterFunctionRemoved(final AfterFunctionRemovedEvent event) {
            public String getFunction() {
                return event.getFunction();
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void beforeProcessAdded(final BeforeProcessAddedEvent event) {
            public org.drools.definition.process.Process getProcess() {
                return new ProcessAdapter(event.getProcess());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterProcessAdded(final AfterProcessAddedEvent event) {
            public org.drools.definition.process.Process getProcess() {
                return new ProcessAdapter(event.getProcess());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void beforeProcessRemoved(final BeforeProcessRemovedEvent event) {
            public org.drools.definition.process.Process getProcess() {
                return new ProcessAdapter(event.getProcess());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    public void afterProcessRemoved(final AfterProcessRemovedEvent event) {
            public org.drools.definition.process.Process getProcess() {
                return new ProcessAdapter(event.getProcess());
            }
            public KnowledgeBase getKnowledgeBase() {
                return new KnowledgeBaseAdapter((org.kie.internal.KnowledgeBase) event.getKieBase());
            }
        });
    }
    @Override
    public int hashCode() {
        return .hashCode();
    }
    @Override
    public boolean equals(Object obj) {
    }
New to GrepCode? Check out our FAQ X