Class GrouperUtil

java.lang.Object
edu.internet2.middleware.grouper.util.GrouperUtil

public class GrouperUtil extends Object
utility methods for grouper. Generally these are static methods.
  • Field Details

    • objectMapper

      public static final com.fasterxml.jackson.databind.ObjectMapper objectMapper
      Object mapper to serialize and deserialize json string and beans
    • LOG_ERROR

      public static final String LOG_ERROR
      See Also:
    • ONE_KB

      public static final long ONE_KB
      The number of bytes in a kilobyte.
      See Also:
    • ONE_MB

      public static final long ONE_MB
      The number of bytes in a megabyte.
      See Also:
    • ONE_GB

      public static final long ONE_GB
      The number of bytes in a gigabyte.
      See Also:
    • PROMPT_KEY_SCHEMA_EXPORT_ALL_TABLES

      public static String PROMPT_KEY_SCHEMA_EXPORT_ALL_TABLES
      prompt key for schema export
    • PROMPT_KEY_RESET_DATA

      public static String PROMPT_KEY_RESET_DATA
      prompt key for reset data
    • stopPromptingUser

      public static boolean stopPromptingUser
      dont prompt while testing etc, but make sure there has been at least one prompt
    • timestampIsoUtcMicrosWithoutZtoString

      public static final DateFormat timestampIsoUtcMicrosWithoutZtoString
    • timestampIsoUtcSeconds

      public static final DateFormat timestampIsoUtcSeconds
    • timestampIsoHoursMinutesTZ

      public static final DateFormat timestampIsoHoursMinutesTZ
    • timestampHoursMinutesLocalDateTime

      public static final DateFormat timestampHoursMinutesLocalDateTime
    • timestampHoursMinutesSecondsLocalDateTime

      public static final DateFormat timestampHoursMinutesSecondsLocalDateTime
    • timestampHoursMinutes

      public static final DateFormat timestampHoursMinutes
    • timestampHoursMinutesAMPM

      public static final DateFormat timestampHoursMinutesAMPM
    • DATE_FORMAT

      public static final String DATE_FORMAT
      string format of dates
      See Also:
    • TIMESTAMP_FILE_FORMAT

      public static final String TIMESTAMP_FILE_FORMAT
      string format of dates for file names
      See Also:
    • DATE_FORMAT2

      public static final String DATE_FORMAT2
      string format of dates
      See Also:
    • DATE_FORMAT3

      public static final String DATE_FORMAT3
      See Also:
    • DATE_MINUTES_SECONDS_FORMAT

      public static final String DATE_MINUTES_SECONDS_FORMAT
      format including minutes and seconds: yyyy/MM/dd HH:mm:ss
      See Also:
    • DATE_MINUTES_SECONDS_NO_SLASH_FORMAT

      public static final String DATE_MINUTES_SECONDS_NO_SLASH_FORMAT
      format including minutes and seconds: yyyyMMdd HH:mm:ss
      See Also:
    • TIMESTAMP_FORMAT

      public static final String TIMESTAMP_FORMAT
      format on screen of config for milestone: yyyy/MM/dd HH:mm:ss.SSS
      See Also:
    • TIMESTAMP_NO_SLASH_FORMAT

      public static final String TIMESTAMP_NO_SLASH_FORMAT
      format on screen of config for milestone: yyyyMMdd HH:mm:ss.SSS
      See Also:
    • NOT_FOUND

      public static final int NOT_FOUND
      special number when a number is not found
      See Also:
    • DEFAULT_BUFFER_SIZE

      public static final int DEFAULT_BUFFER_SIZE
      The name says it all.
      See Also:
    • EMPTY_STRING_ARRAY

      public static final String[] EMPTY_STRING_ARRAY
      An empty immutable String array.
    • EMPTY_OBJECT_ARRAY

      public static final Object[] EMPTY_OBJECT_ARRAY
      An empty immutable Object array.
    • EMPTY

      public static final String EMPTY
      The empty String "".
      Since:
      2.0
      See Also:
    • INDEX_NOT_FOUND

      public static final int INDEX_NOT_FOUND
      Represents a failed index search.
      Since:
      2.1
      See Also:
    • stringFieldNames

      public static Map<Class<?>,Set<String>> stringFieldNames
      map of class to the list of fields which are string type
    • JAVA_IO_TMPDIR

      public static final String JAVA_IO_TMPDIR
      See Also:
    • HTML_REPLACE

      public static final String[] HTML_REPLACE
      array for converting HTML to string
    • HTML_REPLACE_NO_SINGLE

      public static final String[] HTML_REPLACE_NO_SINGLE
      array for converting HTML to string
    • HTML_SEARCH_NO_SINGLE

      public static final String[] HTML_SEARCH_NO_SINGLE
      array for converting HTML to string
  • Constructor Details

    • GrouperUtil

      public GrouperUtil()
  • Method Details

    • main

      public static void main(String[] args) throws Exception
      Throws:
      Exception
    • jsonJacksonListObjectArrayFromJsonPointers

      public static List<Object[]> jsonJacksonListObjectArrayFromJsonPointers(com.fasterxml.jackson.databind.JsonNode rootJsonNode, String jsonPointerOfArrayNode, List<String> jsonPointersOfSubFields)
      start the sub field with JSON_NODE_ROOT if you want the pointer from root node instead of array node
      Parameters:
      rootJsonNode -
      jsonPointerOfArrayNode - json path that returns a list e.g. /a/b
      jsonPointersOfSubFields - from the perspective of the array node, e.g. /c/d
      Returns:
      the list of object arrays not null
    • substituteExpressionPrintNode

      public static void substituteExpressionPrintNode(org.apache.commons.jexl2.parser.JexlNode jexlNode, String prefix)
    • generateRsaKeypair

      public static String[] generateRsaKeypair(int keySize)
      generate RSA key public private pair.
      Parameters:
      keySize - e.g 2048
      Returns:
    • gshRunScript

      public static String gshRunScript(String script)
      run a GSH script
      Parameters:
      script -
      lightWeight - will use an abbreviated groovysh.profile for faster speed. built in commands arent there and imports largely arent there
      Returns:
      the output
    • gshRunScript

      public static String gshRunScript(String script, boolean lightWeight)
      run a GSH script
      Parameters:
      script -
      lightWeight - will use an abbreviated groovysh.profile for faster speed. built in commands arent there and imports largely arent there
      inputMap - puts variables in a context to be retrieved with GrouperUtil.gshRetrieveInputValueObject(), GrouperUtil.gshRetrieveInputValueString(), GrouperUtil.gshRetrieveInputValueInteger(), GrouperUtil.gshRetrieveInputValueBoolean()
      Returns:
      the full output
    • gshRunScriptReturnResult

      public static GrouperGroovysh.GrouperGroovyResult gshRunScriptReturnResult(String script, boolean lightWeight)
      run a GSH script
      Parameters:
      script -
      lightWeight - will use an abbreviated groovysh.profile for faster speed. built in commands arent there and imports largely arent there
      inputMap - puts variables in a context to be retrieved with GrouperUtil.gshRetrieveInputValueObject(), GrouperUtil.gshRetrieveInputValueString(), GrouperUtil.gshRetrieveInputValueInteger(), GrouperUtil.gshRetrieveInputValueBoolean()
      Returns:
      the full output
    • setClear

      public static void setClear(Collection<?> set)
    • exceptionFinallyInjectOrThrow

      public static void exceptionFinallyInjectOrThrow(Exception tryException, Exception finallyException)
      in a finally block, take an exception and inject and throw the existing exception, or just throw the finally exception
      Parameters:
      tryException -
      finallyException -
    • j2eeRetrieveSourceIpAddress

      public static String j2eeRetrieveSourceIpAddress()
      get the source IP address or null if cant
      Returns:
      IP address
    • normalize

      @Deprecated public static String normalize(String form, String text)
      Deprecated.
      use this instead org.apache.commons.lang3.StringUtils.stripAccents((String)currentValue);
      take out accented chars with grouperUtil.normalize("NFD", groupAttribute).replaceAll("\\p{M}", "")
      Parameters:
      form -
      text -
      Returns:
      the normalized string
    • isInRetriableCode

      public static boolean isInRetriableCode()
      Returns:
      true if we're in code that would be retried if there's a failure
    • threadLocalInRetriableCodeAssign

      public static void threadLocalInRetriableCodeAssign()
      used to indicate if we're in code that would be retried if there's a failure
    • threadLocalInRetriableCodeClear

      public static void threadLocalInRetriableCodeClear()
      used to indicate if we're in code that would be retried if there's a failure call within a finally block to remove
    • splitTrimEmailAddresses

      public static String splitTrimEmailAddresses(String emailAddresses)
      take email addresses from a textarea and turn them into semi separated
      Parameters:
      emailAddresses -
      Returns:
      string of email addresses
    • normalizeEmailAddresses

      public static String normalizeEmailAddresses(String emailAddresses)
      take email addresses from a textarea and turn them into semi separated
      Parameters:
      emailAddresses - can be whitespace, comma, or semi separated
      Returns:
      the email addresses semi separated
    • validEmail

      public static boolean validEmail(String email)
      Parameters:
      email -
      Returns:
      true if valid, false if not
    • subjectHasAttribute

      public static boolean subjectHasAttribute(Subject subject, String attributeName)
      see if a subject has an attribute
      Parameters:
      subject -
      attributeName -
      Returns:
      true if the subject has an attribute
    • matchSqlString

      public static boolean matchSqlString(String sqlMatcher, String testText)
      match sqlLike string see if a sql like string matches a real string. e.g. if the input is a:b:%, and the input is: a:b:test:that, then it returns true
      Parameters:
      sqlMatcher -
      testText -
      Returns:
      true if matches, false if not
    • setShorten

      public static <T> Set<T> setShorten(Set<T> theSet, int maxSize)
      shorten a set if it is too long
      Type Parameters:
      T -
      Parameters:
      theSet -
      maxSize -
      Returns:
      the new set
    • formatNumberWithCommas

      public static String formatNumberWithCommas(Long number)
      Parameters:
      number - e.g. 12345678
      Returns:
      the string, e.g. 12,345,678
    • compare

      public static int compare(Comparable first, Comparable second)
      compare null safe
      Parameters:
      first -
      second -
      Returns:
      0 for equal, 1 for greater, -1 for less
    • convertSources

      public static Set<Source> convertSources(String sources)
      e.g. ('g:gsa', 'jdbc')
      Parameters:
      sources - is comma separated source id's
      Returns:
      the set of sources
    • convertSources

      public static Set<Source> convertSources(String[] sourceIds)
      e.g. ['g:gsa', 'jdbc']
      Parameters:
      sourceIds - is an array of source ids
      Returns:
      the set of sources
    • escapeSingleQuotes

      public static String escapeSingleQuotes(String string)
      escape single quotes in javascript
      Parameters:
      string -
      Returns:
      the escaped string
    • escapeDoubleQuotes

      public static String escapeDoubleQuotes(String string)
      escape double quotes in javascript
      Parameters:
      string -
      Returns:
      the escaped string
    • escapeDoubleQuotesForString

      public static String escapeDoubleQuotesForString(String string)
      escape double quotes in javascript
      Parameters:
      string -
      Returns:
      the escaped string
    • escapeDoubleQuotesSlashesAndNewlinesForString

      public static String escapeDoubleQuotesSlashesAndNewlinesForString(String string)
      escape double quotes in javascript
      Parameters:
      string -
      Returns:
      the escaped string
    • escapeNewlinesForString

      public static String escapeNewlinesForString(String string)
      escape double quotes in javascript
      Parameters:
      string -
      Returns:
      the escaped string
    • escapeSlashesForString

      public static String escapeSlashesForString(String string)
      escape slashes
      Parameters:
      string -
      Returns:
      the escaped string
    • convertSourcesToSqlInString

      @Deprecated public static String convertSourcesToSqlInString(Set<Source> sources)
      Deprecated.
      moved to @See HibUtils
      e.g. ('g:gsa', 'jdbc')
      Parameters:
      sources -
      Returns:
      the in string, of sources sorted alphabetically
    • toMap

      public static Map<String,String> toMap(String... strings)
      turn some strings into a map
      Parameters:
      strings -
      Returns:
      the map (never null)
    • toStringObjectMap

      public static Map<String,Object> toStringObjectMap(Object... stringObjects)
      turn some strings into a map
      Parameters:
      stringObjects - is an array of String,Object,String,Object etc where the Strings are the key, and the Object is the value
      Returns:
      the map (never null)
    • convertMillisToFriendlyString

      public static String convertMillisToFriendlyString(Integer duration)
      convert millis to friendly string
      Parameters:
      duration -
      Returns:
      the friendly string
    • convertMillisToFriendlyString

      public static String convertMillisToFriendlyString(Long duration)
      convert millis to friendly string
      Parameters:
      duration -
      Returns:
      the friendly string
    • deleteFile

      public static void deleteFile(File file)
      Delete a file, throw exception if cannot
      Parameters:
      file -
    • argAfter

      public static String argAfter(String[] args, String argBefore)
      return the arg after the argBefore, or null if not there, or exception if argBefore is not found
      Parameters:
      args -
      argBefore -
      Returns:
      the arg
    • append

      public static void append(StringBuilder result, String separatorIfResultNotEmpty, String stringToAppend)
      append and maybe put a separator in there
      Parameters:
      result -
      separatorIfResultNotEmpty -
      stringToAppend -
    • byteCountToDisplaySize

      public static String byteCountToDisplaySize(long size)
      Returns a human-readable version of the file size (original is in bytes).
      Parameters:
      size - The number of bytes.
      Returns:
      A human-readable display value (includes units).
    • getLog

      public static org.apache.commons.logging.Log getLog(Class<?> theClass)
      get a logger, and auto-create log dirs if havent done yet
      Parameters:
      theClass -
      Returns:
      the logger
    • fileCopy

      public static void fileCopy(File src, File dest)
    • fileCopyExampleResourceIfNotExist

      public static void fileCopyExampleResourceIfNotExist(String exampleResource, String resource)
      Parameters:
      exampleResource -
      resource -
    • logDirsCreateIfNotDone

      public static void logDirsCreateIfNotDone()
      auto-create log dirs if not done yet
    • logErrorNextException

      public static void logErrorNextException(org.apache.commons.logging.Log log, Throwable throwable, int timeToLive)
      find a next exception in the stack and log it
      Parameters:
      log - logger
      throwable - exception to look for next exceptions in
      timeToLive - so we dont loop forever
    • hasOption

      public static boolean hasOption(int options, int option)
      see if options have a specific option by int bits
      Parameters:
      options -
      option -
      Returns:
      if the option is there
    • isPrintGrouperLogsToConsole

      public static boolean isPrintGrouperLogsToConsole()
      if the grouper logs go to the console or not
      Returns:
      if
    • fileCanonicalPath

      public static String fileCanonicalPath(File file)
      get canonical path of file
      Parameters:
      file -
      Returns:
      the path
    • logDirPrint

      public static String logDirPrint()
      print the log dir to the console so the logs are easy to find
      Returns:
      the log dir message
    • suffixAfterChar

      public static String suffixAfterChar(String input, char theChar)
      return the suffix after a char. If the char doesnt exist, just return the string
      Parameters:
      input - string
      theChar - char
      Returns:
      new string
    • oracleStandardNameFromJava

      public static String oracleStandardNameFromJava(String javaName)
      get the oracle underscore name e.g. javaNameHere -> JAVA_NAME_HERE
      Parameters:
      javaName - the java convention name
      Returns:
      the oracle underscore name based on the java name
    • mapEquals

      public static <K, V> boolean mapEquals(Map<K,V> first, Map<K,V> second)
      see if two maps are the equivalent (based on number of entries, and the equals() method of the keys and values)
      Type Parameters:
      K -
      V -
      Parameters:
      first -
      second -
      Returns:
      true if equal
    • mapDifferences

      public static <K, V> void mapDifferences(Map<K,V> first, Map<K,V> second, Set<K> differences, String prefix)
      see if two maps are the equivalent (based on number of entries, and the equals() method of the keys and values)
      Type Parameters:
      K -
      V -
      Parameters:
      first - map to check diffs
      second - map to check diffs
      differences - set of keys (with prefix) of the diffs
      prefix - for the entries in the diffs (e.g. "attribute__"
    • sleep

      public static void sleep(long millis)
      sleep, if interrupted, throw runtime
      Parameters:
      millis -
    • sleepWithStdoutCountdown

      public static void sleepWithStdoutCountdown(int seconds)
      Parameters:
      seconds -
    • encryptSha

      public static String encryptSha(String plaintext)
      encrypt a message to SHA
      Parameters:
      plaintext -
      Returns:
      the hash
    • encryptShaHex

      public static String encryptShaHex(String plaintext)
      encrypt a message to SHA
      Parameters:
      plaintext -
      Returns:
      the hash
    • injectInException

      public static boolean injectInException(Throwable t, String message)
      If we can, inject this into the exception, else return false
      Parameters:
      t -
      message -
      Returns:
      true if success, false if not
    • findGrouperPropertiesDbMatch

      public static boolean findGrouperPropertiesDbMatch(boolean whitelist, String user, String url)
      see if there is a grouper properties db match
      Parameters:
      whitelist - true if whitelist, false if blacklist
      user - is the db user
      url - is the db url
      Returns:
      true if found match, false if not
    • promptUserAboutDbChanges

      public static void promptUserAboutDbChanges(String reason, boolean checkResponse)
      prompt the user about db changes
      Parameters:
      reason - e.g. delete all tables
      checkResponse - true if the response from the user should be checked, or just display the prompt
    • ldapConvertDnToSubPath

      public static String ldapConvertDnToSubPath(String dn, String baseDn, String searchDn)
      convert from uid=someapp,ou=people,dc=myschool,dc=edu baseDn is edu searchDn is myschool to people:someapp i.e. take apart a bushy dns
      Parameters:
      dn -
      baseDn - if there is one, take it off
      searchDn - if there is one after the baseDn is off, take it off
      Returns:
      the subpath
    • ldapConvertDnToSpecificValue

      public static String ldapConvertDnToSpecificValue(String dn)
      convert from uid=someapp,ou=people,dc=myschool,dc=edu to someapp
      Parameters:
      dn -
      Returns:
    • ldapEscapeRdn

      public static String ldapEscapeRdn(String rdnString)
      This takes a string of attribute=value and makes sure that special, dn-relevant characters are escaped, particularly commas, pluses, etc
      Parameters:
      rdnString - An RDN: attribute=value
      Returns:
    • ldapEscapeRdnValue

      public static String ldapEscapeRdnValue(String rdnValue)
      This takes a string of value and makes sure that special, dn-relevant characters are escaped, particularly commas, pluses, etc
      Parameters:
      rdnValue - An RDN value: value
      Returns:
      the escaped value
    • ldapAdDateCurrent

      public static long ldapAdDateCurrent()
      active directory date from millis 1970 date
      Returns:
      the AD date
    • ldapAdDateFromMillis1970

      public static long ldapAdDateFromMillis1970(long millisSince1970)
      active directory date from millis 1970 date
      Parameters:
      millisSince1970 -
      Returns:
      the AD date
    • ldapBushyDn

      public static String ldapBushyDn(String groupName, String rdnAttributeName, String ouAttributeName, boolean performRdnEscaping, boolean performFilterEscaping)
      Parameters:
      groupName -
      rdnAttributeName -
      ouAttributeName -
      performRdnEscaping -
      performFilterEscaping -
      Returns:
    • ldapBushyDn

      public static String ldapBushyDn(String groupName, String rdnAttributeName, String rdnAttributeValue, String ouAttributeName, boolean performRdnEscaping, boolean performFilterEscaping)
      Parameters:
      groupName -
      rdnAttributeName -
      rdnAttributeValue -
      ouAttributeName -
      performRdnEscaping -
      performFilterEscaping -
      Returns:
    • ldapFilterEscape

      public static String ldapFilterEscape(String s)
    • promptUserAboutChanges

      public static void promptUserAboutChanges(String reason, boolean checkResponse, String dbType, String url, String user)
      prompt the user about db changes
      Parameters:
      reason - e.g. delete all tables
      checkResponse - true if the response from the user should be checked, or just display the prompt
      dbType - should be db or ldap
      url - to check for
      user - user for db
    • uniqueId

      public static String uniqueId()
      get a unique string identifier based on the current time, this is not globally unique, just unique for as long as this server is running...
      Returns:
      String
    • fileFromResourceName

      public static File fileFromResourceName(String resourceName)
      get a file name from a resource name
      Parameters:
      resourceName - is the classpath location
      Returns:
      the file path on the system
    • getLocationFromResourceName

      public static String getLocationFromResourceName(String resourceName)
      get a full path from a resource name
      Parameters:
      resourceName - is the classpath location
      Returns:
      Full path to the resource. For files, the file path on the system; otherwise, the resource URL
    • computeUrl

      public static URL computeUrl(String resourceName, boolean canBeNull)
      compute a url of a resource
      Parameters:
      resourceName -
      canBeNull - if cant be null, throw runtime
      Returns:
      the URL
    • classLoader

      public static ClassLoader classLoader()
      fast class loader
      Returns:
      the class loader
    • nonNull

      public static <T> T[] nonNull(T[] array, Class<?> theClass)
      make sure a array is non null. If null, then return an empty array.
      Type Parameters:
      T -
      Parameters:
      array -
      theClass - to make array from
      Returns:
      the list or empty list if null
    • stripSuffix

      public static String stripSuffix(String string, String suffix)
      strip the suffix off
      Parameters:
      string -
      suffix -
      Returns:
      the string without the suffix
    • stripPrefix

      public static String stripPrefix(String string, String prefix)
      strip the prefix off
      Parameters:
      string -
      prefix -
      Returns:
      the string without the suffix
    • prefixOrSuffix

      public static String prefixOrSuffix(String startString, String separator, boolean isPrefix)
      get the prefix or suffix of a string based on a separator
      Parameters:
      startString - is the string to start with
      separator - is the separator to split on
      isPrefix - if thre prefix or suffix should be returned
      Returns:
      the prefix or suffix, if the separator isnt there, return the original string
    • indent

      public static String indent(String string, boolean failIfTypeNotFound)
       this method will indent xml or json.
       this is for logging or documentations purposes only and should
       not be used for a production use (since it is not 100% tested
       or compliant with all constructs like xml CDATA
      
       For xml, assumes elements either have text or sub elements, not both.
       No cdata, nothing fancy.
      
       If the input is <a><b><c>hey</c><d><e>there</e></d></b></a>
       It would output:
       <a>
         <b>
           <c>hey</c>
           <d>
             <e>there</e>
           </d>
         </b>
       </a>
      
       For , if the input is: {"a":{"b\"b":{"c\\":"d"},"e":"f","g":["h":"i"]}}
       It would output:
       {
         "a":{
           "b\"b":{
             "c\\":"d"
           },
           "e":"f",
           "g":[
             "h":"i"
           ]
         }
       }
      
      
       
      Parameters:
      string -
      failIfTypeNotFound -
      Returns:
      the indented string, 2 spaces per line
    • jsonConvertTo

      public static String jsonConvertTo(Object object)
      convert an object to json.
      Parameters:
      object -
      Returns:
      the string of json
    • jsonConvertTo

      public static String jsonConvertTo(Object object, boolean includeObjectNameWrapper)
      convert an object to json.
      Parameters:
      object -
      Returns:
      the string of json
    • jsonJacksonFieldNames

      public static Set<String> jsonJacksonFieldNames(com.fasterxml.jackson.databind.JsonNode jsonNode)
      get field names from json node, assume field names are unique
      Parameters:
      jsonNode -
      Returns:
    • jsonJacksonGetString

      public static String jsonJacksonGetString(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as string and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonAssignJsonPointerString

      public static void jsonJacksonAssignJsonPointerString(com.fasterxml.jackson.databind.JsonNode jsonNode, String jsonPointer, Object value)
      assign a jackson field
      Parameters:
      objectNode -
      jsonPointer - e.g. /a/b/c/d
      value -
    • jsonJacksonAssignString

      public static void jsonJacksonAssignString(com.fasterxml.jackson.databind.node.ObjectNode objectNode, String fieldName, String value)
      assign a jackson field
      Parameters:
      jsonNode -
      fieldName -
    • jsonJacksonAssignBoolean

      public static void jsonJacksonAssignBoolean(com.fasterxml.jackson.databind.node.ObjectNode objectNode, String fieldName, Boolean value)
      assign a jackson field
      Parameters:
      jsonNode -
      fieldName -
    • jsonJacksonAssignLong

      public static void jsonJacksonAssignLong(com.fasterxml.jackson.databind.node.ObjectNode objectNode, String fieldName, Long value)
      assign a jackson field
      Parameters:
      jsonNode -
      fieldName -
    • jsonJacksonAssignStringArray

      public static void jsonJacksonAssignStringArray(com.fasterxml.jackson.databind.node.ObjectNode objectNode, String fieldName, Collection<String> values)
      assign a jackson field
      Parameters:
      jsonNode -
      fieldName -
    • jsonJacksonAssignObjectNodeArray

      public static void jsonJacksonAssignObjectNodeArray(com.fasterxml.jackson.databind.node.ObjectNode objectNode, String fieldName, Collection<com.fasterxml.jackson.databind.node.ObjectNode> values)
      assign a jackson array
      Parameters:
      objectNode -
      fieldName -
      values -
    • jsonJacksonGetString

      public static String jsonJacksonGetString(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName, String defaultString)
      get a field as string and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetString

      public static String jsonJacksonGetString(com.fasterxml.jackson.databind.node.ArrayNode arrayNode, int index)
      get a field as string and handle null
      Parameters:
      arrayNode -
      index -
      Returns:
      the string
    • jsonJacksonGetArrayNode

      public static com.fasterxml.jackson.databind.node.ArrayNode jsonJacksonGetArrayNode(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as node or array. could return null if not there
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the node or array
    • jsonJacksonGetNode

      public static com.fasterxml.jackson.databind.JsonNode jsonJacksonGetNode(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as node or array. could return null if not there
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the node or array
    • jsonJacksonGetStringSet

      public static Set<String> jsonJacksonGetStringSet(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as string set. could return null if not there
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetBoolean

      public static Boolean jsonJacksonGetBoolean(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as boolean and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetBoolean

      public static Boolean jsonJacksonGetBoolean(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName, Boolean defaultBoolean)
      get a field as boolean and handle null
      Parameters:
      jsonNode -
      fieldName -
      defaultBoolean - if null use this value
      Returns:
      the string
    • jsonJacksonGetBooleanFromJsonPointer

      public static Boolean jsonJacksonGetBooleanFromJsonPointer(com.fasterxml.jackson.databind.JsonNode jsonNode, String jsonPointer, Boolean defaultBoolean)
      get a field as boolean and handle null
      Parameters:
      jsonNode -
      jsonPointer - e.g. /a/b
      defaultBoolean - if null use this value
      Returns:
      the string
    • jsonJacksonGetLong

      public static Long jsonJacksonGetLong(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as long and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetLong

      public static Long jsonJacksonGetLong(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName, Long defaultLong)
      get a field as long and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetInteger

      public static Integer jsonJacksonGetInteger(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName)
      get a field as integer and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonGetInteger

      public static Integer jsonJacksonGetInteger(com.fasterxml.jackson.databind.JsonNode jsonNode, String fieldName, Integer defaultInteger)
      get a field as integer and handle null
      Parameters:
      jsonNode -
      fieldName -
      Returns:
      the string
    • jsonJacksonNode

      public static com.fasterxml.jackson.databind.node.ObjectNode jsonJacksonNode()
    • jsonJacksonArrayNode

      public static com.fasterxml.jackson.databind.node.ArrayNode jsonJacksonArrayNode()
    • jsonJacksonNode

      public static com.fasterxml.jackson.databind.JsonNode jsonJacksonNode(String json)
    • jsonJacksonToString

      public static String jsonJacksonToString(com.fasterxml.jackson.databind.JsonNode jsonNode)
      convert a json node to acutal json
      Parameters:
      jsonNode -
      Returns:
    • jsonConvertToNoWrap

      public static String jsonConvertToNoWrap(Object object)
      convert an object to json without wrapping it with the simple class name.
      Parameters:
      object -
      Returns:
      the string of json
    • jsonConvertTo

      public static void jsonConvertTo(Object object, Writer writer)
      convert an object to json. note this wraps the gson with the object simple name so it can be revived
      Parameters:
      object -
      writer -
    • jsonConvertFrom

      public static Object jsonConvertFrom(Map<String,Class<?>> conversionMap, String json)
      convert an object from json. note this works well if there are no collections, just real types, arrays, etc.
      Parameters:
      conversionMap - is the class simple name to class of objects which are allowed to be brought back. Note: only the top level object needs to be registered
      json -
      Returns:
      the object
    • jsonConvertFromMap

      public static <T> T jsonConvertFromMap(Map<String,Object> jsonMap, Class<T> theClass)
      convert an object from Map.
      Parameters:
      jsonMap - is the json map
      theClass - is the class that the object should be coverted into. Note: only the top level object needs to be registered
      Returns:
      the object
    • jsonConvertFrom

      public static <T> T jsonConvertFrom(String json, Class<T> theClass)
      convert an object from json. note this works well if there are no collections, just real types, arrays, etc.
      Parameters:
      json - is the json string, not wrapped with a simple class name
      theClass - is the class that the object should be coverted into. Note: only the top level object needs to be registered
      Returns:
      the object
    • jsonConvertFrom

      public static <T> T jsonConvertFrom(com.fasterxml.jackson.databind.JsonNode jsonNode, Class<T> theClass)
      convert a jsonNode into POJO.
      Parameters:
      jsonNode -
      theClass - is the class that the object should be coverted into. Note: only the top level object needs to be registered
      Returns:
      the object
    • jsonConvertFromObjectToObjectNode

      public static com.fasterxml.jackson.databind.node.ObjectNode jsonConvertFromObjectToObjectNode(Object object)
      convert a POJO into ObjectNode
      Parameters:
      object - Note: only the top level object needs to be registered
      Returns:
      ObjectNode
    • extensionFromName

      public static String extensionFromName(String name)
      get the extension from name. if name is a:b:c, name is c
      Parameters:
      name -
      Returns:
      the name
    • nameInFolderDirect

      public static boolean nameInFolderDirect(String name, String folder)
       see if a name is in a folder (not subfolder).  if name is a:b:c, and folder is a:b, then yes
       if a:b:c and a:c, then no
       if a:b:c and a, then no
       
      Parameters:
      name -
      folder -
      Returns:
      the name
    • forName

      public static Class forName(String origClassName)
      Returns the class object.
      Parameters:
      origClassName - is fully qualified
      Returns:
      the class
    • newInstance

      public static <T> T newInstance(Class<T> theClass)
      Construct a class
      Type Parameters:
      T - template type
      Parameters:
      theClass -
      Returns:
      the instance
    • parentStemNameFromName

      public static String parentStemNameFromName(String name)
      Deprecated.
      dont use this! call the overload and specify if you want root stem or not
      get the parent stem name from name. if already a root stem then just return null. e.g. if the name is a:b:c then the return value is a:b
      Parameters:
      name -
      Returns:
      the parent stem name or null if none
    • parentStemNameFromName

      public static String parentStemNameFromName(String name, boolean nullForRoot)
      get the parent stem name from name. if already a root stem then just return null. e.g. if the name is a:b:c then the return value is a:b
      Parameters:
      name -
      nullForRoot - null for root, otherwise colon
      Returns:
      the parent stem name or null if none
    • defaultIfBlank

      public static String defaultIfBlank(String string, String defaultStringIfBlank)
      return the string or the other if the first is blank
      Parameters:
      string -
      defaultStringIfBlank -
      Returns:
      the string or the default one
    • defaultIfNull

      public static <T> T defaultIfNull(T theValue, T defaultIfTheValueIsNull)
      genericized method to see if first is null, if so then return second, else first.
      Type Parameters:
      T -
      Parameters:
      theValue - first input
      defaultIfTheValueIsNull - second input
      Returns:
      the first if not null, second if no
    • addIfNotThere

      public static <T> void addIfNotThere(Collection<T> list, Collection<T> listToAdd)
      add each element of listToAdd if it is not already in list
      Type Parameters:
      T -
      Parameters:
      list - to add to
      listToAdd - each element will be added to list, or null if none
    • toStringFields

      public static String toStringFields(Object object, Set<String> fieldNames)
      print out an object by fields
      Parameters:
      object -
      fieldNames -
      Returns:
      the string representation or null if null
    • collectionContains

      public static boolean collectionContains(Collection<Object> collection, Object object)
      Parameters:
      collection -
      object -
      Returns:
      true if the collection contains this object
    • collectionToString

      public static String collectionToString(Collection collection)
      convert a set to a string (comma separate)
      Parameters:
      collection -
      Returns:
      the String
    • setToString

      public static String setToString(Set set)
      convert a set to a string (comma separate)
      Parameters:
      set -
      Returns:
      the String
    • MapToString

      @Deprecated public static String MapToString(Map map)
      Deprecated.
      use mapToString(map)
      convert a set to a string (comma separate)
      Parameters:
      map -
      Returns:
      the String
    • mapToString

      public static String mapToString(Map map)
      convert a set to a string (comma separate)
      Parameters:
      map -
      Returns:
      the String
    • toStringForLog

      public static String toStringForLog(Object object)
      print out various types of objects
      Parameters:
      object -
      Returns:
      the string value
    • toStringForLogHtml

      public static String toStringForLogHtml(Object object)
      print out various types of objects
      Parameters:
      object -
      Returns:
      the string value
    • toStringForLog

      public static String toStringForLog(Object object, boolean newLines)
      print out various types of objects
      Parameters:
      object -
      Returns:
      the string value
    • toStringForLog

      public static String toStringForLog(Object object, int maxChars)
      print out various types of objects
      Parameters:
      object -
      maxChars - is the max chars that should be returned (abbreviate if longer), or -1 for any amount
      Returns:
      the string value
    • batchNumberOfBatches

      public static int batchNumberOfBatches(int count, int batchSize, boolean haveAtLeastOne)
      If batching this is the number of batches
      Parameters:
      count - is size of set
      batchSize -
      haveAtLeastOne - is true if there should be at least one run even if the collection is empty (e.g. for queries based on other things)
      Returns:
      the number of batches
    • batchNumberOfBatches

      @Deprecated public static int batchNumberOfBatches(int count, int batchSize)
      Deprecated.
      use batchNumberOfBatches(Collection<?> collection, int batchSize, boolean haveAtLeastOne)
      If batching this is the number of batches. Will return at least 1
      Parameters:
      count - is size of set
      batchSize -
      Returns:
      the number of batches
    • batchNumberOfBatches

      @Deprecated public static int batchNumberOfBatches(Collection<?> collection, int batchSize)
      Deprecated.
      use batchNumberOfBatches(Collection<?> collection, int batchSize, boolean haveAtLeastOne)
      If batching this is the number of batches, will return at least 1
      Parameters:
      collection -
      batchSize -
      Returns:
      the number of batches
    • batchNumberOfBatches

      public static int batchNumberOfBatches(Collection<?> collection, int batchSize, boolean haveAtLeastOne)
      If batching this is the number of batches, will return at least 1
      Parameters:
      collection -
      batchSize -
      haveAtLeastOne - is true if there should be at least one run even if the collection is empty (e.g. for queries based on other things)
      Returns:
      the number of batches
    • findParentStemNames

      public static Set<String> findParentStemNames(Collection<Group> groups)
      if the groups are: a:b:c:d and a:d:r, then return the strings: :, a, a:b, a:b:c, a:d
      Parameters:
      groups -
      Returns:
      the set of stem names
    • findParentStemNames

      public static Set<String> findParentStemNames(String objectName)
      if the groups are: a:b:c:d, then return the strings: :, a, a:b, a:b:c
      Parameters:
      objectName -
      Returns:
      the set of stem names
    • batchList

      public static <T> List<T> batchList(List<T> collection, int batchSize, int batchIndex)
      retrieve a batch by 0 index. Will return an array of size batchSize or the remainder. the array will be full of elements. Note, this requires an ordered input (so use linkedhashset not hashset if doing sets)
      Type Parameters:
      T - template type
      Parameters:
      collection -
      batchSize -
      batchIndex -
      Returns:
      the list This never returns null, only empty list
    • splitTrim

      public static String[] splitTrim(String input, String separator)
      split a string based on a separator into an array, and trim each entry (see the Commons Util trim() for more details)
      Parameters:
      input - is the delimited input to split and trim
      separator - is what to split on
      Returns:
      the array of items after split and trimmed, or null if input is null. will be trimmed to empty
    • splitTrimToList

      public static List<String> splitTrimToList(String input, String separator)
      split a string based on a separator into an array, and trim each entry (see the Commons Util trim() for more details)
      Parameters:
      input - is the delimited input to split and trim
      separator - is what to split on
      Returns:
      the list of items after split and trimmed, or null if input is null. will be trimmed to empty
    • splitTrimToSet

      public static Set<String> splitTrimToSet(String input, String separator)
      split a string based on a separator into an array, and trim each entry (see the Commons Util trim() for more details)
      Parameters:
      input - is the delimited input to split and trim
      separator - is what to split on
      Returns:
      the set of items after split and trimmed, or null if input is null. will be trimmed to empty
    • splitTrim

      public static String[] splitTrim(String input, String separator, boolean treatAdjacentSeparatorsAsOne)
      split a string based on a separator into an array, and trim each entry (see the Commons Util trim() for more details)
      Parameters:
      input - is the delimited input to split and trim
      separator - is what to split on
      treatAdjacentSeparatorsAsOne -
      Returns:
      the array of items after split and trimmed, or null if input is null. will be trimmed to empty
    • escapeUrlEncode

      public static String escapeUrlEncode(String string)
      escape url chars (e.g. a # is %23)
      Parameters:
      string - input
      Returns:
      the encoded string
    • escapeUrlDecode

      public static String escapeUrlDecode(String string)
      unescape url chars (e.g. a space is %20)
      Parameters:
      string - input
      Returns:
      the encoded string
    • nonNull

      public static <T> List<T> nonNull(List<T> list)
      make sure a list is non null. If null, then return an empty list
      Type Parameters:
      T -
      Parameters:
      list -
      Returns:
      the list or empty list if null
    • nonNull

      public static <T> Collection<T> nonNull(Collection<T> list)
      make sure a collection is non null. If null, then return an empty list
      Type Parameters:
      T -
      Parameters:
      list -
      Returns:
      the list or empty list if null
    • nonNull

      public static <T> Set<T> nonNull(Set<T> set)
      make sure a list is non null. If null, then return an empty set
      Type Parameters:
      T -
      Parameters:
      set -
      Returns:
      the set or empty set if null
    • nonNull

      public static <K, V> Map<K,V> nonNull(Map<K,V> map)
      make sure it is non null, if null, then give new map
      Type Parameters:
      K - key of map
      V - value of map
      Parameters:
      map - is map
      Returns:
      set non null
    • toList

      public static <T> List<T> toList(T... objects)
      return a list of objects from varargs. Though if there is one object, and it is a list, return it.
      Type Parameters:
      T - template type of the objects
      Parameters:
      objects -
      Returns:
      the list or null if objects is null
    • toArrayObject

      public static Object[] toArrayObject(Object... objects)
      return an array of objects from varargs for JEXL
      Parameters:
      objects -
      Returns:
      the array or null if objects is null
    • toListObject

      public static List<Object> toListObject(Object... objects)
      return a list of objects from varargs. Though if there is one object, and it is a list, return it. template type of the objects
      Parameters:
      objects -
      Returns:
      the list or null if objects is null
    • toListClasses

      public static List<Class<?>> toListClasses(Class<?>... classes)
      convert classes to a list
      Parameters:
      classes -
      Returns:
      list of classes
    • toSet

      public static <T> Set<T> toSet(T... objects)
      return a set of objects from varargs.
      Type Parameters:
      T - template type of the objects
      Parameters:
      objects -
      Returns:
      the set
    • toSetObjectType

      public static <T> Set<Object> toSetObjectType(T... objects)
      return a set of objects from varargs.
      Type Parameters:
      T - template type of the objects
      Parameters:
      objects -
      Returns:
      the set
    • toSetObject

      public static <T> Set<T> toSetObject(T object)
      return a set of string
      Type Parameters:
      T - template type of the objects
      Parameters:
      object -
      Returns:
      the set
    • timestampIsoUtcSecondsConvertToString

      public static String timestampIsoUtcSecondsConvertToString(Timestamp timestamp)
      Parameters:
      timestamp -
      Returns:
      timestamp string
    • timestampIsoUtcMicrosConvertToString

      public static String timestampIsoUtcMicrosConvertToString(Timestamp timestamp)
      2024-06-24T08:00:53.123456Z
      Parameters:
      timestamp -
      Returns:
      timestamp string
    • timestampIsoUtcMicrosConvertFromString

      public static Timestamp timestampIsoUtcMicrosConvertFromString(String utcStringWithMicros)
      2023-06-29T18:27:01.227972Z
      Parameters:
      utcStringWithMicros -
      Returns:
      timestamp which is only specific to millis
    • timestampIsoUtcSecondsConvertFromString

      public static Timestamp timestampIsoUtcSecondsConvertFromString(String string)
      allow: 2023-06-29T18:27:01Z allow: 2023-06-29T18:27:01.227972Z
      Parameters:
      timestamp -
      Returns:
      timestamp string
    • assertion

      public static void assertion(boolean isTrue, String reason)
      If false, throw an assertException, and give a reason
      Parameters:
      isTrue -
      reason -
    • assignField

      public static void assignField(Class theClass, Object invokeOn, String fieldName, Object dataToAssign, boolean callOnSupers, boolean overrideSecurity, boolean typeCast, Class<? extends Annotation> annotationWithValueOverride)
      assign data to a field
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      fieldName - method name to call
      dataToAssign - data
      callOnSupers - if static and method not exists, try on supers
      overrideSecurity - true to call on protected or private etc methods
      typeCast - true if we should typecast
      annotationWithValueOverride - annotation with value of override
    • assignField

      public static void assignField(Class theClass, Object invokeOn, String fieldName, Object dataToAssign, Class<? extends Annotation> annotationWithValueOverride)
      assign data to a field. Will find the field in superclasses, will typecast, and will override security (private, protected, etc)
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      fieldName - method name to call
      dataToAssign - data
      annotationWithValueOverride - annotation with value of override
    • assignField

      public static void assignField(Field field, Object invokeOn, Object dataToAssign, boolean overrideSecurity, boolean typeCast)
      assign data to a field
      Parameters:
      field - is the field to assign to
      invokeOn - to call on or null for static
      dataToAssign - data
      overrideSecurity - true to call on protected or private etc methods
      typeCast - true if we should typecast
    • iterator

      public static Iterator iterator(Object collection)
      null safe iterator getter if the type if collection
      Parameters:
      collection -
      Returns:
      the iterator
    • length

      public static int length(Object arrayOrCollection)
      Null safe array length or map
      Parameters:
      arrayOrCollection -
      Returns:
      the length of the array (0 for null)
    • isArrayOrCollection

      public static boolean isArrayOrCollection(Object arrayOrCollection)
      is array or collection
      Parameters:
      arrayOrCollection -
      Returns:
      true or false
    • next

      public static Object next(Object arrayOrCollection, Iterator iterator, int index)
      If array, get the element based on index, if Collection, get it based on iterator.
      Parameters:
      arrayOrCollection -
      iterator -
      index -
      Returns:
      the object
    • remove

      public static Object remove(Object arrayOrCollection, int index)
      Remove the iterator or index
      Parameters:
      arrayOrCollection -
      index -
      Returns:
      the object list or new array
    • remove

      public static Object remove(Object arrayOrCollection, Iterator iterator, int index)
      Remove the iterator or index
      Parameters:
      arrayOrCollection -
      iterator -
      index -
      Returns:
      the object list or new array
    • classesString

      public static String classesString(Object object)
      print the simple names of a list of classes
      Parameters:
      object -
      Returns:
      the simple names
    • classNameCollection

      public static String classNameCollection(Object object)
      null safe classname method, max out at 20
      Parameters:
      object -
      Returns:
      the classname
    • className

      public static String className(Object object)
      null safe classname method, gets the unenhanced name
      Parameters:
      object -
      Returns:
      the classname
    • unenhanceClass

      public static Class unenhanceClass(Class theClass)
      if a class is enhanced, get the unenhanced version
      Parameters:
      theClass -
      Returns:
      the unenhanced version
    • assignField

      public static void assignField(Field field, Object invokeOn, Object dataToAssign, boolean overrideSecurity, boolean typeCast, Class<? extends Annotation> annotationWithValueOverride)
      assign data to a field
      Parameters:
      field - is the field to assign to
      invokeOn - to call on or null for static
      dataToAssign - data
      overrideSecurity - true to call on protected or private etc methods
      typeCast - true if we should typecast
      annotationWithValueOverride - annotation with value of override, or null if none
    • assignField

      public static void assignField(Object invokeOn, String fieldName, Object dataToAssign)
      assign data to a field. Will find the field in superclasses, will typecast, and will override security (private, protected, etc)
      Parameters:
      invokeOn - to call on or null for static
      fieldName - method name to call
      dataToAssign - data
    • field

      public static Field field(Class theClass, String fieldName, boolean callOnSupers, boolean throwExceptionIfNotFound)
      get a field object for a class, potentially in superclasses
      Parameters:
      theClass -
      fieldName -
      callOnSupers - true if superclasses should be looked in for the field
      throwExceptionIfNotFound - will throw runtime exception if not found
      Returns:
      the field object or null if not found (or exception if param is set)
    • fieldNames

      public static Set<String> fieldNames(Class theClass, Class fieldType, boolean includeStaticFields)
      return a set of Strings for a class and type. This is not for any supertypes, only for the type at hand. includes final fields
      Parameters:
      theClass -
      fieldType - or null for all
      includeStaticFields -
      Returns:
      the set of strings, or the empty Set if none
    • dbVersionDescribeDifferences

      public static String dbVersionDescribeDifferences(Object theOld, Object theNew, Set<String> differentFieldNames)
      put in english how an object changed
      Parameters:
      theOld -
      theNew -
      differentFieldNames -
      Returns:
      the differences
    • fieldNames

      public static Set<String> fieldNames(Class theClass, Class superclassToStopAt, Class<?> fieldType, boolean includeSuperclassToStopAt, boolean includeStaticFields, boolean includeFinalFields)
      get all field names from a class, including superclasses (if specified)
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      fieldType - is the type of the field to get
      includeSuperclassToStopAt - if we should include the superclass
      includeStaticFields - if include static fields
      includeFinalFields - if final fields should be included
      Returns:
      the set of field names or empty set if none
    • fieldNames

      public static Set<String> fieldNames(Class theClass, Class superclassToStopAt, Class<?> fieldType, boolean includeSuperclassToStopAt, boolean includeStaticFields, boolean includeFinalFields, Class<? extends Annotation> markerAnnotationToIngore)
      get all field names from a class, including superclasses (if specified). ignore a certain marker annotation
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      fieldType - is the type of the field to get
      includeSuperclassToStopAt - if we should include the superclass
      includeStaticFields - if include static fields
      includeFinalFields - if final fields should be included
      markerAnnotationToIngore - if this is not null, then if the field has this annotation, then do not include in list
      Returns:
      the set of field names
    • fieldNames

      public static Set<String> fieldNames(Class theClass, Class superclassToStopAt, Class<? extends Annotation> markerAnnotationToIngore)
      get all field names from a class, including superclasses (if specified) (up to and including the specified superclass). ignore a certain marker annotation. Dont get static or final field, and get fields of all types
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      markerAnnotationToIngore - if this is not null, then if the field has this annotation, then do not include in list
      Returns:
      the set of field names or empty set if none
    • fields

      public static Set<Field> fields(Class theClass, Class superclassToStopAt, Class fieldType, boolean includeSuperclassToStopAt, boolean includeStaticFields, boolean includeFinalFields, Class<? extends Annotation> markerAnnotation, boolean includeAnnotation)
      get all fields from a class, including superclasses (if specified)
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      fieldType - is the type of the field to get
      includeSuperclassToStopAt - if we should include the superclass
      includeStaticFields - if include static fields
      includeFinalFields - if final fields should be included
      markerAnnotation - if this is not null, then if the field has this annotation, then do not include in list (if includeAnnotation is false)
      includeAnnotation - true if the attribute should be included if annotation is present, false if exclude
      Returns:
      the set of fields (wont return null)
    • fields

      public static Set<Field> fields(Class theClass, Class superclassToStopAt, Class<? extends Annotation> markerAnnotation, boolean includeAnnotation)
      get all fields from a class, including superclasses (if specified) (up to and including the specified superclass). ignore a certain marker annotation, or only include it. Dont get static or final field, and get fields of all types
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      markerAnnotation - if this is not null, then if the field has this annotation, then do not include in list (if includeAnnotation is false)
      includeAnnotation - true if the attribute should be included if annotation is present, false if exclude
      Returns:
      the set of field names or empty set if none
    • compareObjectFields

      public static Set<String> compareObjectFields(Object first, Object second, Set<String> fieldsToCompare, String mapPrefix)
      compare two objects, compare primitives, Strings, maps of string attributes. if both objects equal each others references, then return empty set. then, if not, then if either is null, return all fields
      Parameters:
      first -
      second -
      fieldsToCompare -
      mapPrefix - is the prefix for maps which are compared (e.g. attribute__)
      Returns:
      the set of fields which are different. never returns null
    • clone

      public static <T> T clone(T object, Set<String> fieldsToClone)
      clone an object, assign primitives, Strings, maps of string attributes. Clone GrouperCloneable fields.
      Type Parameters:
      T - template
      Parameters:
      object -
      fieldsToClone -
      Returns:
      the cloned object or null if input is null
    • cloneFields

      public static <T> void cloneFields(T object, T result, Set<String> fieldsToClone)
      clone an object, assign primitives, Strings, maps of string attributes. Clone GrouperCloneable fields.
      Type Parameters:
      T - template
      Parameters:
      object -
      result -
      fieldsToClone -
    • cloneValue

      public static <T> T cloneValue(T value)
      helper method to clone the value of a field. just returns the same reference for primitives and immutables. Will subclone GrouperCloneables, and will throw exception if not expecting the type. Will clone sets, lists, maps.
      Type Parameters:
      T - template
      Parameters:
      value -
      Returns:
      the cloned value
    • methodNames

      public static Set<String> methodNames(Class<?> theClass, Class<?> superclassToStopAt, boolean includeSuperclassToStopAt, boolean includeStaticMethods)
      simple method to get method names
      Parameters:
      theClass -
      superclassToStopAt -
      includeSuperclassToStopAt -
      includeStaticMethods -
      Returns:
      the set of method names
    • methodByName

      public static Method methodByName(Class<?> theClass, String methodName, Class<?> superclassToStopAt, boolean includeSuperclassToStopAt, boolean includeStaticMethods, boolean exceptionIfNotFound)
      simple method to get method names
      Parameters:
      theClass -
      methodName -
      superclassToStopAt -
      includeSuperclassToStopAt -
      includeStaticMethods -
      exceptionIfNotFound -
      Returns:
      the set of method names
    • methodsHelper

      public static void methodsHelper(Class<?> theClass, Class<?> superclassToStopAt, boolean includeSuperclassToStopAt, boolean includeStaticMethods, Class<? extends Annotation> markerAnnotation, boolean includeAnnotation, Set<Method> methodSet)
      get the set of methods
      Parameters:
      theClass -
      superclassToStopAt -
      includeSuperclassToStopAt -
      includeStaticMethods -
      markerAnnotation -
      includeAnnotation -
      methodSet -
    • method

      public static Method method(Class<?> theClass, String methodName, Object paramTypesOrArrayOrList, Class<?> superclassToStopAt, boolean includeSuperclassToStopAt, boolean isStaticOrInstance, Class<? extends Annotation> markerAnnotation, boolean includeAnnotation)
      get the set of methods
      Parameters:
      theClass -
      methodName -
      paramTypesOrArrayOrList - types of the params
      superclassToStopAt -
      includeSuperclassToStopAt -
      isStaticOrInstance - true if static
      markerAnnotation -
      includeAnnotation -
      Returns:
      the method or null if not found
    • fieldValue

      public static Object fieldValue(Class theClass, Object invokeOn, String fieldName, boolean callOnSupers, boolean overrideSecurity, boolean considerFieldValuable)
      find out a field value
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      fieldName - method name to call
      callOnSupers - if static and method not exists, try on supers
      overrideSecurity - true to call on protected or private etc methods
      considerFieldValuable - if the FieldValueable interface should be considered
      Returns:
      the current value
    • fieldValue

      public static Object fieldValue(Field field, Object invokeOn)
      get the value of a field, override security if needbe
      Parameters:
      field -
      invokeOn -
      Returns:
      the value of the field
    • fieldValue

      public static Object fieldValue(Field field, Object invokeOn, boolean overrideSecurity)
      get the value of a field
      Parameters:
      field -
      invokeOn -
      overrideSecurity -
      Returns:
      the value of the field
    • fieldValue

      public static Object fieldValue(Object invokeOn, String fieldName)
      find out a field value (invoke on supers, override security)
      Parameters:
      invokeOn - to call on or null for static
      fieldName - method name to call
      Returns:
      the current value
    • callMethod

      public static Object callMethod(Class theClass, Object invokeOn, String methodName)
      helper method for calling a method with no params (could be in superclass)
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      methodName - method name to call
      Returns:
      the data
    • callMethod

      public static Object callMethod(Class theClass, Object invokeOn, String methodName, Object paramTypesOrArrayOrList, Object paramsOrListOrArray)
      helper method for calling a method (could be in superclass)
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      methodName - method name to call
      paramTypesOrArrayOrList - types of the params
      paramsOrListOrArray - data
      Returns:
      the data
    • callMethod

      public static Object callMethod(Class theClass, Object invokeOn, String methodName, Object paramTypesOrArrayOrList, Object paramsOrListOrArray, boolean callOnSupers)
      helper method for calling a method
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      methodName - method name to call
      paramTypesOrArrayOrList - types of the params
      paramsOrListOrArray - data
      callOnSupers - if static and method not exists, try on supers
      Returns:
      the data
    • construct

      public static <T> T construct(Class<T> theClass, Class[] types, Object[] args)
      construct an instance by reflection
      Type Parameters:
      T -
      Parameters:
      theClass -
      args -
      types -
      Returns:
      the instance
    • listToMap

      public static <K, V> Map<K,V> listToMap(List<V> list, Class<K> keyClass, Class<V> valueClass, String keyPropertyName)
       turn a list into map
       
      Type Parameters:
      K - is the template of the key of the map
      V - is the template of the value of the map
      Parameters:
      list - is the list to convert
      valueClass - type of the result (can typecast)
      keyClass - is the type of the key of the map
      keyPropertyName - name of the javabeans property for the key in the map
      Returns:
      the ordered set or the empty set if not found (never null)
    • callMethod

      public static Object callMethod(Class theClass, Object invokeOn, String methodName, Object paramTypesOrArrayOrList, Object paramsOrListOrArray, boolean callOnSupers, boolean overrideSecurity)
      helper method for calling a method
      Parameters:
      theClass - the class which has the method
      invokeOn - to call on or null for static
      methodName - method name to call
      paramTypesOrArrayOrList - types of the params
      paramsOrListOrArray - data
      callOnSupers - if static and method not exists, try on supers
      overrideSecurity - true to call on protected or private etc methods
      Returns:
      the data
    • invokeMethod

      public static Object invokeMethod(Method method, Object invokeOn)
      Safely invoke a reflection method that takes no args
      Parameters:
      method - to invoke
      invokeOn - if NO_PARAMS then will not pass in params.
      Returns:
      the result
    • invokeMethod

      public static Object invokeMethod(Method method, Object invokeOn, Object paramsOrListOrArray)
      Safely invoke a reflection method
      Parameters:
      method - to invoke
      invokeOn -
      paramsOrListOrArray - must be an arg. If null, will pass null. if NO_PARAMS then will not pass in params.
      Returns:
      the result
    • toArray

      public static Object toArray(Object objectOrArrayOrCollection)
      Convert a list to an array with the type of the first element e.g. if it is a list of Person objects, then the array is Person[]
      Parameters:
      objectOrArrayOrCollection - is a list
      Returns:
      the array of objects with type of the first element in the list
    • toArray

      public static <T> T[] toArray(Collection collection, Class<T> theClass)
      convert a list into an array of type of theClass
      Type Parameters:
      T - is the type of the array
      Parameters:
      collection - list to convert
      theClass - type of array to return
      Returns:
      array of type theClass[] filled with the objects from list
    • callMethod

      public static Object callMethod(Class theClass, String methodName)
      helper method for calling a static method up the stack. method takes no args (could be in superclass)
      Parameters:
      theClass - the class which has the method
      methodName - method name to call
      Returns:
      the data
    • callMethod

      public static Object callMethod(Class theClass, String methodName, boolean callOnSupers)
      helper method for calling a static method with no params
      Parameters:
      theClass - the class which has the method
      methodName - method name to call
      callOnSupers - if we should try the super classes if not exists in this class
      Returns:
      the data
    • callMethod

      public static Object callMethod(Class theClass, String methodName, Object paramTypesOrArrayOrList, Object paramsOrListOrArray)
      helper method for calling a static method up the stack
      Parameters:
      theClass - the class which has the method
      methodName - method name to call
      paramTypesOrArrayOrList - types of the params
      paramsOrListOrArray - data
      Returns:
      the data
    • callMethod

      public static Object callMethod(Object invokeOn, String methodName)
      helper method for calling a method with no params (could be in superclass), will override security
      Parameters:
      invokeOn - instance to invoke on
      methodName - method name to call not exists in this class
      Returns:
      the data
    • replace

      public static String replace(String text, Object searchFor, Object replaceWith)
      replace a string or strings from a string, and put the output in a string buffer. This does not recurse
      Parameters:
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
      Returns:
      the string
    • replace

      public static String replace(String text, Object searchFor, Object replaceWith, boolean recurse)
      replace a string or strings from a string, and put the output in a string buffer
      Parameters:
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
      recurse - if true then do multiple replaces (on the replacements)
      Returns:
      the string
    • replace

      public static String replace(String text, Object searchFor, Object replaceWith, boolean recurse, boolean removeIfFound)
      replace a string or strings from a string, and put the output in a string buffer
      Parameters:
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
      recurse - if true then do multiple replaces (on the replacements)
      removeIfFound - true if removing from searchFor and replaceWith if found
      Returns:
      the string
    • replace

      public static String replace(String text, String repl, String with)

      Replaces all occurrences of a String within another String.

      A null reference passed to this method is a no-op.

       replace(null, *, *)        = null
       replace("", *, *)          = ""
       replace("any", null, *)    = "any"
       replace("any", *, null)    = "any"
       replace("any", "", *)      = "any"
       replace("aba", "a", null)  = "aba"
       replace("aba", "a", "")    = "b"
       replace("aba", "a", "z")   = "zbz"
       
      Parameters:
      text - text to search and replace in, may be null
      repl - the String to search for, may be null
      with - the String to replace with, may be null
      Returns:
      the text with any replacements processed, null if null String input
      See Also:
    • replace

      public static String replace(String text, String repl, String with, int max)

      Replaces a String with another String inside a larger String, for the first max values of the search String.

      A null reference passed to this method is a no-op.

       replace(null, *, *, *)         = null
       replace("", *, *, *)           = ""
       replace("any", null, *, *)     = "any"
       replace("any", *, null, *)     = "any"
       replace("any", "", *, *)       = "any"
       replace("any", *, *, 0)        = "any"
       replace("abaa", "a", null, -1) = "abaa"
       replace("abaa", "a", "", -1)   = "b"
       replace("abaa", "a", "z", 0)   = "abaa"
       replace("abaa", "a", "z", 1)   = "zbaa"
       replace("abaa", "a", "z", 2)   = "zbza"
       replace("abaa", "a", "z", -1)  = "zbzz"
       
      Parameters:
      text - text to search and replace in, may be null
      repl - the String to search for, may be null
      with - the String to replace with, may be null
      max - maximum number of values to replace, or -1 if no maximum
      Returns:
      the text with any replacements processed, null if null String input
    • isEmpty

      public static boolean isEmpty(String str)

      Checks if a String is empty ("") or null.

       isEmpty(null)      = true
       isEmpty("")        = true
       isEmpty(" ")       = false
       isEmpty("bob")     = false
       isEmpty("  bob  ") = false
       

      NOTE: This method changed in Lang version 2.0. It no longer trims the String. That functionality is available in isBlank().

      Parameters:
      str - the String to check, may be null
      Returns:
      true if the String is empty or null
    • replace

      public static void replace(StringBuffer outBuffer, String text, Object searchFor, Object replaceWith)
      replace a string or strings from a string, and put the output in a string buffer. This does not recurse
      Parameters:
      outBuffer - stringbuffer to write to
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
    • replace

      public static void replace(StringBuffer outBuffer, String text, Object searchFor, Object replaceWith, boolean recurse)
      replace a string or strings from a string, and put the output in a string buffer
      Parameters:
      outBuffer - stringbuffer to write to
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
      recurse - if true then do multiple replaces (on the replacements)
    • replace

      public static void replace(Writer outWriter, String text, Object searchFor, Object replaceWith)
      replace a string or strings from a string, and put the output in a string buffer. This does not recurse
      Parameters:
      outWriter - writer to write to
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
    • replace

      public static void replace(Writer outWriter, String text, Object searchFor, Object replaceWith, boolean recurse)
      replace a string or strings from a string, and put the output in a string buffer
      Parameters:
      outWriter - writer to write to
      text - string to look in
      searchFor - string array to search for
      replaceWith - string array to replace with
      recurse - if true then do multiple replaces (on the replacements)
    • packInts

      public static long packInts(int first, int second)
      pack two ints into a long. Note: the first is held in the left bits, the second is held in the right bits
      Parameters:
      first - is first int
      second - is second int
      Returns:
      the long which has two ints in there
    • unpackInt

      public static int unpackInt(long theLong, boolean isFirst)
      take a long
      Parameters:
      theLong - to unpack
      isFirst - true for first, false for second
      Returns:
      one of the packed ints, first or second
    • get

      public static Object get(Object arrayOrCollection, int index)
      Get a specific index of an array or collection (note for collections and iterating, it is more efficient to get an iterator and iterate
      Parameters:
      arrayOrCollection -
      index -
      Returns:
      the object at that index
    • toString

      public static String toString(Collection<Source> sources)
      convert a collection of sources to a string
      Parameters:
      sources -
      Returns:
      the string
    • toStringSafe

      public static String toStringSafe(Object object)
      fail safe toString for Exception blocks, and include the stack if there is a problem with toString()
      Parameters:
      object -
      Returns:
      the toStringSafe string
    • booleanValue

      public static boolean booleanValue(Object object)
      get the boolean value for an object, cant be null or blank
      Parameters:
      object -
      Returns:
      the boolean
    • booleanValue

      public static boolean booleanValue(Object object, boolean defaultBoolean)
      get the boolean value for an object
      Parameters:
      object -
      defaultBoolean - if object is null or empty
      Returns:
      the boolean
    • booleanObjectValue

      public static Boolean booleanObjectValue(Object object)
      get the Boolean value for an object
      Parameters:
      object -
      Returns:
      the Boolean or null if null or empty
    • nullOrBlank

      public static boolean nullOrBlank(Object object)
      is an object null or blank
      Parameters:
      object -
      Returns:
      true if null or blank
    • getter

      public static Method getter(Class theClass, String fieldName, boolean callOnSupers, boolean throwExceptionIfNotFound)
      get a getter method object for a class, potentially in superclasses
      Parameters:
      theClass -
      fieldName -
      callOnSupers - true if superclasses should be looked in for the getter
      throwExceptionIfNotFound - will throw runtime exception if not found
      Returns:
      the getter object or null if not found (or exception if param is set)
    • getterHelper

      public static Method getterHelper(Class theClass, String fieldName, String getterName, boolean callOnSupers, boolean throwExceptionIfNotFound)
      get a setter method object for a class, potentially in superclasses
      Parameters:
      theClass -
      fieldName -
      getterName - name of setter
      callOnSupers - true if superclasses should be looked in for the setter
      throwExceptionIfNotFound - will throw runtime exception if not found
      Returns:
      the setter object or null if not found (or exception if param is set)
    • getterNameFromPropertyName

      public static String getterNameFromPropertyName(Class theClass, String propertyName)
      generate getBb from bb
      Parameters:
      propertyName -
      Returns:
      the getter
    • getters

      public static Set<Method> getters(Class theClass, Class superclassToStopAt, Class<? extends Annotation> markerAnnotation, Boolean includeAnnotation)
      get all getters from a class, including superclasses (if specified) (up to and including the specified superclass). ignore a certain marker annotation, or only include it. Dont get static or final getters, and get getters of all types
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      markerAnnotation - if this is not null, then if the field has this annotation, then do not include in list (if includeAnnotation is false)
      includeAnnotation - true if the attribute should be included if annotation is present, false if exclude
      Returns:
      the set of field names or empty set if none
    • isGetter

      public static boolean isGetter(Method method)
      if the method name starts with get, and takes no args, and returns something, then getter
      Parameters:
      method -
      Returns:
      true if getter
    • assignSetter

      public static void assignSetter(Object invokeOn, String fieldName, Object dataToAssign, boolean typeCast)
      assign data to a setter. Will find the field in superclasses, will typecast, and will override security (private, protected, etc)
      Parameters:
      invokeOn - to call on or null for static
      fieldName - method name to call
      dataToAssign - data
      typeCast - will typecast if true
      Throws:
      PropertyDoesNotExistUnchecked - if not there
    • isSetter

      public static boolean isSetter(Method method)
      if the method name starts with get, and takes no args, and returns something, then getter
      Parameters:
      method -
      Returns:
      true if getter
    • setter

      public static Method setter(Class theClass, String fieldName, boolean callOnSupers, boolean throwExceptionIfNotFound)
      get a setter method object for a class, potentially in superclasses
      Parameters:
      theClass -
      fieldName -
      callOnSupers - true if superclasses should be looked in for the setter
      throwExceptionIfNotFound - will throw runtime exception if not found
      Returns:
      the setter object or null if not found (or exception if param is set)
    • setterHelper

      public static Method setterHelper(Class theClass, String fieldName, String setterName, boolean callOnSupers, boolean throwExceptionIfNotFound)
      get a setter method object for a class, potentially in superclasses
      Parameters:
      theClass -
      fieldName -
      setterName - name of setter
      callOnSupers - true if superclasses should be looked in for the setter
      throwExceptionIfNotFound - will throw runtime exception if not found
      Returns:
      the setter object or null if not found (or exception if param is set)
    • setterNameFromPropertyName

      public static String setterNameFromPropertyName(String propertyName)
      generate setBb from bb
      Parameters:
      propertyName -
      Returns:
      the setter
    • setters

      public static Set<Method> setters(Class theClass, Class superclassToStopAt, Class<?> fieldType, boolean includeSuperclassToStopAt, Class<? extends Annotation> markerAnnotation, boolean includeAnnotation)
      get all setters from a class, including superclasses (if specified)
      Parameters:
      theClass - to look for fields in
      superclassToStopAt - to go up to or null to go up to Object
      fieldType - is the type of the field to get
      includeSuperclassToStopAt - if we should include the superclass
      markerAnnotation - if this is not null, then if the field has this annotation, then do not include in list (if includeAnnotation is false)
      includeAnnotation - true if the attribute should be included if annotation is present, false if exclude
      Returns:
      the set of fields (wont return null)
    • propertyName

      public static String propertyName(Method method)
      If this is a getter or setter, then get the property name
      Parameters:
      method -
      Returns:
      the property name
    • propertyList

      public static <T> List<T> propertyList(Collection<?> collection, String propertyName, Class<T> fieldType)
      take a collection of beans, and go through and get all the values of one of the javabean properties, and make a list of those values.
      Type Parameters:
      T -
      Parameters:
      collection -
      propertyName -
      fieldType -
      Returns:
      the list
    • propertyType

      public static Class propertyType(Class theClass, String propertyName)
      use reflection to get a property type based on getter or setter or field
      Parameters:
      theClass -
      propertyName -
      Returns:
      the property type
    • typeCast

      public static <T> T typeCast(Object value, Class<T> theClass)
      If necessary, convert an object to another type. if type is Object.class, just return the input. Do not convert null to an empty primitive
      Type Parameters:
      T - is template type
      Parameters:
      value -
      theClass -
      Returns:
      the object of that instance converted into something else
    • newFileUniqueName

      public static File newFileUniqueName(String parentDirName, String namePrefix, String nameSuffix, boolean createFile)
       make a new file in the name prefix dir.  If parent dir name is c:\temp
       and namePrefix is grouperDdl and nameSuffix is sql, then the file will be:
      
       c:\temp\grouperDdl_20080721_13_45_43_123.sql
      
       If the file exists, it will make a new filename, and create the empty file, and return it
       
      Parameters:
      parentDirName - can be blank for current dir
      namePrefix - the part before the date part
      nameSuffix - the last part of file name (can contain dot or will be the extension
      createFile - true to create the file
      Returns:
      the created file
    • dateLongValue

      public static Long dateLongValue(String date)
      convert a string date into a long date (e.g. for xml export)
      Parameters:
      date -
      Returns:
      the long or null if the date was null or blank
    • dateStringValue

      public static String dateStringValue(Date date)
      date object to a string:
      Parameters:
      date -
      Returns:
      the long or null if the date was null or blank
    • dateStringValue

      public static String dateStringValue(Long theDate)
      date object to a string:
      Parameters:
      theDate -
      Returns:
      the long or null if the date was null or blank
    • dateValue

      public static Date dateValue(Object inputObject)
       Convert an object to a java.util.Date.  allows, dates, null, blank,
       yyyymmdd or yyyymmdd hh24:mm:ss
       or yyyy/MM/dd HH:mm:ss.SSS
       
      Parameters:
      inputObject - is the String or Date to convert
      Returns:
      the Date
    • stringToDate2

      public static Date stringToDate2(String input)
      take as input: yyyy/mm/dd yyyy-mm-dd dd-mon-yyyy yyyy/mm/dd hh:mm:ss dd-mon-yyyy hh:mm:ss yyyy/mm/dd hh:mm:ss.SSS dd-mon-yyyy hh:mm:ss.SSS
      Parameters:
      input -
      Returns:
      the date
    • monthInt

      public static int monthInt(String mon)
      convert a month string to an int (1 indexed). e.g. if input is feb or Feb or february or February return 2
      Parameters:
      mon -
      Returns:
      the month
    • isBlank

      public static boolean isBlank(Object input)
      See if the input is null or if string, if it is empty or blank (whitespace)
      Parameters:
      input -
      Returns:
      true if blank
    • isEmpty

      public static boolean isEmpty(Object input)
      See if the input is null or if string, if it is empty (whitespace)
      Parameters:
      input -
      Returns:
      true if empty
    • typeCast

      public static <T> T typeCast(Object value, Class<T> theClass, boolean convertNullToDefaultPrimitive, boolean useNewInstanceHooks)
      If necessary, convert an object to another type. if type is Object.class, just return the input
      Type Parameters:
      T - is the type to return
      Parameters:
      value -
      theClass -
      convertNullToDefaultPrimitive - if the value is null, and theClass is primitive, should we convert the null to a primitive default value
      useNewInstanceHooks - if theClass is not recognized, then honor the string "null", "newInstance", or get a constructor with one param, and call it
      Returns:
      the object of that instance converted into something else
    • isScalar

      public static boolean isScalar(Class<?> type)
      see if a class is a scalar (not bean, not array or list, etc)
      Parameters:
      type -
      Returns:
      true if scalar
    • toTimestamp

      public static Timestamp toTimestamp(Object input)
       Convert a string or object to a timestamp (could be string, date, timestamp, etc)
       yyyymmdd
       or
       yyyy/MM/dd
       or
       yyyy-MM-dd
        or 
       yyyy/MM/dd HH:mm:ss
       or
       yyyy/MM/dd HH:mm:ss.SSS
       or
       yyyy/MM/dd HH:mm:ss.SSSSSS
      
       
      Parameters:
      input -
      Returns:
      the timestamp
      Throws:
      RuntimeException - if invalid format
    • stringValue

      public static String stringValue(Object input)
      convert an object to a string
      Parameters:
      input - is the object to convert
      Returns:
      the String conversion of the object
    • timestampToString

      public static String timestampToString(Date timestamp)
      Convert a timestamp into a string: yyyy/MM/dd HH:mm:ss.SSS
      Parameters:
      timestamp -
      Returns:
      the string representation
    • timestampToFileString

      public static String timestampToFileString(Date timestamp)
      Convert a timestamp into a string: yyyy_MM_dd__HH_mm_ss_SSS
      Parameters:
      timestamp -
      Returns:
      the string representation
    • stringValue

      public static String stringValue(Date date)
      convert a date to the standard string yyyymmdd
      Parameters:
      date -
      Returns:
      the string value
    • stringToTimestamp

      public static Timestamp stringToTimestamp(String input)
      convert a string to timestamp based on the following formats:
       yyyyMMdd
       yyyy/MM/dd
       yyyy/MM/dd HH:mm:ss
       yyyy/MM/dd HH:mm:ss.SSS
       yyyy/MM/dd HH:mm:ss.SSSSSS
       
      Parameters:
      input -
      Returns:
      the timestamp object
    • stringToTimestampTimeRequiredWithoutSeconds

      public static Timestamp stringToTimestampTimeRequiredWithoutSeconds(String input)
      convert a string to timestamp based on the following formats:
       2011-07-18T15:24+02:00
       2011/07/18 15:24
       2011/07/18 3:24 PM
       
      Parameters:
      input -
      Returns:
      the timestamp object
    • stringToTimestampTimeRequiredLocalDateTime

      public static Timestamp stringToTimestampTimeRequiredLocalDateTime(String input)
      convert a string to timestamp based on the following formats:
       2022-02-15T15:27:42
       2022-02-15T15:27
       
      Parameters:
      input -
      Returns:
      the timestamp object
    • bigDecimalObjectValue

      public static BigDecimal bigDecimalObjectValue(Object input)
      Convert an object to a byte, allow nulls
      Parameters:
      input -
      Returns:
      the boolean object value
    • byteObjectValue

      public static Byte byteObjectValue(Object input)
      Convert an object to a byte, allow nulls
      Parameters:
      input -
      Returns:
      the boolean object value
    • byteValue

      public static byte byteValue(Object input)
      convert an object to a byte
      Parameters:
      input -
      Returns:
      the byte
    • doubleObjectValue

      public static Double doubleObjectValue(Object input, boolean allowNullBlank)
      get the Double value of an object
      Parameters:
      input - is a number or String
      allowNullBlank - used to default to false, if true, return null if nul inputted
      Returns:
      the Double equivalent
    • doubleValue

      public static double doubleValue(Object input)
      get the double value of an object
      Parameters:
      input - is a number or String
      Returns:
      the double equivalent
    • doubleValueNoError

      public static double doubleValueNoError(Object input)
      get the double value of an object, do not throw an exception if there is an error
      Parameters:
      input - is a number or String
      Returns:
      the double equivalent
    • floatObjectValue

      public static Float floatObjectValue(Object input, boolean allowNullBlank)
      get the Float value of an object
      Parameters:
      input - is a number or String
      allowNullBlank - true if allow null or blank
      Returns:
      the Float equivalent
    • floatValue

      public static float floatValue(Object input)
      get the float value of an object
      Parameters:
      input - is a number or String
      Returns:
      the float equivalent
    • floatValue

      public static float floatValue(Object input, float defaultValue)
      get the float value of an object
      Parameters:
      input - is a number or String
      Returns:
      the float equivalent
    • floatValueNoError

      public static float floatValueNoError(Object input)
      get the float value of an object, do not throw an exception if there is an error
      Parameters:
      input - is a number or String
      Returns:
      the float equivalent
    • intObjectValue

      public static Integer intObjectValue(Object input, boolean allowNullBlank)
      get the Integer value of an object
      Parameters:
      input - is a number or String
      allowNullBlank - true if convert null or blank to null
      Returns:
      the Integer equivalent
    • intValue

      public static int intValue(Object input)
      convert an object to a int
      Parameters:
      input -
      Returns:
      the number
    • intValue

      public static int intValue(Object input, int valueIfNull)
      convert an object to a int
      Parameters:
      input -
      valueIfNull - is if the input is null or empty, return this value
      Returns:
      the number
    • stemCalculateTopLevelStems

      public static Set<String> stemCalculateTopLevelStems(Set<String> stems)
      if these are the stems to sync: a:b:c, a:b, a:d, a:b:d, then the top level are: a:b, a:d
      Returns:
    • stemRemoveChildStemsOfTopStem

      public static void stemRemoveChildStemsOfTopStem(List<Stem> stems)
      remove stems that are children of the top level stem
      Parameters:
      stems -
    • stemRemoveAncestorStemsOfChildStem

      public static void stemRemoveAncestorStemsOfChildStem(Collection<String> stemNames)
      remove stems that are ancestor of the child stem
      Parameters:
      stems -
    • stemRemoveChildStemsOfTopStemName

      public static void stemRemoveChildStemsOfTopStemName(Collection<String> stemNames)
      remove stems that are children of the top level stem
      Parameters:
      stems -
    • intValueNoError

      public static int intValueNoError(Object input)
      get the int value of an object, do not throw an exception if there is an error
      Parameters:
      input - is a number or String
      Returns:
      the int equivalent
    • longObjectValue

      public static Long longObjectValue(Object input, boolean allowNullBlank)
      get the Long value of an object
      Parameters:
      input - is a number or String
      allowNullBlank - true if null or blank converts to null
      Returns:
      the Long equivalent
    • timestampObjectValue

      public static Timestamp timestampObjectValue(Object input, boolean allowNullBlank)
      get the Timestamp value of an object
      Parameters:
      input - is a timestamp or long
      allowNullBlank - true if null or blank converts to null
      Returns:
      the Long equivalent
    • longValue

      public static long longValue(Object input)
      convert an object to a long
      Parameters:
      input -
      Returns:
      the number
    • logFirstMax

      public static String logFirstMax(Collection<?> collection, int numberToLog)
      log first few items, separate with semicolons and spaces
      Parameters:
      collection -
      numberToLog -
      Returns:
      the string to log
    • multiKeySet

      public static Set<MultiKey> multiKeySet(Collection<Object[]> collection)
      take a collection of Objectp[
      Parameters:
      collection -
      Returns:
      the set of multikeys
    • longValue

      public static long longValue(Object input, long valueIfNull)
      convert an object to a long
      Parameters:
      input -
      valueIfNull - is if the input is null or empty, return this value
      Returns:
      the number
    • longValueNoError

      public static long longValueNoError(Object input)
      get the long value of an object, do not throw an exception if there is an error
      Parameters:
      input - is a number or String
      Returns:
      the long equivalent
    • shortObjectValue

      public static Short shortObjectValue(Object input)
      get the Short value of an object. converts null or blank to null
      Parameters:
      input - is a number or String
      Returns:
      the Long equivalent
    • shortValue

      public static short shortValue(Object input)
      convert an object to a short
      Parameters:
      input -
      Returns:
      the number
    • charObjectValue

      public static Character charObjectValue(Object input)
      get the Character wrapper value for the input
      Parameters:
      input - allow null, return null
      Returns:
      the Character object wrapper
    • charValue

      public static char charValue(Object input)
      convert an object to a char
      Parameters:
      input -
      Returns:
      the number
    • createParentDirectories

      public static void createParentDirectories(File file)
      Create the parent directories for a file if they do not already exist
      Parameters:
      file -
    • saveStringIntoFile

      public static void saveStringIntoFile(File file, String contents)
      save a string into a file, file does not have to exist
      Parameters:
      file - is the file to save to
      contents - is the contents of the file
    • whitespaceRemove

      public static String whitespaceRemove(String input)
      remove whitespace from string
      Returns:
      new string
    • whitespaceNormalizeNewLines

      public static String whitespaceNormalizeNewLines(String input)
      normalize new lines to unix
      Parameters:
      input -
      Returns:
      new string
    • whitespaceCountNewLines

      public static int whitespaceCountNewLines(String input)
      normalize newlines then count newlines
      Parameters:
      input -
      Returns:
      new string
    • saveStringIntoFile

      public static boolean saveStringIntoFile(File file, String contents, boolean onlyIfDifferentContents, boolean ignoreWhitespace)
      save a string into a file, file does not have to exist
      Parameters:
      file - is the file to save to
      contents - is the contents of the file
      onlyIfDifferentContents - true if only saving due to different contents
      ignoreWhitespace - true to ignore whitespace
      Returns:
      true if contents were saved (thus different if param set)
    • writeStringToFile

      public static void writeStringToFile(File file, String data, String encoding) throws IOException

      Writes data to a file. The file will be created if it does not exist.

      There is no readFileToString method without encoding parameter because the default encoding can differ between platforms and therefore results in inconsistent results.

      Parameters:
      file - the file to write.
      data - The content to write to the file.
      encoding - encoding to use
      Throws:
      IOException - in case of an I/O error
      UnsupportedEncodingException - if the encoding is not supported by the VM
    • readFileIntoString

      public static String readFileIntoString(File file)
      Parameters:
      file - is the file to read into a string
      Returns:
      String
    • readResourceIntoString

      public static String readResourceIntoString(String resourceName, boolean allowNull)
      Parameters:
      resourceName - is the string resource from classpath to read (e.g. grouper.properties)
      allowNull - is true if its ok if the resource is null or if it is not found or blank or whatever.
      Returns:
      String or null if allowed or RuntimeException if not allowed
    • readFileToString

      public static String readFileToString(File file, String encoding) throws IOException

      Reads the contents of a file into a String.

      There is no readFileToString method without encoding parameter because the default encoding can differ between platforms and therefore results in inconsistent results.

      Parameters:
      file - the file to read.
      encoding - the encoding to use
      Returns:
      The file contents or null if read failed.
      Throws:
      IOException - in case of an I/O error
    • replaceWhitespaceWithSpace

      public static String replaceWhitespaceWithSpace(String input)
      replace all whitespace with space
      Parameters:
      input -
      Returns:
      the string
    • closeQuietly

      public static void closeQuietly(InputStream input)
      Unconditionally close an InputStream. Equivalent to InputStream.close(), except any exceptions will be ignored.
      Parameters:
      input - A (possibly null) InputStream
    • closeQuietly

      public static void closeQuietly(OutputStream output)
      Unconditionally close an OutputStream. Equivalent to OutputStream.close(), except any exceptions will be ignored.
      Parameters:
      output - A (possibly null) OutputStream
    • closeQuietly

      public static void closeQuietly(Reader input)
      Unconditionally close an Reader. Equivalent to Reader.close(), except any exceptions will be ignored.
      Parameters:
      input - A (possibly null) Reader
    • closeQuietly

      public static void closeQuietly(Writer writer)
      close a writer quietly
      Parameters:
      writer -
    • closeQuietly

      public static void closeQuietly(XMLStreamWriter writer)
      close a writer quietly
      Parameters:
      writer -
    • toString

      public static String toString(InputStream input, String encoding) throws IOException
      Get the contents of an InputStream as a String.
      Parameters:
      input - the InputStream to read from
      encoding - The name of a supported character encoding. See the IANA Charset Registry for a list of valid encoding types.
      Returns:
      the requested String
      Throws:
      IOException - In case of an I/O problem
    • copy

      public static void copy(InputStream input, Writer output, String encoding) throws IOException
      Copy and convert bytes from an InputStream to chars on a Writer, using the specified encoding.
      Parameters:
      input - the InputStream to read from
      output - the Writer to write to
      encoding - The name of a supported character encoding. See the IANA Charset Registry for a list of valid encoding types.
      Throws:
      IOException - In case of an I/O problem
    • copy

      public static int copy(Reader input, Writer output) throws IOException
      Copy chars from a Reader to a Writer.
      Parameters:
      input - the Reader to read from
      output - the Writer to write to
      Returns:
      the number of characters copied
      Throws:
      IOException - In case of an I/O problem
    • threadJoin

      public static void threadJoin(Thread thread)
      join a thread
      Parameters:
      thread -
    • threadJoin

      public static void threadJoin(Thread thread, long millis)
      join a thread
      Parameters:
      thread -
      millis -
    • convertLongToChar

      public static String convertLongToChar(long theLong)
      this method takes a long (less than 62) and converts it to a 1 character string (a-z, A-Z, 0-9)
      Parameters:
      theLong - is the long (less than 62) to convert to a 1 character string
      Returns:
      a one character string
    • convertLongToCharSmall

      public static String convertLongToCharSmall(long theLong)
      this method takes a long (less than 36) and converts it to a 1 character string (A-Z, 0-9)
      Parameters:
      theLong - is the long (less than 36) to convert to a 1 character string
      Returns:
      a one character string
    • convertLongToString

      public static String convertLongToString(long theLong)
      convert a long to a string by converting it to base 62 (26 lower, 26 upper, 10 digits)
      Parameters:
      theLong - is the long to convert
      Returns:
      the String conversion of this
    • convertLongToStringSmall

      public static String convertLongToStringSmall(long theLong)
      convert a long to a string by converting it to base 36 (26 upper, 10 digits)
      Parameters:
      theLong - is the long to convert
      Returns:
      the String conversion of this
    • incrementChar

      public static char incrementChar(char theChar)
      increment a character (A-Z then 0-9)
      Parameters:
      theChar -
      Returns:
      the value
    • incrementStringInt

      public static char[] incrementStringInt(char[] string)
      Increment a string with A-Z and 0-9 (no lower case so case insensitive apps like windows IE will still work)
      Parameters:
      string -
      Returns:
      the value
    • propertiesFromResourceName

      public static Properties propertiesFromResourceName(String resourceName)
      read properties from a resource, dont modify the properties returned since they are cached
      Parameters:
      resourceName -
      Returns:
      the properties
    • propertiesFromUrl

      public static Properties propertiesFromUrl(String urlString, boolean useCache, boolean useFailSafeCache, GrouperHtmlFilter grouperHtmlFilter)
      this will get the properties from an external url. It will cache these (failsafe), and will escape them based on grouper's properties escaper (configurable)
      Parameters:
      urlString - e.g. http://localhost:8090/grouper/test.properties
      useCache - if should cache for 2 minutes
      useFailSafeCache - if should use this cache for 1 day if the url cant connect
      grouperHtmlFilter -
      Returns:
      the properties
    • propertiesFromFile

      public static Properties propertiesFromFile(File file, boolean useCache)
      properties from file
      Parameters:
      file -
      useCache -
      Returns:
      properties
    • propertiesFromResourceName

      public static Properties propertiesFromResourceName(String resourceName, boolean useCache, boolean exceptionIfNotExist)
      read properties from a resource, dont modify the properties returned since they are cached
      Parameters:
      resourceName -
      useCache -
      exceptionIfNotExist -
      Returns:
      the properties or null if not exist
    • enumValueOfIgnoreCase

      public static <E extends Enum<?>> E enumValueOfIgnoreCase(Class<E> theEnumClass, String string, boolean exceptionOnBlank) throws RuntimeException
      do a case-insensitive matching
      Type Parameters:
      E - generic type
      Parameters:
      theEnumClass - class of the enum
      string -
      exceptionOnBlank - true if exception should be thrown on not found
      Returns:
      the enum or null or exception if not found
      Throws:
      RuntimeException - if there is a problem
    • enumValueOfIgnoreCase

      public static <E extends Enum<?>> E enumValueOfIgnoreCase(Class<E> theEnumClass, String string, boolean exceptionOnBlank, boolean exceptionIfInvalid) throws RuntimeException
      do a case-insensitive matching
      Type Parameters:
      E - generic type
      Parameters:
      theEnumClass - class of the enum
      string -
      exceptionOnBlank - true if exception should be thrown on not found
      exceptionIfInvalid - if there is a string, but it is invalid, if should throw exception
      Returns:
      the enum or null or exception if not found
      Throws:
      RuntimeException - if there is a problem
    • retrievePropertyDescriptor

      public static PropertyDescriptor retrievePropertyDescriptor(Object object, String property)
      if there is a valid accessible property descriptor, get it
      Parameters:
      object -
      property -
      Returns:
      the property descriptor
    • propertyValue

      public static Object propertyValue(Object object, String property)
      this assumes the property exists, and is a simple property
      Parameters:
      object -
      property -
      Returns:
      the value
    • propertiesValue

      public static String propertiesValue(Properties properties, String key)
      get a value (trimmed to e) from a property file
      Parameters:
      properties -
      key -
      Returns:
      the property value
    • propertiesValue

      public static String propertiesValue(Properties properties, Map<String,String> overrideMap, String key)
      get a value (trimmed to e) from a property file
      Parameters:
      properties -
      overrideMap - for testing, to override some properties values
      key -
      Returns:
      the property value
    • propertiesValue

      public static String propertiesValue(Properties properties, Map<String,String> overrideMap, Map<String,String> overrideMap2, String key)
      get a value (trimmed to e) from a property file
      Parameters:
      properties -
      overrideMap - for testing or threadlocal, to override some properties values
      overrideMap2 - for testing, to provide some properties values
      key -
      Returns:
      the property value
    • propertiesValueBoolean

      public static boolean propertiesValueBoolean(Properties properties, String propertyName, boolean defaultValue)
      get a boolean property, or the default if cant find
      Parameters:
      properties -
      propertyName -
      defaultValue -
      Returns:
      the boolean
    • propertiesValueBoolean

      public static boolean propertiesValueBoolean(Properties properties, Map<String,String> overrideMap, String propertyName, boolean defaultValue)
      get a boolean property, or the default if cant find
      Parameters:
      properties -
      overrideMap - for testing to override properties
      propertyName -
      defaultValue -
      Returns:
      the boolean
    • propertiesValueBoolean

      public static boolean propertiesValueBoolean(Properties properties, Map<String,String> overrideMap, Map<String,String> overrideMap2, String propertyName, boolean defaultValue)
      get a boolean property, or the default if cant find
      Parameters:
      properties -
      overrideMap - for testing or threadlocal to override properties
      overrideMap2 - for testing or threadlocal to override properties
      propertyName -
      defaultValue -
      Returns:
      the boolean
    • closeQuietly

      public static void closeQuietly(Connection connection)
      close a connection null safe and dont throw exception
      Parameters:
      connection -
    • closeQuietly

      public static void closeQuietly(org.hibernate.Session session)
      close a session null safe and dont throw exception
      Parameters:
      session -
    • closeQuietly

      public static void closeQuietly(Statement statement)
      close a statement null safe and dont throw exception
      Parameters:
      statement -
    • closeQuietly

      public static void closeQuietly(ResultSet resultSet)
      close a resultSet null safe and dont throw exception
      Parameters:
      resultSet -
    • hostname

      public static String hostname()
      get the hostname of this machine
      Returns:
      the hostname
    • isAscii

      public static boolean isAscii(char input)
      is ascii char
      Parameters:
      input -
      Returns:
      true if ascii
    • lengthAscii

      public static int lengthAscii(String input)
      find the length of ascii chars (non ascii are counted as two)
      Parameters:
      input -
      Returns:
      the length of ascii chars
    • rollbackQuietly

      public static void rollbackQuietly(org.hibernate.Transaction transaction)
      rollback a transaction quietly
      Parameters:
      transaction -
    • rollbackQuietly

      public static void rollbackQuietly(Connection connection)
      rollback a connection quietly
      Parameters:
      connection -
    • stringLength

      public static int stringLength(String string)
      string length
      Parameters:
      string -
      Returns:
      string length
    • closeQuietly

      public static void closeQuietly(Closeable closeable)
      close a writer quietly
      Parameters:
      closeable -
    • fileCreateNewFile

      public static boolean fileCreateNewFile(File file)
      create a new file
      Parameters:
      file -
      Returns:
      if created
    • truncateAscii

      public static String truncateAscii(String input, int requiredLength)
      find the length of ascii chars (non ascii are counted as three)
      Parameters:
      input - is the string to operate on
      requiredLength - length we need the string to be
      Returns:
      the length of ascii chars
    • subjectToString

      public static String subjectToString(Subject subject)
      convert a subject to string safely
      Parameters:
      subject -
      Returns:
      the string value of subject (might be null)
    • readFromFileIfFile

      public static String readFromFileIfFile(String in, boolean disableExternalFileLookup)
      if the input is a file, read string from file. if not, or if disabled from grouper.properties, return the input
      Parameters:
      in -
      disableExternalFileLookup -
      Returns:
      the result
    • mkdirs

      public static void mkdirs(File dir)
      Create directories, throw exception if not possible. This is will be ok if the directory already exists (will not delete it)
      Parameters:
      dir -
    • fixRelativePath

      public static String fixRelativePath(String inPath)
      Parameters:
      inPath -
      Returns:
      string
    • equals

      public static boolean equals(String first, String second)
      null safe string compare
      Parameters:
      first -
      second -
      Returns:
      true if equal
    • isBlank

      public static boolean isBlank(String str)

      Checks if a String is whitespace, empty ("") or null.

       isBlank(null)      = true
       isBlank("")        = true
       isBlank(" ")       = true
       isBlank("bob")     = false
       isBlank("  bob  ") = false
       
      Parameters:
      str - the String to check, may be null
      Returns:
      true if the String is null, empty or whitespace
      Since:
      2.0
    • isNotBlank

      public static boolean isNotBlank(String str)
      Parameters:
      str -
      Returns:
      true if not blank
    • trim

      public static String trim(String str)
      trim whitespace from string
      Parameters:
      str -
      Returns:
      trimmed string
    • equalsIgnoreCase

      public static boolean equalsIgnoreCase(String str1, String str2)
      equalsignorecase
      Parameters:
      str1 -
      str2 -
      Returns:
      true if the strings are equal ignore case
    • trimToEmpty

      public static String trimToEmpty(String str)
      trim to empty, convert null to empty
      Parameters:
      str -
      Returns:
      trimmed
    • abbreviate

      public static String abbreviate(String str, int maxWidth)

      Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "Now is the time for..."

      Specifically:

      • If str is less than maxWidth characters long, return it.
      • Else abbreviate it to (substring(str, 0, max-3) + "...").
      • If maxWidth is less than 4, throw an IllegalArgumentException.
      • In no case will it return a String of length greater than maxWidth.

       StringUtils.abbreviate(null, *)      = null
       StringUtils.abbreviate("", 4)        = ""
       StringUtils.abbreviate("abcdefg", 6) = "abc..."
       StringUtils.abbreviate("abcdefg", 7) = "abcdefg"
       StringUtils.abbreviate("abcdefg", 8) = "abcdefg"
       StringUtils.abbreviate("abcdefg", 4) = "a..."
       StringUtils.abbreviate("abcdefg", 3) = IllegalArgumentException
       
      Parameters:
      str - the String to check, may be null
      maxWidth - maximum length of result String, must be at least 4
      Returns:
      abbreviated String, null if null String input
      Throws:
      IllegalArgumentException - if the width is too small
      Since:
      2.0
    • exceptionConvertToRuntime

      public static RuntimeException exceptionConvertToRuntime(Throwable t)
    • exceptionConvertToRuntime

      public static RuntimeException exceptionConvertToRuntime(Throwable t, String inject)
    • abbreviate

      public static String abbreviate(String str, int offset, int maxWidth)

      Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "...is the time for..."

      Works like abbreviate(String, int), but allows you to specify a "left edge" offset. Note that this left edge is not necessarily going to be the leftmost character in the result, or the first character following the ellipses, but it will appear somewhere in the result.

      In no case will it return a String of length greater than maxWidth.

       StringUtils.abbreviate(null, *, *)                = null
       StringUtils.abbreviate("", 0, 4)                  = ""
       StringUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
       StringUtils.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."
       StringUtils.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."
       StringUtils.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."
       StringUtils.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."
       StringUtils.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."
       StringUtils.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"
       StringUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
       StringUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
       StringUtils.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException
       StringUtils.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException
       
      Parameters:
      str - the String to check, may be null
      offset - left edge of source String
      maxWidth - maximum length of result String, must be at least 4
      Returns:
      abbreviated String, null if null String input
      Throws:
      IllegalArgumentException - if the width is too small
      Since:
      2.0
    • split

      public static String[] split(String str)

      Splits the provided text into an array, using whitespace as the separator. Whitespace is defined by Character.isWhitespace(char).

      The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.

      A null input String returns null.

       StringUtils.split(null)       = null
       StringUtils.split("")         = []
       StringUtils.split("abc def")  = ["abc", "def"]
       StringUtils.split("abc  def") = ["abc", "def"]
       StringUtils.split(" abc ")    = ["abc"]
       
      Parameters:
      str - the String to parse, may be null
      Returns:
      an array of parsed Strings, null if null String input
    • split

      public static String[] split(String str, char separatorChar)

      Splits the provided text into an array, separator specified. This is an alternative to using StringTokenizer.

      The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.

      A null input String returns null.

       StringUtils.split(null, *)         = null
       StringUtils.split("", *)           = []
       StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
       StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
       StringUtils.split("a:b:c", '.')    = ["a:b:c"]
       StringUtils.split("a\tb\nc", null) = ["a", "b", "c"]
       StringUtils.split("a b c", ' ')    = ["a", "b", "c"]
       
      Parameters:
      str - the String to parse, may be null
      separatorChar - the character used as the delimiter, null splits on whitespace
      Returns:
      an array of parsed Strings, null if null String input
      Since:
      2.0
    • split

      public static String[] split(String str, String separatorChars)

      Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.

      The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.

      A null input String returns null. A null separatorChars splits on whitespace.

       StringUtils.split(null, *)         = null
       StringUtils.split("", *)           = []
       StringUtils.split("abc def", null) = ["abc", "def"]
       StringUtils.split("abc def", " ")  = ["abc", "def"]
       StringUtils.split("abc  def", " ") = ["abc", "def"]
       StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
       
      Parameters:
      str - the String to parse, may be null
      separatorChars - the characters used as the delimiters, null splits on whitespace
      Returns:
      an array of parsed Strings, null if null String input
    • split

      public static String[] split(String str, String separatorChars, int max)

      Splits the provided text into an array with a maximum length, separators specified.

      The separator is not included in the returned String array. Adjacent separators are treated as one separator.

      A null input String returns null. A null separatorChars splits on whitespace.

      If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).

       StringUtils.split(null, *, *)            = null
       StringUtils.split("", *, *)              = []
       StringUtils.split("ab de fg", null, 0)   = ["ab", "cd", "ef"]
       StringUtils.split("ab   de fg", null, 0) = ["ab", "cd", "ef"]
       StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
       StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
       
      Parameters:
      str - the String to parse, may be null
      separatorChars - the characters used as the delimiters, null splits on whitespace
      max - the maximum number of elements to include in the array. A zero or negative value implies no limit
      Returns:
      an array of parsed Strings, null if null String input
    • splitByWholeSeparator

      public static String[] splitByWholeSeparator(String str, String separator)

      Splits the provided text into an array, separator string specified.

      The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

      A null input String returns null. A null separator splits on whitespace.

       StringUtils.split(null, *)            = null
       StringUtils.split("", *)              = []
       StringUtils.split("ab de fg", null)   = ["ab", "de", "fg"]
       StringUtils.split("ab   de fg", null) = ["ab", "de", "fg"]
       StringUtils.split("ab:cd:ef", ":")    = ["ab", "cd", "ef"]
       StringUtils.split("abstemiouslyaeiouyabstemiously", "aeiouy")  = ["bst", "m", "sl", "bst", "m", "sl"]
       StringUtils.split("abstemiouslyaeiouyabstemiously", "aeiouy")  = ["abstemiously", "abstemiously"]
       
      Parameters:
      str - the String to parse, may be null
      separator - String containing the String to be used as a delimiter, null splits on whitespace
      Returns:
      an array of parsed Strings, null if null String was input
    • splitByWholeSeparator

      public static String[] splitByWholeSeparator(String str, String separator, int max)

      Splits the provided text into an array, separator string specified. Returns a maximum of max substrings.

      The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

      A null input String returns null. A null separator splits on whitespace.

       StringUtils.splitByWholeSeparator(null, *, *)               = null
       StringUtils.splitByWholeSeparator("", *, *)                 = []
       StringUtils.splitByWholeSeparator("ab de fg", null, 0)      = ["ab", "de", "fg"]
       StringUtils.splitByWholeSeparator("ab   de fg", null, 0)    = ["ab", "de", "fg"]
       StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2)       = ["ab", "cd"]
       StringUtils.splitByWholeSeparator("abstemiouslyaeiouyabstemiously", "aeiouy", 2) = ["bst", "m"]
       StringUtils.splitByWholeSeparator("abstemiouslyaeiouyabstemiously", "aeiouy", 2)  = ["abstemiously", "abstemiously"]
       
      Parameters:
      str - the String to parse, may be null
      separator - String containing the String to be used as a delimiter, null splits on whitespace
      max - the maximum number of elements to include in the returned array. A zero or negative value implies no limit.
      Returns:
      an array of parsed Strings, null if null String was input
    • splitPreserveAllTokens

      public static String[] splitPreserveAllTokens(String str)

      Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer. Whitespace is defined by Character.isWhitespace(char).

      The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.

      A null input String returns null.

       StringUtils.splitPreserveAllTokens(null)       = null
       StringUtils.splitPreserveAllTokens("")         = []
       StringUtils.splitPreserveAllTokens("abc def")  = ["abc", "def"]
       StringUtils.splitPreserveAllTokens("abc  def") = ["abc", "", "def"]
       StringUtils.splitPreserveAllTokens(" abc ")    = ["", "abc", ""]
       
      Parameters:
      str - the String to parse, may be null
      Returns:
      an array of parsed Strings, null if null String input
      Since:
      2.1
    • splitPreserveAllTokens

      public static String[] splitPreserveAllTokens(String str, char separatorChar)

      Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer.

      The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.

      A null input String returns null.

       StringUtils.splitPreserveAllTokens(null, *)         = null
       StringUtils.splitPreserveAllTokens("", *)           = []
       StringUtils.splitPreserveAllTokens("a.b.c", '.')    = ["a", "b", "c"]
       StringUtils.splitPreserveAllTokens("a..b.c", '.')   = ["a", "b", "c"]
       StringUtils.splitPreserveAllTokens("a:b:c", '.')    = ["a:b:c"]
       StringUtils.splitPreserveAllTokens("a\tb\nc", null) = ["a", "b", "c"]
       StringUtils.splitPreserveAllTokens("a b c", ' ')    = ["a", "b", "c"]
       StringUtils.splitPreserveAllTokens("a b c ", ' ')   = ["a", "b", "c", ""]
       StringUtils.splitPreserveAllTokens("a b c ", ' ')   = ["a", "b", "c", "", ""]
       StringUtils.splitPreserveAllTokens(" a b c", ' ')   = ["", a", "b", "c"]
       StringUtils.splitPreserveAllTokens("  a b c", ' ')  = ["", "", a", "b", "c"]
       StringUtils.splitPreserveAllTokens(" a b c ", ' ')  = ["", a", "b", "c", ""]
       
      Parameters:
      str - the String to parse, may be null
      separatorChar - the character used as the delimiter, null splits on whitespace
      Returns:
      an array of parsed Strings, null if null String input
      Since:
      2.1
    • splitPreserveAllTokens

      public static String[] splitPreserveAllTokens(String str, String separatorChars)

      Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer.

      The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.

      A null input String returns null. A null separatorChars splits on whitespace.

       StringUtils.splitPreserveAllTokens(null, *)           = null
       StringUtils.splitPreserveAllTokens("", *)             = []
       StringUtils.splitPreserveAllTokens("abc def", null)   = ["abc", "def"]
       StringUtils.splitPreserveAllTokens("abc def", " ")    = ["abc", "def"]
       StringUtils.splitPreserveAllTokens("abc  def", " ")   = ["abc", "", def"]
       StringUtils.splitPreserveAllTokens("ab:cd:ef", ":")   = ["ab", "cd", "ef"]
       StringUtils.splitPreserveAllTokens("ab:cd:ef:", ":")  = ["ab", "cd", "ef", ""]
       StringUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""]
       StringUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]
       StringUtils.splitPreserveAllTokens(":cd:ef", ":")     = ["", cd", "ef"]
       StringUtils.splitPreserveAllTokens("::cd:ef", ":")    = ["", "", cd", "ef"]
       StringUtils.splitPreserveAllTokens(":cd:ef:", ":")    = ["", cd", "ef", ""]
       
      Parameters:
      str - the String to parse, may be null
      separatorChars - the characters used as the delimiters, null splits on whitespace
      Returns:
      an array of parsed Strings, null if null String input
      Since:
      2.1
    • splitPreserveAllTokens

      public static String[] splitPreserveAllTokens(String str, String separatorChars, int max)

      Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.

      The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. Adjacent separators are treated as one separator.

      A null input String returns null. A null separatorChars splits on whitespace.

      If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).

       StringUtils.splitPreserveAllTokens(null, *, *)            = null
       StringUtils.splitPreserveAllTokens("", *, *)              = []
       StringUtils.splitPreserveAllTokens("ab de fg", null, 0)   = ["ab", "cd", "ef"]
       StringUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "cd", "ef"]
       StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
       StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
       StringUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]
       StringUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]
       StringUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]
       
      Parameters:
      str - the String to parse, may be null
      separatorChars - the characters used as the delimiters, null splits on whitespace
      max - the maximum number of elements to include in the array. A zero or negative value implies no limit
      Returns:
      an array of parsed Strings, null if null String input
      Since:
      2.1
    • join

      public static String join(Object[] array)

      Joins the elements of the provided array into a single String containing the provided list of elements.

      No separator is added to the joined String. Null objects or empty strings within the array are represented by empty strings.

       StringUtils.join(null)            = null
       StringUtils.join([])              = ""
       StringUtils.join([null])          = ""
       StringUtils.join(["a", "b", "c"]) = "abc"
       StringUtils.join([null, "", "a"]) = "a"
       
      Parameters:
      array - the array of values to join together, may be null
      Returns:
      the joined String, null if null array input
      Since:
      2.0
    • join

      public static String join(Object[] array, char separator)

      Joins the elements of the provided array into a single String containing the provided list of elements.

      No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.

       StringUtils.join(null, *)               = null
       StringUtils.join([], *)                 = ""
       StringUtils.join([null], *)             = ""
       StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
       StringUtils.join(["a", "b", "c"], null) = "abc"
       StringUtils.join([null, "", "a"], ';')  = ";;a"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use
      Returns:
      the joined String, null if null array input
      Since:
      2.0
    • join

      public static String join(Object[] array, String separator)

      Joins the elements of the provided array into a single String containing the provided list of elements.

      No delimiter is added before or after the list. A null separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.

       StringUtils.join(null, *)                = null
       StringUtils.join([], *)                  = ""
       StringUtils.join([null], *)              = ""
       StringUtils.join(["a", "b", "c"], "--")  = "a--b--c"
       StringUtils.join(["a", "b", "c"], null)  = "abc"
       StringUtils.join(["a", "b", "c"], "")    = "abc"
       StringUtils.join([null, "", "a"], ',')   = ",,a"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use, null treated as ""
      Returns:
      the joined String, null if null array input
    • join

      public static String join(Iterator iterator, char separator)

      Joins the elements of the provided Iterator into a single String containing the provided elements.

      No delimiter is added before or after the list. Null objects or empty strings within the iteration are represented by empty strings.

      See the examples here: join(Object[],char).

      Parameters:
      iterator - the Iterator of values to join together, may be null
      separator - the separator character to use
      Returns:
      the joined String, null if null iterator input
      Since:
      2.0
    • join

      public static String join(Iterator iterator, String separator)

      Joins the elements of the provided Iterator into a single String containing the provided elements.

      No delimiter is added before or after the list. A null separator is the same as an empty String ("").

      See the examples here: join(Object[],String).

      Parameters:
      iterator - the Iterator of values to join together, may be null
      separator - the separator character to use, null treated as ""
      Returns:
      the joined String, null if null iterator input
    • defaultString

      public static String defaultString(String str)

      Returns either the passed in String, or if the String is null, an empty String ("").

       StringUtils.defaultString(null)  = ""
       StringUtils.defaultString("")    = ""
       StringUtils.defaultString("bat") = "bat"
       
      Parameters:
      str - the String to check, may be null
      Returns:
      the passed in String, or the empty String if it was null
      See Also:
    • defaultString

      public static String defaultString(String str, String defaultStr)

      Returns either the passed in String, or if the String is null, the value of defaultStr.

       StringUtils.defaultString(null, "NULL")  = "NULL"
       StringUtils.defaultString("", "NULL")    = ""
       StringUtils.defaultString("bat", "NULL") = "bat"
       
      Parameters:
      str - the String to check, may be null
      defaultStr - the default String to return if the input is null, may be null
      Returns:
      the passed in String, or the default if it was null
      See Also:
    • defaultIfEmpty

      public static String defaultIfEmpty(String str, String defaultStr)

      Returns either the passed in String, or if the String is empty or null, the value of defaultStr.

       StringUtils.defaultIfEmpty(null, "NULL")  = "NULL"
       StringUtils.defaultIfEmpty("", "NULL")    = "NULL"
       StringUtils.defaultIfEmpty("bat", "NULL") = "bat"
       
      Parameters:
      str - the String to check, may be null
      defaultStr - the default String to return if the input is empty ("") or null, may be null
      Returns:
      the passed in String, or the default
    • capitalize

      public static String capitalize(String str)

      Capitalizes a String changing the first letter to title case as per Character.toTitleCase(char). No other letters are changed.

      A null input String returns null.

       StringUtils.capitalize(null)  = null
       StringUtils.capitalize("")    = ""
       StringUtils.capitalize("cat") = "Cat"
       StringUtils.capitalize("cAt") = "CAt"
       
      Parameters:
      str - the String to capitalize, may be null
      Returns:
      the capitalized String, null if null String input
      Since:
      2.0
    • containsNewline

      public static boolean containsNewline(String string)
      contains newline since JSP cant have a quoted newlines
      Parameters:
      string -
      Returns:
      newline
    • contains

      public static boolean contains(String str, char searchChar)

      Checks if String contains a search character, handling null. This method uses String.indexOf(int).

      A null or empty ("") String will return false.

       StringUtils.contains(null, *)    = false
       StringUtils.contains("", *)      = false
       StringUtils.contains("abc", 'a') = true
       StringUtils.contains("abc", 'z') = false
       
      Parameters:
      str - the String to check, may be null
      searchChar - the character to find
      Returns:
      true if the String contains the search character, false if not or null string input
      Since:
      2.0
    • contains

      public static boolean contains(String str, String searchStr)

      Checks if String contains a search String, handling null. This method uses String.indexOf(int).

      A null String will return false.

       StringUtils.contains(null, *)     = false
       StringUtils.contains(*, null)     = false
       StringUtils.contains("", "")      = true
       StringUtils.contains("abc", "")   = true
       StringUtils.contains("abc", "a")  = true
       StringUtils.contains("abc", "z")  = false
       
      Parameters:
      str - the String to check, may be null
      searchStr - the String to find, may be null
      Returns:
      true if the String contains the search String, false if not or null string input
      Since:
      2.0
    • equalsIgnoreCaseObject

      public static boolean equalsIgnoreCaseObject(Object object1, Object object2)

      Compares two objects for equality, where either one or both objects may be null.

       ObjectUtils.equals(null, null)                  = true
       ObjectUtils.equals(null, "")                    = false
       ObjectUtils.equals("", null)                    = false
       ObjectUtils.equals("", "")                      = true
       ObjectUtils.equals(Boolean.TRUE, null)          = false
       ObjectUtils.equals(Boolean.TRUE, "true")        = false
       ObjectUtils.equals(Boolean.TRUE, Boolean.TRUE)  = true
       ObjectUtils.equals(Boolean.TRUE, Boolean.FALSE) = false
       
      Parameters:
      object1 - the first object, may be null
      object2 - the second object, may be null
      Returns:
      true if the values of both objects are the same
    • equals

      public static boolean equals(Object object1, Object object2)

      Compares two objects for equality, where either one or both objects may be null.

       ObjectUtils.equals(null, null)                  = true
       ObjectUtils.equals(null, "")                    = false
       ObjectUtils.equals("", null)                    = false
       ObjectUtils.equals("", "")                      = true
       ObjectUtils.equals(Boolean.TRUE, null)          = false
       ObjectUtils.equals(Boolean.TRUE, "true")        = false
       ObjectUtils.equals(Boolean.TRUE, Boolean.TRUE)  = true
       ObjectUtils.equals(Boolean.TRUE, Boolean.FALSE) = false
       
      Parameters:
      object1 - the first object, may be null
      object2 - the second object, may be null
      Returns:
      true if the values of both objects are the same
    • equalsSet

      public static boolean equalsSet(Set<?> set1, Set<?> set2)
      see if two sets are deep equals using the equals() method on each item
      Parameters:
      set1 -
      set2 -
      Returns:
      if lists are equal or empty
    • equalsCollectionStringLong

      public static boolean equalsCollectionStringLong(Collection<?> collection1, Collection<?> collection2)
      see if two collections are deep equals based on strings or longs (or conversions)
      Parameters:
      collection1 -
      collection2 -
      Returns:
      if lists are equal or empty
    • equalsLong

      public static boolean equalsLong(Object thisValue, Object thatValue)
      see if two objects long value is the same
      Parameters:
      thisValue -
      thatValue -
      Returns:
      if equal
    • equalsString

      public static boolean equalsString(Object thisValue, Object thatValue)
      see if two strings are equal (or the strings they convert into)
      Parameters:
      thisValue -
      thatValue -
      Returns:
      true if equal
    • equalsList

      public static boolean equalsList(List<?> list1, List<?> list2)
      see if two lists are deep equals using the equals() method on each item
      Parameters:
      list1 -
      list2 -
      Returns:
      if lists are equal
    • getFullStackTraceHtml

      public static String getFullStackTraceHtml(Throwable throwable)

      A way to get the entire nested stack-trace of an throwable.

      Parameters:
      throwable - the Throwable to be examined
      Returns:
      the nested stack trace, with the root cause first
      Since:
      2.0
    • getFullStackTrace

      public static String getFullStackTrace(Throwable throwable)

      A way to get the entire nested stack-trace of an throwable.

      Parameters:
      throwable - the Throwable to be examined
      Returns:
      the nested stack trace, with the root cause first
      Since:
      2.0
    • substituteVariableMapPrint

      public static void substituteVariableMapPrint(Map<String,Object> variableMap)
      print out a variable map as java to try to debug whats going on
      Parameters:
      variableMap -
    • substituteExpressionLanguage

      public static String substituteExpressionLanguage(String stringToParse, Map<String,Object> variableMap)
      substitute an EL for objects
      Parameters:
      stringToParse -
      variableMap -
      Returns:
      the string
    • substituteExpressionLanguage

      @Deprecated public static String substituteExpressionLanguage(String stringToParse, Map<String,Object> variableMap, boolean allowStaticClasses)
      Deprecated.
      substitute an EL for objects
      Parameters:
      stringToParse -
      variableMap -
      allowStaticClasses - if true allow static classes not registered with context
      Returns:
      the string
    • substituteExpressionLanguage

      public static String substituteExpressionLanguage(String stringToParse, Map<String,Object> variableMap, boolean allowStaticClasses, boolean silent)
      substitute an EL for objects
      Parameters:
      stringToParse -
      variableMap -
      allowStaticClasses - if true allow static classes not registered with context
      silent - if silent mode, swallow exceptions (warn), and dont warn when variable not found
      Returns:
      the string
    • substituteExpressionLanguage

      public static String substituteExpressionLanguage(String stringToParse, Map<String,Object> variableMap, boolean allowStaticClasses, boolean silent, boolean lenient)
      substitute an EL for objects
      Parameters:
      stringToParse -
      variableMap -
      allowStaticClasses - if true allow static classes not registered with context
      silent - if silent mode, swallow exceptions (warn), and dont warn when variable not found
      lenient - false if undefined variables should throw an exception. if lenient is true (default) then undefined variables are null
      Returns:
      the string
    • tryMultipleTimes

      public static void tryMultipleTimes(int times, Runnable runnable)
      Parameters:
      times -
      runnable -
    • substituteExpressionLanguageScript

      public static Object substituteExpressionLanguageScript(String script, Map<String,Object> variableMap, boolean allowStaticClasses, boolean silent, boolean lenient)
      substitute an EL for objects
      Parameters:
      script -
      variableMap -
      allowStaticClasses - if true allow static classes not registered with context
      silent - if silent mode, swallow exceptions (warn), and dont warn when variable not found
      lenient - false if undefined variables should throw an exception. if lenient is true (default) then undefined variables are null
      Returns:
      the object
    • getThrowables

      public static Throwable[] getThrowables(Throwable throwable)

      Returns the list of Throwable objects in the exception chain.

      A throwable without cause will return an array containing one element - the input throwable. A throwable with one cause will return an array containing two elements. - the input throwable and the cause throwable. A null throwable will return an array size zero.

      Parameters:
      throwable - the throwable to inspect, may be null
      Returns:
      the array of throwables, never null
    • isNestedThrowable

      public static boolean isNestedThrowable(Throwable throwable)

      Checks whether this Throwable class can store a cause.

      This method does not check whether it actually does store a cause.

      Parameters:
      throwable - the Throwable to examine, may be null
      Returns:
      boolean true if nested otherwise false
      Since:
      2.0
    • isThrowableNested

      public static boolean isThrowableNested()

      Checks if the Throwable class has a getCause method.

      This is true for JDK 1.4 and above.

      Returns:
      true if Throwable is nestable
      Since:
      2.0
    • getCause

      public static Throwable getCause(Throwable throwable)

      Introspects the Throwable to obtain the cause.

      The method searches for methods with specific names that return a Throwable object. This will pick up most wrapping exceptions, including those from JDK 1.4, and NestableException.

      The default list searched for are:

      • getCause()
      • getNextException()
      • getTargetException()
      • getException()
      • getSourceException()
      • getRootCause()
      • getCausedByException()
      • getNested()

      In the absence of any such method, the object is inspected for a detail field assignable to a Throwable.

      If none of the above is found, returns null.

      Parameters:
      throwable - the throwable to introspect for a cause, may be null
      Returns:
      the cause of the Throwable, null if none found or null throwable input
      Since:
      1.0
    • getCause

      public static Throwable getCause(Throwable throwable, String[] methodNames)

      Introspects the Throwable to obtain the cause.

      1. Try known exception types.
      2. Try the supplied array of method names.
      3. Try the field 'detail'.

      A null set of method names means use the default set. A null in the set of method names will be ignored.

      Parameters:
      throwable - the throwable to introspect for a cause, may be null
      methodNames - the method names, null treated as default set
      Returns:
      the cause of the Throwable, null if none found or null throwable input
      Since:
      1.0
    • copy

      public static void copy(InputStream input, Writer output) throws IOException
      Copy bytes from an InputStream to chars on a Writer using the default character encoding of the platform.

      This method buffers the input internally, so there is no need to use a BufferedInputStream.

      This method uses InputStreamReader.

      Parameters:
      input - the InputStream to read from
      output - the Writer to write to
      Throws:
      NullPointerException - if the input or output is null
      IOException - if an I/O error occurs
      Since:
      Commons IO 1.1
    • jarFile

      public static File jarFile(Class sampleClass, boolean printError)
      get a jar file from a sample class
      Parameters:
      sampleClass -
      printError - if error should be printed when there is a problem
      Returns:
      the jar file
    • stripLastSlashIfExists

      public static String stripLastSlashIfExists(String input)
      strip the last slash (/ or \) from a string if it exists
      Parameters:
      input -
      Returns:
      input - the last / or \
    • stripLastCommaOrSemiIfExists

      public static String stripLastCommaOrSemiIfExists(String input)
      strip the last comma or semi from a string if it exists
      Parameters:
      input -
      Returns:
      input - the last , or ;
    • stripFirstSlashIfExists

      public static String stripFirstSlashIfExists(String input)
      strip the first slash (/ or \) from a string if it exists
      Parameters:
      input -
      Returns:
      input - the last / or \
    • retrievePasswordFromStdin

      public static String retrievePasswordFromStdin(boolean dontMask, String prompt)
      retrieve a password from stdin
      Parameters:
      dontMask -
      prompt - to print to user
      Returns:
      the password
    • retrievePasswordFromStdin

      public static final char[] retrievePasswordFromStdin(InputStream in, String prompt) throws IOException
      Parameters:
      in - stream to be used (e.g. System.in)
      prompt - The prompt to display to the user.
      Returns:
      The password as entered by the user.
      Throws:
      IOException
    • stripStart

      public static String stripStart(String str, String stripChars)

      Strips any of a set of characters from the start of a String.

      A null input String returns null. An empty string ("") input returns the empty string.

      If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).

       StringUtils.stripStart(null, *)          = null
       StringUtils.stripStart("", *)            = ""
       StringUtils.stripStart("abc", "")        = "abc"
       StringUtils.stripStart("abc", null)      = "abc"
       StringUtils.stripStart("  abc", null)    = "abc"
       StringUtils.stripStart("abc  ", null)    = "abc  "
       StringUtils.stripStart(" abc ", null)    = "abc "
       StringUtils.stripStart("yxabc  ", "xyz") = "abc  "
       
      Parameters:
      str - the String to remove characters from, may be null
      stripChars - the characters to remove, null treated as whitespace
      Returns:
      the stripped String, null if null String input
    • stripEnd

      @Deprecated public static String stripEnd(String str, String stripChars)
      Deprecated.
      use stripSuffix instead

      Strips any of a set of characters from the end of a String.

      A null input String returns null. An empty string ("") input returns the empty string.

      If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).

       StringUtils.stripEnd(null, *)          = null
       StringUtils.stripEnd("", *)            = ""
       StringUtils.stripEnd("abc", "")        = "abc"
       StringUtils.stripEnd("abc", null)      = "abc"
       StringUtils.stripEnd("  abc", null)    = "  abc"
       StringUtils.stripEnd("abc  ", null)    = "abc"
       StringUtils.stripEnd(" abc ", null)    = " abc"
       StringUtils.stripEnd("  abcyx", "xyz") = "  abc"
       
      Parameters:
      str - the String to remove characters from, may be null
      stripChars - the characters to remove, null treated as whitespace
      Returns:
      the stripped String, null if null String input
    • repeat

      public static String repeat(String str, int repeat)

      Repeat a String repeat times to form a new String.

       StringUtils.repeat(null, 2) = null
       StringUtils.repeat("", 0)   = ""
       StringUtils.repeat("", 2)   = ""
       StringUtils.repeat("a", 3)  = "aaa"
       StringUtils.repeat("ab", 2) = "abab"
       StringUtils.repeat("a", -2) = ""
       
      Parameters:
      str - the String to repeat, may be null
      repeat - number of times to repeat str, negative treated as zero
      Returns:
      a new String consisting of the original String repeated, null if null String input
    • rightPad

      public static String rightPad(String str, int size)

      Right pad a String with spaces (' ').

      The String is padded to the size of size.

       StringUtils.rightPad(null, *)   = null
       StringUtils.rightPad("", 3)     = "   "
       StringUtils.rightPad("bat", 3)  = "bat"
       StringUtils.rightPad("bat", 5)  = "bat  "
       StringUtils.rightPad("bat", 1)  = "bat"
       StringUtils.rightPad("bat", -1) = "bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
    • rightPad

      public static String rightPad(String str, int size, char padChar)

      Right pad a String with a specified character.

      The String is padded to the size of size.

       StringUtils.rightPad(null, *, *)     = null
       StringUtils.rightPad("", 3, 'z')     = "zzz"
       StringUtils.rightPad("bat", 3, 'z')  = "bat"
       StringUtils.rightPad("bat", 5, 'z')  = "batzz"
       StringUtils.rightPad("bat", 1, 'z')  = "bat"
       StringUtils.rightPad("bat", -1, 'z') = "bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padChar - the character to pad with
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
      Since:
      2.0
    • rightPad

      public static String rightPad(String str, int size, String padStr)

      Right pad a String with a specified String.

      The String is padded to the size of size.

       StringUtils.rightPad(null, *, *)      = null
       StringUtils.rightPad("", 3, "z")      = "zzz"
       StringUtils.rightPad("bat", 3, "yz")  = "bat"
       StringUtils.rightPad("bat", 5, "yz")  = "batyz"
       StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
       StringUtils.rightPad("bat", 1, "yz")  = "bat"
       StringUtils.rightPad("bat", -1, "yz") = "bat"
       StringUtils.rightPad("bat", 5, null)  = "bat  "
       StringUtils.rightPad("bat", 5, "")    = "bat  "
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padStr - the String to pad with, null or empty treated as single space
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
    • leftPad

      public static String leftPad(String str, int size)

      Left pad a String with spaces (' ').

      The String is padded to the size of size.

       StringUtils.leftPad(null, *)   = null
       StringUtils.leftPad("", 3)     = "   "
       StringUtils.leftPad("bat", 3)  = "bat"
       StringUtils.leftPad("bat", 5)  = "  bat"
       StringUtils.leftPad("bat", 1)  = "bat"
       StringUtils.leftPad("bat", -1) = "bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
    • leftPad

      public static String leftPad(String str, int size, char padChar)

      Left pad a String with a specified character.

      Pad to a size of size.

       StringUtils.leftPad(null, *, *)     = null
       StringUtils.leftPad("", 3, 'z')     = "zzz"
       StringUtils.leftPad("bat", 3, 'z')  = "bat"
       StringUtils.leftPad("bat", 5, 'z')  = "zzbat"
       StringUtils.leftPad("bat", 1, 'z')  = "bat"
       StringUtils.leftPad("bat", -1, 'z') = "bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padChar - the character to pad with
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
      Since:
      2.0
    • leftPad

      public static String leftPad(String str, int size, String padStr)

      Left pad a String with a specified String.

      Pad to a size of size.

       StringUtils.leftPad(null, *, *)      = null
       StringUtils.leftPad("", 3, "z")      = "zzz"
       StringUtils.leftPad("bat", 3, "yz")  = "bat"
       StringUtils.leftPad("bat", 5, "yz")  = "yzbat"
       StringUtils.leftPad("bat", 8, "yz")  = "yzyzybat"
       StringUtils.leftPad("bat", 1, "yz")  = "bat"
       StringUtils.leftPad("bat", -1, "yz") = "bat"
       StringUtils.leftPad("bat", 5, null)  = "  bat"
       StringUtils.leftPad("bat", 5, "")    = "  bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padStr - the String to pad with, null or empty treated as single space
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
    • substringBefore

      public static String substringBefore(String str, String separator)

      Gets the substring before the first occurrence of a separator. The separator is not returned.

      A null string input will return null. An empty ("") string input will return the empty string. A null separator will return the input string.

       StringUtils.substringBefore(null, *)      = null
       StringUtils.substringBefore("", *)        = ""
       StringUtils.substringBefore("abc", "a")   = ""
       StringUtils.substringBefore("abcba", "b") = "a"
       StringUtils.substringBefore("abc", "c")   = "ab"
       StringUtils.substringBefore("abc", "d")   = "abc"
       StringUtils.substringBefore("abc", "")    = ""
       StringUtils.substringBefore("abc", null)  = "abc"
       
      Parameters:
      str - the String to get a substring from, may be null
      separator - the String to search for, may be null
      Returns:
      the substring before the first occurrence of the separator, null if null String input
      Since:
      2.0