phb_name_num_index.c

最新MTK手机软件源码

    alpha_id_storage.alpha_id = alpha_id;
    alpha_id_storage.storage = storage;

    if (name_num_index->name_index.used_count == 0)
    {
        return (kal_uint16) PHB_INVALID_VALUE;
    }

    candidate = phb_binary_search(
                    name_num_index->name_index.table,
                    &name_num_index->data_entry_table,
                    name_num_index->name_index.used_count,
                    0,
                    (kal_uint16) (name_num_index->name_index.used_count - 1),
                    &alpha_id_storage,
                    (compare_func_type) phb_compare_by_alpha_id_storage);

    if (candidate < name_num_index->name_index.used_count)
    {
        phb_compare_by_alpha_id_storage(
            &name_num_index->data_entry_table,
            &alpha_id_storage,
            &name_num_index->name_index.table[candidate],
            &result);
        if (result.distance > 0)
        {
            return candidate + 1;
        }
    }
    return candidate;
}   /* end of phb_name_num_index_find_index_by_alpha_id_storage */


/*****************************************************************************
 * FUNCTION
 *  phb_name_num_index_find_index_by_num_sig
 * DESCRIPTION
 *  Search the index of first occurence of telephone number in
 *  name_num_index->num_index.
 * PARAMETERS
 *  name_num_index      [?]         
 *  signature           [IN]        
 *  tel_num             [IN]        
 * RETURNS
 *  index to name_num_index->num_index
 *****************************************************************************/
kal_uint16 phb_name_num_index_find_index_by_num_sig(
            name_num_index_type *name_num_index,
            kal_uint8 signature,
            kal_uint8 tel_num)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 candidate;
    compare_result_type result;
    num_sig_type num_sig;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_NAME_NUM_INDEX_FIND_INDEX_BY_NUM_SIG);

    ASSERT(name_num_index != NULL);

    if (name_num_index->num_index.used_count == 0)
    {
        return (kal_uint16) PHB_INVALID_VALUE;
    }

    num_sig.signature = signature;
    num_sig.tel_num = tel_num;

    candidate = phb_binary_search(
                    name_num_index->num_index.table,
                    &name_num_index->data_entry_table,
                    name_num_index->num_index.used_count,
                    0,
                    (kal_uint16) (name_num_index->num_index.used_count - 1),
                    &num_sig,
                    (compare_func_type) phb_compare_by_tel_num_sig);

    if (candidate < name_num_index->num_index.used_count)
    {
        phb_compare_by_tel_num_sig(
            &name_num_index->data_entry_table,
            &num_sig,
            &name_num_index->num_index.table[candidate],
            &result);
        if (result.distance > 0)
        {
            return candidate + 1;
        }
    }
    return candidate;
}   /* end of name_num_index_find_index_by_num */


/*****************************************************************************
 * FUNCTION
 *  phb_name_num_index_find_index_by_num_sig_exact_match
 * DESCRIPTION
 *  Search the index of exact matching of telephone number and `position' stored in
 *  name_num_index->num_index.
 * PARAMETERS
 *  name_num_index      [?]         
 *  signature           [IN]        
 *  tel_num             [IN]        
 *  position            [IN]        
 * RETURNS
 *  index to name_num_index->num_index
 *****************************************************************************/
kal_uint16 phb_name_num_index_find_index_by_num_sig_exact_match(
            name_num_index_type *name_num_index,
            kal_uint8 signature,
            kal_uint8 tel_num,
            kal_uint16 position)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 i;
    kal_uint16 index;

    data_entry_table_type *det;
    pindex_type *name_index;
    pindex_type *num_index;
    num_sig_type num_sig;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_NAME_NUM_INDEX_FIND_INDEX_BY_NUM_SIG_EXACT_MATCH);

    ASSERT(name_num_index != NULL);

    if (name_num_index->name_index.used_count == 0)
    {
        return (kal_uint16) PHB_INVALID_VALUE;
    }

    det = &name_num_index->data_entry_table;
    name_index = &name_num_index->name_index;
    num_index = &name_num_index->num_index;

    num_sig.signature = signature;
    num_sig.tel_num = tel_num;

    index = phb_binary_search(
                num_index->table,
                det,
                num_index->used_count,
                0,
                (kal_uint16) (num_index->used_count - 1),
                &num_sig,
                (compare_func_type) phb_compare_by_tel_num_sig);
    for (i = index; (i < num_index->used_count) &&
         (det->table[num_index->table[i].position].tel_num ==
          det->table[num_index->table[index].position].tel_num); ++i)
    {
        if (num_index->table[i].position == position)
        {
            break;
        }
    }
    return i;
}   /* end of phb_name_num_index_find_index_by_num_sig_exact_match */


