blc/han/blc_hangul.h - C++ 한글 라이브러리

blc_hangul.h 에는 한글 자모 처리와 관련된 클래스와 전역 함수들이 포함되어 있습니다. 여기서 말하는 한글이란, 옛 한글은 포함하지 않은 현대 한글을 의미합니다.

다음의 표는 자모 코드표 입니다. class HangulJamo에 사용됩니다.



이 문서에서는 blc_hangul.h에 포함된 클래스와 전역 함수들에 대해 설명합니다. 아래에 설명된 요소들은 모두 namespace blc::han 내부에 선언되어 있습니다.

• class JamoTable final

  ---

  한글 자모 목록을 모두 담는 클래스 입니다. 초성, 중성, 종성 별로 분류되어 있습니다. 이 클래스의 객체는 단 2개로 한정되며(추가 생성 및 복사 불가), 이중 하나는 한글 자모의 목록을, 다른 하나는 호환용 한글 자모의 목록을 표현합니다. 이 클래스의 public 멤버 상수에 직접 접근하여 사용하는 것은 권장하지 않습니다.

  ---

  
  
  • using 선언된 타입
    • RangeCheckFunction

      ---

      std::function<bool(uint32_t)>의 별칭입니다. 넘겨받은 유니코드가 각각 (호환용) 한글 자모의 초성, 중성, 종성인지 점검하기 위한 표준 함수자 타입입니다.

      ---

      
      
  • 멤버 상수
    • static constexpr uint8_t kOnsetSize_

      ---

      현대 한글의 초성 개수(19개)를 의미합니다.

      ---

      
      
    • static constexpr uint8_t kNucleusSize_

      ---

      현대 한글의 중성 개수(21개)를 의미합니다.

      ---

      
      
    • static constexpr uint8_t kCodaSize_

      ---

      현대 한글의 종성 개수(28개, 채움 포함)를 의미합니다.

      ---

      
      
    • const uint16_t(&kOnsetRef_)[kOnsetSize_]

      ---

      한글 자모 또는 호환용 한글 자모의 초성만을 담는 배열의 참조자 입니다. kOnsetSize_는 19의 값을 갖습니다.

      ---

      
      
    • const uint16_t(&kNucleusRef_)[kNucleusSize_]

      ---

      한글 자모 또는 호환용 한글 자모의 중성만을 담는 배열의 참조자 입니다. kNucleusSize_는 21의 값을 갖습니다.

      ---

      
      
    • const uint16_t(&kCodaRef_)[kCodaSize_]

      ---

      한글 자모 또는 호환용 한글 자모의 종성만을 담는 배열의 참조자 입니다. kCodaSize_는 28(채움 포함)의 값을 갖습니다.

      ---

      
      
    • const RangeCheckFunction kCheckOnset_

      ---

      RangeCheckFunction 타입 상수 객체 입니다. 특정 유니코드가 한글의 초성인지 점검하는 역할을 합니다.

      ---

      
      
    • const RangeCheckFunction kCheckNucleus_

      ---

      RangeCheckFunction 타입 상수 객체 입니다. 특정 유니코드가 한글의 중성인지 점검하는 역할을 합니다.

      ---

      
      
    • const RangeCheckFunction kCheckCoda_

      ---

      RangeCheckFunction 타입 상수 객체 입니다. 특정 유니코드가 한글의 종성인지 점검하는 역할을 합니다.

      ---

      
      
  • 멤버 함수
    • static const JamoTable& GetTable() noexcept

      ---

      상수 멤버 배열 참조자는 한글 자모 배열을 참조하도록, 자모 점검 함수 객체는 한글 자모를 점검하는 함수 객체를 담도록 초기화 된 JamoTable 객체의 참조자를 반환합니다.
      
      JamoTable 객체는, 이 함수와 GetCompatibilityTable 함수, 그리고 AutoSelectTable 함수가 반환하는 참조자를 통해서만 사용할 수 있습니다. 별도로 JamoTable 객체를 생성하거나 복사하는 것은 금지됩니다. 다음은 예제 코드입니다.
      
      

      1. ...
      2.  
      3. auto& tbl = JamoTable::GetTable();
      4.  
      5. // 한글 자모 테이블을 얻습니다.
      6. // JamoTable 객체는 복사를 할 수 없으므로,
      7. // 참조자로 받습니다.
      8. // 이제 tbl을 통해 한글 자모 테이블을 이용할 수 있습니다.
      9.  
      10. ...

      ---

      
      
    • static const JamoTable& GetCompatibilityTable() noexcept

      ---

      상수 멤버 배열 참조자는 호환용 한글 자모 배열을 참조하도록, 자모 점검 함수 객체는 호환용 한글 자모를 점검하는 함수 객체를 담도록 초기화 된 JamoTable 객체의 참조자를 반환합니다.
      
      JamoTable 객체는, 이 함수와 GetTable 함수, 그리고 AutoSelectTable 함수가 반환하는 참조자를 통해서만 사용할 수 있습니다. 별도로 JamoTable 객체를 생성하거나 복사하는 것은 금지됩니다. 다음은 예제 코드입니다.
      
      

      1. ...
      2.  
      3. auto& tbl = JamoTable::GetCompatibilityTable();
      4.  
      5. // 호환용 한글 자모 테이블을 얻습니다.
      6. // JamoTable 객체는 복사를 할 수 없으므로,
      7. // 참조자로 받습니다.
      8. // 이제 tbl을 통해 호환용 한글 자모 테이블을 이용할 수 있습니다.
      9.  
      10. ...

      ---

      
      
    • static const JamoTable& AutoSelectTable(uint32_t unicode) noexcept

      ---

      매개변수 unicode가 갖는 문자값이 한글 호환용 자모인 경우 GetCompatibilityTable 함수가 반환하는 JamoTable 객체의 참조자를, 그렇지 않은 경우 GetTable 함수가 반환하는 JamoTable 객체의 참조자를 반환합니다. 즉, 매개변수 unicode 값에 따라 적절한 JamoTable 객체의 참조자를 반환합니다.
      
      JamoTable 객체는, 이 함수와 GetTable 함수, 그리고 GetCompatibilityTable 함수가 반환하는 참조자를 통해서만 사용할 수 있습니다. 별도로 JamoTable 객체를 생성하거나 복사하는 것은 금지됩니다. 다음은 예제 코드입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. auto& jamo_tbl = JamoTable::AutoSelectTable(U'\x1100');
      10.  
      11. // U+1100은 한글 자모 영역에 속한 문자이므로 jamo_tbl 은
      12. // 한글 자모 테이블이 됩니다.
      13.  
      14. cout << (jamo_tbl == JamoTable::GetTable()) << endl;
      15.  
      16. // 실행 결과는 "1"
      17.  
      18. auto& compatibility_jamo_tbl = JamoTable::AutoSelectTable(U'\x3131');
      19.  
      20. // U+3131은 호환용 한글 자모 영역에 속한 문자이므로
      21. // compatibility_jamo_tbl 은 호환용 한글 자모 테이블이 됩니다.
      22.  
      23. cout << (compatibility_jamo_tbl == JamoTable::GetCompatibilityTable()) << endl;
      24.  
      25. // 실행 결과는 "1"
      26.  
      27. // JamoTable 객체는 복사가 불가능하므로,
      28. // AutoSelectTable의 반환값도 참조자로 받아야 합니다.
      29.  
      30. return 0;
      31. }

      ---

      
      
    • bool operator ==(const JamoTable& rhs) const noexcept

      ---

      this와 rhs 가 같은 JamoTable 객체이면 true를, 다른 객체이면 false를 반환합니다.

      ---

      
      
    • bool operator !=(const JamoTable& rhs) const noexcept

      ---

      this와 rhs 가 다른 JamoTable 객체이면 true를, 같은 객체이면 false를 반환합니다.

      ---

      
      
