otsu.hiNote

クラス hiRegex

java.lang.Object

otsu.hiNote.hiRegex

public class hiRegex
extends Object

正規表現.

範囲解釈,グループ置き換えを強化した正規表現メソッド群を用意しました。

次の例では「関数名('a'...)」というパターンを「関数名_a(...)」に置き換えています。

import otsu.hiNote.*;
public class Test{
   public static void main(String[] args_){
      try{
         String _original="abc('a');def('b',2);int n=xyz('a',2,\"a\");if(ff('a',c)){...}";
         String _result
         =hiRegex.with("(\\w+)\\s\*\('a',?([^)]*)\\)" // 正規表現パターン
                      ,"${1}_a(${2})")                // 置き換えパターン
                 .replace(_original)                  // 置き換え対象文字列
                 .result();                           // 結果を得る
         System.out.println("result="+_result);
         }
      catch(Exception _ex){
         _ex.printStackTrace(System.err);
         System.exit(1);
         }
      }
   }
＊＊＊結果
result=abc_a();def('b',2);int n=xyz_a(2,"a");if(ff_a(c)){...}

• 正規表現に関する基本説明
• 構造化正規表現
• 基本手続き(一関数完結とカスケード式）
• Javaで用意されているメソッドとの比較
• API

本クラスは置き換えを中心に置くものです。
単純にパターンを調べる場合はJavaのPattern,Matcherクラスを使います。

 正規表現に関する基本説明

特殊文字	説明
制御文字以外の単純文字列	制御文字以外の文字の並びは単純にその文字列とのマッチング検証となります。 hiRegex.replaceAll("abbx12-xy\n aBbX12xy-","12","###"); --> abbx###-xy <-- 12が###に置き換わった aBbX###xy- <-- 12が###に置き換わった 次の文字は制御文字であるため、\(バックスラッシュまたは円マーク)でエスケープする必要があります。 \ * + . ? { } ( ) [ ^ $ | 次の文字は[]内に書くときエスケープする必要があります。 \ ^ ] - 次の文字は前置式後置式に出てきますが"(?<="といった特別の並び内だけでありエスケープの必要はありません。 = ! <
.（ドット）	改行以外の任意の一文字
^	領域の先頭を表します。
$	領域の最後を表します。
[文字集合]	[]内のどれか一文字（制御文字を含む） hiRegex.replaceAll("abbx12-xy\n aBbX12xy-","[aAx ]","#"); --> #bb#12-#y <-- aAxがそれぞれ#に置き換わった ##BbX12##Y <-- 空白も#に置き換わった
\に続く一文字(\wなど)	\に続き特定のキー文字を書くと、いくつかの文字集合を表す、文字クラスとなります。 次のものです。 表記 意味 対応する文字集合記述 補足 \d 数字 [0-9] \D 数字以外 [^0-9] \s 空白文字 [ \t\r\n] 改行も含むことに注意が必要です。 \S 空白文字以外 [^ \t\r\n] 改行も排他されることに注意が必要です。 \w 単語に使われる文字 記号以外 \W 記号 記号以外 \\u 英大文字 [A-Z] \U 英大文字以外 [^A-Z] \l 英大文字 [a-z] \L 英子文字以外 [^a-z] \e ESCコードU001B 
\\u hhhh h は0～Fの16進数	unicode4バイトを直接記述します
*	一つ前の文字の0個以上の繰り返し。（最長一致） 前後のパターンも含めた最長一致となります。例えば、次の例ではbbxがマッチしますが、それより長いbbx123xもマッチしますのでbbx123xが採用されます。 hiRegex.replaceAll("abbx12-xy\n aBbX12xy-","b.*x","###"); --> a###y <-- bbx123xが置き換わった。(bxもマッチするが短い） AB###Y ================= hiRegex.replaceAll("abbx12-xy\n aBbX12xy-","12x*","###"); abbx###-xy <-- 12の後xは0個であるがマッチし12が置き換わった aBbX###y- <-- 12の後Axが1個でマッチし12xが置き換わった ================= (参考；よく知られたjava-Stringの問題点) "abbx12-xy\n aBbX12xy-".replaceAll(".*","###"); --> ###### <-- abbx12-xyがマッチした後、長さ0のマッチがあり、その後に改行 ######
*?	一つ前の文字の0個以上の繰り返し。（後方最短一致） 前後のパターンも含めた最長一致となります。例えば、次の例ではbbxもbxもマッチしますが、開始位置をずらしての最短を採ることはなくbbxが採用されます。 .は改行を含まないので次の行にあるaBbX12xy-のxは対象外です。 hiRegex.replaceAll("abbx12-xy\n aBbX12xy-","b.*x","###"); --> a###12-xy <-- bbxが置き換わった。(bxもマッチするが開始位置をずらしての検証はない） AB###Y
+	一つ前の文字の+個以上の繰り返し。
?	直前の文字は省略可能
{数}	直前の文字の指定個の繰り返し
前置式、後置式 (?<=...)：肯定前置 (?<!...)：否定前置 (?=...)：肯定後置 (?!...)：否定後置	当該パターンの前後にあるべきパターン、またはあってはならないパターンを指定します。 前置、後置パターン自体は当該パターンに含まれないものとなります。 例えば次の例の「単語」では前後に単語を構成する以外の文字が必要ですが、それらは「単語」には含まれません。 (?<!\w)\w+(?!\w) : 単語（前後を単語以外の文字で囲まれている。 前置後置はパターン全体から見て内部に置くこともできます。 例えば次の例のhtmlタグでは(a|br....)の後ろに単語以外の文字が後置され、さらにその後ろにパターンが続きます。 </?(a|br|div|p|pre)(?=\W)[^>\n]*> ：　htmlのタグ(この例では一部載せてある,実際にはtable他あり）

 構造化正規表現

hiRegexは単純な正規表現だけではなく、hiPropertyを用い構造化された正規表現を取り扱います。
構造化正規表現は次の特徴を持ちます。

• 複数の変換をシーケンスまたは階層として定義できる
• 対象空間を指定できる
• and条件を付加できる

例えば、開始パターンと終了パターンを示しその中だけでマッチングを行うといったことができます。
またマッチングした部分を単純に置き換えるのではなく、ラムダ関数に引き渡したり、あるいはファイルを読んで置き換えたりもできます。

～目次～

１.	基本構造
１.１	１．１ 定義行の形式と制限
２.	正規表現部
２.１	正規表現補助指定
２.２	正規表現に追加するand論理
２.２.１	and_not
２.２.２	スコープ
２.２.３	スコープの配列
２.２.４	スコープ内の再スキャン
２.２.５	and_or
２.２.６	and
２.３	リテラル
３.	置き換え文字列部
３.１	グループ参照置き換え
３.１.１	グループ参照フォーマット指定
３.２	操作
３.２.１	replace:マッチ部を置き換える
３.２.３	file:マッチ部をファイル内容で置き換える
３.２.４	call:ラムダ関数を呼び出し、その戻り値でマッチ部を置き換える
３.２.５	replace_literal:単純文字列でマッチ部を置き換える
３.３	output:出力する
４.	in-out部
４.１	正規表現で範囲を表す
４.１.１	in
４.１.２	out
４.１.３	条件を重ねる
４.１.４	nest
５.	Param
５.１	階層
５.２	シーケンス
６.	defによる定義と参照
６.１	グループ参照文字列の置き換え
６.２	refによる参照(未実装)<

１．基本構造

次の構造を持ちます。

  ・置き換えパターン指定部
    ・正規表現部        regex  =...
    ・置き換え文字列部  replace=...
  ・in/out範囲指定      in=... , out= ...
  ・下位構造指定        param={...}
  ※「置き換えパターン指定部」と「in/out範囲指定指定」は共存できない
  ※「in/out範囲指定指定」が有る場合は「下位構造指定」が必須

単純に特定のパターンを置き換えるにはregexに正規表現,replaceに置き換えを書きます。

regex  = (kochi|osaka|sapporo)   // "kochi","osaka"または"sapporo"にマッチ
replace= <${0}>                 // ${0}はマッチした文字列全体
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
-->
nagoya,<kochi>,tokyo,OSAKA,miyagi,<sapporo>

replaceの代わりにoutputを使うとマッチした部分のみの文字列が得られます。

regex  = (kochi|osaka|sapporo)  // "kochi","osaka"または"sapporo"にマッチ
output = <${0}>                // ${0}はマッチした文字列全体
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
-->
<kochi><sapporo>

文字列変更に影響を与えずファイル出力を行うprintも用意されています。
デフォルトの出力先は標準エラーです。

regex  = (kochi|osaka|sapporo|tokyo) // "kochi","osaka","sapporo"または"tokyo"にマッチ
output = <${0}>                // ${0}はマッチした文字列全体
print  = "matched:${0}\n"                // ${0}はマッチした文字列全体
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
--> 得られる結果
<kochi><tokyo><sapporo>
--> 標準エラー
matched:kochi
matched:tokyo
matched:sapporo

出力先の変更はwithPrinter(PrintWriter)で行います。

１．１ 定義行の形式と制限

定義行の基本形式はhiPropertyに則っています。

\も直接書けますので、正規表現をほぼそのままの形で記述出来ます。

制限は次の２つです。

• パターンの先頭に引用符が来る場合は引用形式と見做される。
  回避法: =の代わりに$=を使う

     regex  = ".*  // 引用符から改行まで
     ->
     regex $= ".*  // 引用符から改行まで
  

• コメントパターン/*...*/および//から行単まではコメントとして無視される
  回避法: 空マクロで２文字を分断する。正規表現部であれば/を[]で囲み[/]とすることも可能

     /* //から行端まで */
     regex = //.*
     ->
     ${N}=""
     regex = /${N}/.*
     または
     regex = [/]/.*
  

空パターンとする場合は引用形式で空文字を表す""を用います

   /* //から行端までを削除 */
   regex   = [/]/.*
   replace = ""

２．正規表現部

２.１　正規表現補助指定

regexは構造表現を採ることにより、細かな指定を付加することができます。

regex  = {
   regex= (kochi|osaka|sapporo|tokyo) // "kochi","osaka","sapporo"または"tokyo"にマッチ
   ignore_case                  // 大文字/小文字を無視する指定
   }
replace= <${0}>                 // ${0}はマッチした文字列全体
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
-->　OSAKAもマッチする
nagoya,<kochi>,tokyo,<OSAKA>,miyagi,<sapporo>

指定できるのは次のものです。

	ignore_case	:	大文字小文字を無視する
	as_literal	:	単純文字列と見做す。ただしignore_case指定は有効
	single_region	:	'$','^'を行の先端,末端ではなく全体の先端,末端とする
	only_first	:	最初の一度しかマッチさせない
	verbose	:	長さ0でマッチする場合、String.replaceAll(String,String)のバグ仕様に合わせる
	as_group	:	上位段でのマッチング結果を参照しダイナミックに正規表現を与える (in/outのend指定ではinのマッチング結果が参照される）

２.２　正規表現に追加するand論理

正規表現では難しいand論理を付加することができます。

• and_not
• and_or
• and

正規表現にマッチした後、さらに検証を加え最終的にマッチ判断を行うことができます。

regex  = \w+
and_not= (kochi|osaka|sapporo) // kochi osaka sapporo を除く
output = <${0}>                 
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
--> kochiとsapporoが除かれ
<nagoya><tokyo><OSAKA><miyagi>

２.２.１　and_not

and_notは配列表記[..]を使い、チェック用の正規表現を重ねることができます。

regex  = \w+
and_not= [
   {
      regex=(kochi|aomori)
      }
   {
      regex=(osaka|s.*)
      ignore_case            // osakaとsで始まる名前は大文字小文字を無視
      }
   ]
output  = <${0}>                 
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
--> kochi,OSAKA,sapporoが除かれ
<nagoya><tokyo><miyagi>

なお、[]内には異なる形式のデータは置けませんので次のような記述はできません。

// 不可!
regex  = \w+
and_not= [
   (kochi|aomori)           // (文字列)
   {                        // (構造)   データ形式が異なるので不可
      regex=(osaka|s.*)
      ignore_case          
      }
   ]
output  = <${0}> 
-->
otsu.hiNote.hiProperty$TypeConflictionException: 
              "and_not"  at "prop4.txt" line 52 element type conflict 
// 可
regex  = \w+
and_not= [
   (kochi|aomori)
   (osaka|s.*)
   ]
---
nagoya,kochi,tokyo,OSAKA,miyagi,sapporo
-->
<nagoya><tokyo><OSAKA><miyagi>

２.２.２　スコープ

基本の正規表現でマッチした一部分を取り出し判断することもできます。部分はscope=にグループ参照${..}で指定します。

まずand_notを使わない例を示します。この例は文字列の後ろに(...){がつながる関数定義形式とマッチするものです。

// 単語文字以外が前置、長さ１以上の単語文字、長さ0以上の空白、
//                 開始括弧、長さ0以上の閉じ括弧以外の文字、閉じ括弧、ブレイスが後置
regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
output="func:${1}(${2})\n"
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1;char c=0;a1<10;a1++){}
while(x){...}
String[]
cc(String x){...}
-->
func:aa()
func:bb(int a1;char c)
func:for((int a1;char c=0;a1<10;a1++)
func:while(x)
func:cc(String x,char c)

関数だけでなくfor()やwhile()もマッチしていることが分かります。
次の例では関数名に当たる部分scope-${1}をスコープとして指定し、for,if,whileである場合をnot条件にしています.

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
and_not= {
   scope=${1} 
   regex=(if|while|for)
   }
output="func:${1}(${2})\n"
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1;char c=0;a1<10;a1++){}
while(x){...}
String[]
cc(String x,char c){...}
-->
func:aa()
func:bb(int a1;char c)
func:cc(String x,char c)

２.２.３　スコープの配列

括弧を使いscopeを配列にし複数条件を与えることができます。

次の例ではscope-${1}(関数名相当部)のチェックに加えscope${2}がSで始まる場合をnot条件にしています。

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
and_not= [
   {
      scope=${1}
      regex=(if|while|for)
      }
   {
      scope=${2}
      regex=S.*
      }
   ]
output="func:${1}(${2})\n"
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1;char c=0;a1<10;a1++){}
while(x){...}
String[]
cc(String x,char c){...}
-->
func:aa()
func:bb(int a1;char c)

２.２.４　スコープ内の再スキャン

スコープ内を再スキャンすることができます。scopeに再スキャンのための正規表現をregex=で追加します。

次の例ではscope ${2}をさらに再スキャンし、その要素の検証を行っています。

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
and_not={
   scope={
      scope=${2}
      regex=\w+  // この正規表現で${2}を再スキャンする
      }
   regex=(int|char)
   }
output="func:${1}(${2})\n" 
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1=0;a1<10;a1++){}
while(x){...}
cc(String x,char c){...}
-->
func:aa()
func:while(x)

２.２.５　and_or

and_orを付加すれば、条件が一つでもマッチすれば採用、どれもマッチしなければ不採用となります。
and_notと異なりregex単独で表すこともできますが、別にすることにより分かりやすくなります。

次の例ではscope ${2}をさらに再スキャンし、その要素の検証を行っています。

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
and_not={
   scope={
      scope=${2}
      regex=\w+ // この正規表現で${2}を再スキャンする
      }
   regex=(int|char)
   }
output="func:${1}(${2})\n" 
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1=0;a1<10;a1++){}
while(x){...}
cc(String x,char c){...}
-->
func:bb(int a1,char c)
func:for(int a1=0;a1<10;a1++)
func:cc(String x,char c)

