def decompose(self):
        decomp_table = decomp_chars
        
        changed = False
        
        ret = u''
        
        for i in range(len(self)):
            key = unicode(self[i])
            if key in decomp_table:
                ret += decomp_table[key][1]
                changed = True
            else:
                ret += key
        
        if changed:
            return SafeUnicode(ret).decompose()
        
        return self
    
    def compose(self):
        comp_table = decomp_inverse

        ret = u''
        
        slen = len(self)
        i = 0
        
        while i < slen:
            found = None
            found_len = 0
            found_char_len = 0
            for char in comp_table:
                char_len = len(char)
                if self[i:i+char_len] == char:
                    if found_len < char_len:
                        found = comp_table[char][1]
                        found_len = len(found)
                        found_char_len = char_len
            if found == None:
                ret += unicode(self[i])
                i += 1
            else:
                ret += found
                i += found_char_len
        
        return ret

    def reorder(self):
        reorder = [char for char in unicode(self)]
        
        for i in range(len(reorder) - 1):
            first = reorder[i]
            second = reorder[i+1]
            
            if not first in canon_chars or \
                not second in canon_chars:
                continue
            
            if canon_chars[first] == 0 or \
                canon_chars[second] == 0:
                continue
            
            if canon_chars[first] > canon_chars[second]:
                reorder[i+1] = first
                reorder[i]   = second
        
        return SafeUnicode(u''.join(reorder))