public  void addTransformer(ClassFileTransformer transformer) 
{
        addTransformer(transformer, false);
}

 public synchronized  void addTransformer(ClassFileTransformer transformer,
    boolean canRetransform) 
{
        if (transformer == null) {
            throw new NullPointerException("null passed as 'transformer' in addTransformer");
        }
        if (canRetransform) {
            if (!isRetransformClassesSupported()) {
                throw new UnsupportedOperationException(
                  "adding retransformable transformers is not supported in this environment");
            }
            if (mRetransfomableTransformerManager == null) {
                mRetransfomableTransformerManager = new TransformerManager(true);
            }
            mRetransfomableTransformerManager.addTransformer(transformer);
            if (mRetransfomableTransformerManager.getTransformerCount() == 1) {
                setHasRetransformableTransformers(mNativeAgent, true);
            }
        } else {
            mTransformerManager.addTransformer(transformer);
        }
}

 public  void appendToBootstrapClassLoaderSearch(JarFile jarfile) 
{
        appendToClassLoaderSearch0(mNativeAgent, jarfile.getName(), true);
}

 public  void appendToSystemClassLoaderSearch(JarFile jarfile) 
{
        appendToClassLoaderSearch0(mNativeAgent, jarfile.getName(), false);
}

 public Class[] getAllLoadedClasses() 
{
        return getAllLoadedClasses0(mNativeAgent);
}

 public Class[] getInitiatedClasses(ClassLoader loader) 
{
        return getInitiatedClasses0(mNativeAgent, loader);
}

 public long getObjectSize(Object objectToSize) 
{
        if (objectToSize == null) {
            throw new NullPointerException("null passed as 'objectToSize' in getObjectSize");
        }
        return getObjectSize0(mNativeAgent, objectToSize);
}

 public boolean isModifiableClass(Class theClass) 
{
        if (theClass == null) {
            throw new NullPointerException(
                         "null passed as 'theClass' in isModifiableClass");
        }
        return isModifiableClass0(mNativeAgent, theClass);
}

 public boolean isNativeMethodPrefixSupported() 
{
        return mEnvironmentSupportsNativeMethodPrefix;
}

 public boolean isRedefineClassesSupported() 
{
        return mEnvironmentSupportsRedefineClasses;
}

 public boolean isRetransformClassesSupported() 
{
        // ask lazily since there is some overhead
        if (!mEnvironmentSupportsRetransformClassesKnown) {
            mEnvironmentSupportsRetransformClasses = isRetransformClassesSupported0(mNativeAgent);
            mEnvironmentSupportsRetransformClassesKnown = true;
        }
        return mEnvironmentSupportsRetransformClasses;
}

 public  void redefineClasses(ClassDefinition[] definitions) throws ClassNotFoundException 
{
        if (!isRedefineClassesSupported()) {
            throw new UnsupportedOperationException("redefineClasses is not supported in this environment");
        }
        if (definitions == null) {
            throw new NullPointerException("null passed as 'definitions' in redefineClasses");
        }
        for (int i = 0; i <  definitions.length; ++i) {
            if (definitions[i] == null) {
                throw new NullPointerException("element of 'definitions' is null in redefineClasses");
            }
        }
        if (definitions.length == 0) {
            return; // short-circuit if there are no changes requested
        }
        redefineClasses0(mNativeAgent, definitions);
}

 public synchronized boolean removeTransformer(ClassFileTransformer transformer) 
{
        if (transformer == null) {
            throw new NullPointerException("null passed as 'transformer' in removeTransformer");
        }
        TransformerManager mgr = findTransformerManager(transformer);
        if (mgr != null) {
            mgr.removeTransformer(transformer);
            if (mgr.isRetransformable() && mgr.getTransformerCount() == 0) {
                setHasRetransformableTransformers(mNativeAgent, false);
            }
            return true;
        }
        return false;
}

 public  void retransformClasses(Class[] classes) 
{
        if (!isRetransformClassesSupported()) {
            throw new UnsupportedOperationException(
              "retransformClasses is not supported in this environment");
        }
        retransformClasses0(mNativeAgent, classes);
}

 public synchronized  void setNativeMethodPrefix(ClassFileTransformer transformer,
    String prefix) 
{
        if (!isNativeMethodPrefixSupported()) {
            throw new UnsupportedOperationException(
                   "setNativeMethodPrefix is not supported in this environment");
        }
        if (transformer == null) {
            throw new NullPointerException(
                       "null passed as 'transformer' in setNativeMethodPrefix");
        }
        TransformerManager mgr = findTransformerManager(transformer);
        if (mgr == null) {
            throw new IllegalArgumentException(
                       "transformer not registered in setNativeMethodPrefix");
        }
        mgr.setNativeMethodPrefix(transformer, prefix);
        String[] prefixes = mgr.getNativeMethodPrefixes();
        setNativeMethodPrefixes(mNativeAgent, prefixes, mgr.isRetransformable());
}