public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
@Override public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ @Override public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
@Override public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
@Override public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ @Override public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ @Override public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }
public StructValidator getSimpleValidator() { return new Validator(mArity, mElemName); }
/** * Rules for reuse are simple: if we can have any number of * repetitions, we can just use a shared root instance. Although * its count variable will get updated this doesn't really * matter as it won't be used. Otherwise a new instance has to * be created always, to keep track of instance counts. */ public StructValidator newInstance() { return (mArity == '*') ? this : new Validator(mArity, mElemName); }