２.２.６　and

andを付加すれば全条件がマッチした場合のみ採用となります。条件は再スキャンを用い[]を使って配列として記述します。

次の例では関数引数相当部scope-${2}を再スキャンしintとcharが有る場合のみ採用しています。
配列要素内でscopeを省略すると前の要素のscopeが使われます。

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
and= [
  {
     scope={
        scope=${2}
        regex=\w+ // この正規表現で${2}を再スキャンする
        }
     regex=int
     }
  {  // 再スキャンを省略すると前のスキャン定義が有効となる
     regex=char
     }
  ]
output="func:${1}(${2})\n" 
---
int aa(){...}
int bb(int a1;char c){...}
for(int a1=0;a1<10;a1++){}
while(x){...}
cc(String x,char c){...}
-->
func:bb(int a1,char c)

２.３　リテラル

regexの代わりにliteralを使えば単純文字列のマッチングがなされます。

ignore_case等の指定も、and理論の付加もできません。

３.　置き換え文字列部

置き換え文字列部では次の選択ができます。これらは同階層では共存できません。

replace	:	マッチ部を置き換える。 グループ参照可能
file	:	マッチ部をファイル内容で置き換える。 グループ参照可能
call	:	ラムダ関数を呼び出し、その戻り値でマッチ部を置き換える グループ参照可能
replace_literal	:	単純文字列でマッチ部を置き換える

