How to use org.sbml.jsbml.validator.offline.constraints.helper

/**
 * A idChar is a letter, digit or '-'.
 * 
 * @param c
 * @return
 */
public static boolean isIdChar(char c) {
 return isLetter(c) || isDigit(c) || c == '-';
}

/**
 * A letter is either a small letter or big letter.
 * 
 * @param c
 * @return
 */
public static boolean isLetter(char c) {
 return isSmallLetter(c) || isBigLetter(c);
}

 @Override
 public boolean check(ValidationContext ctx, Reaction r) {
  return new DuplicatedElementValidationFunction<Reaction>("listOfReactants").check(ctx, r) 
    && new DuplicatedElementValidationFunction<Reaction>("listOfProducts").check(ctx, r) 
    && new DuplicatedElementValidationFunction<Reaction>("listOfModifiers").check(ctx, r) 
    && new DuplicatedElementValidationFunction<Reaction>("kineticLaw").check(ctx, r); 
 }
};

 @Override
 public boolean check(ValidationContext ctx, Model m) {
  if (m.isSetListOfConstraints() || m.isListOfConstraintsEmpty()) {
   return new UnknownAttributeValidationFunction<TreeNodeWithChangeSupport>().check(ctx, m.getListOfConstraints());
  }
  return true;
 }
};

 @Override
 public boolean check(ValidationContext ctx, Reaction r) {
  boolean check = true;
  
  if (r.isSetListOfModifiers() || r.isListOfModifiersEmpty()) {
   check &= new UnknownElementValidationFunction<TreeNodeWithChangeSupport>().check(ctx, r.getListOfModifiers());
  }
  return check;
 }
};

 @Override
 public boolean check(ValidationContext ctx, QualitativeSpecies q) {
  return new UnknownCoreAttributeAbstractValidationFunction<QualitativeSpecies>().check(ctx, q, QUAL_20301);
 }
};

@Override
public ValidationFunction<?> getValidationFunction(int errorCode, ValidationContext context) {
 ValidationFunction<AssignmentRule> func = null;
 switch (errorCode) {
 case CORE_20910:
  func = new UnknownAttributeValidationFunction<AssignmentRule>();
  break;
 }
 return func;
}

 @Override
 public boolean check(ValidationContext ctx, Unit unit) {
  // 'kind', 'exponent', 'scale' and 'multiplier' are mandatory attributes
  if (!unit.isSetKind() || !unit.isSetExponent()
    || !unit.isSetScale() || !unit.isSetMultiplier())
  {
   return false;
  }
  return super.check(ctx, unit);
 }
};

 @Override
 public boolean check(ValidationContext ctx, KineticLaw kl) {
 
  // checking that the unit are equivalent to substance / time for < L3
  // and extend / time for L3
  if (!ValidationTools.hasCorrectUnits(ctx, kl)) {
   return false;
  }
  
  return true;
 }
};

@Override
public ASTNodeValue pow(ASTNode base, ASTNode exponent)
  throws SBMLException 
{
 return pow(base.compile(this), exponent.compile(this));
}

 @Override
 public boolean check(ValidationContext ctx, SBase sb) {
  if (sb.isSetSBOTerm()) {
   return ValidationTools.isSboTerm(sb.getSBOTermID());
  }
  return true;
 }
};

 @Override
 public boolean check(ValidationContext ctx, FunctionTerm ft) {
  if (ft.isDefaultTerm() && !ft.isSetResultLevel()) {
   return false;
  } else if (ft.isDefaultTerm()) {
   return super.check(ctx, ft);
  }
  
  return true;
 }
};

 @Override
 public boolean check(ValidationContext ctx, QualModelPlugin qmp) {		      
  Boolean onlyOneListOfTransition = new DuplicatedElementValidationFunction<QualModelPlugin>(QualConstants.listOfTransitions).check(ctx, qmp);
  Boolean onlyOneListOfQualSpec = new DuplicatedElementValidationFunction<QualModelPlugin>(QualConstants.listOfQualitativeSpecies).check(ctx, qmp);
  
  return (onlyOneListOfTransition && onlyOneListOfQualSpec);
 }
};

 @Override
 public boolean check(ValidationContext ctx, Model m) {
  if (m.isSetListOfInitialAssignments() || m.isListOfInitialAssignmentsEmpty()) {
   return new UnknownAttributeValidationFunction<TreeNodeWithChangeSupport>().check(ctx, m.getListOfInitialAssignments());
  }
  return true;
 }
};

 @Override
 public boolean check(ValidationContext ctx, Transition t) {
  return new UnknownCoreAttributeAbstractValidationFunction<Transition>().check(ctx, t, QUAL_20401);
 }
};

/**
 * A NameChar (defined in the XML Schema 1.0) can be a letter, a digit, '.',
 * '-', '_', ':', a CombiningChar or Extender.
 * 
 * @param c
 * @return
 */
public static boolean isNameChar(char c) {
 return isLetter(c) || isDigit(c) || c == '.' || c == '-' || c == '_'
   || c == ':';
}

 @Override
 public boolean check(ValidationContext ctx, Model m) {
  
  return new DuplicatedElementValidationFunction<Model>("listOfFunctionDefinitions").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfUnitDefinitions").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfCompartments").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfSpecies").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfParameters").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfInitialAssignments").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfRules").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfConstraints").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfReactions").check(ctx, m) 
    && new DuplicatedElementValidationFunction<Model>("listOfEvents").check(ctx, m); 
 }
};

 @Override
 public boolean check(ValidationContext ctx, Output o) {
  return new UnknownCoreAttributeAbstractValidationFunction<Output>().check(ctx, o, QUAL_20601);
 }
};

 @Override
 public boolean check(ValidationContext ctx, Input i) {
  return new UnknownCoreAttributeAbstractValidationFunction<Input>().check(ctx, i, QUAL_20501);
 }
};

 @Override
 public boolean check(ValidationContext ctx, FunctionTerm ft) {
  boolean func = true;
  if (ft.isDefaultTerm()) {
   func = new UnknownCoreAttributeAbstractValidationFunction<FunctionTerm>().check(ctx, ft, QUAL_20701);
   return func;      
  }
  return true;
 }
};