/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.management;

import java.lang.management.ThreadInfo;

import java.lang.management.MonitorInfo;

import java.lang.management.LockInfo;

import javax.management.openmbean.CompositeType;

import javax.management.openmbean.CompositeData;

import javax.management.openmbean.CompositeDataSupport;

import javax.management.openmbean.OpenDataException;

/**

 * A CompositeData for ThreadInfo for the local management support.

 * This class avoids the performance penalty paid to the

 * construction of a CompositeData use in the local case.

 */

public class ThreadInfoCompositeData extends LazyCompositeData {

    private final ThreadInfo threadInfo;

    private final CompositeData cdata;

    private ThreadInfoCompositeData(ThreadInfo ti) {

        this.threadInfo = ti;

        this.cdata = null;

    }

    private ThreadInfoCompositeData(CompositeData cd) {

        this.threadInfo = null;

        this.cdata = cd;

    }

    public ThreadInfo getThreadInfo() {

        return threadInfo;

    }

    public static ThreadInfoCompositeData getInstance(CompositeData cd) {

        validateCompositeData(cd);

        return new ThreadInfoCompositeData(cd);

    }

    public static CompositeData toCompositeData(ThreadInfo ti) {

        ThreadInfoCompositeData ticd = new ThreadInfoCompositeData(ti);

        return ticd.getCompositeData();

    }