この他置き換えを行わない特殊なメソッドoutputが用意されています。
このメソッドは他のメソッドと同階層で共存できます。同階層の他のメソッドの変更の影響を受けません。Paramを使って変更結果を受ける階層を置けば変更結果のoutputが可能です。

output

:

出力する。 グループ参照可能 このメソッドは他のメソッドと異なり置き換えを行いません。途中でのデータ抜き出しです。

３.１　グループ参照置き換え

正規表現でマッチした文字列のグループ部（括弧で囲まれた部分）を数値または名前で参照できます。
正規表現のグループの他にソース名、行番号、マッチ回数などを参照する特殊な記述も用意されています。

${数字}	正規表現のn番目のグループマッチング値を参照する。 regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{) output="func:${1}(${2})\n" --- int bb(int a1;char c){...} --> func:bb(int a1;char c)
${名前}	正規表現のグループマッチング値を名前で参照する。 regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{) output="func:${FUNC}(${ARG})\n" --- int bb(int a1;char c){...} --> func:bb(int a1;char c)
${_LINE_}	ソースの行番号を得る ただし、replace結果で行数が変わる場合、値は保証されない regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{) output="line-${_LINE_}:${FUNC}(${ARG})\n" --- ... int bb(int a1,char c){...} ... --> (この例では13行目に記述がある) line-13:bb(int a1,char c)
${_SOURCE_}	ソース名を得る read(String)で指定された名前あるいはwith_source_name(String)で指定された名前が得られます。 regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{) output="${_SOURCE_}(${_LINE_}) ${FUNC}(${ARG})\n" --- ... int bb(int a1,char c){...} ... --> (この例ではファイルはin5.txt、18行目に記述がある) in5.txt(18) bb(int a1,char c)
${_SOURCE_LINE_}	ソース名を得る read(String)で指定された名前あるいはwith_source_name(String)で指定された名前と行番号が得られます。 ただし、replace結果で行数が変わる場合、値は保証されません regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{) output="${_SOURCE_LINE_} ${FUNC}(${ARG})\n" --- ... int bb(int a1,char c){...} ... --> (この例ではファイルはin5.txt、18行目に記述がある) in5.txt:23 bb(int a1,char c)
${_NTH_}	マッチ番号。その正規表現の何回目なのかが得られます。 regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{) and_not= { scope=${1} regex=(if|while|for) } output="${_NTH_} ${FUNC}(${ARG})\n" --- int aa(){...} int bb(int a1,char c){...} for(int a1=0;a1<10;a1++){} while(x){...} String[] cc(String x,char c){...} --> マッチしたものがカウントされている 1 aa() 2 bb(int a1,char c) 3 cc(String x,char c)
${_DLMT_}	_NTH_==1の場合空文字となり、それ以外デリミタ（デフォルトはカンマ）となります。 _DLMT_の後ろにコロンに続いて一文字を入れればそれをデリミタとして採用します。 regex =(kochi|osaka|sapporo|tokyo) output=${_DLMT_:#}${0} --- nagoya,kochi,tokyo,OSAKA,miyagi,sapporo --> kochi#tokyo#sapporo

３.１.１　グループ参照フォーマット指定

${}の中を:で区切り、後ろにデータの解釈と、表示フォーマットを指定することができます。

   ${参照:型%フォーマット}
          型 i:int
             L:long
             d:double
             s:String
   例>
      ${_LINE_:i%04d}

参照はグループ参照他_LINE_などの特別参照も可能です。
値は型解釈がなされフォーマット変換されます。
フォーマットはJavaの標準のフォーマットです。

次の例ではマッチ番号${_NTH_}を%04d変換しています。

regex=(?<=\W)(?<FUNC>\w+)\s*\((?<ARG>[^)]*)\)(?=\{)
and_not= {
   scope=${1}
   regex=(if|while|for)
   }
output="${_NTH_:i%04d} ${FUNC}(${ARG})\n"
---
int aa(){...}
int bb(int a1,char c){...}
for(int a1=0;a1<10;a1++){}
while(x){...}
String[]
cc(String x,char c){...}
--->
0001 aa()
0002 bb(int a1,char c)
0003 cc(String x,char c)

次の例では正規表現のグループ参照値をフォーマット変換しています。

regex=(test)([0-9]+)(\.txt)
output="mv ${0} ${1}${2:i%03d}${3}\n"
---
test1.txt test03.txt abc.txt test42.txt test115.txt
--->
mv test1.txt test001.txt
mv test03.txt test003.txt
mv test42.txt test042.txt
mv test115.txt test115.txt

３.２　置き換え操作

正規表現部で得られた情報を元に、結果文字列を作る操作が複数用意されています。

３.２.１　replace:マッチ部を置き換える

マッチした部分をグループ参照し、文字列を置き換えます。

３.２.２　file:マッチ部をファイル内容で置き換える

マッチした部分をグループ参照し、ファイル名と解釈し、ファイル内容で置き換えます。

ファイルの指定法は次の方法が取れます。

    単純ファイル名                        EX) text.txt
    リソースファイル名  res:が付く        EX) res:text.txt
    URL                 res:以外で:が付く EX) http://www.example.com/docs/resource1.html

例を示します。

   --- パターン
   regex=regex=INCLUDE:([\w\./]+)
   file =res:${1}
   --- 入力
   ...
   INCUDE:test.txt
   ...
   ---> 変換
   ...
   (リソース上のtest.txtの中身)
   ...

３.２.３　call:ラムダ関数を呼び出し、その戻り値でマッチ部を置き換える

ラムダ関数設定メソッド
・withFunction(strFunc)
・withFunction(matFunc)
・withFunction(paramFunc)
で設定された関数を呼び出します。

関数の引数は

1. callで与える文字列
2. マッチしたMatcher
3. hiRegex.Parameter情報

となっており、第一引数のみ、第二引数まで、第三引数まで受け取る３種の関数を使用できます。

callで指定するのは第一引数の文字列です。グループ参照ができます。

次の例は正規表現で「int,charを引数に持たない関数」を取得し、ラムダ関数で関数名(${1})を辞書変換しています。

regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
   and_not={
      scope={
         scope=${2}
         regex=\w+  // この正規表現で${2}を再スキャンする
         }
      regex=(int|char)
      }
call=${0} // 第一引数はマッチ領域全体、第二引数がMatcher
--- Test.java
HashMap<String,String> _dict=new HashMap<>();
_dict.put("aa","aFunc");
_dict.put("bb","bFunc");
String _result=hiRegex
              .with("prop5.txt")
              .withFunction((_s_,_m_)->{
                 if(_dict.containsKey(_m_.group(1))){
                    return _dict.get(_m_.group(1))+"("+_m_.group(2)+")";
                    }
                 return _s_;// 登録されていないものはそのまま返す。
                 })
             .read("testData5.txt").result();
--- testData5.txt
int aa(){...}
int aa(int x){...}
int bb(int a1;char c){...}
int bb(String s){...}
ibt cc(){...}
---> 引数にint,charを持たないaa,bbがそれぞれaFunc,bFuncに変わった
int aFunc(){...}
int aa(int x){...}         <-- マッチしない
int bb(int a1;char c){...} <-- マッチしない
int bFunc(String s){...}
ibt cc(){...}              <-- マッチしたが辞書にない

３.２.４　replace_literal:単純文字列でマッチ部を置き換える

replace_literalを使えば、単純文字列を置き換えに使えます。${1}と言った文字列もそのまま使われます。

３.３　output:出力する

マッチした部分をグループ参照し、出力に追加します。

３.４　print:印字する。変更は加わらない