/*****************************************************************************
 * FUNCTION
 *  phb_name_num_index_sort
 * DESCRIPTION
 *  Use phb_fast_quicksort to sort internal indices.
 * PARAMETERS
 *  name_num_index      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void phb_name_num_index_sort(name_num_index_type *name_num_index)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    data_entry_table_type *det;
    pindex_type *name_index;
    pindex_type *num_index;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_NAME_NUM_INDEX_SORT);

    ASSERT(name_num_index != NULL);

    if (name_num_index->name_index.used_count == 0)
    {
        return;
    }

    det = &name_num_index->data_entry_table;
    name_index = &name_num_index->name_index;
    num_index = &name_num_index->num_index;

    phb_fast_quicksort(
        name_index->table,
        det,
        0,
        (kal_uint16) (name_index->used_count - 1),
        (compare_func_type) phb_compare_by_alpha_id_storage_for_sort);

    if (num_index->slots > 0)
    {
        phb_fast_quicksort(
            num_index->table,
            det,
            0,
            (kal_uint16) (num_index->used_count - 1),
            (compare_func_type) phb_compare_by_tel_num_sig_for_sort);
    }
}   /* end of phb_name_num_index_sort */


/*****************************************************************************
 * FUNCTION
 *  phb_istring_icmp
 * DESCRIPTION
 *  
 * PARAMETERS
 *  istr_first      [?]     
 *  istr_second     [?]     
 *  result          [?]     
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_istring_icmp(istring_type *istr_first, istring_type *istr_second, compare_result_type *result)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 len1, len2;
    kal_uint8 min_len, max_len;

    kal_uint8 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_ISTRING_ICMP);

    result->same_count = 0;
    result->distance = 0;

    ASSERT((istr_first != NULL) && (istr_second != NULL));

    len1 = istring_len(istr_first);
    len2 = istring_len(istr_second);

    if (len1 > len2)
    {
        max_len = len1;
        min_len = len2;
    }
    else
    {
        max_len = len2;
        min_len = len1;
    }

    for (i = 0; i < max_len; ++i)
    {
        kal_uint16 char1, char2;

        /* All characters are identical from 0 to min_len. */
        if (i >= min_len)
        {
            /* First is greater than second */
            if (len1 > len2)
            {
                result->distance = istring_char_at(istr_first, i);
            }
            /* First and second is congruence */
            else if (len1 == len2)
            {
                result->distance = 0;
            }
            /* len1 < len2: First is less than second */
            else
            {
                result->distance = -istring_char_at(istr_second, i);
            }

         /** 
          * Special case:
          * Since empty alpha id is desired to be sorted more ascending, 
          * As long as length of either istr_frist or istr_second is 0, 
          * one of which length is 0 have to be treated as greater!!
          * Such that it will be sorted as more ascending.
          */
            if (min_len == 0)
            {
                result->distance = -result->distance;
            }

            break;
        }

        /* First, compare from 0 to min_len */
        else
        {
            char1 = istring_char_at(istr_first, i);
            char2 = istring_char_at(istr_second, i);

         /**
          * Now compare char1 and char2.
          * For a UCS2 character that falls in BASIC LATIN collection(0020 - 007E, 
          * see http://www.evertype.com/standards/iso10646/ucs-collections.html),
          * it should be treated as equal to that in ASCII charset.
          * => This is no problem because get_char convert an ASCII character to an UCS2
          *    character.
          */
            if ((result->distance = compare_chars(char1, char2)) == 0)
            {
                result->same_count++;
            }
            /* First and second is not equal, return distance */
            else
            {
                break;
            }
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  phb_compare_by_key_alpha_id
 * DESCRIPTION
 *  Compare two alpha_id's. Their length could be unequal when comparing.
 *  For ASCII charset, character comparison is case insensitive.
 * PARAMETERS
 *  first                   [?]