• struct Onset final

  ---

  한글 초성과 관련된 연산을 담는 단위전략입니다. class HangulJamo 내부에서 사용되므로 이 단위전략의 멤버를 직접 사용할 일은 없다고 보시면 됩니다. (이 구조체의 멤버에 직접 접근하여 사용하는 것은 권장하지 않습니다)

  ---

  
  
  • 멤버 상수
    • static constexpr uint8_t kSize

      ---

      현대 한글 초성의 개수(19개)를 의미합니다.

      ---

      
      
  • 멤버 함수
    • static const uint16_t* GetArray(const JamoTable& table) noexcept

      ---

      JamoTable 객체로부터 (호환용) 한글 초성을 모두 담은 배열을 가져다 반환합니다.

      ---

      
      
    • static uint32_t Extract(uint32_t unicode) noexcept

      ---

      한글 음절 문자의 유니코드 값을 담은 매개변수 unicode로부터, 한글 음절의 초성 부분만 분리하여 초성 코드를 반환합니다.

      ---

      
      
    • static int32_t Get(int32_t onset_code) noexcept

      ---

      초성 코드값을 갖는 매개변수 onset_code을 가지고, 한글 음절 문자 조립을 위한 값을 계산하여 반환합니다. 이 반환 값을 U+AC00("가")에 더해주면 "가" 라는 음절 문자에서, 초성만을 onset_code(초성 코드)값에 해당하는 초성으로 변경된 음절 문자값(유니코드)이 됩니다.

      ---

      
      
    • static bool CheckRange(uint32_t unicode, const JamoTable& table) noexcept

      ---

      매개변수 unicode의 값이 한글 초성 문자이면 true, 아니면 false를 반환합니다. 매개변수 table에 따라 한글 자모의 초성인지 점검할 수도 있고, 호환용 한글 자모의 초성인지 검사할 수도 있습니다.

      ---

      
      
• struct Nucleus final

  ---

  한글 중성과 관련된 연산을 담는 단위전략입니다. class HangulJamo 내부에서 사용되므로 이 단위전략의 멤버를 직접 사용할 일은 없다고 보시면 됩니다. (이 구조체의 멤버에 직접 접근하여 사용하는 것은 권장하지 않습니다)

  ---

  
  
  • 멤버 상수
    • static constexpr uint8_t kSize

      ---

      현대 한글 중성의 개수(21개)를 의미합니다.

      ---

      
      
  • 멤버 함수
    • static const uint16_t* GetArray(const JamoTable& table) noexcept

      ---

      JamoTable 객체로부터 (호환용) 한글 중성을 모두 담은 배열을 가져다 반환합니다.

      ---

      
      
    • static uint32_t Extract(uint32_t unicode) noexcept

      ---

      한글 음절 문자의 유니코드 값을 담은 매개변수 unicode로부터, 한글 음절의 중성 부분만 분리하여 중성 코드를 반환합니다.

      ---

      
      
    • static int32_t Get(int32_t nucleus_code) noexcept

      ---

      중성 코드값을 갖는 매개변수 nucleus_code을 가지고, 한글 음절 문자 조립을 위한 값을 계산하여 반환합니다. 이 반환 값을 U+AC00("가")에 더해주면 "가" 라는 음절 문자에서, 중성만을 nucleus_code(중성 코드)값에 해당하는 중성으로 변경된 음절 문자값(유니코드)이 됩니다.

      ---

      
      
    • static bool CheckRange(uint32_t unicode, const JamoTable& table) noexcept

      ---

      매개변수 unicode의 값이 한글 중성 문자이면 true, 아니면 false를 반환합니다. 매개변수 table에 따라 한글 자모의 중성인지 점검할 수도 있고, 호환용 한글 자모의 중성인지 검사할 수도 있습니다.

      ---

      
      
