path: root/org.eclipse.osbp.utils/src/org/eclipse/osbp/utils/fillertext/FillerTextProvider.java

/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License v1.0       
 * which accompanies this distribution, and is available at                  
 * http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
package org.eclipse.osbp.utils.fillertext;

import java.sql.Date;
import java.sql.Time;
import java.util.HashMap;
import java.util.Locale;

import org.eclipse.osbp.utils.fillertext.provider.BaseProvider;
import org.eclipse.osbp.utils.fillertext.provider.DateProvider;
import org.eclipse.osbp.utils.fillertext.provider.TextProvider;
import org.joda.time.DateTime;

/**
 * Provides filler texts (german: Blindtext) for different data types,
 * depending on the locale set.
 * <br><br>
 * <b><u><i>Filler text</i> vs. <i>Mock object</i></u></b><br>
 * There is an essential difference between <i>Filler text</i> and <i>Mock object</i>!
 * <ul>
 * <li><b><a href="https://en.wikipedia.org/wiki/Filler_text">Filler text</a> (german: <a href="https://de.wikipedia.org/wiki/Blindtext">Blindtext</a>)</b><br>
 * [...] (also placeholder text or dummy text) is text that shares some characteristics of a real written text, but <b>is random or otherwise generated</b>. It may be used to display a sample of fonts, generate text for testing, or to spoof an e-mail spam filter. The process of using filler text is sometimes called Greeking, although <b>the text itself may be nonsense</b>, or largely Latin, as in Lorem ipsum.[...]<br>
 * [...] Mit Hilfe des Blindtextes kann die Verteilung des Textes auf der Seite (Layout oder Satzspiegel) sowie Lesbarkeit und Platzbedarf der verwendeten Schriftarten (Typografie) beurteilt werden. Er <b>besteht aus einer mehr oder minder sinnlosen Folge von Wörtern, oft auch nur aus wortähnlichen Silbenfolgen</b>. Ein bekanntes Beispiel dafür ist das „lateinische“ Lorem ipsum.[...]
 * </li>
 * <li><b><a href="https://en.wikipedia.org/wiki/Mock_object">Mock object</a> (german: <a href="https://de.wikipedia.org/wiki/Mock-Objekt">Mock-Objekt</a>)</b><br>
 * [...] are <b>simulated objects that mimic the behavior of real objects in controlled ways</b>. A programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts.[...]<br>
 * [...] implementieren die Schnittstellen, über die das zu testende Objekt auf seine Umgebung zugreift. Sie <b>stellen sicher, dass die erwarteten Methodenaufrufe vollständig, mit den korrekten Parametern und in der erwarteten Reihenfolge durchgeführt werden</b>. Das Mock-Objekt liefert keine Echtdaten zurück, sondern <b>vorher zum Testfall passend festgelegte Werte</b>. Das Mock-Objekt kann somit dazu verwendet werden, <b>ein bestimmtes Verhalten nachzustellen</b>.[...]
 * </li>
 * </ul>
 */
public class FillerTextProvider {

	private static HashMap<Locale, FillerTextProvider> sProviders = new HashMap<>();
	private final BaseProvider fBaseProducer;
	private final DateProvider fDateProducer;
	private final TextProvider fTextProducer;
	private final Locale fLocale;
	
	/**
	 *  Get the provider for the given locale. The provider will be cached!
	 *  @see #destroy()
	 *  @param locale
	 *  @return the provider
	 */
	public static FillerTextProvider get(Locale locale) {
		FillerTextProvider provider = sProviders.get(locale);
		if	(provider == null) {
			provider = new FillerTextProvider(locale);
			sProviders.put(locale, provider);
		}
		return provider;
	}
	
	private FillerTextProvider(Locale locale) {
		fLocale = locale;
		fBaseProducer = new BaseProvider();
		fDateProducer = new DateProvider(fBaseProducer);
		fTextProducer = new TextProvider(fBaseProducer, fLocale);
	}
	
	/**
	 *  The provider is removed from the cache
	 *  @see #get(Locale)
	 */
	public void destroy() {
		sProviders.remove(this);
	}
	
