Compara si el nombre del estado actual (no la descripción de toSTring que
es más completa) es igual a la pasada como parámetro.

@param s
326195
public boolean isCurrentState(String s) {
        if (currentState == null) {
            return false;
        }
        return currentState.name.equals(s);
    }
988400
private function _toLowerChars ($s)
    {
        $lowerFilter = new \Zend\Filter\StringToLower;
        $lowerFilter->setEncoding('utf-8');
        return $lowerFilter->filter($s);
    }
880404
@Override
    public boolean contains(CharSequence s) {
        if (s instanceof FastStr) {
            return indexOf((FastStr) s) > -1;
        }
        return indexOf(s.toString()) > -1;
    }
265764
private void setString(String s) {
        _string.reset();
        _string.append(s);
        _length = s.length();
    }
840042
public final int offsetIn(String s) {
    for (int offset = 0; offset < s.length(); ) {
      final int codePoint = s.codePointAt(offset);
      if (matches(codePoint)) {
        return offset;
      }
      offset += Character.charCount(codePoint);
    }
    return NO_MATCH_OFFSET;
  }
1364818
private static boolean contentEquals(String s, char[] chars, int start, int length) {
		if (s.length() != length) {
			return false;
		}
		for (int i = 0; i < length; i++) {
			if (chars[start + i] != s.charAt(i)) {
				return false;
			}
		}
		return true;
	}
1046927
protected function encodeStringLitralForNQuads($s)
    {
        $s = str_replace('\\', '\\\\', $s);
        $s = str_replace("\t", '\t', $s);
        $s = str_replace("\n", '\n', $s);
        $s = str_replace("\r", '\r', $s);
        $s = str_replace('"', '\"', $s);

        return $s;
    }
1341971
public static Double parse(final String s) {
        Double parsed = null;
        try {
            if (s != null) {
                parsed = Double.parseDouble(s);
            }
        } catch (final NumberFormatException e) {
        }
        return parsed;
    }
483568
public static String [] parseArray(String s) {
		// a:2:{i:0;s:12:"PHPSUD_OBJ_2";i:1;s:12:"PHPSUD_OBJ_3";}
		String [] t = s.split(":");
		int z = Integer.parseInt(t[1]);
		String [] res = new String[z];
		for(int i = 0; i < z; i ++) {
			 String a = t[5 + 3*i].split(";")[0];
			 res[i] = a.substring(1).substring(0, a.length() - 2);
		}
		return res;
	}
362807
private static String checkForEmptyString(String s) {
        if (s == null) return null;
        if (s.length() == 0) return null;

        return s;
    }
769248
public function bt($s)
    {
        if (is_array($s)) {
            $out = array();
            foreach ($s as $ss) {
                $out[] = $this->bt($ss);
            }
            return $out;
        }

        if (!$this->bt
            || is_object($s)
            || $s === '*'
            || strpos($s, '.') !== false
            || strpos($s, '(') !== false
            || strpos($s, $this->bt) !== false
        ) {
            return $s;
        }

        return $this->bt.$s.$this->bt;
    }
1167445
public static function unescape($s)
    {
        $out = '';
        /** @noinspection ForeachInvariantsInspection */
        for ($count = 0, $n = \strlen($s); $count < $n; $count++) {
            if ($s[$count] !== '\\') {
                $out .= $s[$count];
            } else {
                // A backslash at the end of the string - ignore it
                if ($count === ($n - 1)) {
                    break;
                }

                switch ($s[++$count]) {
                    case ')':
                    case '(':
                    case '\\':
                        $out .= $s[$count];
                        break;

                    case 'f':
                        $out .= "\x0C";
                        break;

                    case 'b':
                        $out .= "\x08";
                        break;

                    case 't':
                        $out .= "\x09";
                        break;

                    case 'r':
                        $out .= "\x0D";
                        break;

                    case 'n':
                        $out .= "\x0A";
                        break;

                    case "\r":
                        if ($count !== $n - 1 && $s[$count + 1] === "\n") {
                            $count++;
                        }
                        break;

                    case "\n":
                        break;

                    default:
                        $actualChar = \ord($s[$count]);
                        // ascii 48 = number 0
                        // ascii 57 = number 9
                        if ($actualChar >= 48 &&
                            $actualChar <= 57) {
                            $oct = '' . $s[$count];

                            /** @noinspection NotOptimalIfConditionsInspection */
                            if ($count + 1 < $n &&
                                \ord($s[$count + 1]) >= 48 &&
                                \ord($s[$count + 1]) <= 57
                            ) {
                                $count++;
                                $oct .= $s[$count];

                                /** @noinspection NotOptimalIfConditionsInspection */
                                if ($count + 1 < $n &&
                                    \ord($s[$count + 1]) >= 48 &&
                                    \ord($s[$count + 1]) <= 57
                                ) {
                                    $oct .= $s[++$count];
                                }
                            }

                            $out .= \chr(\octdec($oct));
                        } else {
                            // If the character is not one of those defined, the backslash is ignored
                            $out .= $s[$count];
                        }
                }
            }
        }
        return $out;
    }
953780
public static boolean isValidImportString(String s) {
        if (s.equals("*"))
            return true;

        boolean valid = true;
        String t = s;
        int index = t.indexOf('*');

        if (index != -1) {
            // '*' must be last character...
            if (index == t.length() -1) {
                // ... any and preceding character must be '.'
                if ( index-1 >= 0 ) {
                    valid = t.charAt(index-1) == '.';
                    // Strip off ".*$" for identifier checks
                    t = t.substring(0, t.length()-2);
                }
            } else
                return false;
        }

        // Verify string is off the form (javaId \.)+ or javaId
        if (valid) {
            String[] javaIds = t.split("\\.", t.length()+2);
            for(String javaId: javaIds)
                valid &= SourceVersion.isIdentifier(javaId);
        }
        return valid;
    }
545363
@Override
  public Boolean decode(final String s) {
    checkNotNull(s);
    if ("true".equals(s)) {
      return Boolean.TRUE;
    } else if ("false".equals(s)) {
      return Boolean.FALSE;
    } else {
      throw new ConversionException(
          String.format("Strictly-converted booleans must be either 'true' or 'false', not %s", s));
    }
  }
521348
@Override
  final public void write(String s)
    throws IOException
  {
    if (s == null) {
      write(_nullChars, 0, _nullChars.length);
      return;
    }
    
    write(s, 0, s.length());
  }
494844
public static boolean eval(String s) {
        if (S.isEmpty(s)) return false;
        if ("false".equalsIgnoreCase(s)) return false;
        if ("no".equalsIgnoreCase(s)) return false;
        return true;
    }
1162196
private static function needsNormalization($s)
    {
        $j = strlen($s) - 1;

        for ($k = 0; $k <= $j; $k++) {
            if (substr($s, $k, 1) !== '/') break;
        }

        $flag = ($k > 1) ? false : true;
        $i = 0;
        while ($k <= $j) {
            $c = substr($s, $k, 1);
            $c2 = substr($s, $k + 1, 1);
            $c3 = substr($s, $k + 2, 1);

            if ($c === '.' && ($k == $j || $c2 === '/' || $c2 === '.' && ($k + 1 == $j || $c3 === '/'))
            ) {
                $flag = false;
            }
            $i++;
            do {
                if ($k > $j) {
                    continue 2;
                }
            } while (substr($s, $k++, 1) !== '/');
            while ($k <= $j && substr($s, $k, 1) === '/') {
                $flag = false;
                $k++;
            }
        }

        return $flag ? false : $i;
    }