• struct Coda final

  ---

  한글 종성과 관련된 연산을 담는 단위전략입니다. class HangulJamo 내부에서 사용되므로 이 단위전략의 멤버를 직접 사용할 일은 없다고 보시면 됩니다. (이 구조체의 멤버에 직접 접근하여 사용하는 것은 권장하지 않습니다)

  ---

  
  
  • 멤버 상수
    • static constexpr uint8_t kSize

      ---

      현대 한글 종성의 개수(28개, 채움 포함)를 의미합니다.

      ---

      
      
  • 멤버 함수
    • static const uint16_t* GetArray(const JamoTable& table) noexcept

      ---

      JamoTable 객체로부터 (호환용) 한글 종성을 모두 담은 배열을 가져다 반환합니다.

      ---

      
      
    • static uint32_t Extract(uint32_t unicode) noexcept

      ---

      한글 음절 문자의 유니코드 값을 담은 매개변수 unicode로부터, 한글 음절의 종성 부분만 분리하여 종성 코드를 반환합니다.

      ---

      
      
    • static int32_t Get(int32_t coda_code) noexcept

      ---

      종성 코드값을 갖는 매개변수 coda_code을 가지고, 한글 음절 문자 조립을 위한 값을 계산하여 반환합니다. 이 반환 값을 U+AC00("가")에 더해주면 "가" 라는 음절 문자에서, 종성만을 coda_code(종성 코드)값에 해당하는 종성으로 변경된 음절 문자값(유니코드)이 됩니다.

      ---

      
      
    • static bool CheckRange(uint32_t unicode, const JamoTable& table) noexcept

      ---

      매개변수 unicode의 값이 한글 종성 문자이면 true, 아니면 false를 반환합니다. 매개변수 table에 따라 한글 자모의 종성인지 점검할 수도 있고, 호환용 한글 자모의 종성인지 검사할 수도 있습니다.

      ---

      
      