	/**
	 *  The provider uses some internal objects to return consistent filled text,
	 *  for example first, last, full name and email.<br>
	 *  To force the provider to generate new internal objects, call {@link #reset()}!<br>
	 *  This could be necessary, if more than one data row has to be generated.
	 */
	public void reset() {
//		fPerson = null;
	}
	
	/**
	 *  generate a filled text for the given {@link javax.sql.Types}
	 *  @see #generate(FillerTextType, Object...) 
	 *  @param type any supported java.sql.Types
	 *  @param params
	 *  @return the generated filler text object
	 */
	public Object generate(int type, Object...params) {
		return generate(FillerTextType.typeFor(type), params);
	}
	
	/**
	 *  generate a filled text for the given type string
	 *  @see #generate(FillerTextType, Object...) 
	 *  @param type string, can be any <u>case insensitive</u> name of {@link FillerTextType}
	 *  @param params
	 *  @return the generated filler text object
	 */
	public Object generate(String type, Object...params) {
		return generate(FillerTextType.typeFor(type), params);
	}

	/**
	 *  generate a filled text for the given {@link FillerTextType}
	 *  @param type
	 *  @param params, see source code and the corresponding methods for supported paramaters
	 *  @return the generated filler text object
	 */
	public Object generate(FillerTextType type, Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		switch(type) {
			case TIMESTAMP:
				return timestamp(params);
			case DATE:
				return date(params);
			case TIME:
				return time();
			case SIGNEDINTEGER:
				return signedinteger(params);
			case UNSIGNEDINTEGER:
				return unsignedinteger(params);
			case SIGNEDDOUBLE:
			case SIGNEDDECIMAL:
				return signeddouble(params);
			case UNSIGNEDDOUBLE:
			case UNSIGNEDDECIMAL:
				return unsigneddouble(params);
			case TRUEORFALSE:
				return trueOrFalse();
			case BLOB:
			case PARAGRAPH: 
				if	((params.length == 1) && (params[0] instanceof Integer)) {
					return paragraphs((int) params[0]);
				}
				else {
					return paragraph();
				}
			case OTHER:
			case SENTENCE: 
				if	((params.length == 1) && (params[0] instanceof Integer)) {
					return sentences((int) params[0]);
				}
				else {
					return sentence();
				}
			case WORD: 
			case TEXT:
			default:
				if	((params.length == 1) && (params[0] instanceof Integer)) {
					return words((int) params[0]);
				}
				else {
					return word();
				}
		}
	}

	/**
	 * @see FillerTextType#UNSIGNEDINTEGER
	 * @param params may be<ul>
	 * 			<li>none - generate an unsigned (positive) integer in the range 0..100</li>
	 * 			<li>(int)max - generate an unsigned (positive) integer in the range 0..max; same as {@link #unsignedinteger(int)}</li>
	 * 			<li>(int)min,(int)max - generate an unsigned (positive) integer in the range min..max; same as {@link #unsignedinteger(int, int)}</li>
	 * 			<li>(int)min,(int)max,(int)round - generate an unsigned (positive) integer in the range min..max rounding to round; same as {@link #unsignedinteger(int, int, int)}</li>
	 * </ul>
	 * @return the generated filler text object
	 */
	public int unsignedinteger(Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		int length = 0;
		while ((params.length > length) && (params[length] instanceof Integer)) {
			length++;
		}
		switch (length) {
			case 0:
				return unsignedinteger(100);
			case 1:
				return unsignedinteger((int)params[0]);
			case 2:
				return unsignedinteger((int)params[0], (int)params[1]);
			case 3:
			default:
				return unsignedinteger((int)params[0], (int)params[1], (int)params[2]);
		}
	}

	/**
	 * @see FillerTextType#UNSIGNEDINTEGER
	 * @param max - generate an unsigned (positive) integer in the range 0..max
	 * @return the generated filler text object
	 */
	public int unsignedinteger(int max) {
		return unsignedinteger(0, Math.max(0, max));
	}

	/**
	 * generate an unsigned (positive) integer in the range min..max
	 * @see FillerTextType#UNSIGNEDINTEGER
	 * @param min
	 * @param max
	 * @return the generated filler text object
	 */
	public int unsignedinteger(int min, int max) {
		return unsignedinteger(min, max, 1);
	}

