org.apache.commons.lang.ArrayUtils#EMPTY_CHAR_ARRAY源码实例Demo

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

private void loadHolderOfKeyKeys(String pwd, boolean eidonly) throws TechnicalConnectorException {
   LOG.debug("Loading HolderOfKeyKeys");
   char[] password = pwd == null ? ArrayUtils.EMPTY_CHAR_ARRAY : pwd.toCharArray();
   if (this.cache.containsKey("holderofkey")) {
      KeyStore hokstore = (KeyStore)this.cache.get("holderofkey");
      this.session.setHolderOfKeyCredential(new KeyStoreCredential(hokstore, this.config.getProperty("sessionmanager.holderofkey.alias", "authentication"), pwd));
      this.session.setHolderOfKeyPrivateKeys(KeyManager.getDecryptionKeys(hokstore, password));
   } else if (pwd == null && eidonly) {
      Credential authCredential = BeIDCredential.getInstance("session", "Authentication");
      Map<String, PrivateKey> authPK = new HashMap();
      authPK.put("authentication", authCredential.getPrivateKey());
      this.session.setHolderOfKeyCredential(authCredential);
      this.session.setHolderOfKeyPrivateKeys(authPK);
   } else {
      if (pwd == null && !this.config.getBooleanProperty("sessionmanager.holderofkey.emptypassword", false).booleanValue()) {
         return;
      }

      try {
         String pathKeystore = this.config.getProperty("sessionmanager.holderofkey.keystore");
         String privateKeyAlias = this.config.getProperty("sessionmanager.holderofkey.alias", "authentication");
         KeyStoreInfo ksInfo = new KeyStoreInfo(pathKeystore, password, privateKeyAlias, password);
         KeyStoreManager encryptionKeystoreManager = new KeyStoreManager(ksInfo);
         Map<String, PrivateKey> hokPrivateKeys = KeyManager.getDecryptionKeys(encryptionKeystoreManager.getKeyStore(), ksInfo.getPrivateKeyPassword());
         this.session.setHolderOfKeyCredential(new KeyStoreCredential(ksInfo));
         this.session.setHolderOfKeyPrivateKeys(hokPrivateKeys);
         fetchEtk(KeyDepotManager.EncryptionTokenType.HOLDER_OF_KEY, hokPrivateKeys, this.config);
      } catch (Exception var11) {
         throw translate(var11, "HolderOfKey");
      }
   }

}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

/**
 * Copies the builder's character array into a new character array.
 * 
 * @return a new array that represents the contents of the builder
 */
public char[] toCharArray() {
    if (size == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[size];
    System.arraycopy(buffer, 0, chars, 0, size);
    return chars;
}
 

public KeyStoreCredential(UUID keystoreId, KeyStore keyStore, String alias, String password, String quality) throws TechnicalConnectorException {
   super(quality);

   this.keystoreId = keystoreId;
   this.password = password == null ? ArrayUtils.EMPTY_CHAR_ARRAY : password.toCharArray();
   this.alias = alias;
   this.keyStore = keyStore;
}
 

/**
 * Copies part of the builder's character array into a new character array.
 * 
 * @param startIndex  the start index, inclusive, must be valid
 * @param endIndex  the end index, exclusive, must be valid except that
 *  if too large it is treated as end of string
 * @return a new array that holds part of the contents of the builder
 * @throws IndexOutOfBoundsException if startIndex is invalid,
 *  or if endIndex is invalid (but endIndex greater than size is valid)
 */
public char[] toCharArray(int startIndex, int endIndex) {
    endIndex = validateRange(startIndex, endIndex);
    int len = endIndex - startIndex;
    if (len == 0) {
        return ArrayUtils.EMPTY_CHAR_ARRAY;
    }
    char chars[] = new char[len];
    System.arraycopy(buffer, startIndex, chars, 0, len);
    return chars;
}