• class HangulJamo final

  ---

  (호환용) 한글 자모를 처리하기 위한 클래스 템플릿 입니다. 전체 선언은 다음과 같이 됩니다.
  
  

  1. template <
  2. typename JamoType_,
  3. typename = std::enable_if_t<IsJamoType<std::decay_t<JamoType_>>::value>
  4. >
  5. class HangulJamo;
  6.  
  7. // 여기서 JamoType_에는 struct Onset, struct Nucleus, struct Coda
  8. // 이렇게 세 개의 단위전략 중 하나만이 올 수 있습니다.
  9.  
  10. // std::enable_if_t는 JamoType_이 위의 세 개의 단위전략 중 하나인지 점검합니다.

  ---

  
  
  • 멤버 상수
    • static constexpr uint8_t kInvalidCode_

      ---

      올바르지 않은 자모 코드를 의미합니다. 모든 비트가 1인 uint8_t 타입의 상수입니다. 즉, 255의 값을 갖습니다.

      ---

      
      
  • 멤버 함수
    • HangulJamo(...) noexcept

      ---

      HangulJamo 클래스의 생성자 입니다. 생성자는 네 개의 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. HangulJamo() noexcept;
      5. // 기본 생성자 입니다.
      6. // 자모 코드를 kInvalidCode_로 초기화 합니다.
      9. //-----------------------------------------------------------------------------
      10. // 2
      11. HangulJamo(uint32_t unicode, const JamoTable& table) noexcept;
      13. // 문자의 유니코드와 JamoTable(한글 자모에 속하는 문자인지
      14. // 호환용 한글 자모에 속하는 문자인지)을
      15. // 받아 해당하는 조건에 맞는 자모 코드로 초기화 합니다.
      16.  
      17. // 단위전략에 따라 초성, 중성, 종성을 구분합니다.
      18. // 예를들어, 초성 단위전략을 사용중일때는 초성 이외의
      19. // (호환용) 한글 자모를 받아도 kInvalidCode_로 초기화 됩니다.
      20. // 이 경우 오로지 (호환용) 한글 자모 중, 초성에 해당하는
      21. // 문자만을 받았을때, 초성의 자모 코드로 초기화 됩니다.
      23. // unicode에 담긴 문자가 (호환용) 한글 자모가 아니거나,
      24. // table은 호환용 한글 자모인데 unicode는 한글 자모, 혹은 그 반대의 경우에는
      25. // 자모 코드를 kInvalidCode_로 초기화 합니다.
      28. //-----------------------------------------------------------------------------
      29. // 3
      30. explicit HangulJamo(uint32_t unicode) noexcept;
      32. // 2번 생성자와 같은 일을 하지만, unicode에 담긴 코드값에 따라
      33. // 호환용 한글 자모인지 한글 자모인지를 자동으로 선택합니다
      34. // (table을 자동 선택).
      37. //-----------------------------------------------------------------------------
      38. // 4
      39. HangulJamo(const HangulJamo& rhs) noexcept;
      41. // 복사생성자 입니다. rhs의 자모 코드를 그대로 가져와 초기화 합니다.
      42. // this와 rhs는 같은 단위전략을 사용해야 합니다.

      
      HangulJamo 클래스는 이동 연산이 복사 연산에 비해 효율적이지 않으므로 별도의 이동 연산이 정의되지 않습니다. 다음은 예제 코드 입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. //-------------------------------------------------------------------------
      10. HangulJamo<Onset> onset1(U'\x1100', JamoTable::GetTable());
      11.  
      12. // 한글 자모 영역의 초성 U+1100과, 한글 자모 테이블을 통해 생성됩니다.
      14. cout << onset1.IsValidCode() << endl;
      15.  
      16. // 실행 결과 "1"
      17.  
      18.  
      19. //-------------------------------------------------------------------------
      20. HangulJamo<Nucleus> nucleus1(U'\x1100', JamoTable::GetTable());
      21.  
      22. // 단위전략은 중성을 사용했으나, 넘겨준 유니코드가 초성이기 때문에
      23. // 올바르지 않은 값을 갖도록 생성됩니다.
      24.  
      25. cout << nucleus1.IsValidCode() << endl;
      26.  
      27. // 실행 결과 "0"
      28.  
      29.  
      30. //-------------------------------------------------------------------------
      31. HangulJamo<Onset> onset2(U'\x3131', JamoTable::GetTable());
      32.  
      33. // 호환용 한글 자모 영역의 초성 U+3131을 넘겨주었으나
      34. // 테이블이 호환용 한글 자모 테이블이 아니라 한글 자모 테이블이므로,
      35. // 올바르지 않은 값을 갖도록 생성됩니다.
      36.  
      37. cout << onset2.IsValidCode() << endl;
      38.  
      39. // 실행 결과 "0"
      40.  
      41.  
      42. //-------------------------------------------------------------------------
      43. HangulJamo<Onset> onset4(U'\x1100');
      44. HangulJamo<Onset> onset5(U'\x3131');
      45.  
      46. // 테이블 종류를 생략하면 자동으로 적절한 테이블이 선택됩니다.
      47.  
      48. cout << onset4.IsValidCode() << ' ' << onset5.IsValidCode() << endl;
      49.  
      50. // 실행 결과 "1 1"
      51.  
      52.  
      53. //-------------------------------------------------------------------------
      54. HangulJamo<Nucleus> nucleus2(U'\x1100');
      55.  
      56. // 테이블을 생략하더라도 단위전략과 넘겨준 유니코드는
      57. // 적절한 조합이어야 합니다.
      58.  
      59. // 유니코드는 한글 자모 영역의 초성이므로
      60. // 올바르지 않은 값을 갖도록 생성됩니다.
      61.  
      62. cout << nucleus2.IsValidCode() << endl;
      63.  
      64. // 실행 결과 "0"
      65.  
      66. return 0;
      67. }

      
      JamoTable에 관한 자세한 설명을 보려면 이 문장을 클릭하세요.

      ---

      
      
    • HangulJamo& operator =(...) & noexcept

      ---

      대입 연산자 입니다. 대입 연산자는 두 가지의 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. HangulJamo& operator =(const HangulJamo& rhs) & noexcept;
      4.  
      5. // 복사 대입 연산자 입니다. rhs의 자모 코드 값을 그대로 가져와
      6. // this 에 대입합니다.
      7.  
      8. // this와 rhs는 같은 단위전략을 사용해야 합니다.
      9.  
      10.  
      11. //-----------------------------------------------------------------------------
      12. // 2
      13. HangulJamo& operator =(uint32_t unicode) & noexcept;
      14.  
      15. // 매개변수 unicode가 갖는 문자 값이 (호환용) 한글 자모인 경우,
      16. // 해당 자모 코드를 this에 대입합니다.
      17.  
      18. // 단위전략에 따라 초성, 중성, 종성을 구분합니다.
      19. // 예를들어, 초성 단위전략을 사용중일때는 초성 이외의
      20. // (호환용) 한글 자모를 받아도, this는 kInvalidCode_의
      21. // 자모 코드 값을 갖게 됩니다.
      22. // 이 경우 오로지 (호환용) 한글 자모 중, 초성에 해당하는
      23. // 문자만을 받았을 때, this가 초성의 자모 코드를 갖게 됩니다.
      24.  
      25. // unicode에 담긴 코드값에 따라 호환용 한글 자모인지 한글 자모인지를
      26. // 자동으로 선택합니다(세 번째 생성자와 동일).

      
      HangulJamo 클래스는 이동 연산이 복사 연산에 비해 효율적이지 않으므로 별도의 이동 연산이 정의되지 않습니다.

      ---

      
      
    • bool IsValidCode() const noexcept

      ---

      this가 갖고 있는 자모 코드가 유효한 코드이면 true, 그렇지 않으면 false를 반환합니다. 한글 초성과 중성, 그리고 종성은 서로 개수가 다르므로 사용하는 단위전략에 따라 유효한 자모 코드의 범위가 다릅니다. 즉, 초성 단위전략 사용 시 0 ~ 18 까지의 값이 유효하고, 중성 단위전략 사용 시 0 ~ 20 까지의 값이 유효하며, 종성 단위전략 사용 시 0 ~ 27 까지의 값이 유효합니다.

      ---

      
      
    • uint8_t SetUnicode(...) noexcept

      ---

      이 함수는 두 가지의 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. uint8_t SetUnicode(uint32_t unicode, const JamoTable& table) noexcept;
      4.  
      5. // 문자의 유니코드와 JamoTable(한글 자모에 속하는 문자인지
      6. // 호환용 한글 자모에 속하는 문자인지)를 받아 해당하는
      7. // 조건에 맞는 자모 코드를 this에 대입합니다.
      8.  
      9. // 단위전략에 따라 초성, 중성, 종성을 구분합니다.
      10. // 예를 들어, 초성 단위전략을 사용중일때는 초성 이외의
      11. // (호환용) 한글 자모를 받아도 this는 kInvalidCode_의
      12. // 값을 갖게 됩니다.
      13. // 이 경우 오로지 (호환용) 한글 자모 중, 초성에 해당하는
      14. // 문자만을 받았을 때, this가 초성의 자모 코드를
      15. // 갖게 됩니다.
      16.  
      17. // unicode에 담긴 문자가 (호환용) 한글 자모가 아니거나,
      18. // table은 호환용 한글 자모인데 unicode는 한글 자모, 혹은
      19. // 그 반대의 경우에는 this의 값이 kInvalidCode_가 됩니다.
      20.  
      21. // 반환값은, 이 함수 호출로 인하여 변경된 this가 갖는 자모 코드 입니다.
      22.  
      23.  
      24. //-----------------------------------------------------------------------------
      25. // 2
      26. uint8_t SetUnicode(uint32_t unicode) noexcept;
      27.  
      28. // 위의 첫 번째 오버로딩 버전과 같은 일을 하지만, unicode에 담긴 코드값에 따라
      29. // 호환용 한글 자모인지 한글 자모인지를 자동으로 선택합니다
      30. // (table을 자동 선택).

      
      두 번째와 세 번째 생성자와 유사하므로, 예제 코드는 생성자를 참고하세요.

      ---

      
      
    • uint8_t SetJamoCode(uint32_t code) noexcept

      ---

      자모 코드값을 직접 this에 세팅합니다. 올바른 범위를 초과하는 값을 넘겨주면, this는 kInvalidCode_값을 갖게 됩니다. 반환 값은, 이 함수 호출로 인해 변경된 this의 자모 코드 입니다.

      ---

      
      
    • uint32_t GetUnicode(const JamoTable& table) const noexcept

      ---

      this가 갖는 자모 코드값과 사용중인 단위전략에 해당하는, (호환용) 한글 자모 문자의 유니코드를 구합니다. 매개변수 table이 한글 자모 테이블이라면, 반환되는 유니코드 문자는 한글 자모 입니다. table이 호환용 한글 자모 테이블이라면, 반환되는 유니코드 문자는 호환용 한글 자모 입니다. 또한, 사용중인 단위전략이 초성/중성/종성 이라면 반환되는 (호환용) 한글 자모도 초성/중성/종성이 됩니다. this가 올바르지 않은 자모 코드값을 갖고 있는 상태에서 이 함수를 호출하면 blc::ustr::encoding::kInvalidCharacter 문자(모든 비트가 1인 32비트 정수 상수)가 반환됩니다. 다음은 예제 코드 입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. HangulJamo<Onset> onset;
      10.  
      11. cout << hex << onset.GetUnicode(JamoTable::GetTable()) << endl;
      12.  
      13. // 기본 생성자는 this를 kInvalidCode_로 초기화 합니다.
      14. // this가 유효하지 않은 자모 코드를 가지고 있을 때
      15. // GetUnicode 함수를 실행하면
      16. // 0xFFFFFFFF(blc::ustr::encoding::kInvalidCharacter)
      17. // 가 반환됩니다.
      18.  
      19. // 실행 결과 "ffffffff"
      20.  
      21. onset.SetJamoCode(0);
      22.  
      23. // 0번 코드를 갖는 초성("ㄱ")으로 세팅합니다.
      24.  
      25. cout << hex << onset.GetUnicode(JamoTable::GetTable()) << endl;
      26.  
      27. // 0번 코드를 갖는 초성 문자의 유니코드를 가져옵니다.
      28. // 이 때, 한글 자모 테이블을 이용했으므로,
      29. // 반환되는 유니코드는 한글 자모 영역의 문자 U+1100이 됩니다.
      30.  
      31. // 실행 결과 "1100"
      32.  
      33. cout << hex << onset.GetUnicode(JamoTable::GetCompatibilityTable()) << endl;
      34.  
      35. // 0번 코드를 갖는 초성 문자의 유니코드를 가져옵니다.
      36. // 이 때, 호환용 한글 자모 테이블을 이용했으므로,
      37. // 반환되는 유니코드는 호환용 한글 자모 영역의 문자 U+3131이 됩니다.
      38.  
      39. // 실행 결과 "3131"
      40.  
      41. return 0;
      42. }

      ---

      
      
    • uint8_t GetJamoCode() const noexcept

      ---

      this가 갖는 자모 코드를 얻어냅니다.

      ---

      
      
    • uint8_t Disassemble(uint32_t unicode) noexcept

      ---

      unicode에 담긴 유니코드가 한글 음절 문자인 경우, 현재 사용중인 단위전략(초성/중성/종성)에 따라 (초성/중성/종성)코드를 this에 담습니다. unicode에 담긴 유니코드가 한글 음절 문자가 아닌 경우에는 this는 kInvalidCode_ 값을 갖게 됩니다. 반환 값은, 이 함수 호출로 인하여 변경된 this가 갖는 자모 코드 입니다. 다음은 예제 코드 입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. HangulJamo<Onset> onset;
      10. char32_t unicode = U'냥';
      11.  
      12. cout << static_cast<int>(onset.Disassemble(unicode)) << endl;
      13.  
      14. // "냥"의 초성 "ㄴ"에 해당하는 초성 코드 2가 반환됩니다.
      15.  
      16. // 실행 결과 "2"
      17.  
      18. cout << static_cast<int>(onset.GetJamoCode()) << endl;
      19.  
      20. // Disassemble 멤버 함수가 값을 반환할 뿐만 아니라
      21. // 대상 객체(여기서는 onset)의 자모 코드값도 변경합니다.
      22.  
      23. // 실행 결과 "2"
      24.  
      25. //-------------------------------------------------------------------------
      26.  
      27. onset.Disassemble(U'a');
      28.  
      29. // 한글 음절 문자가 아닌 문자를 넘겨주면
      30. // this가 올바르지 않은 자모 코드값(kInvalidCode_)
      31. // 을 갖게 됩니다.
      32.  
      33. cout << onset.IsValidCode() << endl;
      34.  
      35. // 실행 결과 "0"
      36.  
      37. return 0;
      38. }

      ---

      
      
    • uint32_t Assemble(uint32_t unicode) const noexcept

      ---

      unicode에 담긴 유니코드가 한글 음절 문자이고 this에 담긴 자모 코드가 유효한 경우, 현재 사용중인 단위전략(초성/중성/종성)에 따라 unicode에 담긴 한글 음절 문자의 초성/중성/종성을 this에 담긴 초성/중성/종성으로 변경하여 반환합니다. unicode에 담긴 유니코드가 한글 음절 문자가 아닌 경우 unicode의 값을 변경없이 그대로 반환합니다. 다음은 예제 코드 입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. HangulJamo<Coda> coda(U'ㅁ');
      10.  
      11. //-------------------------------------------------------------------------
      12. cout << (U'냠' == coda.Assemble(U'냥')) << endl;
      13.  
      14. // 멤버 함수 Assemble 에 넘겨준 한글 음절 문자 "냥"의 종성이,
      15. // coda 가 갖는 종성 코드 16("ㅁ")으로 바뀐 "냠"이 반환됩니다.
      16.  
      17. // 실행 결과 "1"
      18.  
      19.  
      20. //-------------------------------------------------------------------------
      21. cout << (U'a' == coda.Assemble(U'a')) << endl;
      22.  
      23. // 멤버 함수 Assemble 에 한글 음절 문자가 아닌 다른 문자를
      24. // 넘겨주면 변환 없이 그대로 반환합니다.
      25.  
      26. // 실행 결과 "1"
      27.  
      28.  
      29. //-------------------------------------------------------------------------
      30. coda = HangulJamo<Coda>(); // coda를 무효한 자모 코드를 갖도록
      31. cout << (U'냥' == coda.Assemble(U'냥')) << endl;
      32.  
      33. // 대상 객체가 무효한 자모 코드를 갖는 경우
      34. // 멤버 함수 Assemble 에 한글 음절 문자를 넘겨줘도
      35. // 자모의 변환 없이 그대로 반환합니다.
      36.  
      37. // 실행 결과 "1"
      38.  
      39. return 0;
      40. }

      ---

      
      
    • uint32_t Replace(uint32_t unicode, const HangulJamo& new_jamo) const noexcept

      ---

      unicode에 담긴 유니코드가 한글 음절 문자이고, new_jamo와 this가 갖는 자모 코드 값이 유효하며, 현재 사용중인 단위전략(초성/중성/종성)에 따라 unicode에 담긴 한글 음절 문자의 초성/중성/종성이 this가 갖는 초성/중성/종성과 일치하는 경우, 한글 음절 문자의 초성/중성/종성을 new_jamo가 갖는 초성/중성/종성으로 변경하여 그 유니코드를 반환합니다. this와 new_jamo는 같은 단위전략을 사용해야 합니다. 다음은 예제 코드입니다.
      
      

      1. #include "blc/han/blc_hangul.h"
      2. using namespace blc::han;
      3.  
      4. #include <iostream>
      5. using namespace std;
      6.  
      7. int main()
      8. {
      9. HangulJamo<Coda> old_coda(U'ㅁ');
      10. HangulJamo<Coda> new_coda(U'ㅇ');
      11.  
      12. //-------------------------------------------------------------------------
      13. cout << (U'냥' == old_coda.Replace(U'냠', new_coda)) << endl;
      14.  
      15. // 한글 음절 문자 "냠" 에서 종성이 "ㅁ"인 경우
      16. // 종성을 "ㅇ"으로 바꾸는 코드입니다.
      17.  
      18. // 실행 결과 "1"
      19.  
      20.  
      21. //-------------------------------------------------------------------------
      22. cout << (U'삵' == old_coda.Replace(U'삵', new_coda)) << endl;
      23.  
      24. // 한글 음절 문자 "삵"의 종성은 "ㄺ"이므로("ㅁ"이 아님)
      25. // 이 경우 넘겨받은 유니코드 문자를 변환없이
      26. // 그대로 반환합니다.
      27.  
      28. // 실행 결과 "1"
      29.  
      30.  
      31. //-------------------------------------------------------------------------
      32. cout << (U'냥' == HangulJamo<Coda>().Replace(U'냥', new_coda)) << ' '
      33. << (U'냥' == old_coda.Replace(U'냥', HangulJamo<Coda>())) << endl;
      34.  
      35. // 기존의 자모 코드와 새로운 자모 코드 중 하나라도 무효하면
      36. // 넘겨받은 유니코드 문자를 변환없이 그대로 반환합니다
      37. // (기본 생성자는 무효한 값으로 초기화 시킵니다).
      38.  
      39. // 실행 결과 "1 1"
      40.  
      41.  
      42. //-------------------------------------------------------------------------
      43. cout << (U'a' == old_coda.Replace(U'a', new_coda)) << endl;
      45. // 한글 음절 문자가 아닌 문자는
      46. // 변환없이 그대로 반환합니다.
      47.  
      48. // 실행 결과 "1"
      49.  
      50. return 0;
      51. }

      ---

      
      
    • int Compare(const HangulJamo& rhs) const noexcept

      ---

      this와 rhs의 자모 코드를 비교합니다. this의 코드값이 rhs의 코드값보다 크면 1, 작으면 -1, 같으면 0을 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator ==(const HangulJamo& rhs) const noexcept

      ---

      this와 rhs가 같은 자모 코드값을 가지면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator !=(const HangulJamo& rhs) const noexcept

      ---

      this와 rhs가 다른 자모 코드값을 가지면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator <(const HangulJamo& rhs) const noexcept

      ---

      this가 갖는 자모 코드값이 rhs가 갖는 자모 코드값보다 작으면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator >(const HangulJamo& rhs) const noexcept

      ---

      this가 갖는 자모 코드값이 rhs가 갖는 자모 코드값보다 크면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator <=(const HangulJamo& rhs) const noexcept

      ---

      this가 갖는 자모 코드값이 rhs가 갖는 자모 코드값보다 작거나 같으면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
    • bool operator >=(const HangulJamo& rhs) const noexcept

      ---

      this가 갖는 자모 코드값이 rhs가 갖는 자모 코드값보다 크거나 같으면 true, 그렇지 않으면 false를 반환합니다. 같은 단위전략을 사용하는 HangulJamo 객체끼리만 비교가 가능합니다.

      ---

      
      