    protected CompositeData getCompositeData() {

        // Convert StackTraceElement[] to CompositeData[]

        StackTraceElement[] stackTrace = threadInfo.getStackTrace();

        CompositeData[] stackTraceData =

            new CompositeData[stackTrace.length];

        for (int i = 0; i < stackTrace.length; i++) {

            StackTraceElement ste = stackTrace[i];

            stackTraceData[i] = StackTraceElementCompositeData.toCompositeData(ste);

        }

        // Convert MonitorInfo[] and LockInfo[] to CompositeData[]

        CompositeData lockInfoData =

            LockInfoCompositeData.toCompositeData(threadInfo.getLockInfo());

        // Convert LockInfo[] and MonitorInfo[] to CompositeData[]

        LockInfo[] lockedSyncs = threadInfo.getLockedSynchronizers();

        CompositeData[] lockedSyncsData =

            new CompositeData[lockedSyncs.length];

        for (int i = 0; i < lockedSyncs.length; i++) {

            LockInfo li = lockedSyncs[i];

            lockedSyncsData[i] = LockInfoCompositeData.toCompositeData(li);

        }

        MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors();

        CompositeData[] lockedMonitorsData =

            new CompositeData[lockedMonitors.length];

        for (int i = 0; i < lockedMonitors.length; i++) {

            MonitorInfo mi = lockedMonitors[i];

            lockedMonitorsData[i] = MonitorInfoCompositeData.toCompositeData(mi);

        }

        // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH

        final Object[] threadInfoItemValues = {

            threadInfo.getThreadId(),

            threadInfo.getThreadName(),

            threadInfo.getThreadState().name(),

            threadInfo.getBlockedTime(),

            threadInfo.getBlockedCount(),

            threadInfo.getWaitedTime(),

            threadInfo.getWaitedCount(),

            lockInfoData,

            threadInfo.getLockName(),

            threadInfo.getLockOwnerId(),

            threadInfo.getLockOwnerName(),

            stackTraceData,

            lockedMonitorsData,

            lockedSyncsData,

            threadInfo.isDaemon(),

            threadInfo.getPriority(),

        };

        try {

                                            threadInfoItemValues);

        } catch (OpenDataException e) {

            // Should never reach here

            throw new AssertionError(e);

        }

    }

    // Attribute names

    private static final String THREAD_ID       = "threadId";

    private static final String THREAD_NAME     = "threadName";

    private static final String THREAD_STATE    = "threadState";

    private static final String BLOCKED_TIME    = "blockedTime";

    private static final String BLOCKED_COUNT   = "blockedCount";

    private static final String WAITED_TIME     = "waitedTime";

    private static final String WAITED_COUNT    = "waitedCount";

    private static final String LOCK_INFO       = "lockInfo";

    private static final String LOCK_NAME       = "lockName";

    private static final String LOCK_OWNER_ID   = "lockOwnerId";

    private static final String LOCK_OWNER_NAME = "lockOwnerName";

    private static final String STACK_TRACE     = "stackTrace";

    private static final String SUSPENDED       = "suspended";

    private static final String IN_NATIVE       = "inNative";

    private static final String DAEMON          = "daemon";

    private static final String PRIORITY        = "priority";

    private static final String LOCKED_MONITORS = "lockedMonitors";

    private static final String LOCKED_SYNCS    = "lockedSynchronizers";

        THREAD_ID,

        THREAD_NAME,

        THREAD_STATE,

        BLOCKED_TIME,

        BLOCKED_COUNT,

        WAITED_TIME,

        WAITED_COUNT,

        LOCK_NAME,

        LOCK_OWNER_ID,

        LOCK_OWNER_NAME,

        STACK_TRACE,

        SUSPENDED,

    };

        LOCK_INFO,

        LOCKED_MONITORS,

        LOCKED_SYNCS,

    };

        DAEMON,

        PRIORITY,

    };

    public long threadId() {

        return getLong(cdata, THREAD_ID);

    }

    public String threadName() {

        // The ThreadName item cannot be null so we check that

        // it is present with a non-null value.

        String name = getString(cdata, THREAD_NAME);

        if (name == null) {

            throw new IllegalArgumentException("Invalid composite data: " +

                "Attribute " + THREAD_NAME + " has null value");

        }

        return name;

    }

    public Thread.State threadState() {

        return Thread.State.valueOf(getString(cdata, THREAD_STATE));

    }

    public long blockedTime() {

        return getLong(cdata, BLOCKED_TIME);

    }

    public long blockedCount() {

        return getLong(cdata, BLOCKED_COUNT);

    }

    public long waitedTime() {

        return getLong(cdata, WAITED_TIME);

    }

    public long waitedCount() {

        return getLong(cdata, WAITED_COUNT);

    }

    public String lockName() {

        // The LockName and LockOwnerName can legitimately be null,

        // we don't bother to check the value

        return getString(cdata, LOCK_NAME);

    }

    public long lockOwnerId() {

        return getLong(cdata, LOCK_OWNER_ID);

    }

    public String lockOwnerName() {

        return getString(cdata, LOCK_OWNER_NAME);

    }

    public boolean suspended() {

        return getBoolean(cdata, SUSPENDED);

    }

    public boolean inNative() {

        return getBoolean(cdata, IN_NATIVE);

    }

    public boolean isDaemon() {

    }

    public int getPriority(){

    }

    public StackTraceElement[] stackTrace() {

        CompositeData[] stackTraceData =

            (CompositeData[]) cdata.get(STACK_TRACE);

        // The StackTrace item cannot be null, but if it is we will get

        // a NullPointerException when we ask for its length.

        StackTraceElement[] stackTrace =

            new StackTraceElement[stackTraceData.length];

        for (int i = 0; i < stackTraceData.length; i++) {

            CompositeData cdi = stackTraceData[i];

            stackTrace[i] = StackTraceElementCompositeData.from(cdi);

        }

        return stackTrace;

    }

    public LockInfo lockInfo() {

    }

    public MonitorInfo[] lockedMonitors() {

        CompositeData[] lockedMonitorsData =

            (CompositeData[]) cdata.get(LOCKED_MONITORS);

        // The LockedMonitors item cannot be null, but if it is we will get

        // a NullPointerException when we ask for its length.

        MonitorInfo[] monitors =

            new MonitorInfo[lockedMonitorsData.length];

        for (int i = 0; i < lockedMonitorsData.length; i++) {

            CompositeData cdi = lockedMonitorsData[i];

            monitors[i] = MonitorInfo.from(cdi);

        }

        return monitors;

    }

    public LockInfo[] lockedSynchronizers() {

        CompositeData[] lockedSyncsData =

            (CompositeData[]) cdata.get(LOCKED_SYNCS);

        // The LockedSynchronizers item cannot be null, but if it is we will

        // get a NullPointerException when we ask for its length.

        LockInfo[] locks = new LockInfo[lockedSyncsData.length];

        for (int i = 0; i < lockedSyncsData.length; i++) {

            CompositeData cdi = lockedSyncsData[i];

            locks[i] = LockInfo.from(cdi);

        }

        return locks;

    }

     * CompositeType (i.e. contain all attributes with expected

     * names and types).

     */

    public static void validateCompositeData(CompositeData cd) {

        if (cd == null) {

            throw new NullPointerException("Null CompositeData");

        }

        CompositeType type = cd.getCompositeType();

            }

        }

        }

                }

            }

        }

    }

    private static final long serialVersionUID = 2464378539119753175L;

}