/*
 * MosP - Mind Open Source Project         http://www.mosp.jp/
 * Copyright (C) 1987-2009 MIND Co., Ltd.  http://www.e-mind.co.jp/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package jp.mosp.common.part;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

import jp.mosp.common.CommonConst;
import jp.mosp.common.common.KanaConvertUtility;
import jp.mosp.common.common.MospUtility;

/**
 * Stringに関するPartクラス
 * @author yoshida
 * 	@version	0.0.1
 */
public class StringPart {

	/*		配列関連		*/

	/**
	 * 二次元配列を一次元配列へ変換
	 * @param ary 対象二次元配列
	 * @param d 選択No.
	 * @return 選択一次元配列
	 * @throws Exception
	 */	
	public static String[] separateArrayList(String[][] ary, int d) {
		String[] aryName = new String[ary.length];
		for (int i = 0; i < ary.length; i++) {
			aryName[i] = ary[i][d];
		}
		return aryName;
	}

	/**
	 * 配列同士の結合
	 * @param frontarray 前方n行2列
	 * @param behindarray 後方n行2列
	 * @return	String[][]	結合配列
	 */
	public static String[][] combineArray(String[][] frontarray, String[][] behindarray) {
		String[][] result = new String[frontarray.length + behindarray.length][2];
		System.arraycopy(frontarray, 0, result, 0, frontarray.length);
		System.arraycopy(behindarray, 0, result, frontarray.length, behindarray.length);			
		return result;
	}

	/**
	 * 配列同士の結合
	 * @param frontarray 前方n行2列
	 * @param centerarray 中間n行2列
	 * @param behindarray 後方n行2列
	 * @return	String[][]	結合配列
	 */
	public static String[][] combineArray(String[][] frontarray, String[][] centerarray, String[][] behindarray) {
		String[][] result = combineArray(combineArray(frontarray, centerarray), behindarray);
		return result;
	}

