/*----------------------------------------------------------------

  * $Id: Strings.java,v 1.1.1.1 2003/08/21 10:36:29 pkb Exp $

  * 

  * (c)2001 - Paul Blankenbaker */

 //----------------------------------------------------------------

 package com.ccg.macros.at;

 import com.ccg.util.JavaString;

 import com.ccg.macros.*;

 import java.io.IOException;

 import java.util.Vector;

 //----------------------------------------------------------------

 /** General purpose "String" related macros.

  * 

  * <p>This class defines many macros related to the processing of

  * strings. This class is not typically used directly by Java

  * developers, but indirectly when <b>&#064;macro</b> processing text

  * files.</p>

  * 

  * @version $Revision: 1.1.1.1 $

  * 

  * @since 1.0

  * 

  * @author $Author: pkb $ */

 //----------------------------------------------------------------

 public class Strings extends Base {

   //----------------------------------------------------------------

   /** Constructs the object and readies it for {@link #install installation}.

    * 

    * @since        1.0

    * 

    * @see #install */

   //----------------------------------------------------------------

   public Strings() {

     super(true);

   }

   //----------------------------------------------------------------

   /** @javaEscape(TEXT) - create a Java "escape" string from a

    * source string.

    * 

    * <p>This macro evaluates the TEXT argument and then puts in a Java

    * escape code for each character that a escape code exists for (for

    * example, a tab character would become "\t").

    *

    * <p>Refer to the {@link JavaString} class for additional details

    * on the recognized escape codes.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void javaEscape(Output out, Vector args)

     throws IOException, InterpretException {

                                 // encode the string

     String text = getStringParameter(args,0);

     out.write(JavaString.encode(text));

   }

   //----------------------------------------------------------------

   /** @javaUnescape(TEXT) - takes a "escaped" Java string and

    * outputs the "unescaped" values.

    * 

    * <p>This macro evaluates the TEXT argument and then replaces each

    * Java escape code with its proper character (for example, a "\t"

    * would become a REAL tab character).

    *

    * <p>Refer to the {@link JavaString} class for additional details

    * on the recognized escape codes.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void javaUnescape(Output out, Vector args)

     throws IOException, InterpretException {

                                 // decode the string

     String text = getStringParameter(args,0);

     try {

       out.write(JavaString.decode(text));

     } catch (java.text.ParseException pe) {

       throw new InterpretException("@javaUnescape(\""+text+"\") - "+

                                    pe.getMessage());

     }

   }

   //----------------------------------------------------------------

   /** @replaceChar(TEXT,OLDCHAR,NEWCHAR) - replace all occurances

    * of one character with another.

    * 

    * <p>This macro evaluates the TEXT argument passed and replaces ALL

    * occurrences of the OLDCHAR with the NEWCHAR. For example,

    * "@replaceChar("hello world"," ","_")" would result in

    * "hello_world".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void replaceChar(Output out, Vector args)

     throws IOException, InterpretException {

     String text = getStringParameter(args,0);

     String o = getStringParameter(args,1);

     String n = getStringParameter(args,2);

     if (o.length() > 0 && n.length() > 0) {

       text = text.replace(o.charAt(0),n.charAt(0));

     }

     out.write(text);

   }

   //----------------------------------------------------------------

   /** @indexOf(TEXT,SEARCH_IN) - searches for index of text

    * string in larger string.

    * 

    * <p>This macro evaluates the TEXT argument passed and evaluates

    * the SEARCH_IN argument. It then uses the {@link

    * String#indexOf(String)} method and returns th eposition

    * indicated. It is really useful to determine if one string contains

    * another as shown below:

    *

    * <pre>

    * @define("goodValues","megan|erik|scott")

    * @define("lookFor","erik")

    * @if("@indexOf("@lookFor()","@goodValues()")","-1","Not Found","Found")

    * </pre>

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void indexOf(Output out, Vector args)

     throws IOException, InterpretException {

     String text = getStringParameter(args,0);

     String search = getStringParameter(args,1);

     int pos = search.indexOf(text);

     out.write(Integer.toString(pos));

   }

   //----------------------------------------------------------------

   /** @toOsFileName(TEXT) - replace '/' or '\' characters in file

    * names according to the OS preference.

    * 

    * <p>This macro is typically used when creating scripts. It takes a

    * TEXT string and replaces any '/' or '\' characters found with the

    * proper character for the Operating System's file naming

    * scheme. For example, "/tmp\fred.txt" would become

    * "/tmp/fred.txt" on a Unix system and "\tmp\fred.txt" on a

    * Windows system.

    *

    * <p>NOTE: In the future, this macro may strip off any leading

    * drive letter (like "c:" in the DOS world) if the output is for a

    * Unix system.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void toOsFileName(Output out, Vector args)

     throws IOException, InterpretException {

     out.write(com.ccg.io.FileName.fixSlashes(getStringParameter(args,0)));

   }

   //----------------------------------------------------------------

   /** @changeCase(TEXT,MODE) - change the case of TEXT to

    * uppercase, lowercase or mixed case.

    * 

    * <p>This macro is used to change the case of the specified

    * TEXT. The MODE should be "u" if you want UPPER CASE, "l" if you

    * want lower case, or "m" if you want "Mixed Case".

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void changeCase(Output out, Vector args)

     throws IOException, InterpretException {

     String text = getStringParameter(args,0);

     String modeStr = getStringParameter(args,1);

     char mode = 'l';

     if (modeStr.length() > 0) mode = modeStr.charAt(0);

                                 // upper case

     if (mode == 'u') out.write(text.toUpperCase());

                                 // lower case

     else if (mode != 'm') out.write(text.toLowerCase());

     else {                        // mixed case

       int tlen = text.length();

       StringBuffer sb = new StringBuffer(tlen);

       boolean needToUpper = true;

       for (int i = 0; i < tlen; i++) {

         char c = text.charAt(i);

         if (Character.isLetterOrDigit(c)) {

           if (needToUpper) {

             c = Character.toUpperCase(c);

             needToUpper = false;

           } else {

             c = Character.toLowerCase(c);

           }

         }

         else {

           needToUpper = true;

         }

         sb.append(c);

       }

       out.write(sb.toString());

     }

   }

 }