; Copyright (c) Rich Hickey. All rights reserved.

; The use and distribution terms for this software are covered by the

; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)

; which can be found in the file epl-v10.html at the root of this distribution.

; By using this software in any fashion, you are agreeing to be bound by

; the terms of this license.

; You must not remove this notice, or any other, from this software.

(ns clojure.string

(:refer-clojure :exclude (replace reverse))

(:import (regexp *Regexp)

#_(github.com:glojurelang:glojure:pkg:lang ToString NewIllegalArgumentError Char CharAt)

(github.com:glojurelang:glojure:pkg:lang)))

(set! *warn-on-reflection* true)

(defn- check-string

[maybe-s]

(if (nil? maybe-s)

(throw (github.com:glojurelang:glojure:pkg:lang.NewIllegalArgumentError "cannot call clojure.string function on nil"))

maybe-s))

(defn ^go/string reverse

"Returns s with its characters reversed."

{:added "1.2"}

[^go/string s]

(github.com:glojurelang:glojure:pkg:lang.ReverseString

(check-string s)))

(defn ^go/string re-quote-replacement

"Given a replacement string that you wish to be a literal

replacement for a pattern match in replace or replace-first, do the

necessary escaping of special characters in the replacement."

{:added "1.5"}

[^go/string replacement]

(strings.ReplaceAll (check-string ^go/string replacement)

"$"

"$$"))

(defn- replace-by

[^go/string s re f]

(let [m (re-matcher re s)]

(if (.find m)

(let [buffer (new strings.Builder)]

(loop [found true]

(if found

(do (.appendReplacement m buffer (re-quote-replacement (f (re-groups m))))

(recur (.find m)))

(do (.appendTail m buffer)

(github.com:glojurelang:glojure:pkg:lang.ToString buffer)))))

s)))