マッチした部分をグループ参照し、ファイルに書き出します。最終文字出力には影響を与えません。
デフォルトは標準エラーです。withPrinter(PrintWriter)で変更できます。

４．　in-out部

in/out指定で、解析範囲を限定することができます。

in/outは範囲を限定するだけです。範囲内を解析する記述をparamブロックで定義します。

   in=...　範囲定義
   param ={
     ... 範囲内の解析定義
     }

４.１ 正規表現で範囲を表す

４.１.１ in

inで正規表現指定された部分のみが対象となります。

次の例では<X>～</X>の範囲にある=を<=に変換しています。<X>～</X>以外は適用範囲外となります。

in=<X>[\S\s]*?</X>
param={
   regex="="
   replace="<="
   }
---
a=b
<X>
c=d
</X>
e=f
--->
a=b
<X>
c<=d
</X>
e=f

この例では<X>も</X>も範囲内ですが、前置、後置記述を用いて<X>,</X>は含まないようにもできます。

   in=(?<=<X>)[\S\s]*?(?=</X>)

４.１.２　out

outで正規表現で指定された部分以外が対象となります。

次の例では<X>～</X>の外にある=を<=に変換しています。<X>～</X>は適用範囲外となります。

out=<X>[\S\s]*?</X>
param={
   regex="="
   replace="<="
   }
---
a=b
<X>
c=d
</X>
e=f
--->
a<=b
<X>
c=d
</X>
e<=f

４.１.３　条件を重ねる

in/outでは[]を用いた配列で条件を重ねることができます。
条件を重ねた場合先にマッチしたものが有効となります。

次の例では//による行コメントと/*によるブロックコメントが互いにコメントアウトしています。

out=[
   /\*[\S\s]*?\*/ // ブロックコメント
   "//.*"   // 行コメント 引用符は//がこの記述法でのコメントと衝突しているため
   ]
param={
   regex="="
   replace="<="
   }
---
a=b       <-- コメント外
// /*     <-- 行コメント//が先なので/*は無効
c=d       <-- コメント外
/*        <-- /*でブロックコメント開始
e=f       <-- コメント内
// */     <-- ブロックコメント内//は無効、ここでブロックコメントは終わり
g=h       <-- コメント外
*/ <-- ブロックコメントの終了（無視）
i=j        <-- コメント外
--->
a<=b
// /*
c<=d
/*
e=f
// */
g<=h
*/
i<=j

４.１.４　nest

開始パターンと終了パターンは必ずしも１対１に対応するとは限りません。

例えばJava/C++の関数の終了パターンは"}"ですが、途中にある{...}ブロックのため、"}"だけでは関数の開始に対応させることはできません。

nestを使えば"{"がパターンネストを表すものとして"}"との対応を取ることが出来ます。

次の例では関数func_aとfunc_bの先頭にtry-with-resourceブロックの開始部を付加し、最後にブロックの終了部を付加しています。

in={
   start_after=(?<=\W)(func_a|func_b)+\s*\([^)]*\)\{
   end_before=}
   nest=\{
   }
param={
   regex=[\s\S]*
   replace=try(hiTry.T t=hiTry.T.t(true);){${0}}
   }
---
public class Test08 {
   static void func_a(){
      //
      }
   String func_b(){
      if(xx){
         //...
         func_a();
         while(xx){
            //...
            }
         }
      else {
         }
      }
   int func_c(){
      //
     }
-->
public class Test08 {
   static void func_a(){try(hiTry.T t=hiTry.T.t(true);){
      //
      }}
   String func_b(){try(hiTry.T t=hiTry.T.t(true);){
      if(xx){
         //...
         func_a();
         while(xx){
            //...
            }
         }
      else {
         }
      }}
   int func_c(){
      //
      }
   }

５．　paramによる構造

param定義を使って構造化することができます。

param={...}内に基本構造を書くことができます。
構造は階層化できます。
param=[...]で配列として記述することもできます。

５.１　階層

in-outは範囲を定めるだけで、その解釈は下の階層Paramで行います。
値置き換え操作もそれを受けて解釈する階層を置くことができます。

regex=INCLUDE:([\w\./]+)
file =${1}
param={ // fileで読み込んだ内容に処理を施す
   regex=(?<=\W)(\w+)\s*\(([^)]*)\)(?=\{)
   and_not= {
      scope=${1} 
      regex=(if|while|for)
      }
   output="func:${1}(${2})\n"
   }
--- 記述
INCLUDE:Test07.java
--- Test07.java (このファイルを読み込んで展開する )
public class Test07 {
   static void aa(){}
   int
   // 戻り値と関数の間にコメント
   public bb(int x){return x;}
   void /* 戻り値と関数の間にコメント *{@literl}/ cc(String str,char c){
      for(int i=0;i<str.length();++i){}
      }
---> 
func:aa()
func:bb(int x)
func:cc(String str,char c)

５.２　シーケンス

Paramは[]による配列記述でシーケンス化できます。

シーケンスは変更を次々と重ねていく形になります。

次の例では一旦コメント文字列を削除したうえで、細かく解析しています。
細かい解析部では関数名の前に戻り値の型があるものとしています。 この２つの間にコメントが入るとマッチしなくなりますので、解析前にコメントを削除しています。

param=[
   { // コメント部を消す
      in=[
         /\*[\S\s]*?\*/
         "//.*"
         ]
      param={
         regex  =.*
         replace=""
         }
      }
   {
      regex =((\w+\s+)+)(\w+)\s*\(
      output="${_SOURCE_LINE_} ${3}()\n"
      }
   ]
---
public class Test07 {
   static void aa(){}
   int
   // 戻り値と関数の間にコメント
   public bb(int x){return x;}
   void /* 戻り値と関数の間にコメント */ cc(String str,char c){
      for(int i=0;i<str.length();++i){}
      }
   }
-->
in7.txt:16: aa()
in7.txt:17: bb()
in7.txt:20: cc()

６．　defによる定義と参照

defはparamとほぼ同じ形式で、定義のみ行います。
paramの形式に付加し、名前設定name=...を持ちます。
この名前で後で参照することができます。

内部に部分定義のhiRegexを置く形となります。

現版ではdef内部での${_LINE_}や${_SOURCE_}等の特殊な参照は期待した値を得られないことに注意が必要です。

outputは全体のoutputではなく、defのoutputになることも留意してください。

callも無効です。

６.１　グループ参照文字列の置き換え

グループ参照の:の後ろにdefの定義名を書くと、グループ参照値を改めて解析しなおし、その結果を採用します。

次の例では複数行に渡るコメントを行を残して削除しているため、 ${1}で得られる関数戻り値定義は、複数行になりまう。
trim_NLでは

