How to use org.kie.pmml.pmml_4_2.model.mining

public SegmentExecution(String correlationId, 
    String segmentationId, 
    String segmentId, 
    int segmentIndex, 
    String state, 
    String ruleUnitClassName) {
  this.correlationId = correlationId;
  this.segmentationId = segmentationId;
  this.segmentId = segmentId;
  this.segmentIndex = segmentIndex;
  this.state = SegmentExecutionState.valueOf(state);
  this.ruleUnitClassName = ruleUnitClassName;
}

public boolean isAlwaysTrue() {
  return predicateRuleProducer.isAlwaysTrue();
}

public boolean isAlwaysFalse() {
  return predicateRuleProducer.isAlwaysFalse();
}

  public static PredicateRuleProducer getPredicateProducer(Serializable serializable) {
    if (serializable instanceof SimplePredicate) return new SimpleSegmentPredicate((SimplePredicate)serializable);
    if (serializable instanceof SimpleSetPredicate) return new SimpleSetSegmentPredicate((SimpleSetPredicate)serializable);
    if (serializable instanceof CompoundPredicate) return new CompoundSegmentPredicate((CompoundPredicate)serializable);
    if (serializable instanceof True) return new BooleanSegmentPredicate((True)serializable);
    if (serializable instanceof False) return new BooleanSegmentPredicate((False)serializable);
    throw new IllegalArgumentException("Serializable object [" + serializable.getClass().getName() + "] is not one of the known predicate types");
  }
}

private String buildSurrogationPredicate() {
  StringBuilder builder = new StringBuilder();
  String predicate = this.getPrimaryPredicateRule();
  builder.append("( ").append(predicate).append(" )");
  for (int lastPred = 0; lastPred < getSubpredicateCount(); lastPred++) {
    predicate = this.getNextPredicateRule(lastPred);
    if (predicate != null) {
      builder.append(" || ( ").append(predicate).append(" )");
    }
  }
  return builder.toString();
}

public MiningSegmentWeight(MiningSegment segment) {
  super();
  this.segmentationId = segment.getOwner().getSegmentationId();
  this.segmentId = segment.getSegmentId();
  List<String> targets = segment.getTargetsForWeighting();
  if (targets != null && !targets.isEmpty()) {
    this.targetName = targets.get(0);
  }
  this.weight = segment.getWeight();
}
public MiningSegmentWeight(String segmentationId, String segmentId, String targetName, Double weight) {

@Test
public void testSimpleWithFieldNamesMap() {
  MiningSegmentTransfer mst = new MiningSegmentTransfer(simpleResult,"SEGMENT_2");
  mst.addResultToRequestMapping("var1", "someVarA");
  doBaselineAssertions(simpleResult,mst);
  assertEquals(1,mst.getResultFieldNameToRequestFieldName().size());
}

@Override
public String getPredicateRule() {
  if (booleanOperator.equalsIgnoreCase("and")) {
    return buildAndPredicate();
  } else if (booleanOperator.equalsIgnoreCase("or")) {
    return buildOrPredicate();
  } else if (booleanOperator.equalsIgnoreCase("xor")) {
    return buildXorPredicate();
  } else if (hasSurrogation()) {
    return buildSurrogationPredicate();
  }
  return null;
}

private void doPredicateRetrieve(String expected) {
  SimpleSetSegmentPredicate sssp = new SimpleSetSegmentPredicate(predicate);
  String text = sssp.getPredicateRule();
  assertNotNull(text);
  assertEquals(expected,text);
}

@Test
public void testSimpleResult() {
  MiningSegmentTransfer mst = new MiningSegmentTransfer(simpleResult,"SEGMENT_2");
  doBaselineAssertions(simpleResult,mst);
}

  public String getSegmentationAgendaId() {
    return getOwner().getModelId()+"_"+getSegmentationId();
  }
}

@Override
public String toString() {
  StringBuilder bldr = new StringBuilder("MiningSegmentTransfer [");
  bldr.append("correlationId=").append(correlationId).append(", ");
  bldr.append("segmentationId=").append(segmentationId).append(", ");
  bldr.append("fromSegmentId=").append(fromSegmentId).append(", ");
  bldr.append("toSegmentId=").append(toSegmentId).append(", ");
  bldr.append("resultFieldNameToRequestFieldName=").append(requestFromResultMap).append(", ");
  bldr.append("inboundResult=").append(inboundResult).append(", ");
  bldr.append("outboundRequest=").append(getOutboundRequest());
  
  bldr.append("]");
  return bldr.toString();
}

public String getPredicateText() {
  return this.predicateRuleProducer.getPredicateRule();
}

public String getMissingFieldName() {
  return "m".concat(getCapitalizedFieldName());
}

public String getTargetForWeighting() {
  List<String> targets = this.getTargetsForWeighting();
  return (targets != null && !targets.isEmpty()) ? targets.get(0):null;
}

public String generateRules() {
  StringBuilder bldr = new StringBuilder();
  if (this.scoreable && this.segmentation != null) {
    bldr.append(segmentation.generateSegmentationRules());
  }
  return bldr.toString();
}

public String getSegmentPackageName() {
  StringBuilder builder = new StringBuilder(segmentPackageRootName);
  builder.append(".mining.segment_").append(this.getSegmentId());
  return builder.toString();
}

private void initSegments(List<Segment> segments) {
  if (segments != null && !segments.isEmpty()) {
    for (int index = 0; index < segments.size(); index++) {
      Segment seg = segments.get(index);
      MiningSegment ms = new MiningSegment(this,seg,index);
      miningSegments.add(ms);
    }
  }
}

public MiningSegment( MiningSegmentation owner, Segment segment, int segmentIndex) {
  this.owner = owner;
  
  this.internalModel = PMML4ModelFactory.getInstance().getModel(segment,owner);
  this.segmentId = segment.getId();
  this.segmentIndex = segmentIndex;
  this.weight = segment.getWeight();
  if (segment.getSimplePredicate() != null) {
    predicateRuleProducer = new SimpleSegmentPredicate(segment.getSimplePredicate());
  } else if (segment.getSimpleSetPredicate() != null) {
    predicateRuleProducer = new SimpleSetSegmentPredicate(segment.getSimpleSetPredicate());
  } else if (segment.getCompoundPredicate() != null) {
    predicateRuleProducer = new CompoundSegmentPredicate(segment.getCompoundPredicate());
  } else if (segment.getTrue() != null) {
    predicateRuleProducer = new BooleanSegmentPredicate(segment.getTrue());
  } else if (segment.getFalse() != null) {
    predicateRuleProducer = new BooleanSegmentPredicate(segment.getFalse());
  }
}

public void setState(String state) {
  this.state = SegmentExecutionState.valueOf(state);
}