<p>parseArray.</p>

@param s a {@link java.lang.String} object.
@return an array of {@link java.lang.String} objects.
483568
public static String [] parseArray(String s) {
		// a:2:{i:0;s:12:"PHPSUD_OBJ_2";i:1;s:12:"PHPSUD_OBJ_3";}
		String [] t = s.split(":");
		int z = Integer.parseInt(t[1]);
		String [] res = new String[z];
		for(int i = 0; i < z; i ++) {
			 String a = t[5 + 3*i].split(";")[0];
			 res[i] = a.substring(1).substring(0, a.length() - 2);
		}
		return res;
	}
1280729
public static byte[] decode(String s)
  {
	  ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int len = s.length();
 	  
	  boolean toggle = false;
	  int keep = 0;

    for (int i = 0; i < len; i++) {
      char ch = s.charAt(i);
 	    int n = ALPHABET.indexOf(Character.toLowerCase(ch));
	    if (n == -1) {
		    throw new 
		      IllegalArgumentException(s+" is not properly encoded");
	    }

 	    toggle = !toggle;

 	    if (toggle) {
		    keep = n;
	    } else {
		    baos.write((keep << 4) | n);
 	    }
 	  }
	  return baos.toByteArray();
  }
675580
public static byte[] stringUToByteArr(String s) {
    char c;
    byte[] b = new byte[2 * s.length()];
    for (int i = 0; i < s.length(); i++) {
      c = s.charAt(i);
      b[2 * i + 1] = (byte) c;
      b[2 * i] = (byte) (c >> 8);
    }
    return b;
  }
279625
@Pure
	public static MACNumber[] parse(String addresses) {
		if ((addresses == null) || ("".equals(addresses))) { //$NON-NLS-1$
			return new MACNumber[0];
		}
		final String[] adrs = addresses.split(Pattern.quote(Character.toString(MACNUMBER_SEPARATOR)));
		final List<MACNumber> list = new ArrayList<>();
		for (final String adr : adrs) {
			list.add(new MACNumber(adr));
		}
		final MACNumber[] tab = new MACNumber[list.size()];
		list.toArray(tab);
		list.clear();
		return tab;
	}
57264
public static long[] parseLongs(String[] array) {
    long[] result = new long[array.length];
    for (int i = 0; i < array.length; i++)
      result[i] = Long.parseLong(array[i]);
    return result;
  }
919764
public Object parseArray() {
    ArrayList arr = new ArrayList();
    advance();
    if(T.isValueType()) {
      arr.add(parseValue());
      while(T.getType() == TokenType.COMMA) {
        advance();
        arr.add(parseValue());
      }
    }
    checkAndSkip(TokenType.RSQUARE, "]");
    return arr;
  }
760469
public final static byte[] readByteArray(final ObjectInputStream s) throws IOException {
		final byte[] a = new byte[readVByte(s)];
		s.readFully(a);
		return a;
	}
331708
public static byte[] fromHexString(String s) {
		if (s.length() % 2 != 0) {
			throw new IllegalArgumentException(s);
		}
		byte[] array = new byte[s.length() / 2];
		for (int i = 0; i < array.length; i++) {
			int b = Integer.parseInt(s.substring(i * 2, i * 2 + 2), SIXTEEN);
			array[i] = (byte) (_0XFF & b);
		}
		return array;
	}
215266
public static String[] objectArrayToStringArray(final Object[] objectArray) {
		if( objectArray == null ) {
			return null;
		}
		
		final String[] stringArray = new String[objectArray.length];
		for( int i = 0; i < objectArray.length; i++ ) {
			stringArray[i] = objectArray[i] != null ? objectArray[i].toString() : null;
		}
		
		return stringArray;
	}
490103
private <E> Object parse( String s, Class fclz ) {
    if( fclz.equals(String.class) ) return s; // Strings already the right primitive type
    if( fclz.isArray() ) {      // An array?
      read(s,    0       ,'[',fclz);
      read(s,s.length()-1,']',fclz);
      String[] splits = s.substring(1,s.length()-1).split(",");
      Class<E> afclz = (Class<E>)fclz.getComponentType();
      E[] a= (E[])Array.newInstance(afclz,splits.length);
      for( int i=0; i<splits.length; i++ )
        a[i] = (E)parse(splits[i],afclz);
      return a;
    }
    if( fclz.equals(Key.class) ) return Key.make(s);

    throw new RuntimeException("Unimplemented schema fill from "+fclz.getSimpleName());
  }  
  private int read( String s, int x, char c, Class fclz ) {
    if( peek(s,x,c) ) return x+1;
    throw new IllegalArgumentException("Expected '"+c+"' while reading a "+fclz.getSimpleName()+", but found "+s);
  }
  private boolean peek( String s, int x, char c ) { return x < s.length() && s.charAt(x) == c; }
}
1166847
public List<Object> parseArray() throws IOException {
		Type t = lexer.readNextToken();
		if (t != Type.START_ARRAY) {
			throw new IOException("Unexpected token: " + t);
		}
		
		return parseArrayInternal();
	}
573596
static byte[] toBytes(final String s) {
    try {
      return (byte[]) toBytes.invoke(null, s);
    } catch (Exception e) {
      throw new RuntimeException("toBytes=" + toBytes, e);
    }
  }
583204
public static byte[] decode(String s)
    {
        int len = s.length();
        if (len % 2 != 0)
        {
            return null;
        }

        byte[] bytes = new byte[len / 2];
        int pos = 0;

        for (int i = 0; i < len; i += 2)
        {
            byte hi = (byte) Character.digit(s.charAt(i), 16);
            byte lo = (byte) Character.digit(s.charAt(i + 1), 16);
            bytes[pos++] = (byte) (hi * 16 + lo);
        }

        return bytes;
    }
623883
public static String sort( String s )
	{
		char[] chars = s.toCharArray();
		Arrays.sort( chars );
		return new String( chars );
	}
72523
private <T> List<T> parseArray(JSONArray items, Class<T> clazz) {

        List<T> result = new ArrayList<T>();
        for (Object onode : items) {
            JSONObject jnode = (JSONObject) onode;

            T item;
            try {
                item = clazz.getDeclaredConstructor(JSONObject.class, DGraph.class).newInstance(jnode, this);
            } catch (InstantiationException | 
                    IllegalAccessException | 
                    IllegalArgumentException | 
                    InvocationTargetException | 
                    NoSuchMethodException | 
                    SecurityException e) {
                throw new AamWriterException(e);
            }

            result.add(item);
        }
        return result;
    }
1254459
@Override
    public String[] read(ScanBuffer buffer) {
        int length = getLength(buffer);
        if (length<0) return null;
        String[] result = new String[length];
        for (int i = 0; i < length; i++) {
            result[i]=stringSerializer.read(buffer);
        }
        return result;
    }
1268135
private FormatString[] parse(String s) {
        ArrayList<FormatString> al = new ArrayList<>();
        for (int i = 0, len = s.length(); i < len; ) {
            int nextPercent = s.indexOf('%', i);
            if (s.charAt(i) != '%') {
                // This is plain-text part, find the maximal plain-text
                // sequence and store it.
                int plainTextStart = i;
                int plainTextEnd = (nextPercent == -1) ? len: nextPercent;
                al.add(new FixedString(s.substring(plainTextStart,
                                                   plainTextEnd)));
                i = plainTextEnd;
            } else {
                // We have a format specifier
                FormatSpecifierParser fsp = new FormatSpecifierParser(s, i + 1);
                al.add(fsp.getFormatSpecifier());
                i = fsp.getEndIdx();
            }
        }
        return al.toArray(new FormatString[al.size()]);
    }