param=[
   { // コメント部を消す
      in=[
         /\*[\S\s]*?\*/
         "//.*"
         ]
      param={
         regex  =.*
         replace=""
         }
      }
   {
      regex =((\w+\s+)+)(\w+)\s*\(
      def = {
         name =trim_NL
         regex=\w+         // 単語を得て（改行を含む空白文字にはマッチしない)
         output="${0} "    // 空白を一個付けたものを出力する
         }
      output="${_SOURCE_LINE_} ${1:trim_NL} ${3}()\n"
      }
   ]
---
public class Test07 {
   static void aa(){}
   int
   // 戻り値と関数の間にコメント
   public bb(int x){return x;}
   void /* 戻り値と関数の間にコメント */ cc(String str,char c){
      for(int i=0;i<str.length();++i){}
      }
   }
-->
in7.txt:28: static void  aa()
in7.txt:29: int public  bb()
in7.txt:32: void  cc()
- - - - - trim_NLを作用させない場合${1}には改行が含まれます。
in7.txt:40: static void  aa()
in7.txt:41: int
   
   public  bb()
in7.txt:44: void   cc()

６.２　refによる参照(未実装)

 構造化正規表現サンプル

本ライブラリのjavadoc用のエスケープ処理に用いている構造化正規表現のhiProperty記述を示します.

次の例は実際に本ライブラリのJavadoc用の簡易エスケープ処理を行っている記述です。
inでJavadoc記述の範囲(/**...*/)を指定し、outでHTMLのコメント部範囲(<!--...-->)を外しています。
その範囲内で<,>,@および&を変換しています。
REFo{...}とREF{...}はリンク記述を簡単にするための特別なものですが、その他は汎用性の高いものとなっています。

${JDOC_TAGS}と${HTML_TAGS}定義はhiPropertyの単純文字列展開マクロ機構を利用しています。

// マクロ:本体の参照部に単純に展開される;キーワードの並びを見やすく分離した
${JDOC_TAGS}=param|see|return|link|throws|exception|literal
${HTML_TAGS}=a|b|br|code|caption|center|div|input|ol|li|p|pre|span|table|ul|tr|td|blockquote
param = {
   in=/\*\*[\s\S]*?\*/    // Javadocの範囲のみ対象とする
   param={
      out=<!--[\s\S]*?-->  // HTMLのコメント外を対象とする
      param=[
        { // REFo{ref [text..]}
           regex=REFo\{(\w+)\s*(.*?)\}
           replace=<a class=A1 href="#o${1}">${2|1}</a>
           }
        { // REF{ref,text}
           regex=REF\{(?<ref>\S+?)\s+(?<text>.*?)\}
           replace=<a class=A1 href="../../otsu/hiNote/${ref}"><code>${text}</code></a>
           }
        {  // javadocの特殊パラメタ以外の@
           regex=@(?!(${JDOC_TAGS}))
           replace={@literal @}
           }
        { // &を&amp;に置き換える
           regex=&(?!([a-zA-Z]{2,6};))
           replace_literal=&amp;
           }
        { // '<'を&lt;に '>'を&gt;にする
           out={@literal @}param\s.* // @paramには<T>などの総称名が入るので範囲から外す
           param={
              out={ // HTMLタグ <table ...>など は範囲から外す
                 regex=</?(${HTML_TAGS})(?=\W)[^>\n]*>
                 ignore_case
                 }
              param=[
                 {
                    regex=<
                    replace=&lt;
                    }
                 {
                    regex=>
                    replace=&gt;
                    }
                 ]
              }
           }
        ]
     }
  }

この中で'<'および'>'を&lt;、&gt;に置き換える処理は

   +-- /\*\*[\s\S]*?\*/ の中（javadoc記述)
       +-- <!--  --> の外(HTMLコメント)
           +-- {@literal @}param 行の外(<T>などの総称名がある
               +-- <table>　などのHTMLタグの外

という範囲で行ってます。

HTMLタグの判断は

  < が有って
     / が有るまたは無で
       名前以外の文字が後置されるHTMLタグ名(a|b|br|code...)が有って
          >以外または改行以外が0個以上つながり
              >がある

という形です。

 基本手続き(一関数完結とカスケード式）

２種類の使用方法があります。

• hiRegex.replaceAll()１メソッドで行う
• hiRegex.with()に始まる一連のメソッドで行う（カスケード式)

with系は次のメソッド構成を持ちます。プログラムはhiRegex.with()で作られるhiRegexオブジェクトにその他のメソッドを適用していく形になります。

正規表現および置き換え パターン指定 hiRegexオブジェクトを返す staticメソッド	withPropFile(String) with(File)	hiPropertyファイルによる設定
	with(hiProperty)	hiPropertyオブジェクトによる設定
	withRegex(String,String) with(Pattern,String)	正規表現文字列と置き換え文字列による設定
	withRegex(char,String,String)	逆スラッシュ代替文字、正規表現文字列と置き換え文字列による設定
	withQ(char,String,String)	逆スラッシュ代替文字、正規表現文字列と置き換え文字列による設定。シングルクオートはダブルクオートになる。
補助指定	withOption(long)	正規表現文字列を用いた設定の補助指定。 hiU.LITERAL:正規表現ではなく文字通りとしてマッチさせる hiU.ONLY_MATCHED:マッチした部分のみ出力 hiU.IGNORE_CASE:大文字小文字を無視 hiU.ONLY_FIRST:最初の１回のマッチのみ有効 hiU.SINGLE_REGION:行単位を無視 hiU.NO_GROUP:置き換えでグループ参照しない
	withFunction(strFunc) withFunction(matFunc) withFunction(paramFunc)	マッチ通知を受けるラムダ関数. 引数は 第1:パターンで置き換えられた文字列 第2:マッチしたMatcher 第3:当該階層のhiRegex.Parameter 戻り値が置き換え値となります。
置き換え対象指示	read(String)	指定ファイルを読み込む。 utf-8で読み込まれ、行の区切りは"\n"となる。
	replace(String)	置き換え対象文字列を指定する
結果取得	write(String)	指定ファイルに出力する utf-8、行の区切りは"\n"となる。 この関数の戻りはhiRegexなのでさらにhiRegexメソッドを続けることができる。
	result()	結果文字列を得る。 この関数の戻りはStringなのでこの後ろにhiRegexメソッドを続けることはできない。
	result(StringBuilder)	output結果ではなく、replace結果を得る。replace結果は引数のStrngBuilderに得る。 outputとreplaceを混在させた記述がある場合次の様にして別々に結果を得ることができる。 StringBuilder replace_result=new SringBulder(); // replace結果 String output_result; // output結果 out_put= hiRegex.with("prop.txt") .read("data.txt") .result(replace_result) .result();

単純な置き換えの例を示します。

   // repaceAllの例
      String _lines = "... 変換対象文字列 ...";
      String _result= hiRegex.replaceAll(_lines
                                        ,"(?<=\\W)string(?=\\W)","String");
   // withを使った例
      String _lines = "... 変換対象文字列 ...";
      String _result= hiRegex.with("(?<=\\W)string(?=\\W)","String")
                             .replace_literal(_lines).result();

with系のメソッドではファイルの読み書きが用意されています。

   // repaceAllの例
      try(BufferedReader _br= hiFile.openTextFileR("./in.txt");
          PrintWriter    _pw= hiFile.openTextFileW("./out.txt");){
         String     _lines = hiFile.readLines(_br,"\n");
         _br.close();
         String     _result= hiRegex.replaceAll(_lines,"(?<=\\W)string(?=\\W)","String");
         _pw.print(_result);
         _pw.close();
         }
      catch(Exception _ex){
         throw hiU.rap(_ex);
         }
   // withの例
      hiRegex.with("(?<=\\W)string(?=\\W)","String")
             .read("./in.txt")
             .write("./out.txt");

replaceAllでは引数の順番で引数の意味を定めているため混乱しがちですが、with系ではパラメタ毎にメソッドが用意されていますので、視認性に優れます。

   // repaceAllの例
      String _lines="..."; // 文字列
      HashSet<String> _names=new HashSet<>();
      String _result=hiRegex.replaceAll(
          _lines                                            // 先頭が対象文字列
         ,"^\\s*public\\s+String\\s+(\\w+)(?=\\W)","${0}"   // 2番目がパターン
         ,(_s_,_m_)->{_names.add(_m_.group(1));return _s_;} // 3番目が処理
         ,hiU.IGNORE_CASE                                   // 4番目がオプション
         );
   // withの例
      String _lines="..."; // 文字列
      HashSet<String> _names=new HashSet<>();
      String _result=hiRegex
         .withRegex("^\\s*public\\s+String\\s+(\\w+)(?=\\W)","${0}") // 先頭withでパターン
         .withOption(hiU.IGNORE_CASE)
         .withFunction((_s_,_m_)->{_names.add(_m_.group(1));return _s_;})
         .replace_literal(_lines).result();                     // 最後に対象指定と結果取得

hiProperty(正規表現/変換定義）もファイル名で指定できますので、定義ファイル、入力ファイル、出力ファイルからなる変換では次のような記述ができます。

   // withの例
      hiRegex.with(new File("./prop.txt"))
             .read("./in.txt")
             .write("./out.txt");

 Javaで用意されているメソッドとの比較

Javaで用意されているPatternとMatcherを用いた操作の例とhiRegexを用いた例を載せます。

この例では16から始まる10桁または13桁の数値文字列をunixEpochだとして、日付文字列に変換します。
否定前置、否定後置で、数値列の一部を取り出すことを禁止してあります。
10桁部文字列に3桁部文字列を連結します。
3桁部が無い場合"000"を連結します。

import java.util.*;
import java.util.regex.*;
import java.text.*;
public class TestNoOtsu {
   static String     target_text  = "ab1624461468492cd1624461468ef162446146gh2624461468ij";
   static Pattern    unixEpochPtn = Pattern.compile("(?<!\\d)((16\\d{8})(\\d{3})?)(?!\\d)");
   static DateFormat dateFormat   = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
   public static void main(String[] args_){
      try{
         int           _sta    = 0;
         StringBuilder _sb     = new StringBuilder();
         Matcher       _matcher= unixEpochPtn.matcher(target_text);
         while( _matcher.find() ){
            String _unixEpcText= _matcher.group(2);
            if( _matcher.group(3)!=null )_unixEpcText+=_matcher.group(3);
            else                         _unixEpcText+="000";
            Date   _date   = new Date(Long.parseLong(_unixEpcText));
            String _dateStr= dateFormat.format(_date);
            _sb.append(target_text.substring(_sta,_matcher.start(1))+"<"+_dateStr+">");
            _sta=_matcher.end(1);
            }
         _sb.append(target_text.substring(_sta));
         System.out.println(_sb.toString());
         }
      catch(Exception e){
         e.printStackTrace(System.err);
         System.exit(1);
         }
      }
   }
正規表現の括弧はグループとしてマッチします。
  １回目
    <-- 1     -->
    <-- 2  -->
              <3>
  ２回目
                   <-- 1   ->
                   <-- 2   ->
                   3:null
  この後はマッチするものはない(16で始まっていない、数値桁数が違う)
  ab1624461468492cd1624461468ef162446146gh2624461468ij
結果は
  ab<2021/06/24 00:17:48.492>cd<2021/06/24 00:17:48.000>ef162446146gh2624461468ij
となります。

マッチした場所以外の部分とマッチして変更した部分をStringBuilderを用いて連結し、最終結果を得ています。
 matcher.start(1)は第１グループの開始位置を示します。
 matcher.end(1) は第１グループの終了位置の後ろ示します。

同じ操作をhiRegexを用いて行ったものを載せます。

import otsu.hiNote.*;
public class Test {
   static String     target_text="ab1624461468492cd1624461468ef162446146gh2624461468ij"
                                +"AB11624461468492CD16244614684922EF";
   public static void main(String[] args_){
      try{
         System.out.println(
            hiRegex.withRegex("(?<!\\d)((16\\d{8})(\\d{3})?)(?!\\d)")
                   .withFunction((_s_,_m_)->{
                      String _unixEpcText= _m_.group(2);
                      if( _m_.group(3)!=null )_unixEpcText+=_m_.group(3);
                      else                    _unixEpcText+="000";
                      return "<"+hiTime.dispTime(hiU.atol(_unixEpcText))+">";
                      })
                   .replace(target_text).result()
            );
         }
      catch(Exception e){
         e.printStackTrace(hiU.err);
         System.exit(1);
         }
      }
   }

マッチした単位でラムダ関数呼び出しとなります。関数の戻り値で、マッチした部分の文字列が置き換わります。

_m_は{java.util.regex.Matcher}ですがimportは不要です。
正規表現は文字列で与えていますが、Patternを作成して与えることも可能です。

日時文字列の取得にhiTime.dispTime(long)を用いています。
もちろんDate,SimpleDateFormatを用いても構いません。

 --- API ---

ネストされたクラスのサマリー

ネストされたクラス

修飾子とタイプ	クラスと説明
static class	hiRegex.ExclusiveKeyException
static class	hiRegex.FormatException
static class	hiRegex.IllegalSequenceException
static class	hiRegex.MissingParamException
static class	hiRegex.MultipledKeyException
static class	hiRegex.NotYetSupporedException
static class	hiRegex.Parameter

フィールドのサマリー

フィールド

修飾子とタイプ	フィールドと説明
static String	EOL single_regionでの行末パターン
static String	SOL single_regionでの行先頭パターン

メソッドのサマリー

修飾子とタイプ	メソッドと説明
static boolean	matches(String text_, String regex_) 完全一致するか調べる
static String	re(char escape_char_, String text_) 正規表現上の"\"を別文字で与える.
static String[]	re(char escape_char_, String[] texts_) 正規表現上の"\"を別文字で与える.
hiRegex	read(String fileName_) 指定ファイルを読み込み置き換える.
hiRegex	replace(String text_) 指定文字列を置き換える.
static String	replaceAll(String original_text_, hiProperty prop_) hiPropertyで示されるパターンにそって置き換える.
static String	replaceAll(String original_text_, hiProperty prop_, hiU.BiFunctionEx<String,Matcher,String,Exception> func_) hiPropertyで示されるパターンにそって置き換える.
static String	replaceAll(String original_text_, hiProperty prop_, hiU.FunctionEx<String,String,Exception> func_) hiPropertyで示されるパターンにそって置き換える.
static String	replaceAll(String original_text_, hiProperty prop_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> func_) hiPropertyで示されるパターンにそって置き換える.
static String	replaceAll(String text_, Pattern pattern_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, hiU.FunctionEx<String,String,Exception> strFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, hiU.FunctionEx<String,String,Exception> strFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, String replacement_) 正規表現でマッチする部分を置き換え.
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.FunctionEx<String,String,Exception> strFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.FunctionEx<String,String,Exception> strFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)
static String	replaceAll(String text_, Pattern pattern_, String replacement_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, Pattern pattern_, String replacement_, long option_) 正規表現でマッチする部分を置き換え.
static String	replaceAll(String text_, String regex_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, hiU.FunctionEx<String,String,Exception> strFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, hiU.FunctionEx<String,String,Exception> strFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, String replacement_) 正規表現でマッチする部分を置き換え.
static String	replaceAll(String text_, String regex_, String replacement_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)
static String	replaceAll(String text_, String regex_, String replacement_, hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, String replacement_, hiU.FunctionEx<String,String,Exception> strFunc_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, String replacement_, hiU.FunctionEx<String,String,Exception> strFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, String replacement_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)
static String	replaceAll(String text_, String regex_, String replacement_, hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_, long option_) 正規表現でマッチする部分を置き換え(ラムダ式使用).
static String	replaceAll(String text_, String regex_, String replacement_, long option_) 正規表現でマッチする部分を置き換え.
static String	reQ(char escape_char_, String text_) 正規表現上の"\"を別文字で与え,'を"に置き換える.
static String[]	reQ(char escape_char_, String[] texts_) 正規表現上の"\"を別文字で与え,'を"に置き換える.
String	result() 置き換え結果を取得する
hiRegex	result(StringBuilder sb_) 置き換え結果を取得する. outputの結果とreplaceの結果をそれぞれ取得します。
hiRegex	set_source_name(String sourceName_)
hiRegex	with_line_separator(String lineSeparator_) 最終結果の改行コードを指定のものにする.
hiRegex	with_source_name(String sourceName_) ${_SOURCE_}で得られる名前をセットする
static hiRegex	with(char alt_char_, String regex_str_, String replacement_str_) 逆スラッシュ代替文字,正規表現文字列と置き換え文字列からセットする.
static hiRegex	with(File propFile_) 定義をファイルからセットする.
static hiRegex	with(hiProperty prop_) hiPropertyからセットする.
static hiRegex	with(hiProperty prop_, hiRegex entry_) hiPropertyからセットする.
static hiRegex	with(Pattern pattern_) 正規表現文字列と置き換え文字列からセットする.
static hiRegex	with(Pattern pattern_, String replacement_str_) 正規表現文字列と置き換え文字列からセットする.
static hiRegex	with(String regex_str_, String replacement_str_)
static hiRegex	withFile(String propFileName_) 指定定義ファイルにより変換準備のできたhiRegexを得る.
hiRegex	withFunction(hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_) マッチ部の通知を受けるラムダ関数追加.
hiRegex	withFunction(hiU.FunctionEx<String,String,Exception> strFunc_) マッチ部の通知を受けるラムダ関数追加.
hiRegex	withFunction(hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> paramFunc_) マッチ部の通知を受けるラムダ関数追加.
hiRegex	withOption(long option_) 正規表現文字列と置き換え文字列による定義にオプションを追加する.
hiRegex	withPrinter(PrintWriter pw_) printでの出力先を設定する.
hiRegex	withProgress(PrintStream ps_, int interval_) 進行状態を表示する
hiRegex	withProgress(PrintWriter pw_, int interval_) 進行状態を表示する
static hiRegex	withPropFile(String propFileName_) 定義をファイルからセットする.
static hiRegex	withQ(char alt_char_, String regex_str_, String replacement_str_) 逆スラッシュ代替文字,正規表現文字列と置き換え文字列からセットする.
static hiRegex	withRegex(char escape_, String regex_str_) 正規表現文字列と置き換え文字列からセットする.
static hiRegex	withRegex(char escape_, String regex_str_, String replacement_str_) 正規表現文字列と置き換え文字列からセットする.
static hiRegex	withRegex(String regex_str_) 正規表現文字列と置き換え文字列からセットする.
static hiRegex	withRegex(String regex_str_, String replacement_str_) 正規表現文字列と置き換え文字列からセットする.
hiRegex	write(String fileName_) 指定ファイルを置き換え対象文字列として読み込む.

クラスから継承されたメソッド java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

フィールドの詳細

SOL

public static final String SOL

single_regionでの行先頭パターン

関連項目:

定数フィールド値

EOL

public static final String EOL

single_regionでの行末パターン

関連項目:

定数フィールド値

メソッドの詳細

withPropFile

public static hiRegex withPropFile(String propFileName_)

定義をファイルからセットする.

パラメータ:

propFileName_ - 定義ファイル名

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(File propFile_)

定義をファイルからセットする.

パラメータ:

propFile_ - 定義ファイル

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(hiProperty prop_)

hiPropertyからセットする.

パラメータ:

prop_ - 定義ファイル名

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(hiProperty prop_,
                           hiRegex entry_)

hiPropertyからセットする.

パラメータ:

prop_ - 定義ファイル名

entry_ - 入り口のhiRegex

戻り値:

hiRegexオブジェクト

withRegex

public static hiRegex withRegex(String regex_str_,
                                String replacement_str_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

regex_str_ - 正規表現

replacement_str_ - 置き換え文字列

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(String regex_str_,
                           String replacement_str_)

withRegex

public static hiRegex withRegex(char escape_,
                                String regex_str_,
                                String replacement_str_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

escape_ - 正規表現エスケープ文字

regex_str_ - 正規表現(逆スラッシュの代わりにescapeを使った表現)

replacement_str_ - 置き換え文字列

戻り値:

hiRegexオブジェクト

withRegex

public static hiRegex withRegex(String regex_str_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

regex_str_ - 正規表現

戻り値:

hiRegexオブジェクト

withRegex

public static hiRegex withRegex(char escape_,
                                String regex_str_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

escape_ - 正規表現エスケープ文字

regex_str_ - 正規表現(逆スラッシュの代わりにescapeを使った表現)

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(Pattern pattern_,
                           String replacement_str_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

pattern_ - 正規表現

replacement_str_ - 置き換え文字列

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(Pattern pattern_)

正規表現文字列と置き換え文字列からセットする.

パラメータ:

pattern_ - 正規表現

戻り値:

hiRegexオブジェクト

with

public static hiRegex with(char alt_char_,
                           String regex_str_,
                           String replacement_str_)

逆スラッシュ代替文字,正規表現文字列と置き換え文字列からセットする.

リテラル正規表現文字列内の逆ラッシュを別文字で代替します。

hiRegex.with("(\\w+)\\s\*\('a',?([^)]*)\\)" // 正規表現パターン
            ,"${1}_a(${2})")                // 置き換えパターン
の代わりに
hiRegex.with('%'                            // 代理文字
            ,"(%w+)%s*%('a',?([^)]*)%)"     // 正規表現パターン
            ,"${1}_a(${2})")                // 置き換えパターン

内容と衝突しない限り置き換え文字に制約はありません。通常正規表現との衝突の無い%#/の何れかを使います。
この文字自体のエスケープはありません。

パラメータ:

alt_char_ - 逆スラッシュ代替文字

regex_str_ - 正規表現

replacement_str_ - 置き換え文字列

戻り値:

hiRegexオブジェクト

withQ

public static hiRegex withQ(char alt_char_,
                            String regex_str_,
                            String replacement_str_)

逆スラッシュ代替文字,正規表現文字列と置き換え文字列からセットする.

リテラル正規表現文字列内の逆ラッシュを別文字で代替しダブルクオートをシングルクオートで代替します。

パラメータ:

alt_char_ - 逆スラッシュ代替文字

regex_str_ - 正規表現

replacement_str_ - 置き換え文字列

戻り値:

hiRegexオブジェクト

withOption

public hiRegex withOption(long option_)

正規表現文字列と置き換え文字列による定義にオプションを追加する.

次のオプションが追加できます。

• hiU.LITERAL:正規表現ではなく文字通りとしてマッチさせる
• hiU.NO_GROUP:置き換えでグループ参照しない
• hiU.VERBOSE:マッチ状況などを表示
• hiU.IGNORE_CASE:大文字小文字を無視
• hiU.ONLY_FIRST:最初の１回のマッチのみ有効
• hiU.ONLY_MATCHED:マッチした部分のみ出力
• hiU.SINGLE_REGION行単位を無視

パラメータ:

option_ - オプション

戻り値:

hiRegexオブジェクト

withFunction

public hiRegex withFunction(hiU.FunctionEx<String,String,Exception> strFunc_)

マッチ部の通知を受けるラムダ関数追加.

ラムダ関数は

• 第一引数はマッチ部の置き換え結果です
• 戻り値がマッチ部の置き換えに使われます
• 何も変更しない場合は第一引数を返します

パラメータ:

strFunc_ - 関数

戻り値:

hiRegexオブジェクト

withFunction

public hiRegex withFunction(hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)

マッチ部の通知を受けるラムダ関数追加.

ラムダ関数は

• 第一引数はマッチ部の置き換え結果です
• 第二引数はマッチしたMatcherです
• 戻り値がマッチ部の置き換えに使われます
• 何も変更しない場合は第一引数を返します

パラメータ:

matFunc_ - 関数

戻り値:

hiRegexオブジェクト

withFunction

public hiRegex withFunction(hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> paramFunc_)

マッチ部の通知を受けるラムダ関数追加.

ラムダ関数は

• 第一引数はマッチ部の置き換え結果です
• 第二引数はマッチしたMatcherです
• 第三引数はhiRegex.Parameterです。
• 戻り値がマッチ部の置き換えに使われます
• 何も変更しない場合は第一引数を返します

パラメータ:

paramFunc_ - 関数

戻り値:

hiRegexオブジェクト

withPrinter

public hiRegex withPrinter(PrintWriter pw_)

printでの出力先を設定する.

パラメータ:

pw_ - 出力先

戻り値:

hiRegexオブジェクト

withProgress

public hiRegex withProgress(PrintWriter pw_,
                            int interval_)

進行状態を表示する

パラメータ:

pw_ - 出力先

interval_ - 出力間隔

戻り値:

hiRegexオブジェクト

withProgress

public hiRegex withProgress(PrintStream ps_,
                            int interval_)

進行状態を表示する

パラメータ:

ps_ - 出力先 (System.errなど)

interval_ - 出力間隔

戻り値:

hiRegexオブジェクト

read

public hiRegex read(String fileName_)

指定ファイルを読み込み置き換える.

次のような形で使います。

   String _result= hiRegex.withProp("prop.txt") // 方式定義ファイル取り込み
                          .read("in.txt")   // 対象文字列ファイル指定
                          .result();            // 結果取得

ファイルの文字コードはどちらもutf-8です。

パラメータ:

fileName_ - ファイル名

戻り値:

hiRegexオブジェクト

replace

public hiRegex replace(String text_)

指定文字列を置き換える.

次のような形で使います。

   String _src   = "...";// 置き換え対象文字列
   String _result= hiRegex.withProp("prop.txt") // 方式定義ファイル取り込み
                          .replace_literal(_src)    // 対象文字列ファイル指定
                          .result();            // 結果取得

ファイルの文字コードはどちらもutf-8です。

パラメータ:

text_ - 置き換え対象文字列

戻り値:

hiRegexオブジェクト

result

public String result()

置き換え結果を取得する

戻り値:

置き換え結果

result

public hiRegex result(StringBuilder sb_)

置き換え結果を取得する. outputの結果とreplaceの結果をそれぞれ取得します。

パラメータ:

sb_ - replace結果を追加するStringBuilder

戻り値:

hiRegexオブジェクト

write

public hiRegex write(String fileName_)

指定ファイルを置き換え対象文字列として読み込む.

次のような形で使います。

   hiRegex.withProp("prop.txt")  // 方式定義ファイル指定
          .read("in.txt")    // 対象文字列ファイル指定
          .write("out.txt");  // 置き換えを実行し指定ファイルに出力

ファイルの文字コードはどちらもutf-8です。

パラメータ:

fileName_ - ファイル名

戻り値:

replaceAllした結果

replaceAll

public static String replaceAll(String original_text_,
                                hiProperty prop_,
                                hiU.FunctionEx<String,String,Exception> func_)

hiPropertyで示されるパターンにそって置き換える. hiPropertyで与えられる構造化正規表現によって文字列の置き換えを行います。
構造化正規表現に関してはhiRegexがサポートする構造化正規表現を参照してください。

パラメータ:

original_text_ - 変換対象

prop_ - パターン

func_ - ラムダ関数

戻り値:

変換結果

replaceAll

public static String replaceAll(String original_text_,
                                hiProperty prop_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> func_)

hiPropertyで示されるパターンにそって置き換える. hiPropertyで与えられる構造化正規表現によって文字列の置き換えを行います。
構造化正規表現に関してはhiRegexがサポートする構造化正規表現を参照してください。

パラメータ:

original_text_ - 変換対象

prop_ - パターン

func_ - ラムダ関数

戻り値:

変換結果

replaceAll

public static String replaceAll(String original_text_,
                                hiProperty prop_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> func_)

hiPropertyで示されるパターンにそって置き換える.

パラメータ:

original_text_ - 変換対象

prop_ - パターン

func_ - ラムダ関数

戻り値:

変換結果

replaceAll

public static String replaceAll(String original_text_,
                                hiProperty prop_)

hiPropertyで示されるパターンにそって置き換える. hiPropertyで与えられる構造化正規表現によって文字列の置き換えを行います。
構造化正規表現に関してはhiRegexがサポートする構造化正規表現を参照してください。

パラメータ:

original_text_ - 変換対象

prop_ - パターン

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                long option_)

正規表現でマッチする部分を置き換え.

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

option_ - オプション hiU.NO_GROUP hiU.IGNORE_CASE hiU.LITERAL hiU.SIMGLE_REGION

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                long option_)

正規表現でマッチする部分を置き換え.

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

option_ - オプション hiU.NO_GROUP hiU.IGNORE_CASE hiU.LITERAL hiU.SIMGLE_REGION

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_)

正規表現でマッチする部分を置き換え.

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_)

正規表現でマッチする部分を置き換え.

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.FunctionEx<String,String,Exception> strFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

strFunc_ - Stringを引数とする置き換えラムダ式

option_ - オプション hiU.NO_GROUP hiU.IGNORE_CASE hiU.LITERAL hiU.SIMGLE_REGION

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.FunctionEx<String,String,Exception> strFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

strFunc_ - Stringを引数とする置き換えラムダ式

option_ - オプション hiU.NO_GROUP hiU.IGNORE_CASE hiU.LITERAL hiU.SIMGLE_REGION

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.FunctionEx<String,String,Exception> strFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

strFunc_ - Stringを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.FunctionEx<String,String,Exception> strFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

strFunc_ - Stringを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

matFunc_ - String,Matcherを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

matFunc_ - String,Matcherを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

matFunc_ - String,Matcherを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

matFunc_ - String,Matcherを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.FunctionEx<String,String,Exception> strFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

strFunc_ - Stringを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.FunctionEx<String,String,Exception> strFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

strFunc_ - Stringを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.FunctionEx<String,String,Exception> strFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

strFunc_ - Stringを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.FunctionEx<String,String,Exception> strFunc_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

String.replaceAll(String,String)と異なり、replacement_はグループ参照しません。

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

strFunc_ - Stringを引数とする置き換えラムダ式

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

matFunc_ - String,Matcherを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

matFunc_ - String,Matcherを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.BiFunctionEx<String,Matcher,String,Exception> matFunc_)

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

regex_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                String regex_,
                                String replacement_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_,
                                long option_)

