Input:
/**Trim each element in the given string array and return the resulting array.**/
public static String[] trimArrayElements(String[] array){


Input:
/**Check whether the length of the given two byte arrays is the same.**/
public static boolean isSameLength(final byte[] array1,final byte[] array2){


Input:
/**Pop an abstract type from the output frame stack and return its value.**/
private int pop(){


Input:
/**Convert the given Boolean array to primitives. Return ArrayUtils.EMPTY_BOOLEAN_ARRAY for an empty array, return null for null array.**/
public static boolean[] toPrimitive(final Boolean[] array){


Input:
/** If the message does not exist in the dict messages, or it exists but the timestamp (seconds) difference is bigger than 10, put the message and timestamp into messages and return true, otherwise return false.**/
public boolean shouldPrintMessage(int timestamp,String message){


Input:
/**Return the string representation of the given object, return an empty string if the object is null.**/
public static String toString(Object obj){


Input:
/**Decode octets to characters with UTF-8, append them to the given StringBuilder, and return the index to the next unchecked character.**/
private static int decodeOctets(int i,ByteBuffer bb,StringBuilder sb){


Input:
/**Init a currentFrame with the given offset, numLocal and numStack, return 3 finally.**/
int visitFrameStart(final int offset,final int numLocal,final int numStack){


Input:
/**Enlarge the byte vector data, by increasing it by the given size.**/
private void enlarge(final int size){


Input:
/**Delete the given file if it exists**/
protected static void deleteFile(String fileName){


Input:
/**Compute the hash code of the whole array, by accumulating the multiplication of each element hash code and the  MULTIPLIER.**/
public static int nullSafeHashCode(long[] array){


Input:
/**Perform a right node rotation on the AVL tree.**/
private TreeNode<T> rotateRight(TreeNode<T> node){


Input:
/**Add all the jar files in the given dir to the classpath. The classpath is represented as a Vector of URLs.**/
@SuppressWarnings("unchecked") public static void addToClassPath(Vector<URL> cpV,String dir){


Input:
/**Format the buffered string with the pattern converter, and return the result.**/
public String format(LoggingEvent event){


Input:
/**Compute and return the length of the request content header, return the content length if NumberFormatException happens.**/
public long contentLength(){


Input:
/**Return the index of the last directory separator character, under Unix or Windows.**/
public static int indexOfLastSeparator(String filename){


Input:
/**Parse the header part starting from the given end position and return the index of the enter sequence. **/
private int parseEndOfLine(String headerPart,int end){


Input:
/**Find the last index of the searchStr in str, and return INDEXNOTFOUND if str is empty.**/
public static int lastIndexOf(String str,String searchStr){


Input:
/**Write the given byte array b into the output stream that this class represents.**/
@Override public void write(byte b[]) throws IOException {


Input:
/**Return the id by concatenating the point and the entity id with id connector.**/
public String id(String entityId){


Input:
/**Convert a Boolean to a boolean handling null by returning false.**/
public static boolean toBoolean(Boolean bool){


Input:
/**Compute and return an identity automorphism for the given graph.**/
public static <V,E>IsomorphicGraphMapping<V,E> identity(Graph<V,E> graph){


Input:
/**Delete the file or the whole directory when exiting.**/
public static void forceDeleteOnExit(File file) throws IOException {


Input:
/**Add a log record message to be displayed in the LogTable, with the SwingUtilities.**/
public void addMessage(final LogRecord lr){


Input:
/**Construct a complete bipartite graph from partitions A and B.**/
@Override public void generateGraph(Graph<V,E> target,Map<String,V> resultMap){


Input:
/**Searche for a byte of the specified value in the buffer, starting at the specified position.**/
protected int findByte(byte value,int pos){


Input:
/**Use ProtobufOutput and the LinkedBuffer to write the message into the given OutputStream out, and return the message size.**/
public static <T>int writeDelimitedTo(OutputStream out,T message,Schema<T> schema,LinkedBuffer buffer) throws IOException {


Input:
/**Return the string built by this string builder.**/
public String toString(){


Input:
/**Write the message in the event into a temp file.**/
protected void subAppend(LoggingEvent event){


Input:
/**Add a new type entry of the given value into the type table of this symbol table. Does nothing if the type table already contains a similar type. Return the index of the type entry in the symbol table.**/
int addType(final String value){


Input:
/**Resolve and return the arguments for the genericType using the type variable information for the targetType. Returns null if  genericType is not parameterized or if arguments cannot be resolved.**/
public static Class<?>[] resolveArguments(Type genericType,Class<?> targetType){


Input:
/**Accept the data into the buffer if its id does not exist in the buffer. Otherwise try to combine it with the existing value, and remove it if the combined is abandoned.**/
@Override public void accept(final METRICS data){


Input:
/**Insert this bucket in the data structure before the given bucket.**/
void insertBefore(Bucket bucket){


Input:
/**Check the available space of this InputStream according to the index.**/
@Override public int available() throws IOException {


Input:
/**Return mappings with fields that do not exist in the input mappings. The input mappings should be history mapping from the current index.**/
public Mappings diffStructure(String tableName,Mappings mappings){


Input:
/**Add the given target channels to the consumeTargets.**/
public void addNewTarget(Channels channels,IConsumer consumer){


Input:
/**Create the "lf5" directory in the Documents and Settings directory on Windows machines, or the user.home variable points on all other platforms.**/
public static void createConfigurationDirectory(){


Input:
/**Read a signed long value.**/
public long readLong(final int offset){


Input:
/**Return true if the contents of the internal array bytes and the provided array data match.**/
public boolean equals(final byte[] data,int offset,final int len){


Input:
/**Return an EMPTY_BYTE_OBJECT_ARRAY array for a null or empty input array.**/
public static Byte[] nullToEmpty(final Byte[] array){


Input:
/**Send a message to each of the connections in telnet-friendly output. **/
public synchronized void send(final String message){


Input:
/**Return an EMPTY_BOOLEAN_OBJECT_ARRAY array for a null or empty input array.**/
public static Boolean[] nullToEmpty(final Boolean[] array){


Input:
/**Place a  LoggingEvent in the buffer buf.**/
public void put(LoggingEvent o){

Place a  LoggingEvent in the buffer buf.


Input:
/**Split time ranges to insure the start time and end time is small than FETCH_DATA_DURATION.**/
protected List<TimeRange> buildTimeRanges(long start,long end){


Input:
/**Convert an array of object Bytes to primitives, return null for a null input array.**/
public static byte[] toPrimitive(final Byte[] array){


Input:
/**Follow the dayStep to reformat the time bucket with TIME_BUCKET_FORMATTER. For example, if dayStep == 11, 20000105 re-formatted time bucket is 20000101, 20000115 re-formatted time bucket is 20000112, 20000123 re-formatted time bucket is 20000123.**/
static long compressTimeBucket(long timeBucket,int dayStep){


Input:
/**Compute the size of the utf8 string beginning at the specified  index  with the specified length.**/
public static int computeUTF8Size(final CharSequence str,final int index,final int len){


Input:
/**Convert an array to list, return empty list for null array.**/
public static <T>List<T> asList(T[] a){


Input:
/**Remove a value from the values if the map keys contains the val. Returns true if actually removed, and false otherwise.**/
public boolean remove(int val){


Input:
/**Return true if the given string starts with the specified case-insensitive prefix, false otherwise.**/
public static boolean startsWithIgnoreCase(String str,String prefix){


Input:
/**Compute all vertices by iterating over the edges of this graph.**/
private Set<V> initVisibleVertices(){


Input:
/**Reverse the given String as per.**/
public static String reverse(final String str){


Input:
/**Get a substring from the specified String avoiding exceptions. **/
public static String sub(String str,int start,int end){


Input:
/**Put an array of bytes into this byte vector, enlarge the byte vector automatically if necessary.**/
public ByteVector putByteArray(final byte[] byteArrayValue,final int byteOffset,final int byteLength){


Input:
/**Wrap an HttpServletRequest with the Builder.**/
public static AtmosphereRequest wrap(HttpServletRequest request){


Input:
/**Write the utf8-encoded bytes from the string into the LinkedBuffer.**/
public static LinkedBuffer writeUTF8(final CharSequence str,final WriteSession session,final LinkedBuffer lb){


Input:
/**Remove this edge from both doubly linked lists of the tree edges.**/
public void removeFromTreeEdgeList(){


Input:
/**Find the value corresponding to key in props, then perform variable substitution on the found value. Return the substitution result, or the value in case of exception. **/
public static String findAndSubst(String key,Properties props){


Input:
/**Append the detail of an int array to the buffer, starting with arrayStart and ending with arrayEnd, and separating with arraySeparator.**/
protected void appendDetail(StringBuffer buffer,String fieldName,int[] array){


Input:
/**Return the servlet session id**/
public static String sessionId(){


Input:
/**Check whether a character string is a dight. If yes, true is returned. Otherwise, false is returned.**/
public static boolean isDigits(String str){


Input:
/**Check whether a character is a parameter separator. If yes, true is returned. Otherwise, false is returned.**/
private static boolean isParameterSeparator(final char c){


Input:
/**Determines whether a character string ends with a specified suffix.**/
private static boolean endsWith(final String str,final String suffix,final boolean ignoreCase){


Input:
/**Decode the raw path.**/
public static List<PathSegmentImpl> decodePath(URI u,boolean decode){


Input:
/**If array is null or its length is 0, convert array to EMPTY_CHARACTER_OBJECT_ARRAY. Otherwise, return array itself.**/
public static Character[] nullToEmpty(final Character[] array){


Input:
/**Check whether there is a thrown**/
public boolean hasThrown(){


Input:
/**Return the value at the top of the stack**/
public static String peek(){


Input:
/**Add the value to the original value of the key.**/
public void valueAccumulation(String key,Long value){


Input:
/**If the stack is not empty, the last element of the stack is returned. Otherwise, null is returned.**/
public InputStream next() throws IOException {


Input:
/**Check if the named logger exists. If so return its reference, otherwise returns null.**/
public Logger exists(String name){


Input:
/**Check whether the specified converter exists in converters. If yes, converter is returned. If no, null is returned.**/
public Converter lookup(final Class<?> clazz){


Input:
/**Read raw varint**/
public long readRawVarint64() throws IOException {


Input:
/**If the double type array is null or its length is 0, convert array to EMPTY_CHARACTER_OBJECT_ARRAY. Otherwise, return array itself.**/
public static Double[] nullToEmpty(final Double[] array){


Input:
/**Pop the various value according to the first character of the descriptor.**/
private void pop(final String descriptor){


Input:
/**Write bytes of length len from a byte array**/
@Override public void write(final byte b[],final int off,final int len) throws IOException {


Input:
/**Swap values at indexes i and j in arr**/
public static final <V>void swap(V[] arr,int i,int j){


Input:
/**Determine whether the actual response is a Partial Content**/
public Boolean isPartialContentResponse(){


Input:
/**Check whether the array of the double type is empty.**/
public static boolean isEmpty(final double[] array){


Input:
/**Check whether lastwrite is - 1. If yes, return - 1. Otherwise, return System.currentTimeMillis().**/
public long lastWriteTimeStampInMilliseconds(){


Input:
/**Add an edge whose start point is sourceVertex and end point is targetVertex to touchingVerticesToEdgeMap.**/
protected void addToIndex(V sourceVertex,V targetVertex,E e){


Input:
/**Creates an array of the file type based on all file names in java.class.path and returns the array.**/
private static File[] classPath(){


Input:
/**Copy the source string and transfer each character to lowecase.**/
private static String[] copyStrings(final String[] src){


Input:
/**Divide a box into two equal boxes on the x axis.**/
public static Pair<Box2D,Box2D> splitAlongXAxis(Box2D box){


Input:
/**Convert the original data array to a longer array.**/
private void enlarge(final int size){


Input:
/**Check whether appender elements exist in appenderList. If yes, true is returned. Otherwise, false is returned.**/
public boolean isAttached(Appender appender){


Input:
/**Compares two values. If the difference between the two values is less than epsilon, 0 is returned. Otherwise, Double.compare is invoked.**/
@Override public int compare(Double o1,Double o2){


Input:
/**If the key whose value is val does not exist in the map, add (val, val) to the map and return true. Otherwise, return false.**/
public boolean insert(int val){


Input:
/**Check whether all fields exist in properties.**/
private boolean containsAllFields(Fields fields){


Input:
/**Converts a name of the string type to a character array and converts the first letter to an uppercase letter.**/
public static String capitalize(String name){


Input:
/**Write the content into the LinkedBuffer.**/
public static int writeTo(final DataOutput out,LinkedBuffer node) throws IOException {


Input:
/**Check whether the parameter bool is not true.**/
public static boolean isNotTrue(Boolean bool){


Input:
/**Convert a value in a vs array to a string**/
public String toString(){


Input:
/**Create a string supplier which returns unique integer strings starting from the given start.**/
@SuppressWarnings("unchecked") public static Supplier<String> createStringSupplier(int start){


Input:
/**Formats LoggingEvent as a fixed-format string**/
public String format(final LoggingEvent event){


Input:
/**If the length of the array is 0, return EMPTY_DOUBLE_ARAY. Otherwise, convert the array to an array of the double type.**/
public static double[] toPrimitive(final Double[] array){


Input:
/**Add abstractType to the initializations variable.**/
private void addInitializedType(final int abstractType){


Input:
/**Add the elements indexed from start to end in currentFrame to Frame.**/
private void putAbstractTypes(final int start,final int end){


Input:
/**Read from the buffer.**/
public void readFrom(final InputStream in) throws IOException {


Input:
/**Write the byte array b to the buffer based on the encoding.**/
@Override public void write(final byte[] b) throws IOException {


Input:
/**Converts the content in JSONWriter to a string.**/
@SuppressWarnings("unchecked") public String toString(JSONWriter.Feature... features){


Input:
/**If the length of the value string is 0, the default type is returned. Otherwise, the element at the first position of the string is returned.**/
@Override protected Object convertToType(final Class<?> type,final Object value) throws Exception {


Input:
/**Check whether str contains elements in searchStrArray. If yes, true is returned. If no, false is returned.**/
public static boolean containsAnyIgnoreCase(String str,List<String> searchStrArray){


Input:
/**Returns the element at the location specified by desiredCapacity in primeCapacities.**/
public static int nextPrime(int desiredCapacity){


Input:
/**Obtains the character value of ch. If ch is null, defaultValue is returned.**/
public static char toChar(final Character ch,final char defaultValue){


Input:
/**Returns the first element in candidates that matches the source.**/
public static Object findFirstMatch(Collection source,Collection candidates){


Input:
/**Trim the end space of the str.**/
public static String trimTrailingWhitespace(String str){


Input:
/**Initializes a directory.**/
public void init(){


Input:
/**Read string from a buffer.**/
@Override public String readString() throws IOException {


Input:
/**Obtains the number corresponding to the character c.**/
private static int digitValue(final char c){


Input:
/**Put the "content" from the  jsonObject to the content.**/
private Map<String,Object> buildContent(JsonObject jsonObject){


Input:
/**Remove the mapping from atmosphereHandlers.**/
public AtmosphereFramework removeAtmosphereHandler(String mapping){


Input:
/**Copy bytes from LinkedBuffer and return.**/
public final byte[] toByteArray(){


Input:
/**Unescapes Java that found in the String.**/
public static String unescapeJava(String str) throws Exception {


Input:
/**Translate a MIME standard charset name into the Java equivalent.**/
private static String javaCharset(String charset){


Input:
/**Check whether an obj variable is of the String type.**/
public static Object quoteIfString(Object obj){


Input:
/**Returns the previous ListNode.**/
@Override public ListNode<E> previousNode(){


Input:
/**Read a short value from classFileBuffer**/
public short readShort(final int offset){


Input:
/**Copy the given array and add a default value at the end.**/
private static Object copyArrayGrow1(final Object array,final Class<?> newArrayComponentType){


Input:
/**Calculate the floor of the logarithmic value of the given value in base 2.**/
private int computeBinaryLog(int n){


Input:
/**Return the intersection between two sets.**/
private Set<V> intersection(Set<V> set1,Set<V> set2){


Input:
/**If collection is null, convert collection to EMPTY_STRING_ARRAY. Otherwise, convert collection to an array of strings and return the array. ???**/
static String[] toNoNullStringArray(Collection<?> collection){


Input:
/**Check whether a character string is all consist of zero. **/
private static boolean isAllZeros(String s){


Input:
/**Filter and return null for the null and abort message in BroadcastAction, return the action message otherwise. **/
protected Object filter(Object msg){


Input:
/**Convert process properties to the JsonObject.**/
private JsonObject convertProperties(List<KeyStringValuePair> properties){


Input:
/**Remove any inactive nodes from the Category tree and return the number of removed nodes.**/
protected int removeUnusedNodes(){


Input:
/**Return the label by the given bytecode offset if it has been created. Otherwise, creat a new label and return it.**/
protected Label readLabel(final int bytecodeOffset,final Label[] labels){


Input:
/**Check whether a string is true or false after ignore cases and trim the whitespaces at both ends. If so, its boolean value is returned. Otherwise, dEfault is returned.**/
public static boolean toBoolean(String value,boolean dEfault){


Input:
/**Trim the leading whitespaces in a string.**/
public static String trimLeadingWhitespace(String str){


Input:
/**Read a CONSTANT_Utf8 constant pool entry in the classFileBuffer.**/
final String readUtf(final int constantPoolEntryIndex,final char[] charBuffer){


Input:
/**Convert a hexadecimal number to binary and return its character type.**/
private static char decodeHexNibble(final char c){


Input:
/**Convert object to string  if the object is not null. Otherwise, null is returned.**/
public static String toString(Object object){


Input:
/**Calculate the factorial of the given number.**/
public static long factorial(int n){


Input:
/**Find a circulator to the node that satisfies the Interface predicate.**/
private OuterFaceCirculator selectOnOuterFace(Predicate<Node> predicate,Node start,Node stop,int dir){


Input:
/**Add an event as the last event in the buffer.**/
public void add(LoggingEvent event){


Input:
/**Compare two numbers.**/
private static int compareSigned(long a,long b){


Input:
/**Convert an enumeration to a string array.**/
public static String[] toStringArray(Enumeration<String> enumeration){


Input:
/**Add a byte array into the byte vector.**/
public ByteVector putByteArray(final byte[] byteArrayValue,final int byteOffset,final int byteLength){


Input:
/**Return an unmodifiable list that contains all methods in the BeanMap.**/
public Collection<Object> values(){


Input:
/**Compute a hash code according to the type.**/
@Override public int hashCode(){


Input:
/**Delete characters that exists in the intersection between two character strings of the first character string and return the first character string that is modified.**/
public static String deleteAny(String inString,String charsToDelete){


Input:
/**If the match between the url and the pattern occurs, return the match result. Otherwise, return null.**/
public final MatchResult match(CharSequence uri){


Input:
/**Convert an ASCII encoded character to hex.**/
public static byte convertHexDigit(byte b){


Input:
/**Add files in the stack in reverse order.**/
private void addReverse(final InputStream[] files){


Input:
/**Check whether the key contains null.**/
private void check(String modelName) throws IllegalStateException {


Input:
/**Read the next buffer in the buffer.**/
public byte readByte() throws IOException {


Input:
/**Suspend the AtmosphereResource based on its transport value.**/
@Override public Action inspect(AtmosphereResource r){


Input:
/**Return the sum of the weights entering a vertex.**/
public double vertexWeight(Set<V> v){


Input:
/**Compare two events by their timeStamp.**/
public int compare(Object aObj1,Object aObj2){


Input:
/**Remove the appender by the given name from the list of appenders.**/
public void removeAppender(String name){


Input:
/**Call the doAppend method on all attached appenders. **/
public int appendLoopOnAppenders(LoggingEvent event){


Input:
/**Convert the given Integer array to primitives. Return ArrayUtils.EMPTY_INT_ARRAY for an empty array, return null for null array.**/
public static int[] toPrimitive(final Integer[] array){


Input:
/**Register the value in REGISTRY if the value is not null.**/
static void register(Object value){


Input:
/**Return the number of non-zero entries of a row.**/
public int nonZeros(int row){


Input:
/**Check whether the element exists in the collection. **/
public static boolean containsInstance(Collection collection,Object element){


Input:
/**Check whether the character is ASCII 7 bit control.**/
public static boolean isAsciiControl(final char ch){


Input:
/**Check whether a map contains a mapping for the specified key.**/
@Override public boolean containsKey(final Object key){


Input:
/**Convert an array of primitive booleans to objects.**/
public static Boolean[] toObject(final boolean[] array){


Input:
/**Copy bytes to a byte array.**/
public byte[] toByteArray(){


Input:
/**Convert a set representation to a graph path.**/
protected GraphPath<V,E> edgeSetToTour(Set<E> tour,Graph<V,E> graph){


Input:
/**Convert an array of primitive shorts to objects.**/
public static Short[] toObject(final short[] array){


Input:
/**Add constant information generated by its name and type to the constant pool and return the index of the constant.**/
int addConstantNameAndType(final String name,final String descriptor){


Input:
/**Unescape a dot identifier string.**/
private String unescapeId(String input){


Input:
/**Concatenate two string arrays into one.**/
public static String[] concatenateStringArrays(String[] array1,String[] array2){


Input:
/**Move all vertices from the minimum label bucket to the bucket with label 0 and clear the minimum label bucket.**/
private void reload(List<Set<Integer>> bucketsByLabel,List<Integer> labels,int minLabel){


Input:
/**Append a string to a string array.**/
public static String[] addStringToArray(String[] array,String str){


Input:
/**Return the frequencies that the substring appears in the string.**/
public static int countOccurrencesOf(String str,String sub){


Input:
/**Check whether there is at least one instance of the implementation class in the lists. If so, true is returned. Otherwise, false is returned.**/
private boolean checkDuplicate(final List<AtmosphereInterceptor> interceptorList,Class<? extends AtmosphereInterceptor> c){


Input:
/**Append a byte array to a buffer.**/
protected void appendDetail(StringBuffer buffer,String fieldName,byte[] array){


Input:
/**Check whether there are unvisited vertices. If so, return true. Otherwise, return false.**/
@Override public boolean hasNext(){


Input:
/**Pop the given number of elements from the stack.**/
private void pop(final int elements){


Input:
/**Check whether the existed buckets are the same as the buckets.**/
public boolean isCompatible(DataTable dataset){


Input:
/**Find class by the given class name.**/
private Class findClass(final String className) throws ClassNotFoundException {


Input:
/**Get next vertext from a graph.**/
@Override protected V provideNextVertex(){


Input:
/**Add the number of lines. **/
final void addLineNumber(final int lineNumber){


Input:
/**Remove the doubly linked list node that call the function.**/
void removeSelf(){


Input:
/**Change the elements whose values are oldName to newName in column**/
public void overrideName(String oldName,String newName){


Input:
/**Remove the doubly circular linked list node.If success return true,otherwise return false.**/
private boolean unlink(ListNodeImpl<E> node){


Input:
/**Return a list whose nodes are sequences,and the sequences'lower bound are all minSequence,and the length increases sequentially with SEQUENCE_RANGE_BATCH_SIZE but the upper bound is maxSequence.**/
public List<SequenceRange> buildSequenceRanges(){


Input:
/**If dataBytes is equal to null,return false,otherwise return true.**/
public boolean hasBytes(){


Input:
/**Return the path without the extension.**/
public static String stripFilenameExtension(String path){


Input:
/**Return a string which is consist of the values of elements in the given array.If array is equal to null,return null,or return ArrayUtils.EMPTY_CHAR_ARRAY if the size of array is equal to zero.**/
public static char[] toPrimitive(final Character[] array){


Input:
/**Parses out a token until any of the given terminators is encountered and then return the token.**/
private String parseToken(final char[] terminators){


Input:
/**Trim all the characters which are equal to the given character and appear at the beginning of the given string,and return the trimmed string.**/
public static String trimLeadingCharacter(String str,char leadingCharacter){


Input:
/**Return an array of Integer objects which are converted from an array of primitive ints.(the other situations are like 636766fe1a6d9265ec017838)**/
public static Integer[] toObject(final int[] array){


Input:
/**Return an array of Double objects which are converted from an array of primitive doubles.(similar to 636767041a6d9265ec01790f)**/
public static Double[] toObject(final double[] array){


Input:
/**Return a pair of the list of suffix sum and the sum of all elements of bounds.**/
private Pair<List<Integer>,Long> computeSuffixSum(List<Integer> bounds){


Input:
/**Reverse the order of the given elements in the specified range.**/
public static final <V>void reverse(V[] arr,int from,int to){


Input:
/**Move the nodes of the given doubly linked list to a new list sequentially.**/
private void moveAllListNodes(DoublyLinkedList<E> list){


Input:
/**Return true if the given string has the specified prefix with optional cases which can be ignored,or both string and prefix are null.Otherwise return false. **/
private static boolean startsWith(final String str,final String prefix,final boolean ignoreCase){


Input:
/**Return the Character object converted from the given character.**/
public static Character toCharacterObject(final char ch){


Input:
/**Return true if the character is ASCII alphabetic upper case.Otherwise return false.**/
public static boolean isAsciiAlphaUpper(final char ch){


Input:
/**Return a decision based on the message generated by the event and whether the given string is matched.**/
public int decide(LoggingEvent event){


Input:
/**Return true if the given name is a member variable of this template,otherwise return false.**/
public final boolean isTemplateVariablePresent(String name){


Input:
/**Put all of the both readable and writable methods from the given map to this map.**/
public void putAllWriteable(BeanMap map){


Input:
/**Return the given string's length.If the string is null,and zero will be returned.**/
public static int length(final String str){


Input:
/**Return true if the given character is a hex digit,otherwise return false.**/
private static boolean isHex(final char c){


Input:
/**Decoding a string follow the Base64 regular to an array,and return a string  constructed from the array according to UTF_8.**/
public static String base64Decode(final String s){


Input:
/**Return true if the length of array1 is the same as the length of array2 or both them are null,otherwise return false.**/
public static boolean isSameLength(final double[] array1,final double[] array2){


Input:
/**Return a Meteor object based on the HttpServletRequest r.**/
public static Meteor lookup(HttpServletRequest r){


Input:
/**Split the given string toSplit at the first occurrence of the given delimiter,and return two substrings that don't include the delimiter.**/
public static String[] split(String toSplit,String delimiter){


Input:
/**Select an edge which isn't a circle in the graph,compute the list of the minimal separators in the neighborhood of the edge and put the pair of list and edge into the return list.Repeat for each edge in the graph and then return the final list.**/
private List<Pair<List<Pair<Integer,Integer>>,E>> computeGlobalSeparatorList(){


Input:
/**Return a clone of the given array.**/
public static char[] clone(final char[] array){


Input:
/**Put the given array of files into a stack in reverse order. **/
private void addReverse(final File[] files){


Input:
/**Select the specified row in the given JTable and scroll the given JScrollPane to the row. **/
public static void selectRow(int row,JTable table,JScrollPane pane){


Input:
/**Divide an int into four bytes and put the bytes into a byte vector called data in big endian order.The vector will be enlarged if necessary.And return the object.(和636767031a6d9265ec0178cd一样)**/
public ByteVector putInt(final int intValue){


Input:
/**Given two arrays with the given length count,return true if the array a is equal to array b,otherwise return false.**/
public static boolean arrayequals(byte[] a,byte[] b,int count){


Input:
/**The given name can be split into several substrings by ".",and abbreviate the name in the buf by deleting the first count substrings. **/
public void abbreviate(final int nameStart,final StringBuffer buf){


Input:
/**Resolve the class of the first bound for the typeVariable recursively,return Unknown.class if it can't be resolved.Otherwise return the bound.**/
public static Type resolveBound(TypeVariable<?> typeVariable){


Input:
/**Return true if the subgraph of the given graph induced by the given vertices is a clique,otherwise return false.**/
private static <V,E>boolean isClique(Graph<V,E> graph,Set<V> vertices){


Input:
/**The type of key has several lower bounds conducted by different function,this function will return a list of the maximum lower bound of each key in the given list.**/
private List<Integer> computeLowerBounds(List<K> keys){


Input:
/**Pop different value of type based on the first character of the given descriptor.**/
private void pop(final String descriptor){


Input:
/**Return true if the given character is a ASCII seven bit character,otherwise return false.**/
public static boolean isAscii(final char ch){


Input:
/**The type of key has several upper bounds conducted by different function,this function will return a list of the minimum upper bound of each key in the given list.**/
private List<Integer> computeUpperBounds(List<K> keys){


Input:
/**Encoding the given string by changing '{' and '}' to the specified character for each,return the string after encoding.**/
public static String encodeTemplateNames(String s){


Input:
/**Using TOLERANCE_DOUBLE_COMPARATOR to compare two points for equality,return true the point p1 is equal to another point p2,otherwise return false.**/
public static boolean equals(Point2D p1,Point2D p2){


Input:
/**Adding an instance of AtmosphereResourceEventListener e into a list and return the  AtmosphereResource object which call the function.**/
@Override public AtmosphereResource addEventListener(AtmosphereResourceEventListener e){


Input:
/**Combine the substring before FOLDER_SEPARATOR of the given path with the given relative path to construct a new full file path,and return the full file path.**/
public static String applyRelativePath(String path,String relativePath){


Input:
/**Return the first index of the searchStr in the given string.**/
public static int indexOf(String str,String searchStr){


Input:
/**Return a new array of strings converted from the elements which are not null of the given array,if the size of the array is zero,it will throw an exception.**/
static String[] toNoNullStringArray(Object[] array){


Input:
/**Return the last index of the extension separator in the given filename,it will return -1 if the filename doesn't have the separator or there is a directory separator after it.**/
public static int indexOfExtension(String filename){


Input:
/**Return true if the timestamp minus the lastUpdateTimestamp is greater than expiredThreshold,otherwise return false.**/
public boolean isExpired(long timestamp,long expiredThreshold){


Input:
/**Return the edge connecting the previously returned node with the current node.**/
Edge edgeToNext(){


Input:
/**Return true if starting at the given index,the given string matches the given substring.Otherwise return false.**/
public static boolean substringMatch(CharSequence str,int index,CharSequence substring){


Input:
/**Haddling a logging event by using layout.format(),and if layout.ignoresThrowable() is true,it will continue to send the StrRep of the event.**/
protected void append(LoggingEvent event){


Input:
/**Return the String object that contains the given character.**/
public static String toString(final char ch){


Input:
/**Check if the field should be packed,if so,read the field and update the internal state. It will throw an exception when the process of reading is wrong.**/
private void checkIfPackedField() throws IOException {


Input:
/**Return a field tag, and if reach the EOF the tag will be zero.It will throw an exception when the tag is equal to zero after logical shift right  TAG_TYPE_BITS.**/
public int readTag() throws IOException {


Input:
/**Put two bytes into a byte vector called data.The vector will be enlarged if necessary.And return the ByteVector object.**/
final ByteVector put11(final int byteValue1,final int byteValue2){


Input:
/**Return the string that contains the content range from offset to limit(when limit is zero,the upper bound will be count-1) and count.**/
private String buildContentRange(){


Input:
/**Load the thread snapshots from the given file in the specified time range,and return the list of those thread snapshots.**/
public static List<ThreadSnapshot> parseFromFileWithTimeRange(File file,List<ProfileAnalyzeTimeRange> timeRanges) throws IOException {