TrySZSort.cpp

Native TrySZSort

FCIMPL4(INT32, ArrayHelper::TrySZSort, ArrayBase * keys, ArrayBase * items, UINT32 left, UINT32 right)
    //in an array is not single-dimensional with initial index, null is not sorted
    if (keys->GetRank() != 1 || keys->GetLowerBoundsPtr()[0] != 0)
        return FALSE;
 
    // Getting array element type
    TypeHandle keysTH = keys->GetElementTypeHandle();
    // If it is not an in-built primitive type
    const CorElementType keysElType = keysTH.GetSigCorElementType();
    if (!CorTypeInfo::IsPrimitiveType(keysElType))
        return FALSE;
    if (items != NULL) {
        TypeHandle itemsTH = items->GetElementTypeHandle();
        if (keysTH != itemsTH)
            return FALSE;   // Can't currently handle sorting different types of arrays.
    }
 
    // Optimization for the array from one element
    if (left == right || right == 0xffffffff)
        return TRUE;
 
    //Then the special version of sorting is called that is written on the basis of the C++ templates.
    switch(keysElType) {
    case ELEMENT_TYPE_I1: // 1-byte signed integer(sbyte)
        ArrayHelpers::QuickSort((I1*) keys->GetDataPtr(), (I1*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_U1: // 1-byte unsigned integer(byte)
    case ELEMENT_TYPE_BOOLEAN: // Логический тип (bool)
        ArrayHelpers::QuickSort((U1*) keys->GetDataPtr(), (U1*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_I2: // 2-byte signed integer (short)
        ArrayHelpers::QuickSort((I2*) keys->GetDataPtr(), (I2*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_U2: // 2-byte unsigned integer (ushort)
    case ELEMENT_TYPE_CHAR: // Character type (char)
        ArrayHelpers::QuickSort((U2*) keys->GetDataPtr(), (U2*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_I4: // 4-byte signed integer (int)
        ArrayHelpers::QuickSort((I4*) keys->GetDataPtr(), (I4*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_U4: // 4-byte unsigned integer (uint)
        ArrayHelpers::QuickSort((U4*) keys->GetDataPtr(), (U4*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_R4: // 4-byte floating point number (float)
        ArrayHelpers::QuickSort((R4*) keys->GetDataPtr(), (R4*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_I8: // 8-byte signed integer (long)
        ArrayHelpers::QuickSort((I8*) keys->GetDataPtr(), (I8*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_U8: // 8-byte unsigned integer(ulong)
        ArrayHelpers::QuickSort((U8*) keys->GetDataPtr(), (U8*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_R8: // 8-byte floating point number (double)
        ArrayHelpers::QuickSort((R8*) keys->GetDataPtr(), (R8*) (items == NULL ? NULL : items->GetDataPtr()), left, right);
        break;
 
    case ELEMENT_TYPE_I: // Dimension of integer in machine code (IntPtr)
    case ELEMENT_TYPE_U: // Dimension of unsigned integer in machine code (UIntPtr)
        // In V1.0, IntPtr & UIntPtr are not fully supported types.  They do 
        // not implement IComparable, so searching & sorting for them should
        // fail.  In V1.1 or V2.0, this should change.                                   
        return FALSE;
 
    default:
        return FALSE;
    }
    return TRUE;
}



Native QuickSort

/ Template class designed for sorting
template 
class ArrayHelpers
{
 static void QuickSort(KIND keys[], KIND items[], int left, int right) {
  do {
     int i = left;
     int j = right;
     KIND x = keys[(i + j) >> 1];
      do {
          while (Compare(keys[i], x) < 0) i++;
          while (Compare(x, keys[j]) < 0) j--; if (i > j) break;
           if (i < j) {
            KIND key = keys[i];
            keys[i] = keys[j];
            keys[j] = key;
             if (items != NULL) {
               KIND item = items[i];
               items[i] = items[j];
               items[j] = item;
             }
         }
       i++;
       j--;
     }
      while (i <= j);
       if (j - left <= right - i) 
        {
          if (left < j) QuickSort(keys, items, left, j);
            left = i;
         }
       else 
        {
         if (i < right) QuickSort(keys, items, i, right);
            right = j;
        }
      } 
      while (left < right);
    }
};