• 전역 함수

  ---

  blc_hangul.h 헤더에 선언된 전역 함수의 목록입니다.

  ---

  
  
  • constexpr inline bool IsCompatibilityJamo(uint32_t unicode) noexcept

    ---

    매개변수 unicode에 담긴 유니코드가 호환용 한글 자모 영역의 문자인 경우 true를, 그렇지 않으면 false를 반환합니다.

    ---

    
    
  • constexpr inline bool IsHangulSyllable(uint32_t unicode) noexcept

    ---

    매개변수 unicode에 담긴 유니코드가 한글 음절 문자(가[U+AC00] ~ 힣[U+D7A3])인 경우 true를, 그렇지 않으면 false를 반환합니다.

    ---

    
    
  • uint32_t JamoToCompatibilityJamo(uint32_t unicode) noexcept

    ---

    한글 자모 영역의 유니코드를 호환용 한글 자모 영역의 유니코드로 변환합니다. 호환용 한글 자모 영역의 일부 문자는 초성과 종성을 겸하는 경우가 있으므로, 역변환은 불가능합니다. 한글 자모 영역의 문자가 아닌 문자는 변환 없이 그대로 반환합니다.

    ---

    
    
  • uint32_t ReplaceJamo(uint32_t unicode,
    HangulJamo<Onset> old_onset,
    HangulJamo<Nucleus> old_nucleus,
    HangulJamo<Coda> old_coda,
    const HangulJamo<Onset>& new_onset,
    const HangulJamo<Nucleus>& new_nucleus,
    const HangulJamo<Coda>& new_coda
    ) noexcept

    ---

    매개변수 unicode에 담긴 문자가 한글 음절 문자인 경우, 이 문자에서 초성/중성/종성 을 각각 검색해 일치하는 경우 새로운 초성/중성/종성 으로 변경한 문자를 반환합니다. "old_초성/중성/종성"또는 "new_초성/중성/종성"이 올바르지 않은 값인 경우 해당 초성/중성/종성 은 찾아바꾸기를 수행하지 않습니다. 즉, 일부러 초성/중성/종성 중 일부를 변환에서 제외하려면, 매개변수 "old_초성/중성/종성" 또는 "new_초성/중성/종성"에 기본 생성자로 생성한 HangulJamo 객체를 넘겨주면 됩니다. 다음은 예제 코드 입니다.
    
    

    1. #include "blc/han/blc_hangul.h"
    2. using namespace blc::han;
    3.  
    4. #include <iostream>
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. HangulJamo<Onset> old_onset(U'ㅁ'), new_onset(U'ㄴ');
    10. HangulJamo<Nucleus> old_nucleus(U'ㅓ'), new_nucleus(U'ㅑ');
    11. HangulJamo<Coda> invalid_coda;
    12. char32_t result = ReplaceJamo(
    13. U'멍',
    14. old_onset, old_nucleus, invalid_coda,
    15. new_onset, new_nucleus, invalid_coda
    16. );
    17.  
    18. // 위의 함수 호출문은 "멍"이라는 한글 음절 문자를
    19. // "냥" 이라는 한글 음절 문자로 변환합니다.
    20.  
    21. cout << (U'냥' == result) << endl;
    22.  
    23. // 실행 결과 "1"
    24.  
    25. return 0;
    26. }

    
    이러한 변환은 한글 자모 낱자에 대해서도 작동합니다(한글 자모 영역의 낱자는 초성/중성/종성 구분이 있으며, 호환용 한글 자모 영역의 낱자에 대해서는, 초성과 종성을 겸하는 낱자를 초성으로 간주하고 처리합니다. 초성으로 변환을 적용할 수 없는 경우(old_onset 또는 new_onset이 무효한 값인 경우) 종성으로 간주하고 처리합니다).

    ---

    
    
  • std::string ReplaceAllJamo(const std::string& str,
    HangulJamo<Onset> old_onset,
    HangulJamo<Nucleus> old_nucleus,
    HangulJamo<Coda> old_coda,
    const HangulJamo<Onset>& new_onset,
    const HangulJamo<Nucleus>& new_nucleus,
    const HangulJamo<Coda>& new_coda,
    const ustr::CheckCharFuncType& check_char = ustr::CheckCharFuncType()
    )

    ---

    ReplaceJamo 함수가 하는 일을 문자열 str의 모든 문자에 대해 적용합니다. 문자열 str은 DefaultEncoding(UTF-8)로 인코딩 되어 있어야 합니다. check_char를 통해 올바르지 않은 DefaultEncoding(UTF-8) 문자를 처리하는 함수를 지정할 수 있습니다. CheckCharFuncType에 대한 자세한 설명은 아래의 참고자료에서 볼 수 있습니다.
    참고자료

    ---

    
    
  • auto KSX5002ToQwerty(...)

    ---

    문자 하나 또는 문자열의 모든 문자에 대해, 한글 두벌식 키보드를 눌렀을 때 입력되는 한글 자모를, 영어 쿼티 키보드 입력 모드로 놓고 같은 키를 눌렀을 때 입력되는 영어 알파벳으로 변환하는 함수입니다. 이 함수는 두 개의 오버로딩 버전(문자 하나만 처리, 문자열의 모든 문자에 대해 처리)이 제공됩니다.
    
    

    1. //-----------------------------------------------------------------------------
    2. // 1
    3. uint32_t KSX5002ToQwerty(uint32_t unicode);
    4.  
    5. // 매개변수 unicode에 담긴 유니코드 문자가 한글 자모일 때,
    6. // 한글 두벌식 키보드에서 이 자모를 입력하기 위해 누르는 키를
    7. // 영어 쿼티 키보드로 눌렀을 때 입력되는 영어 알파벳으로 변환합니다.
    8.  
    9. // unicode에 담긴 문자가 한글 자모가 아니거나 한 번의 키 입력으로
    10. // 입력할 수 있는 한글 자모가 아닌 경우(예를 들어 ㄺ 같은)
    11. // unicode의 값을 변환 없이 그대로 반환합니다.
    12.  
    13.  
    14. //-----------------------------------------------------------------------------
    15. // 2
    16. std::string KSX5002ToQwerty(
    17. const std::string& str,
    18. const ustr::CheckCharFuncType& check_char = ustr::CheckCharFuncType()
    19. );
    20.  
    21. // 위의 1번 오버로딩 버전의 기능을, 문자열 str의 모든 문자에 대해 적용합니다.
    22. // 문자열 str은 DefaultEncoding(UTF-8)로 인코딩 되어 있어야 합니다.
    23.  
    24. // check_char을 통해 올바르지 않은 DefaultEncoding(UTF-8) 문자를 처리하는 함수를
    25. // 지정할 수 있습니다. CheckCharFuncType에 대한 자세한 설명은
    26. // 아래의 참고자료에서 볼 수 있습니다.
    27. // 참고자료

    ---

    
    
  • auto QwertyToKSX5002(...)

    ---

    문자 하나 또는 문자열의 모든 문자에 대해, 영어 쿼티 키보드를 눌렀을 때 입력되는 영어 알파벳을, 한글 두벌식 입력 모드로 놓고 같은 키를 눌렀을 때 입력되는 한글 자모로 변환하는 함수입니다. 이 함수는 두 개의 오버로딩 버전(문자 하나만 처리, 문자열의 모든 문자에 대해 처리)이 제공됩니다.
    
    

    1. //-----------------------------------------------------------------------------
    2. // 1
    3. uint32_t QwertyToKSX5002(uint32_t unicode);
    4.  
    5. // 매개변수 unicode에 담긴 유니코드 문자가 영어 알파벳일 때,
    6. // 영어 쿼티 키보드에서 이 알파벳을 입력하기 위해서 누르는 키를
    7. // 한글 두벌식 키보드로 눌렀을 때 입력되는 한글 자모로 변환합니다.
    8.  
    9. // QWERTOP 를 제외한 나머지 대문자는 소문자의 경우와
    10. // 동일하게 처리합니다.
    11.  
    12. // unicode에 담긴 문자가 영어 알파벳이 아닌 경우
    13. // unicode의 값을 변환 없이 그대로 반환합니다.
    14.  
    15.  
    16. //-----------------------------------------------------------------------------
    17. // 2
    18. std::string QwertyToKSX5002(
    19. const std::string& str,
    20. const ustr::CheckCharFuncType& check_char = ustr::CheckCharFuncType()
    21. );
    22.  
    23. // 위의 1번 오버로딩 버전의 기능을, 문자열 str의 모든 문자에 대해 적용합니다.
    24. // 문자열 str은 DefaultEncoding(UTF-8)로 인코딩 되어 있어야 합니다.
    25.  
    26. // check_char을 통해 올바르지 않은 DefaultEncoding(UTF-8) 문자를 처리하는 함수를
    27. // 지정할 수 있습니다. CheckCharFuncType에 대한 자세한 설명은
    28. // 아래의 참고자료에서 볼 수 있습니다.
    29. // 참고자료

    ---