src.com.ibm.as400.access.Mlog Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
There is a newer version: 20.0.7
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename:  Mlog.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) 2005-2006 International Business Machines Corporation and
// others.  All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;


/**
 *  Mlog is a debugging tool.
 *
 *  Multi-threading considerations:
 *  Probably not thread-safe if several threads have access to the same
 *  instance.
 *
 */

import java.nio.CharBuffer;

/* *
 * This class is used for tracing purposes
 *
 */
class Mlog
{
    final static char[] hexa = new char[] {'0','1','2','3','4','5','6','7',
                                           '8','9','a','b','c','d','e','f'};

    static int loRange = 100;
    static int hiRange = 100;
    static int cnt = 1;

    static boolean logFlag;

    public static boolean logEnable( boolean newFlag )
    {
        boolean oldFlag = logFlag;
        logFlag = newFlag;
        return oldFlag;
    }

    public static void putLine( String s )
    {
        if (!logFlag)  return;
        int len = s.length();
        if (len <= (loRange + hiRange))
          Trace.log(Trace.CONVERSION,  cnt++ + ": " + s );
        else
        {
          Trace.log(Trace.CONVERSION,  cnt++ + ": " + s.substring( 0, loRange ) );
          Trace.log(Trace.CONVERSION,  ". . . " + (len - loRange - hiRange) + " chars omitted . . ." );
          Trace.log(Trace.CONVERSION,  s.substring( len - hiRange, len ) );
        }
    }

    public static String toHex( char[] chars, boolean compact )
    {
        return toHex( chars, 0, chars.length, compact );
    }

    public static String toHex( char[] input, int offset, int limit, boolean compact )
    {
        if (limit <= offset)  return "";
        int len = limit - offset;
        char[] chars = new char[len * 5];
        int k = 0;
        int c;
        for (int i = offset; i < limit; i++)
        {
            c = input[i];
            if (c < 0x100)
            {
                if (!compact)
                {
                    chars[k++] = '0';
                    chars[k++] = '0';
                }
            }
            else
            {
                chars[k++] = hexa[c >> 12];
                chars[k++] = hexa[(c & 0x0F00) >> 8];
            }
            chars[k++] = hexa[(c & 0x00F0) >> 4];
            chars[k++] = hexa[c & 0x000F];
            chars[k++] = ' ';
        }
        return new String( chars, 0, k - 1 );
    }

    public static String toHex( String s, boolean compact )
    {
        return toHex( s.toCharArray(), 0, s.length(), compact );
    }

    public static void putHexLine( char[] input, boolean compact )
    {
        if (logFlag)  putHexLine( input, 0, input.length, compact );
    }

    public static void putHexLine( char[] input, int offset, int limit, boolean compact )
    {
        if (!logFlag)  return;
        int len = limit - offset;
        if (len <= (loRange + hiRange))
        {
          Trace.log(Trace.CONVERSION,  cnt   + ": " + toHex( input, offset, limit, compact ) );
          Trace.log(Trace.CONVERSION,  cnt++ + ": " + new String( input, offset, limit - offset ) );
        }
        else
        {
          Trace.log(Trace.CONVERSION,  cnt   + ": " + toHex( input, offset, offset + loRange, compact ) );
          Trace.log(Trace.CONVERSION,  ". . . " + (len - loRange - hiRange) + " chars omitted . . ." );
          Trace.log(Trace.CONVERSION,  toHex( input, limit - hiRange, limit, compact ) );
          Trace.log(Trace.CONVERSION,  cnt++ + ": " + new String( input, offset, loRange ) );
          Trace.log(Trace.CONVERSION,  ". . . " + (len - loRange - hiRange) + " chars omitted . . ." );
          Trace.log(Trace.CONVERSION,  new String( input, limit - hiRange, hiRange ) );
        }
    }

    public static void putHexLine( String s )
    {
        if (logFlag)  putHexLine( s.toCharArray(), false );
    }

    public static void putHexLine( String s, boolean compact )
    {
        if (logFlag)  putHexLine( s.toCharArray(), compact );
    }

    public static boolean logReturn( boolean flag )
    {
        if (logFlag)  putLine( "return flag = " + flag );
        return flag;
    }

    public static char[] logReturn( char[] chars )
    {
        if (logFlag)
        {
            putLine( "return chars = " + toHex( chars, true ) );
            cnt--;
            putLine( "return chars = " + new String( chars ) );
        }
        return chars;
    }

    public static String logReturn( String s )
    {
        if (logFlag)
        {
            putLine( "return string = " + toHex( s, true ) );
            cnt--;
            putLine( "return string = " + s );
        }
        return s;
    }

    public static CharBuffer logReturn( CharBuffer cb )
    {
        if (logFlag)
        {
            putLine( "return buffer = " + toHex( cb.toString(), true ) );
            cnt--;
            putLine( "return buffer = " + cb.toString() );
        }
        return cb;
    }

    public static void printStackTrace( String s )
    {
        if (!logFlag)  return;
        Exception e = new Exception();
        StackTraceElement[] stack = e.getStackTrace();
        putLine( "Entering:  " + s );
        for (int i = 1; i < stack.length; i++)
        {
            cnt--;
            putLine( "   " + stack[i].toString() );
        }
    }

}