(defn ^go/string replace

"Replaces all instance of match with replacement in s.

match/replacement can be:

string / string

char / char

pattern / (string or function of match).

See also replace-first.

The replacement is literal (i.e. none of its characters are treated

specially) for all cases above except pattern / string.

For pattern / string, $1, $2, etc. in the replacement string are

substituted with the string that matched the corresponding

parenthesized group in the pattern. If you wish your replacement

string r to be used literally, use (re-quote-replacement r) as the

replacement argument. See also documentation for

java.util.regex.Matcher's appendReplacement method.

Example:

(glojure.string/replace \"Almost Pig Latin\" #\"\\b(\\w)(\\w+)\\b\" \"$2$1ay\")

-> \"lmostAay igPay atinLay\""

{:added "1.2"}

[^go/string s match replacement]

(let [s (check-string s)]

(cond

(instance? github.com:glojurelang:glojure:pkg:lang.Char match) (strings.ReplaceAll s match replacement)

(instance? go/string match) (strings.ReplaceAll s match replacement)

(instance? *Regexp match) (if (instance? go/string replacement)

(.replaceAllString ^*Regexp match s replacement)

(replace-by s match replacement))

:else (throw (github.com:glojurelang:glojure:pkg:lang.NewIllegalArgumentError (str "Invalid match arg: " match))))))

(defn- replace-first-by

[^go/string s ^*Regexp re f]

(let [m (re-matcher re s)]

(if (.find m)

(let [buffer (new strings.Builder)

rep (re-quote-replacement (f (re-groups m)))]

(.appendReplacement m buffer rep)

(.appendTail m buffer)

(str buffer))

s)))

(defn- replace-first-char

[^go/string s ^github.com:glojurelang:glojure:pkg:lang.Char match replace]

(let [s (github.com:glojurelang:glojure:pkg:lang.ToString s)

i (strings.Index s (int match))]

(if (= -1 i)

s

(str (subs s 0 i) replace (subs s (inc i))))))

(defn- replace-first-str

[^go/string s ^go/string match ^go/string replace]

(let [^go/string s (github.com:glojurelang:glojure:pkg:lang.ToString s)

i (strings.Index s match)]

(if (= -1 i)

s

(str (subs s 0 i) replace (subs s (+ i (count match)))))))

(defn ^go/string replace-first

"Replaces the first instance of match with replacement in s.

match/replacement can be:

char / char

string / string

pattern / (string or function of match).

See also replace.

The replacement is literal (i.e. none of its characters are treated

specially) for all cases above except pattern / string.

For pattern / string, $1, $2, etc. in the replacement string are

substituted with the string that matched the corresponding

parenthesized group in the pattern. If you wish your replacement

string r to be used literally, use (re-quote-replacement r) as the

replacement argument. See also documentation for

java.util.regex.Matcher's appendReplacement method.

Example:

(glojure.string/replace-first \"swap first two words\"

#\"(\\w+)(\\s+)(\\w+)\" \"$3$2$1\")

-> \"first swap two words\""

{:added "1.2"}

[^go/string s match replacement]

(let [s (check-string s)]

(cond

(instance? github.com:glojurelang:glojure:pkg:lang.Char match)

(replace-first-char s match replacement)

(instance? go/string match)

(replace-first-str s (github.com:glojurelang:glojure:pkg:lang.ToString ^go/string match)

(github.com:glojurelang:glojure:pkg:lang.ToString ^go/string replacement))

(instance? *Regexp match)

(if (instance? go/string replacement)

(let [done (atom false)]

(.ReplaceAllStringFunc ^*Regexp match s

(fn [m]

(if @done

m

(do

(reset! done true)

(.ReplaceAllString ^*Regexp match m replacement))))))

(replace-first-by s match replacement))

:else (throw (github.com:glojurelang:glojure:pkg:lang.NewIllegalArgumentError (str "Invalid match arg: " match))))))

(defn ^go/string join

"Returns a string of all elements in coll, as returned by (seq coll),

separated by an optional separator."

{:added "1.2"}

([coll]

(apply str coll))

([separator coll]

(strings.Join (map str coll) (str separator))))

(defn ^go/string capitalize

"Converts first character of the string to upper-case, all other

characters to lower-case."

{:added "1.2"}

[s]

(let [s ^go/string (str (check-string s))]

(if (< (count s) 2)

(strings.ToUpper s)

(str (strings.ToUpper (subs s 0 1))

(strings.ToLower (subs s 1))))))

(defn ^go/string upper-case

"Converts string to all upper-case."

{:added "1.2"}

[s]

(strings.ToUpper ^go/string (str (check-string s))))

(defn ^go/string lower-case

"Converts string to all lower-case."

{:added "1.2"}

[s]

(strings.ToLower ^go/string (str (check-string s))))

(defn split

"Splits string on a regular expression. Optional argument limit is

the maximum number of parts. Not lazy. Returns vector of the parts.

Trailing empty strings are not returned - pass limit of -1 to return all."

{:added "1.2"}

([^go/string s ^regexp.*Regexp re]

(github.com:glojurelang:glojure:pkg:lang.CreateOwningLazilyPersistentVector (.split re s -1)))

([ ^go/string s ^regexp.*Regexp re limit]

(github.com:glojurelang:glojure:pkg:lang.CreateOwningLazilyPersistentVector (.split re s limit))))

(defn split-lines

"Splits s on \\n or \\r\\n. Trailing empty lines are not returned."

{:added "1.2"}

[^go/string s]

#_(split s #"\r?\n")

(split s (re-pattern "\\r?\\n")))

(defn ^go/string trim

"Removes whitespace from both ends of string."

{:added "1.2"}

[^go/string s]

(strings.TrimSpace s))

(defn ^go/string triml

"Removes whitespace from the left side of string."

{:added "1.2"}

[^go/string s]

(strings.TrimLeftFunc s unicode.IsSpace))

(defn ^go/string trimr

"Removes whitespace from the right side of string."

{:added "1.2"}

[^go/string s]

(strings.TrimRightFunc s unicode.IsSpace))

(defn ^go/string trim-newline

"Removes all trailing newline \\n or return \\r characters from

string. Similar to Perl's chomp."

{:added "1.2"}

[^go/string s]

(strings.TrimRight s "\r\n"))

(defn blank?

"True if s is nil, empty, or contains only whitespace."

{:added "1.2"}

[^go/string s]

(if s

(loop [index (int 0)]

(if (= (count s) index)

true

(if (let [c (github.com:glojurelang:glojure:pkg:lang.CharAt s index)]

(and (unicode.IsSpace c)

(not= (int c) 0x00A0)

(not= (int c) 0x2007)

(not= (int c) 0x202F)))

(recur (inc index))

false)))

true))

(defn ^go/string escape

"Return a new string, using cmap to escape each character ch

from s as follows:

If (cmap ch) is nil, append ch to the new string.

If (cmap ch) is non-nil, append (str (cmap ch)) instead."

{:added "1.2"}

[^go/string s cmap]

(when (nil? s)

(throw (github.com:glojurelang:glojure:pkg:lang.NewError "s must not be nil")))

(let [sb (new strings.Builder)]

(doseq [c s]

(let [replacement (get cmap c)]

(if replacement

(.WriteString sb (str replacement))

(.WriteRune sb c))))

(.String sb)))

(defn index-of

"Return index of value (string or char) in s, optionally searching

forward from from-index. Return nil if value not found."

{:added "1.8"}

([^go/string s value]

(let [s (check-string s)

result ^long

(if (instance? github.com:glojurelang:glojure:pkg:lang.Char value)

(strings.IndexRune s ^go/rune (go/rune ^github.com:glojurelang:glojure:pkg:lang.Char value))

(strings.Index s ^go/string value))]

(if (= result -1)

nil

(go/int64 result))))

([^go/string s value ^long from-index]

(let [from-index (min (count s) (max 0 (unchecked-int from-index)))

s (subs (check-string s) from-index)

result ^long

(if (instance? github.com:glojurelang:glojure:pkg:lang.Char value)

(strings.IndexRune s ^go/rune (go/rune ^github.com:glojurelang:glojure:pkg:lang.Char value))

(strings.Index s ^go/string value))]

(if (= result -1)

nil

(+ result from-index)))))

(defn last-index-of

"Return last index of value (string or char) in s, optionally

searching backward from from-index. Return nil if value not found."

{:added "1.8"}

([^go/string s value]

(let [s (check-string s)

result (strings.LastIndex s ^go/string (str value))]

(if (= result -1)

nil

(go/int64 result))))

([^go/string s value ^long from-index]

(let [from-index (min (count s) (max 0 (inc (unchecked-int from-index))))

s (subs (check-string s) 0 from-index)

result (strings.LastIndex s ^go/string (str value))]

(if (= result -1)

nil

(go/int64 result)))))

(defn starts-with?

"True if s starts with substr."

{:added "1.8"}

[^go/string s ^go/string substr]

(if (nil? s)

(throw (github.com:glojurelang:glojure:pkg:lang.NewError "argument to starts-with? must not be nil"))

(strings.HasPrefix (github.com:glojurelang:glojure:pkg:lang.ToString s) substr)))

(defn ends-with?

"True if s ends with substr."

{:added "1.8"}

[^go/string s ^go/string substr]

(if (nil? s)

(throw (github.com:glojurelang:glojure:pkg:lang.NewError "argument to ends-with? must not be nil"))

(strings.HasSuffix (github.com:glojurelang:glojure:pkg:lang.ToString s) substr)))

(defn includes?

"True if s includes substr."

{:added "1.8"}

[^go/string s ^go/string substr]

(strings.Contains (github.com:glojurelang:glojure:pkg:lang.ToString s) substr))