正規表現でマッチする部分を置き換え(ラムダ式使用).

パラメータ:

text_ - 変換対象

pattern_ - 変換場所を示す正規表現

replacement_ - 置き換え文字列

matFunc_ - String,Matcher,Parameterを引数とする置き換えラムダ式

option_ - オプション

戻り値:

変換結果

replaceAll

public static String replaceAll(String text_,
                                Pattern pattern_,
                                String replacement_,
                                hiU.TriFunctionEx<String,Matcher,hiRegex.Parameter,String,Exception> matFunc_)

matches

public static boolean matches(String text_,
                              String regex_)

完全一致するか調べる

パラメータ:

text_ - テキスト

regex_ - 正規表現

戻り値:

true:マッチした　false:マッチしなかった

re

public static String re(char escape_char_,
                        String text_)

正規表現上の"\"を別文字で与える.

正規表現文字列をプログラムソース上に書く場合の"\"の扱いのわずらわしさを避けるためのものです。

   // 与えたい正規表現 set\s*:\s*\(\s*(\w+)\s*\)  set : ( ABC )  など
   String _regex=               "set\\s*:\\s\*\(\\s*(\\w+)\\s\*\)";
   String _regex= hiRegex.re('!',"set!s*:!s*!(!s*(!w+)!s*!)");
   // 与えたい文字列   set\s\*\\s*"(\w+)"         set \ "ABC" など
   String _regex=                "set\\s\*\\\\\s*\"(\\w+)\"";
   String _regex= hiRegex.re('!',"set!s*!!!s*\"(!w+)\"");

