src.com.ibm.as400.util.commtrace.Formatter Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
There is a newer version: 11.1
///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                                 
//                                                                             
// Filename: Formatter.java
//                                                                             
// The source code contained herein is licensed under the IBM Public License   
// Version 1.0, which has been approved by the Open Source Initiative.         
// Copyright (C) 2002 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.util.commtrace;

import java.lang.String;
import java.lang.StringBuffer;
import java.lang.Integer;
import java.util.StringTokenizer;
import com.ibm.as400.access.Trace;

/**
 * Implements a printf style formatter.

 * The format specifier is {v,w,j} where v is the element number in the arg list

 * for the variable to be formatted, w is the field width, and the j values are:

 *   r: Right Justification, allow overflow if l > w

 *   R: Right Justification, do not allow overflow

 *   l: Left Justification, allow overflow if l > w

 *   L: Left Justification, do not allow overflow

 * 
 */
abstract class Formatter {
	private static final String CLASS="Formatter";	
	/**
	 * send a justified string with the specifed arguments to Trace.log. 
	 * @param fmt       Format of this string.                       
	 * @param args      arguments to be formatted.                   
	 */
	public static void jprintf(String fmt, Object[] args) {
		if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
			Trace.log(Trace.INFORMATION,CLASS + "jprintf() " + jsprintf(fmt, args));
		}
	}

	/**
	 * create a justified string with the specifed arguments and a maximum length.
	 * @param maxlen    maximum length of this String
	 * @param fmt       Format of this string.                       
	 * @param args      arguments to be formatted.
	 * @return		String
	 */
	public static String jsnprintf(int maxlen, String fmt, Object[] args) {
		StringBuffer out= new StringBuffer(maxlen);
		StringTokenizer t= new StringTokenizer(fmt, "{}", true);

		int s= 0;
		String token;

		try {
			while (true) {
				token= t.nextToken();
				if (!token.equals("{")) {
					out.append(token);
				} else {
					token= t.nextToken();
					if (token.equals("{")) {
						out.append(token);
					} else {
						StringBuffer varspec= new StringBuffer(20);
						while (!token.equals("}")) {
							varspec.append(token);
							token= t.nextToken();
						}

						// Now var contains a format spec
						StringTokenizer vars= new StringTokenizer(varspec.toString(), ", ", false);
						int n= Integer.decode(vars.nextToken()).intValue();
						if (vars.hasMoreElements() == false) {
							out.append(args[n]);
						} else {
							int w= Integer.decode(vars.nextToken()).intValue();
							if (w < 0) {
								w= -w;
							}
							String j= vars.nextToken();
							String x= args[n].toString();
							int l= x.length();

							// r: Right Justification, allow overflow if l > w
							// R: Right Justification, do not allow overflow
							// l: Left Justification, allow overflow if l > w
							// L: Left Justification, do not allow overflow

							if (j.equalsIgnoreCase("r")) {
								if (l < w) {
									out.append(repeater(" ", w - l)).append(x);
								} else if (j.equals("r")) {
									out.append(x);
								} else {
									out.append(x.substring(l - w));
								}
							} else if (j.equalsIgnoreCase("l")) {
								if (l < w) {
									out.append(x).append(repeater(" ", w - l));
								} else if (j.equals("l")) {
									out.append(x);
								} else {
									out.append(x.substring(0, w));
								}
							} else {
								out.append(args[n]);
							}
						}
					}
				}
			}
		} catch (Throwable e) {
			// At some point, getting a token or possibly dereffing args[n] will fail.  Just return what was formatted so far.
		}

		// Truncate output if a max length was set.
		if (maxlen > 0) {
			if (out.length() > maxlen) {
				out.setLength(maxlen);
			}
		}

		return out.toString();
	}

	/**
	 * create a justified string with the specifed arguments. 
	 * @param fmt       Format of this string.                       
	 * @param args      arguments to be formatted.
	 * @return		String
	 */
	public static String jsprintf(String fmt, Object[] args) {
		return jsnprintf(0, fmt, args);
	}

	/**
	 * creates a string consisting of s repeated n times.
	 * @param s        String to repeat.                
	 * @param n        number of times to repeat s.
	 * @return		String
	 */
	public static String repeater(String s, int n) {
		if (n <= 0) {
			return "";
		}
		StringBuffer out= new StringBuffer(s.length() * n);
		while (n-- > 0) {
			out.append(s);
		}
		return out.toString();
	}
}