icuSources/i18n/titletrn.cpp

   1 /*
   2 **********************************************************************
   3 *   Copyright (C) 2001-2004, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 *   Date        Name        Description
   7 *   05/24/01    aliu        Creation.
   8 **********************************************************************
   9 */
  10
  11 #include "unicode/utypes.h"
  12
  13 #if !UCONFIG_NO_TRANSLITERATION
  14
  15 #include "unicode/uchar.h"
  16 #include "unicode/uniset.h"
  17 #include "unicode/ustring.h"
  18 #include "titletrn.h"
  19 #include "umutex.h"
  20 #include "ucase.h"
  21 #include "cpputils.h"
  22
  23 U_NAMESPACE_BEGIN
  24
  25 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TitlecaseTransliterator)
  26
  27 TitlecaseTransliterator::TitlecaseTransliterator(const Locale& theLoc) :
  28     CaseMapTransliterator(theLoc, UNICODE_STRING("Any-Title", 9), NULL)
  29 {
  30     // Need to look back 2 characters in the case of "can't"
  31     setMaximumContextLength(2);
  32 }
  33
  34 /**
  35  * Destructor.
  36  */
  37 TitlecaseTransliterator::~TitlecaseTransliterator() {
  38 }
  39
  40 /**
  41  * Copy constructor.
  42  */
  43 TitlecaseTransliterator::TitlecaseTransliterator(const TitlecaseTransliterator& o) :
  44     CaseMapTransliterator(o)
  45 {
  46 }
  47
  48 /**
  49  * Assignment operator.
  50  */
  51 TitlecaseTransliterator& TitlecaseTransliterator::operator=(
  52                              const TitlecaseTransliterator& o) {
  53     CaseMapTransliterator::operator=(o);
  54     return *this;
  55 }
  56
  57 /**
  58  * Transliterator API.
  59  */
  60 Transliterator* TitlecaseTransliterator::clone(void) const {
  61     return new TitlecaseTransliterator(*this);
  62 }
  63
  64 /**
  65  * Implements {@link Transliterator#handleTransliterate}.
  66  */
  67 void TitlecaseTransliterator::handleTransliterate(
  68                                   Replaceable& text, UTransPosition& offsets,
  69                                   UBool isIncremental) const
  70 {
  71     // TODO reimplement, see ustrcase.c
  72     // using a real word break iterator
  73     //   instead of just looking for a transition between cased and uncased characters
  74     // call CaseMapTransliterator::handleTransliterate() for lowercasing? (set fMap)
  75     // needs to take isIncremental into account because case mappings are context-sensitive
  76     //   also detect when lowercasing function did not finish because of context
  77
  78     if (offsets.start >= offsets.limit) {
  79         return;
  80     }
  81
  82     // case type: >0 cased (UCASE_LOWER etc.)  ==0 uncased  <0 case-ignorable
  83     int32_t type;
  84
  85     // Our mode; we are either converting letter toTitle or
  86     // toLower.
  87     UBool doTitle = TRUE;
  88
  89     // Determine if there is a preceding context of cased case-ignorable*,
  90     // in which case we want to start in toLower mode.  If the
  91     // prior context is anything else (including empty) then start
  92     // in toTitle mode.
  93     UChar32 c;
  94     int32_t start;
  95     for (start = offsets.start - 1; start >= offsets.contextStart; start -= U16_LENGTH(c)) {
  96         c = text.char32At(start);
  97         type=ucase_getTypeOrIgnorable(fCsp, c);
  98         if(type>0) { // cased
  99             doTitle=FALSE;
 100             break;
 101         } else if(type==0) { // uncased but not ignorable
 102             break;
 103         }
 104         // else (type<0) case-ignorable: continue
 105     }
 106
 107     // Convert things after a cased character toLower; things
 108     // after an uncased, non-case-ignorable character toTitle.  Case-ignorable
 109     // characters are copied directly and do not change the mode.
 110     UCaseContext csc;
 111     uprv_memset(&csc, 0, sizeof(csc));
 112     csc.p = &text;
 113     csc.start = offsets.contextStart;
 114     csc.limit = offsets.contextLimit;
 115
 116     UnicodeString tmp;
 117     const UChar *s;
 118     int32_t textPos, delta, result, locCache=0;
 119
 120     for(textPos=offsets.start; textPos<offsets.limit;) {
 121         csc.cpStart=textPos;
 122         c=text.char32At(textPos);
 123         csc.cpLimit=textPos+=U16_LENGTH(c);
 124
 125         type=ucase_getTypeOrIgnorable(fCsp, c);
 126         if(type>=0) { // not case-ignorable
 127             if(doTitle) {
 128                 result=ucase_toFullTitle(fCsp, c, utrans_rep_caseContextIterator, &csc, &s, fLocName, &locCache);
 129             } else {
 130                 result=ucase_toFullLower(fCsp, c, utrans_rep_caseContextIterator, &csc, &s, fLocName, &locCache);
 131             }
 132             doTitle = (UBool)(type==0); // doTitle=isUncased
 133
 134             if(csc.b1 && isIncremental) {
 135                 // fMap() tried to look beyond the context limit
 136                 // wait for more input
 137                 break;
 138             }
 139
 140             if(result>=0) {
 141                 // replace the current code point with its full case mapping result
 142                 // see UCASE_MAX_STRING_LENGTH
 143                 if(result<=UCASE_MAX_STRING_LENGTH) {
 144                     // string s[result]
 145                     tmp.setTo(FALSE, s, result);
 146                     delta=result-U16_LENGTH(c);
 147                 } else {
 148                     // single code point
 149                     tmp.setTo(result);
 150                     delta=tmp.length()-U16_LENGTH(c);
 151                 }
 152                 text.handleReplaceBetween(csc.cpStart, textPos, tmp);
 153                 if(delta!=0) {
 154                     textPos+=delta;
 155                     csc.limit=offsets.contextLimit+=delta;
 156                     offsets.limit+=delta;
 157                 }
 158             }
 159         }
 160     }
 161     offsets.start=textPos;
 162 }
 163
 164 U_NAMESPACE_END
 165
 166 #endif /* #if !UCONFIG_NO_TRANSLITERATION */