パラメータ:

escape_char_ - エスケープ文字

text_ - 正規表現用の文字列

戻り値:

正規表現化された文字列

reQ

public static String reQ(char escape_char_,
                         String text_)

正規表現上の"\"を別文字で与え,'を"に置き換える.

正規表現文字列をプログラムソース上に書く場合の"\"の扱いのわずらわしさを避けるためのものです。

   // 与えたい正規表現 set\s*:\s*\(\s*(\w+)\s*\)  set : ( ABC )  など
   String _regex=               "set\\s*:\\s\*\(\\s*(\\w+)\\s\*\)";
   String _regex= hiRegex.re('!',"set!s*:!s*!(!s*(!w+)!s*!)");
   // 与えたい文字列   set\s\*\\s*"(\w+)"         set \ "ABC" など
   String _regex=                "set\\s\*\\\\\s*\"(\\w+)\"";
   String _regex= hiRegex.re('!',"set!s*!!!s*\"(!w+)\"");

パラメータ:

escape_char_ - エスケープ文字

text_ - 正規表現用の文字列

戻り値:

正規表現化された文字列

re

public static String[] re(char escape_char_,
                          String[] texts_)

正規表現上の"\"を別文字で与える.

パラメータ:

escape_char_ - エスケープ文字

texts_ - 正規表現用の文字列の配列(変更されない)

戻り値:

正規表現化された文字列の配列

reQ

public static String[] reQ(char escape_char_,
                           String[] texts_)

正規表現上の"\"を別文字で与え,'を"に置き換える.

パラメータ:

escape_char_ - エスケープ文字

texts_ - 正規表現用の文字列の配列(変更されない)

戻り値:

正規表現化された文字列の配列

withFile

public static hiRegex withFile(String propFileName_)

指定定義ファイルにより変換準備のできたhiRegexを得る.

パラメータ:

propFileName_ - 定義ファイル名

戻り値:

hiRegexオブジェクト

with_source_name

public hiRegex with_source_name(String sourceName_)

${_SOURCE_}で得られる名前をセットする

パラメータ:

sourceName_ - ソース名

戻り値:

hiRegexオブジェクト

set_source_name

public hiRegex set_source_name(String sourceName_)

with_line_separator

public hiRegex with_line_separator(String lineSeparator_)

最終結果の改行コードを指定のものにする. 文字列の中の次のコードを指定のコードに置き換えます。

• \n
• \r
• \r\n

パラメータ:

lineSeparator_ - null指定でキャンセルできます

戻り値:

hiRegexオブジェクト