	/**
	 * generate an unsigned (positive) integer in the range min..max
	 * @see FillerTextType#UNSIGNEDINTEGER
	 * @param min
	 * @param max
	 * @param round
	 * @return the generated filler text object
	 */
	public int unsignedinteger(int min, int max, int round) {
		int result = fBaseProducer.randomBetween(Math.min(min, max), Math.max(min, max));
		if	(round > 1) {
			result = ((result + round/2) / round) * round;
		}
		return result;
	}

	/**
	 * @see FillerTextType#SIGNEDINTEGER
	 * @param params may be<ul>
	 * 			<li>none - generate a signed (positive or negative) integer in the range -100..100</li>
	 * 			<li>(int)max - generate a signed (positive or negative) integer in the range -max..max; same as {@link #signedinteger(int)}</li>
	 * 			<li>(int)min,(int)max - generate a signed (positive or negative) integer in the range min..max; same as {@link #signedinteger(int, int)}</li>
	 * 			<li>(int)min,(int)max,(int)round - generate an unsigned (positive) integer in the range min..max rounding to round; same as {@link #signedinteger(int, int, int)}</li>
	 * </ul>
	 * @return the generated filler text object
	 */
	public int signedinteger(Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		int length = 0;
		while ((params.length > length) && (params[length] instanceof Integer)) {
			length++;
		}
		switch (length) {
			case 0:
				return signedinteger(100);
			case 1:
				return signedinteger((int)params[0]);
			case 2:
				return signedinteger((int)params[0], (int)params[1]);
			case 3:
			default:
				return signedinteger((int)params[0], (int)params[1], (int)params[2]);
		}
	}

	/**
	 * @see FillerTextType#SIGNEDINTEGER
	 * @param max - generate a signed (positive or negative) integer in the range -max..max
	 * @return the generated filler text object
	 */
	public int signedinteger(int range) {
		return signedinteger(-Math.abs(range), Math.abs(range));
	}

	/**
	 * generate a signed (positive or negative) integer in the range min..max
	 * @see FillerTextType#SIGNEDINTEGER
	 * @param min
	 * @param max
	 * @return the generated filler text object
	 */
	public int signedinteger(int min, int max) {
		return signedinteger(min, max, 1);
	}

	/**
	 * generate a signed (positive or negative) integer in the range min..max
	 * @see FillerTextType#SIGNEDINTEGER
	 * @param min
	 * @param max
	 * @param round, must be positive
	 * @return the generated filler text object
	 */
	public int signedinteger(int min, int max, int round) {
		int result = fBaseProducer.randomBetween(Math.min(min, max), Math.max(min, max));
		if	(round > 1) {
			result = ((result + round/2) / round) * round;
		}
		return result;
	}

	/**
	 * @see FillerTextType#UNSIGNEDDOUBLE
	 * @param params may be<ul>
	 * 			<li>none - generate an unsigned (positive) double in the range 0.00..100.00 with two decimal digits</li>
	 * 			<li>(int)decimals - generate an unsigned (positive) double in the range 0.00..100.00 with (decimal) decimal digits; same as {@link #unsigneddouble(int)}</li>
	 * 			<li>(int)decimals,(double)max - generate an unsigned (positive) double in the range 0..max with (decimal) decimal digits; same as {@link #unsigneddouble(int,double)}</li>
	 * 			<li>(int)decimals,(double)min,(double)max - generate an unsigned (positive) double in the range min..max with (decimal) decimal digits; same as {@link #unsigneddouble(int,double,double)}</li>
	 * 			<li>(int)decimals,(double)min,(double)max,(double)round - generate an unsigned (positive) double in the range min..max with (decimal) decimal digits rounding; same as {@link #unsigneddouble(int,double,double,double)}</li>
	 * </ul>
	 * @return the generated filler text object
	 */
	public double unsigneddouble(Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		int length = 0;
		int decimals = 2;
		if	((params.length > 0) && (params[0] instanceof Integer)) {
			decimals = (int)params[0];
			while ((params.length > length+1) && (params[length+1] instanceof Double)) {
				length++;
			}
		}
		switch (length) {
			case 0:
				return unsigneddouble(decimals);
			case 1:
				return unsigneddouble(decimals, (double)params[1]);
			case 2:
				return unsigneddouble(decimals, (double)params[1], (double)params[2]);
			case 3:
			default:
				return unsigneddouble(decimals, (double)params[1], (double)params[2], (double)params[3]);
		}
	}
	
