You are using to_mixed as a nice shortcut to solve your issue, although it was not really designed for what you're trying to achieve (it's more about transforming technical names like client_number to ClientNumber, but almost not more).
If you run ABAP 7.55, PCRE can be used.
Otherwise, it's probably better to not use to_mixed, but some code straight to the point.
Based on the rules you defined (I completed with the last two ones):
- every single letter followed by a dot should be lower case
- every character after a dot should be upper case
- every character after an opening bracket should be upper case
- every character after a space should be upper case
- the first character should be upper case
- all other characters should be lower case
I see that there are conflicting rules so let's suppose that the rule number 1 has the priority over the others.
Below example shows code for PCRE (ABAP >= 7.55) and classic code with REDUCE (ABAP >= 7.40 SP 8).
EDIT: I have added comments for the PCRE code.
CLASS ltc_main DEFINITION
FOR TESTING
DURATION SHORT
RISK LEVEL HARMLESS.
PRIVATE SECTION.
METHODS run_all_test_cases FOR TESTING.
METHODS run_one_test_case
IMPORTING
input TYPE csequence
exp TYPE csequence
RETURNING
VALUE(result) TYPE string.
METHODS with_pcre " ABAP >= 7.55
IMPORTING
input TYPE csequence
RETURNING
VALUE(result) TYPE string.
METHODS without_pcre
IMPORTING
input TYPE csequence
RETURNING
VALUE(result) TYPE string.
ENDCLASS.
CLASS ltc_main IMPLEMENTATION.
METHOD run_all_test_cases.
run_one_test_case( input = `AGGSTALL` exp = `Aggstall` ).
run_one_test_case( input = `BAD KÖTZTING` exp = `Bad Kötzting` ).
run_one_test_case( input = `RIED A.HAIDSTEIN` exp = `Ried a.Haidstein` ).
run_one_test_case( input = `SCHMID I.LEHEN` exp = `Schmid i.Lehen` ).
run_one_test_case( input = `TAUFKIRCHEN (VILS)` exp = `Taufkirchen (Vils)` ).
run_one_test_case( input = `BAD KÖNIGSHOFEN I.GRABFELD` exp = `Bad Königshofen i.Grabfeld` ).
run_one_test_case( input = `.A.b` exp = `.a.B` ). " rule 1 has priority over rule 2
run_one_test_case( input = `(a.` exp = `(a.` ). " rule 1 has priority over rule 3
run_one_test_case( input = ` a.` exp = ` a.` ). " rule 1 has priority over rule 4
run_one_test_case( input = `a.` exp = `a.` ). " rule 1 has priority over rule 5
ENDMETHOD.
METHOD run_one_test_case.
cl_abap_unit_assert=>assert_equals( act = with_pcre( input = input ) exp = exp msg = |Input: { input } -> Exp: { exp }| ).
cl_abap_unit_assert=>assert_equals( act = without_pcre( input = input ) exp = exp ).
ENDMETHOD.
METHOD with_pcre.
result = replace( val = input
pcre = `(?:`
& `(\w\.)` " subgroup $1: either word char followed by dot
& `|(?<=\.)(\w)` " subgroup $2: or word char preceded by dot
& `|(?<=\()(\w)` " subgroup $3: or word char preceded by start bracket
& `|(?<=\ )(\w)` " subgroup $4: or word char preceded by space
& `|^(\w)` " subgroup $5: or word char at start
& `|(.)` " subgroup $6: or any character
& `)`
with = `\l$1` " convert character of subgroup $1 to lower case
& `\u$2` " convert character of subgroup $2 to upper case
& `\u$3` " convert character of subgroup $3 to upper case
& `\u$4` " convert character of subgroup $4 to upper case
& `\u$5` " convert character of subgroup $5 to upper case
& `\l$6` " convert character of subgroup $6 to lower case
occ = 0 ).
ENDMETHOD.
METHOD without_pcre.
result = reduce #( init t = ``
prev = ``
char = cond string( when input <> `` then substring( val = input off = 0 len = 1 ) )
for off = 0 while off < strlen( input )
let next = cond string( when off + 1 < strlen( input ) then substring( val = input off = off + 1 len = 1 ) )
in
next t = t && COND string(
WHEN next = '.' THEN to_lower( char )
WHEN prev = '.' THEN to_upper( char )
WHEN prev = '(' THEN to_upper( char )
WHEN prev = ` ` THEN to_upper( char )
WHEN off = 0 THEN to_upper( char )
ELSE to_lower( char ) )
prev = char
char = next ).
ENDMETHOD.
ENDCLASS.
