org.drools.planner.config.localsearch.decider.forager.ForagerConfig Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of drools-planner-core Show documentation
Show all versions of drools-planner-core Show documentation
Drools Planner optimizes automated planning by combining metaheuristic search algorithms with rule
engine powered score calculation. This is the drools-planner-core module which contains metaheuristic
algorithms.
/*
* Copyright 2010 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.drools.planner.config.localsearch.decider.forager;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import org.drools.planner.config.localsearch.decider.deciderscorecomparator.DeciderScoreComparatorFactoryConfig;
import org.drools.planner.config.util.ConfigUtils;
import org.drools.planner.core.localsearch.decider.forager.AcceptedForager;
import org.drools.planner.core.localsearch.decider.forager.Forager;
import org.drools.planner.core.localsearch.decider.forager.PickEarlyType;
import org.drools.planner.core.score.definition.ScoreDefinition;
@XStreamAlias("forager")
public class ForagerConfig {
private Class foragerClass = null;
@XStreamAlias("deciderScoreComparatorFactory")
private DeciderScoreComparatorFactoryConfig deciderScoreComparatorFactoryConfig
= new DeciderScoreComparatorFactoryConfig();
private PickEarlyType pickEarlyType = null;
protected Integer minimalAcceptedSelection = null;
public Class getForagerClass() {
return foragerClass;
}
public void setForagerClass(Class foragerClass) {
this.foragerClass = foragerClass;
}
public DeciderScoreComparatorFactoryConfig getDeciderScoreComparatorFactoryConfig() {
return deciderScoreComparatorFactoryConfig;
}
public void setDeciderScoreComparatorFactoryConfig(
DeciderScoreComparatorFactoryConfig deciderScoreComparatorFactoryConfig) {
this.deciderScoreComparatorFactoryConfig = deciderScoreComparatorFactoryConfig;
}
public PickEarlyType getPickEarlyType() {
return pickEarlyType;
}
public void setPickEarlyType(PickEarlyType pickEarlyType) {
this.pickEarlyType = pickEarlyType;
}
public Integer getMinimalAcceptedSelection() {
return minimalAcceptedSelection;
}
public void setMinimalAcceptedSelection(Integer minimalAcceptedSelection) {
this.minimalAcceptedSelection = minimalAcceptedSelection;
}
// ************************************************************************
// Builder methods
// ************************************************************************
public Forager buildForager(ScoreDefinition scoreDefinition) {
if (foragerClass != null) {
try {
return foragerClass.newInstance();
} catch (InstantiationException e) {
throw new IllegalArgumentException("foragerClass (" + foragerClass.getName()
+ ") does not have a public no-arg constructor", e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException("foragerClass (" + foragerClass.getName()
+ ") does not have a public no-arg constructor", e);
}
}
PickEarlyType pickEarlyType = (this.pickEarlyType == null) ? PickEarlyType.NEVER : this.pickEarlyType;
int minimalAcceptedSelection = (this.minimalAcceptedSelection == null)
? Integer.MAX_VALUE : this.minimalAcceptedSelection;
AcceptedForager forager = new AcceptedForager(pickEarlyType, minimalAcceptedSelection);
forager.setDeciderScoreComparatorFactory(deciderScoreComparatorFactoryConfig.buildDeciderScoreComparatorFactory());
return forager;
}
public void inherit(ForagerConfig inheritedConfig) {
// TODO this is messed up
if (foragerClass == null && pickEarlyType == null && minimalAcceptedSelection == null) {
foragerClass = inheritedConfig.getForagerClass();
pickEarlyType = inheritedConfig.getPickEarlyType();
minimalAcceptedSelection = inheritedConfig.getMinimalAcceptedSelection();
}
if (deciderScoreComparatorFactoryConfig == null) {
deciderScoreComparatorFactoryConfig = inheritedConfig.getDeciderScoreComparatorFactoryConfig();
} else if (inheritedConfig.getDeciderScoreComparatorFactoryConfig() != null) {
deciderScoreComparatorFactoryConfig.inherit(inheritedConfig.getDeciderScoreComparatorFactoryConfig());
}
}
}