geode-core/src/main/java/org/apache/geode/internal/SmHelper.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package org.apache.geode.internal;

import org.apache.geode.internal.i18n.LocalizedStrings;

import java.util.*;
import java.lang.reflect.*;
import java.io.InvalidClassException;

/**
 * This class defines general native utils.
 *
 *
 */
public class SmHelper {

  static final boolean pureMode = PureJavaMode.isPure();

  /* ================== Native Methods =========================== */

  /**
   * Returns the size in bytes of a C pointer in this shared library, returns 4 for a 32 bit shared
   * library, and 8 for a 64 bit shared library
   */
  public static int pointerSizeBytes() {
    if (pureMode) {
      throw new IllegalStateException(
          LocalizedStrings.SmHelper_POINTERSIZEBYTES_UNAVAILABLE_IN_PURE_MODE.toLocalizedString());
    } else {
      return _pointerSizeBytes();
    }
  }

  private static native int _pointerSizeBytes();


  /* ================== System Administration =========================== */

  /**
   * Sleeps for the specified number of nanoseconds.
   */
  private static native void _nanosleep(int nanos);

  /**
   * Sleeps for the specified number of nanoseconds.
   */
  public static void nanosleep(long nanos) throws InterruptedException {
    if (Thread.interrupted())
      throw new InterruptedException();
    if (nanos <= 0) {
      return;
    }
    if (nanos >= 1000000) {
      Thread.sleep(nanos / 1000000, (int) (nanos % 1000000));
    } else {
      if (pureMode) {
        // fix for bug 35150
        Thread.yield();
      } else {
        _nanosleep((int) nanos);
      }
    }
  }

  /**
   * Returns the GemFire native code library's version string.
   */
  public static String getNativeVersion() {
    if (pureMode) {
      return LocalizedStrings.SmHelper_NATIVE_CODE_UNAVAILABLE.toLocalizedString();
    } else {
      return _getNativeVersion();
    }
  }

  private static native String _getNativeVersion();

  public static String getSystemId() {
    if (pureMode) {
      return "pureJavaMode";
    } else {
      return _getSystemId();
    }
  }

  private static native String _getSystemId();

  /** Cache of class -> has zero-arg constructor */
  private static Map zeroArgConstructorCache = new HashMap();

  /** Cache of class -> has public zero-arg constructor */
  private static Map publicConstructorCache = new HashMap();

  /**
   * Allocates a new JOM instance of <code>c</code> and invokes the zero-argument constructor of
   * <code>initClass</code> on the new object to initialize it. This takes the place of the late,
   * lamented <code>allocateNewObject</code> method of <code>java.io.ObjectInputStream</code> in JDK
   * 1.3.
   *
   * @throws InvalidClassException If <code>c</code> or <code>initClass</code> represents a
   *         primitive class.
   * @throws NoSuchMethodError If <code>initClass</code> doesn't have a zero-argument constructor
   * @throws IllegalAccessException If the zero-argument constructor is not public (only for
   *         <code>Externalizable</code> classes in which <code>c.equals(initClass)</code>
   */
  public static Object allocateJOMObject(Class c, Class initClass)
      throws IllegalAccessException, InvalidClassException {
    if (c.isPrimitive()) {
      throw new InvalidClassException(LocalizedStrings.SmHelper_IS_PRIMITIVE.toLocalizedString(),
          c.getName());

    } else if (initClass.isPrimitive()) {
      throw new InvalidClassException(LocalizedStrings.SmHelper_IS_PRIMITIVE.toLocalizedString(),
          initClass.getName());
    }

    // boolean hasZeroArgInit;
    if (!zeroArgConstructorCache.containsKey(initClass)) {
      try {
        // Constructor init =
        initClass.getDeclaredConstructor(new Class[0]);
        if (Modifier.isPublic(initClass.getModifiers())) {
          publicConstructorCache.put(initClass, Boolean.TRUE);

        } else {
          publicConstructorCache.put(initClass, Boolean.FALSE);
        }

      } catch (NoSuchMethodException ex) {
        zeroArgConstructorCache.put(initClass, Boolean.FALSE);
        throw new NoSuchMethodError();
      }

    } else {
      Boolean b = (Boolean) zeroArgConstructorCache.get(initClass);
      if (!b.booleanValue()) {
        throw new NoSuchMethodError();
      }
    }

    // // Doesn't let us invoke the non-public constructors of inner
    // // classes
    // boolean isPublic =
    // ((Boolean) publicConstructorCache.get(initClass)).booleanValue();
    // if (c.equals(initClass) && !isPublic) {
    // throw new IllegalAccessException();
    // }

    return _allocateJOMObject(c, initClass);
  }

  /**
   * Natively allocates a new JOM instance of <code>c</code> and invokes the zero-argument
   * constructor of <code>initClass</code> on the new object to initialize it. This takes the place
   * of the late, lamented <code>allocateNewObject</code> method of
   * <code>java.io.ObjectInputStream</code> in JDK 1.3.
   */
  private static native Object _allocateJOMObject(Class c, Class initClass);

  /**
   * Uses native code to set the value of an object JOM field
   */
  public static native void _setObjectField(Object o, Field field, Object newValue);
}