	/**
	 * 配列同士の結合
	 * @param list
	 * @return
	 */
	public static String[][] combineArray(List<String[][]> list) {
		String[][] result = new String[0][2];
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			String[][] array = (String[][]) iter.next();
			result = combineArray(result, array);
		}
		return result.clone();
	}

	/**
	 * 有り／無しリスト
	 * @return [0]…無し、[1]…有り
	 */
	public static String[][] getExistenceArray() {
		String[][] result = new String[2][2];
		result[0][0] = CommonConst.NAM_COMMON_FLAG_OFF;
		result[0][1] = CommonConst.NAM_COMMON_NASI;
		result[1][0] = CommonConst.NAM_COMMON_FLAG_ON;
		result[1][1] = CommonConst.NAM_COMMON_ARI;
		return result;
	}

	/**
	 * 有り／無しリスト
	 * @return [0]…無、[1]…有
	 */
	public static String[][] getExistenceShortArray() {
		String[][] result = new String[2][2];
		result[0][0] = CommonConst.NAM_COMMON_FLAG_OFF;
		result[0][1] = CommonConst.NAM_MISSING_INPUT_OFF_OPT;
		result[1][0] = CommonConst.NAM_COMMON_FLAG_ON;
		result[1][1] = CommonConst.NAM_MISSING_INPUT_ON;
		return result;
	}

	/**
	 * 同一配列チェック
	 * @param ary1		対象配列１
	 * @param ary2		対象配列２
	 * @return
	 * <p>
	 * 配列が一緒であればtrue、そうでない場合false
	 * </p>
	 */
	public static boolean checkArraysEquals(String[] ary1, String[] ary2) {
		if (Arrays.equals(ary1, ary2)) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 一次元配列をListへ
	 * @param array
	 * @return
	 */
	public static List<String> arrayToList(String[] array) {
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < array.length; i++) {
			list.add(array[i]);
		}
		return list;
	}

	/**
	 * 配列→カンマ区切りの文字列
	 * @param array		対象一次元配列
	 * @return
	 */
	public static String convArrayToFormattedByComma(String[] array) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i]);
			if (i != array.length -1) {
				sb.append(CommonConst.STR_UNDER_SEPARATOR);
			}
		}			
		return sb.toString();
	}

	/**
	 * 配列次元変換
	 * @param ary1D		変換元一次元配列
	 * @return	変換後二次元配列
	 */
	public static String[][] convArrayDimension(String[] ary1D) {
		String[][] array = new String[1][2];
		array[0][0] = "";
		array[0][1] = "";
		if (ary1D != null) {
			array[0][0] = ary1D[0];
			array[0][1] = ary1D[1];
		}
		return array;
	}

	/**
	 * 配列次元変換
	 * @param ary2D		変換元二次元配列
	 * @return	変換後一次元配列
	 */
	public static String[] convArrayDimension(String[][] ary2D) {
		String[] array = new String[2];
		array[0] = "";
		array[1] = "";
		if (ary2D != null) {
			array[0] = ary2D[0][0];
			array[1] = ary2D[0][1];
		}
		return array;
	}

	/**
	 * 一次元配列生成
	 * @param str1		対象要素１
	 * @param str2		対象要素２
	 * @return　生成配列
	 */
	public static String[] createArray(String str1, String str2) {
		return new String[]{ str1, str2 };
	}

	/**
	 * 空白プルダウン取得
	 * @return  空白プルダウン用配列
	 */
	public static String[][] getBlankArray() {
		String[][] array = new String[1][2];
		array[0][0] = "";
		array[0][1] = "";
		return array;
	}

	/**
	 * 空白配列生成
	 * @param arraySize		生成配列長
	 * @return	空白配列
	 */
	public static String[][] getBlankArray(int arraySize) {
		String[][] array = new String[arraySize][2];
		for (int i = 0; i < array.length; i++) {
			array[i][0] = "";
			array[i][1] = "";
		}
		return array;
	}

	/**
	 * 在職/退職リスト取得
	 * @return 在職/退職リスト
	 */
	public static String[][] getRetirementFlagArrayAll() {
		// 配列の作成
		return addArrayFirstRowSpace(getRetirementFlagArray());
	}

	/**
	 * 在職/退職リスト取得（空欄無し）
	 * @return 在職/退職リスト
	 */
	public static String[][] getRetirementFlagArray() {
		// 配列の作成
		String[][] aryRetirementFlag = new String[3][2];
		aryRetirementFlag[0][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_OFF);
		aryRetirementFlag[0][1] = CommonConst.NAM_RETIREMENT_OFF;
		aryRetirementFlag[1][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_LEAVE);
		aryRetirementFlag[1][1] = CommonConst.NAM_RETIREMENT_LEAVE;
		aryRetirementFlag[2][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_ON);
		aryRetirementFlag[2][1] = CommonConst.NAM_RETIREMENT_ON;
		return aryRetirementFlag;
	}

	/**
	 * 名称取得
	 * @param code  取得対象コード
	 * @return コード名称
	 */
	public static String getCodeName(String code, String[][] array) {
		String codeName = code;
		if (array == null) {
			return codeName;
		}
		for (int i = 0; i < array.length; i++) {
			if (code.equals(array[i][0])) {
				codeName = array[i][1];
				break;
			}
		}
		return codeName;
	}

	/**
	 * コード取得
	 * @param name  取得対象コード
	 * @param array  取得対象配列
	 * @return コード名称
	 */
	public static String getCodeValue(String name, String[][] array) {
		String codeValue = name;
		if (array == null) {
			return codeValue;
		}
		for (int i = 0; i < array.length; i++) {
			if (name.equals(array[i][1])) {
				codeValue = array[i][0];
				break;
			}
		}
		return codeValue;
	}

	/**
	 * 年プルダウン取得
	 * @param year 基準年
	 * @return 年プルダウン用文字列配列
	 */
	public static String[][] getYearArray(int year) {
		String[][] aryYear = new String[3][2];
		aryYear[0][0] = String.valueOf(year - 1);
		aryYear[0][1] = String.valueOf(year - 1);
		aryYear[1][0] = String.valueOf(year);
		aryYear[1][1] = String.valueOf(year);
		aryYear[2][0] = String.valueOf(year + 1);
		aryYear[2][1] = String.valueOf(year + 1);
		return aryYear;
	}

	/**
	 * 年プルダウン取得
	 * @param year 基準年
	 * @param former 過去
	 * @param further 未来
	 * @return 年プルダウン用文字列配列
	 */
	public static String[][] getYearArray(int year, int former, int further) {
		String[][] aryYear = new String[former + further + 1][2];
		int i = 0;
		int index = 0;
		for (i = year - former; i < year; i++) {
			aryYear[index][0] = String.valueOf(i);
			aryYear[index][1] = String.valueOf(i);
			index++;
		}
		aryYear[index][0] = String.valueOf(year);
		aryYear[index][1] = String.valueOf(year);
		index++;
		for (i = year + 1; i <= year + further; i ++) { 
			aryYear[index][0] = String.valueOf(i);
			aryYear[index][1] = String.valueOf(i);
			index++;
		}
		return aryYear;
	}

	/**
	 * 月プルダウン取得
	 * @return 月プルダウン用文字列配列
	 */
	public static String[][] getMonthArray() {
		String[][] aryMonth = new String[12][2];
		for (int i = 0; i < 12; i++) {
			aryMonth[i][0] = String.valueOf(i + 1);
			aryMonth[i][1] = String.valueOf(i + 1);
		}
		return aryMonth;
	}

	/**
	 * 日プルダウン取得
	 * @return 月プルダウン用文字列配列
	 */
	public static String[][] getDayArray() {
		String[][] aryDay = new String[31][2];
		for (int i = 0; i < 31; i++) {
			aryDay[i][0] = String.valueOf(i + 1);
			aryDay[i][1] = String.valueOf(i + 1);
		}
		return aryDay;
	}

	/**
	 * 時間プルダウン取得
	 * @param hour          開始時
	 * @param minute        開始分
	 * @param count         データ数
	 * @param interval      データ間隔(分)
	 * @param isValueMinute 分設定フラグ(true：valueは分単位、false：valueは時間文字列)
	 * @return 時間プルダウン用文字列配列
	 */
	public static String[][] getTimeArray(int hour, int minute, int count, int interval, boolean isValueMinute) {
		String[][] aryTime = new String[count][2];
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.HOUR_OF_DAY, hour);
		cal.set(Calendar.MINUTE, minute);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		for (int i = 0; i < count; i++) {
			if (isValueMinute) {
				aryTime[i][0] = String.valueOf(cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE));
			} else {
				aryTime[i][0] = MospUtility.getDateString(cal.getTime(), CommonConst.FORMAT_TIME_SHORT);
			}
			aryTime[i][1] = MospUtility.getDateString(cal.getTime(), CommonConst.FORMAT_TIME_SHORT);
			cal.add(Calendar.MINUTE, interval);
		}
		return aryTime;
	}

	/**
	 * 数値プルダウン取得
	 * @param start		開始値
	 * @param end		終了値
	 * @param interval	間隔
	 * @return 数値プルダウン用文字列配列
	 */
	public static String[][] getCountArray(int start, int end, int interval) {
		int count = (end - start) / interval + 1;
		int value = start;
		String[][] aryCount = new String[count][2];
		for (int i = 0; i < count; i++) {
			aryCount[i][0] = String.valueOf(value);
			aryCount[i][1] = String.valueOf(value);
			value += interval;
		}
		return aryCount;
	}

	/**
	 * プルダウン行除去
	 * @param target 除去対象プルダウン配列
	 * @param value 除去対象行値
	 * @return 除去後プルダウン
	 */
	public static String[][] removeArrayRow(String[][] target, String value) {
		int count = target.length;
		for (int i = 0; i < target.length; i++) {
			if (target[i][0].equals(value)) {
				--count;
			}
		}
		String[][] aryNew = new String[count][2];
		count = 0;
		for (int i = 0; i < target.length; i++) {
			if (target[i][0].equals(value)) {
				continue;
			}
			aryNew[count][0] = target[i][0];
			aryNew[count][1] = target[i][1];
			++count;
		}
		return aryNew;
	}

	/**
	 * プルダウンの先頭行に空白を追加
	 * @param target 対象プルダウン配列
	 * @return 追加後プルダウン
	 */
	public static String[][] addArrayFirstRowSpace(String[][] target) {
		return addArrayFirstRowValue(target, "", "");
	}

	/**
	 * プルダウンの先頭行に任意の値を追加
	 * @param target 対象プルダウン配列
	 * @param code 対象行コード
	 * @param value 対象行表示値
	 * @return aryNew	生成配列
	 */
	public static String[][] addArrayFirstRowValue(String[][] target, String code, String value) {
		String[][] aryNew = new String[target.length + 1][2];
		for (int i = 0; i < aryNew.length; i++) {
			if (i == 0) {
				aryNew[0][0] = code;
				aryNew[0][1] = value;
			} else {
				aryNew[i][0] = target[i - 1][0];
				aryNew[i][1] = target[i - 1][1];
			}
		}
		return aryNew;
	}

	/**
	 * プルダウンの最終行に任意の値を追加
	 * @param target 対象プルダウン配列
	 * @param code 対象行コード
	 * @param value 対象行表示値
	 * @return aryNew	生成配列
	 */
	public static String[][] addArrayLastRowValue(String[][] target, String code, String value) {
		String[][] aryNew = new String[target.length + 1][2];
		for (int i = 0; i < aryNew.length; i++) {
			if (i == aryNew.length -1) {
				aryNew[i][0] = code;
				aryNew[i][1] = value;
			} else {
				aryNew[i][0] = target[i][0];
				aryNew[i][1] = target[i][1];
			}
		}
		return aryNew;
	}

	/*		文字列関連	*/

	/**
	 * StringのNull、長さチェック
	 * @param str		対象String
	 * @return
	 * <p>Nullもしくは長さが0の場合true、そうでない場合false</p>
	 */
	public static boolean isNull(String str) {
		try {
			if (str == null || str.length() == 0) {
				return true;
			}
		} catch (NullPointerException e) {
			return true;
		}
		return false;
	}

	/**
	 * StringのNotNullチェック
	 * @param str		対象String
	 * @return
	 * <p>Nullもしくは長さが0以外の場合true、そうでない場合false</p>
	 */
	public static boolean isNotNull(String str) {
		return !isNull(str);
	}

	/**
	 * ハイフン分割メソッド
	 * @param code 対象データ
	 * @param hyphen ハイフン数
	 * @return 分割配列<br>
	 * ハイフンとハイフンの間に何も無い場合、
	 * 配列に「""」が代入される。
	 * 
	 */
	public static String[] divideByHyphen(String code, int hyphen) {
		String[] base = code.split(CommonConst.FILE_NAME_SEPARATOR);
		String[] ar = new String[hyphen + 1];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * ハイフン分割メソッド
	 * @param code 対象データ
	 * @return 分割配列<br>
	 * ハイフンとハイフンの間に何も無い場合、
	 * 配列に「""」が代入される。<br>
	 * ハイフンで文字列が終わる場合、ハイフンの前の文字列までを、
	 * 配列にする。
	 */
	public static String[] divideByHyphen(String code) {
		String[] base = code.split(CommonConst.FILE_NAME_SEPARATOR);
		String[] ar = new String[base.length];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * 改行表示処理
	 * @param aStr 改行対象文字列
	 * @return 改行後文字列
	 */
	public static String brHTML(String aStr) {
		char c;
		String strTarget = aStr != null ? aStr : "";
		StringBuffer returnStr = new StringBuffer();
		int length = strTarget.length();
		for (int i = 0; i < length; i++) {
			c = strTarget.charAt(i); 
			if (c == '\n') {
				returnStr = returnStr.append("<br>");
			} else if (c == '<') {
				returnStr = returnStr.append("&lt;");
			} else if(c == '>') {
				returnStr = returnStr.append("&gt;");
			} else if(c == '&') {
				returnStr = returnStr.append("&amp;");
			} else if(c == '"') {
				returnStr = returnStr.append("&quot;");
			} else if(c == '\'') {
				returnStr = returnStr.append("&#39;");
			} else {
				returnStr = returnStr.append(c);
			}
		}
		return new String(returnStr);
	}

	/**
	 * ゼロ付の数字から整数へ変換
	 * @param number ゼロ付数字
	 * @return 整数
	 */
	public static String removeZero(String number) {
		return String.valueOf(Integer.parseInt(number));
	}

	/**
	 * 整数からゼロ付の数字へ変換
	 * @param number
	 * @return String	数字（0~9）→（00~09）
	 */
	public static String addZero(int number) {
		StringBuffer sb = new StringBuffer();
		if (number < 10) {
			sb.append(CommonConst.NAM_COMMON_INTEGER_INITIAL_VALUE);
		}
		sb.append(number);
		return sb.toString();
	}

	/**
	 * 整数からゼロ付の数字へ変換
	 * @param number
	 * @return String	数字（0~9）→（00~09）
	 */
	public static String addZero(String number) {
		StringBuffer sb = new StringBuffer();
		if (number.length() < 2) {
			sb.append(CommonConst.NAM_COMMON_INTEGER_INITIAL_VALUE);
		}
		sb.append(number);
		return sb.toString();
	}

	/**
	 * 郵便番号分離メソッド
	 * @param	code 郵便番号
	 * @return 前3桁
	 */
	public static String divideYubinCodeForward(String code) {
		String[] ar = code.split(CommonConst.STR_SEPARATOR);
		if (ar.length > 0) {
			return ar[0];
		} else {
			return "";
		}	
	}

	/**
	 * 郵便番号分離メソッド
	 * @param	code 郵便番号
	 * @return 後4桁
	 */
	public static String divideYubinCodeBackward(String code) {
		String[] ar = code.split(CommonConst.STR_SEPARATOR);
		if (ar.length > 1) {
			return ar[1];
		} else {
			return "";
		}
	}

	/**
	 * カンマ分割メソッド
	 * @param code 対象データ
	 * @param comma カンマ数
	 * @return 分割配列<br>
	 * カンマとカンマの間に何も無い場合、
	 * 配列に「""」が代入される。
	 * 
	 */
	public static String[] divideByComma(String code, int comma) {
		String[] base = code.split(CommonConst.KEY_SEPARATOR);
		String[] ar = new String[comma + 1];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * カンマ分割メソッド
	 * @param code 対象データ
	 * @return 分割配列<br>
	 * カンマとカンマの間に何も無い場合、
	 * 配列に「""」が代入される。
	 */
	public static String[] divideByComma(String code) {
		String[] base = code.split(CommonConst.KEY_SEPARATOR);
		String[] ar = new String[base.length];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * カンマ結合メソッド
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	public static String combineByComma(String[] array) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i]);
			if (i < array.length - 1) {
				sb.append(CommonConst.KEY_SEPARATOR);
			}			
		}
		return sb.toString();
	}

	/**
	 * スラッシュ分割メソッド
	 * @param code		対象コード
	 * @return　分割配列
	 */
	public static String[] divideBySlash(String code) {
		String[] base = code.split(CommonConst.SEPARATOR_DATE);
		String[] ar = new String[base.length];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * スラッシュ分割メソッド
	 * @param code		対象コード
	 * @param slash		スラッシュ数
	 * @return　分割配列
	 */
	public static String[] divideBySlash(String code, int slash) {
		String[] base = code.split(CommonConst.SEPARATOR_DATE);
		String[] ar = new String[slash + 1];
		for (int i = 0; i < base.length; i++) {
			ar[i] = base[i];
		}
		for (int i = 0; i < ar.length; i++) {
			if (ar[i] == null) {
				ar[i] = "";
			}
		}
		return ar;
	}

	/**
	 * nullに初期値をセット
	 * @param obj
	 * @param init
	 * @return	string 変換文字列
	 */
	public static String convNullToInitialValue(Object obj, String init) {
		String value = init;
		if (obj == null) {
			return value;
		} else {
			return (String)obj;
		}
	}
	/**
	 * 文字列を分割する
	 * @param Sspl1
	 * @param Sspl2
	 * @param Sspl3
	 * @return	分割文字列
	 */
	public static String splitStrings(String Sspl1, String Sspl2, int Sspl3) {
		if (Sspl1.length() > 0){
			if (Sspl1.indexOf(Sspl2) != -1)  {
				int i = Sspl1.indexOf(Sspl2);
				if (Sspl3 == 0) {
					return Sspl1.substring(0,i);
				} else {
					return Sspl1.substring(i+1,Sspl1.length());
				}
			} else {
				return Sspl1;
			}
		} else {
			return "";
		}
	}

	/**
	 * 仮名文字列を半角カナへ統一
	 * @param input		対象仮名文字列
	 * @return	半角カナ変換後文字列
	 */
	public static String toHankakuKana(String input) {
		return KanaConvertUtility.convZenkakuToHankaku(KanaConvertUtility.convHiraGanaToHankaku(input));
	}

	/**
	 * 全角スペースを半角スペースへ変換
	 * @param input		全角スペースが含まれる文字列
	 * @return	全角スペースを半角スペースへ変換後の文字列
	 */
	public static String to1byteSpace(String input) {
		StringBuffer sb = new StringBuffer();
		String[] aryInput = input.split("　");
		for (int i = 0; i < aryInput.length; i++) {
			sb.append(aryInput[i]);
			if (i != aryInput.length -1) {
				sb.append(CommonConst.NAM_COMMON_HALF_KANA_SPACE);
			}
		}
		return sb.toString();
	}

	/*	フラグ変換	*/

	/**
	 * フラグ変換（String→boolean）
	 * @param target 対象String
	 * @param trueflag trueを返す条件
	 * @param falseflag falseを返す条件
	 * @return 結果 どちらでもない場合false
	 */
	public static boolean convFlagToBoolean(String target, String trueflag, String falseflag) {
		if (target.equals(trueflag)) {
			return true;
		} else if (target.equals(falseflag)) {
			return false;
		} else {
			return false;
		}
	}

	/**
	 * フラグ変換（String→boolean）
	 * @param target 対象String
	 * @param trueflag trueを返す条件
	 * @return 結果
	 */
	public static boolean convFlagToBoolean(String target, String trueflag) {
		if (target.equals(trueflag)) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * フラグ変換（int→boolean）
	 * @param target 対象int
	 * @param trueflag trueを返す条件
	 * @return 結果
	 */
	public static boolean convFlagToBoolean(int target, int trueflag) {
		if (target == trueflag) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * フラグ変換（boolean→String）
	 * @param isTrue 	trueの場合のString
	 * @param isFalse	falseの場合のString
	 * @param flag 		true or false
	 * @return	String 	判別名称
	 */
	public static String returnStringFlag(String isTrue, String isFalse, boolean flag) {
		if (flag) {
			return isTrue;
		} else {
			return isFalse;
		}
	}

	/**
	 * フラグ変換（boolean→String）
	 * @param flag 	true or false
	 * @return true…OFF、false…ON
	 */
	public static String returnTrueIsOff(boolean flag) {
		if (flag) {
			return CommonConst.NAM_COMMON_FLAG_OFF;
		} else {
			return CommonConst.NAM_COMMON_FLAG_ON;
		}
	}

	/**
	 * フラグ変換（boolean→String）
	 * @param flag 	true or false
	 * @return true…ON、false…OFF
	 */
	public static String returnTrueIsOn(boolean flag) {
		if (flag) {
			return CommonConst.NAM_COMMON_FLAG_ON;
		} else {
			return CommonConst.NAM_COMMON_FLAG_OFF;
		}
	}

}