	/**
	 * @see FillerTextType#UNSIGNEDDOUBLE
	 * @param decimals - generate an unsigned (positive) double in the range 0.00..100.00 with (decimal) decimal digits
	 * @return the generated filler text object
	 */
	public double unsigneddouble(int decimals) {
		return unsigneddouble(decimals, 100);
	}
	
	/**
	 * generate an unsigned (positive) double in the range 0..max with (decimal) decimal digits
	 * @see FillerTextType#UNSIGNEDDOUBLE
	 * @param decimals
	 * @param max
	 * @return the generated filler text object
	 */
	public double unsigneddouble(int decimals, double max) {
		return unsigneddouble(decimals, 0, Math.max(0, max));
	}

	/**
	 * generate an unsigned (positive) double in the range min..max with (decimal) decimal digits
	 * @see FillerTextType#UNSIGNEDDOUBLE
	 * @param decimals
	 * @param min
	 * @param max
	 * @return the generated filler text object
	 */
	public double unsigneddouble(int decimals, double min, double max) {
		return unsigneddouble(decimals, min, max, 0.0);
	}

	/**
	 * generate an unsigned (positive) double in the range min..max with (decimal) decimal digits
	 * @see FillerTextType#UNSIGNEDDOUBLE
	 * @param decimals
	 * @param min
	 * @param max
	 * @param round; must be > 0.0
	 * @return the generated filler text object
	 */
	public double unsigneddouble(int decimals, double min, double max, double round) {
		double factor = Math.pow(10.0, Math.max(0, decimals));
		double result = fBaseProducer.randomBetween(Math.min(min, max), Math.max(min, max));
		if	(round > 0.0) {
			result = Math.round((result + round/2) / round) * round;
		}
		return Math.rint (result * factor) / factor;
	}

	/**
	 * @see FillerTextType#SIGNEDDOUBLE
	 * @param params may be<ul>
	 * 			<li>none - generate a signed (positive or negative) double in the range 0.00..100.00 with two decimal digits</li>
	 * 			<li>(int)decimals - generate a signed (positive or negative) double in the range 0.00..100.00 with (decimal) decimal digits; same as {@link #signeddouble(int)}</li>
	 * 			<li>(int)decimals,(double)max - generate  signed (positive or negative) double in the range 0..max with (decimal) decimal digits; same as {@link #signeddouble(int,double)}</li>
	 * 			<li>(int)decimals,(double)min,(double)max - generate a signed (positive or negative) double in the range min..max with (decimal) decimal digits; same as {@link #signeddouble(int,double,double)}</li>
	 * 			<li>(int)decimals,(double)min,(double)max,(double)round - generate an signed (positive or negative) double in the range min..max with (decimal) decimal digits rounding; same as {@link #signeddouble(int,double,double,double)}</li>
	 * </ul>
	 * @return the generated filler text object
	 */
	public double signeddouble(Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		int length = 0;
		int decimals = 2;
		if	((params.length > 0) && (params[0] instanceof Integer)) {
			decimals = (int)params[0];
			while ((params.length > length+1) && (params[length+1] instanceof Double)) {
				length++;
			}
		}
		switch (length) {
			case 0:
				return signeddouble(decimals);
			case 1:
				return signeddouble(decimals, (double)params[1]);
			case 2:
				return signeddouble(decimals, (double)params[1], (double)params[2]);
			case 3:
			default:
				return signeddouble(decimals, (double)params[1], (double)params[2], (double)params[3]);
		}
	}

	/**
	 * @see FillerTextType#SIGNEDDOUBLE
	 * @param decimals - generate a signed (positive or negative) double in the range 0.00..100.00 with (decimal) decimal digits
	 * @return the generated filler text object
	 */
	public double signeddouble(int decimals) {
		return signeddouble(decimals, 100);
	}

	/**
	 * generate  signed (positive or negative) double in the range 0..max with (decimal) decimal digits
	 * @see FillerTextType#SIGNEDDOUBLE
	 * @param decimals
	 * @param max
	 * @return the generated filler text object
	 */
	public double signeddouble(int decimals, double range) {
		return signeddouble(decimals, -Math.abs(range), Math.abs(range));
	}

