環境依存文字のパリーデーションを理解したい

Question

環境依存文字のバリデーションを理解したいのですが、以下のコードを理解したいです。ポイントやどこを理解したらわかりやすいでしょうか？

package xxx.validator;

import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;

import javax.faces.FacesException;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.internal.FacesMessageUtil;
import javax.faces.internal.UIComponentUtil;
import javax.faces.validator.Validator;

import org.apache.commons.lang.StringUtils;
import org.seasar.framework.util.AssertionUtil;
import org.seasar.framework.util.StringUtil;
import org.seasar.teeda.extension.exception.ExtendValidatorException;
import org.seasar.teeda.extension.util.TargetCommandUtil;
import org.seasar.teeda.extension.validator.ValidationTargetSelectable;

public class InvalidCharsetValidator implements Validator, ValidationTargetSelectable {

  public static final String INVALID_CHARSET_MESSAGE_ID = "xxx";

  private String target;

  private String[] targets;

  private String messageId;

  private String charSet;

  private List<String> invalidCharList;

  @Override
  public void validate(FacesContext context, UIComponent component, Object value) throws FacesException {
      AssertionUtil.assertNotNull("context", context);
      AssertionUtil.assertNotNull("component", component);

      if (!isTargetCommandValidation(context, targets)) {
          return;
      }

      if (value == null) {
          return;
      }

      if (hasInvalidCharset(value)) {
          Object[] args = new Object[] { UIComponentUtil.getLabel(component),
                  StringUtils.join(invalidCharList.toArray(new String[0]), ",") };
          String msgId = (getMessageId() != null) ? getMessageId() : INVALID_CHARSET_MESSAGE_ID;
          FacesMessage message = FacesMessageUtil.getMessage(context, msgId, args);
          throw new ExtendValidatorException(message, new String[] { msgId });
      }
  }

  protected boolean hasInvalidCharset(Object value) {
      if (value == null || !(value instanceof String)) {
          return false;
      }

      String strValue = (String) value;
      Charset charset = Charset.forName(charSet); // 文字セット（コード）の設定
      CharsetEncoder encoder = charset.newEncoder(); // エンコーダーの生成

      invalidCharList = new ArrayList<String>();
      for (int i = 0; strValue != null && i < strValue.length(); i++) {
          char target_c = strValue.charAt(i);

          // Unicodeマッピング不整合が発生する文字を事前に変換
          target_c = convertMappingMismatchChar(target_c, charset);

          // エンコード可能かどうかを１文字づつチェック
          if (!encoder.canEncode(target_c)) {

              if (Character.isHighSurrogate(target_c)) {
                  // サロゲートペアの場合
                  char[] invalidChars = Character.toChars(Character.toCodePoint(target_c, strValue.charAt(i + 1)));
                  addInvalidCharList(new String(invalidChars));
                  i++;
              } else {
                  // サロゲートペアではない場合
                  addInvalidCharList(new Character(target_c).toString());
              }

          }
      }
      return invalidCharList.size() > 0;
  }

  /**
   * Unicodeマッピング不整合が発生する特殊文字の変換
   * 入力値を EUC_JP または Shift_JIS として扱う場合にUnicodeマッピング不整合が発生する文字を個別に変換して回避するため変換を行う
   * 以下の文字を変換の対象としている
   *   ￠(0xFFE0)
   *   ￡(0xFFE1)
   *   ￢(0xFFE2)
   *   ∥(0x2225)
   *   －(0xFF0D)
   *   ～(0xFF5E)
   *   ―(0x2015)
   * @param target_c 対象文字
   * @return 変換後文字
   */
  private char convertMappingMismatchChar(char target_c, Charset charset) {
      if (StringUtils.equals("EUC-JP", charset.name()) || StringUtils.equals("Shift_JIS", charset.name())) {
          switch (target_c) {
          case (char) 0xFFE0:
              target_c = (char) 0x00A2;
              break;
          case (char) 0xFFE1:
              target_c = (char) 0x00A3;
              break;
          case (char) 0xFFE2:
              target_c = (char) 0x00AC;
              break;
          case (char) 0x2225:
              target_c = (char) 0x2016;
              break;
          case (char) 0xFF0D:
              target_c = (char) 0x2212;
              break;
          case (char) 0xFF5E:
              target_c = (char) 0x301C;
              break;
          case (char) 0x2015:
              target_c = (char) 0x2014;
              break;
          default:
              break;
          }
      }
      return target_c;
  }

  protected void addInvalidCharList(String str) {
      invalidCharList.add("\"" + str + "\"");
  }

  public String getMessageId() {
      return !StringUtil.isEmpty(messageId) ? messageId : INVALID_CHARSET_MESSAGE_ID;
  }

  public void setMessageId(String messageId) {
      this.messageId = messageId;
  }

  public String getCharSet() {
      return charSet;
  }

  public void setCharSet(String charSet) {
      this.charSet = charSet;
  }

  public List<String> getInvalidCharList() {
      return invalidCharList;
  }

  public void setInvalidCharList(List<String> invalidCharList) {
      this.invalidCharList = invalidCharList;
  }

  @Override
  public String getTarget() {
      return target;
  }

  @Override
  public void setTarget(String target) {
      this.target = target;
      if (StringUtil.isEmpty(target)) {
          return;
      }
      targets = StringUtil.split(target, ", ");
  }

  @Override
  public boolean isTargetCommandValidation(FacesContext context, String[] targets) {
      return TargetCommandUtil.isTargetCommand(context, targets);
  }

}

Answer 1

基本的には1文字ずつ取り出して target_c = strValue.charAt(i);

変換先文字コード charSet で target_c が表現できるか見ています：
// エンコード可能かどうかを１文字づつチェック if (!encoder.canEncode(target_c)) {

ただし、Unicode では「サロゲートペア」といって、2文字（正確にはコードポイント）の組み合わせで1文字を表現することがあり、
ペアの最初の1文字でサロゲートペアか判定して
Character.isHighSurrogate(target_c)
サロゲートペアなら続きの文字と合わせて「変換できない文字リスト」に追加しています。

で、その前に、変換先文字コードが EUC-JP, Shift_JIS の場合に
Java で通常 変換できない記号を自前で別の文字として読み替えて、変換できることにしています：

// Unicodeマッピング不整合が発生する文字を事前に変換
target_c = convertMappingMismatchChar(target_c, charset);

最終的に変換できない文字リストが空ならバリデーションに合格する感じです。