	/**
	 * generate a signed (positive or negative) double in the range min..max with (decimal) decimal digits
	 * @see FillerTextType#SIGNEDDOUBLE
	 * @param decimals
	 * @param max
	 * @param min
	 * @return the generated filler text object
	 */
	public double signeddouble(int decimals, double min, double max) {
		return signeddouble(decimals, min, max, 0.0);
	}

	/**
	 * generate a signed (positive or negative) double in the range min..max with (decimal) decimal digits
	 * @see FillerTextType#SIGNEDDOUBLE
	 * @param decimals
	 * @param max
	 * @param min
	 * @param round; must be > 0.0
	 * @return the generated filler text object
	 */
	public double signeddouble(int decimals, double min, double max, double round) {
		double factor = Math.pow(10.0, Math.max(0, decimals));
		double result = fBaseProducer.randomBetween(Math.min(min, max), Math.max(min, max));
		if	(round > 0.0) {
			result = Math.round((result + round/2) / round) * round;
		}
		return Math.rint (result * factor) / factor;
	}
	
	/**
	 *  @see FillerTextType#TRUEORFALSE
	 *  @return the generated filler text object
	 */
	public Boolean trueOrFalse() {
		return fBaseProducer.trueOrFalse();
	}

	/**
	 * @see FillerTextType#TIMESTAMP
	 * @param params may be<ul>
	 * 			<li>none - same as {@link #timestamp(int)} with parameter 0</li>
	 * 			<li>(int)yearsToPastOrInFuture - generate a timestamp with a range of years from now; same as {@link #timestamp(int)}</li>
	 * 			<li>(int)from,(int)to - generate a timestamp between two years including both years; same as {@link #timestamp(int, int)}</li>
	 * </ul>
	 *  @return the generated filler text object
	 */
	public DateTime timestamp(Object...params) {
		if	((params.length == 1) && (params[0] instanceof Object[])) {
			params = (Object[]) params[0];
		}
		int length = 0;
		while ((params.length > length) && (params[length] instanceof Integer)) {
			length++;
		}
		switch (length) {
			case 0:
				return timestamp(0);
			case 1:
				return timestamp((int) params[0]);
			case 2:
				default:
				return timestamp((int) params[0], (int) params[1]);
		}
	}
	
	/**
	 *  generate a timestamp between two years including both years
	 *  @see FillerTextType#TIMESTAMP
	 *  @param from may be<ul>
	 *  <li>either a year after 1900</li>
	 *  <li>otherwise it will be interpreted as an offset to the actual year</li>
	 *  </ul>
	 *  @param to may be<ul>
	 *  <li>either a year after 1900</li>
	 *  <li>otherwise it will be interpreted as an offset to the actual year</li>
	 *  </ul>
	 *  @return the generated filler text object
	 */
	public DateTime timestamp(int from, int to) {
		if	(from < 1900) {
			from += DateTime.now().getYear();
		}
		if	(to < 1900) {
			to += DateTime.now().getYear();
		}
		return fDateProducer.randomDateBetweenYears(Math.min(from,  to), Math.max(from, to));
	}

	/**
	 *  generate a timestamp with a range of years from now
	 *  @see FillerTextType#TIMESTAMP
	 *  @param yearsToPastOrInFuture may be<ul>
	 *  <li>0, then a timestamp inside the actual year will be generated
	 *  <li>negative, then a timestamp in the yearsToPastOrInFuture years before now = past will be generated 
	 *  <li>postive, then a timestamp in the yearsToPastOrInFuture years before now = will be generated 
	 *  </ul>
	 *  @return the generated filler text object
	 */
	public DateTime timestamp(int yearsToPastOrInFuture) {
		if	(yearsToPastOrInFuture == 0) {
			return timestamp(0, 0);
		}
		else if	(yearsToPastOrInFuture < 0) {
			return fDateProducer.randomDateInThePast(-yearsToPastOrInFuture);
		}
		else {
			return fDateProducer.randomDateInTheFuture(yearsToPastOrInFuture);
		}
	}

	/**
	 * @see FillerTextType#DATE
	 * @param params may be<ul>
	 * 			<li>none - same as {@link #date(int)} with parameter 0</li>
	 * 			<li>(int)yearsToPastOrInFuture - generate a date with a range of years from now; same as {@link #date(int)}</li>
	 * 			<li>(int)from,(int)to - generate a date between two years including both years; same as {@link #date(int, int)}</li>
	 * </ul>
	 *  @return the generated filler text object
	 */
	@SuppressWarnings("deprecation")
	public Date date(Object...params) {
		DateTime dt = timestamp(params);
		return (new Date(dt.getYear()-1900, dt.getMonthOfYear()-1, dt.getDayOfMonth()));		
	}

	/**
	 *  generate a date (without time) between two years including both years
	 *  @see FillerTextType#DATE
	 *  @param from may be<ul>
	 *  <li>either a year after 1900</li>
	 *  <li>otherwise it will be interpreted as an offset to the actual year</li>
	 *  </ul>
	 *  @param to may be<ul>
	 *  <li>either a year after 1900</li>
	 *  <li>otherwise it will be interpreted as an offset to the actual year</li>
	 *  </ul>
	 *  @return the generated filler text object
	 */
	@SuppressWarnings("deprecation")
	public Date date(int from, int to) {
		DateTime dt = timestamp(from, to);
		return (new Date(dt.getYear()-1900, dt.getMonthOfYear()-1, dt.getDayOfMonth()));		
	}

	/**
	 *  generate a date (without time) with a range of years from now
	 *  @see FillerTextType#DATE
	 *  @param yearsToPastOrInFuture may be<ul>
	 *  <li>0, then a date inside the actual year will be generated
	 *  <li>negative, then a date in the yearsToPastOrInFuture years before now = past will be generated 
	 *  <li>postive, then a date in the yearsToPastOrInFuture years before now = will be generated 
	 *  </ul>
	 *  @return the generated filler text object
	 */
	@SuppressWarnings("deprecation")
	public Date date(int yearsToPastOrInFuture) {
		DateTime dt = timestamp(yearsToPastOrInFuture);
		return (new Date(dt.getYear()-1900, dt.getMonthOfYear()-1, dt.getDayOfMonth()));		
	}
	
	/**
	 *  generate a time (without date)
	 *  @see FillerTextType#TIME
	 *  @return the generated filler text object
	 */
	@SuppressWarnings("deprecation")
	public Time time() {
		DateTime dt = fDateProducer.randomDateInThePast(1);
		return (new Time(dt.getHourOfDay(), dt.getMinuteOfHour(), dt.getSecondOfMinute()));		
	}
	
	/**
	 *  @see FillerTextType#PARAGRAPH 
	 *  @return the generated filler text object, containing one paragraph
	 */
	public String paragraph() {
		return fTextProducer.paragraph(1);
	}
	
	/**
	 *  @see FillerTextType#PARAGRAPH 
	 *  @param count 0 uses the internal default count value
	 *  @return the generated filler text object, containing count paragraph(s)
	 */
	public String paragraphs(int count) {
		if	(count > 0) {
			return fTextProducer.paragraph(count);
		}
		else {
			return paragraph();
		}
	}
	
	/**
	 *  @see FillerTextType#SENTENCE 
	 *  @return the generated filler text object, containing one sentence
	 */
	public String sentence() {
		return fTextProducer.sentence(1);
	}
	
	/**
	 *  @see FillerTextType#SENTENCE 
	 *  @param count 0 uses the internal default count value
	 *  @return the generated filler text object, containing count sentence(s)
	 */
	public String sentences(int count) {
		if	(count > 0) {
			return fTextProducer.sentence(count);
		}
		else {
			return sentence();
		}
	}
	
	/**
	 *  @see FillerTextType#WORD 
	 *  @return the generated filler text object, containing one word
	 */
	public String word() {
		return fTextProducer.word(1);
	}
	
	/**
	 *  @see FillerTextType#WORD 
	 *  @param count 0 uses the internal default count value
	 *  @return the generated filler text object, containing count word(s)
	 */
	public String words(int count) {
		if	(count > 0) {
			return fTextProducer.word(count);
		}
		else {
			return word();
		}
	}

	public String numerify(String numberString) {
		return fBaseProducer.numerify(numberString);
	}
}