int IndexComparator::compare()

in src/cas/lowlevel_indexcomparator.cpp [166:300]
128 lines of code
21 McCabe index (conditional complexity)

    int IndexComparator::compare(uima::lowlevel::FSHeap const & heap, TyFS fs1, TyFS fs2) const {
      if (fs1 == fs2) {
        return 0;
      }
      assert( heap.getTypeSystem().subsumes( iv_tyType, heap.getType(fs1)) );
      assert( heap.getTypeSystem().subsumes( iv_tyType, heap.getType(fs2)) );
      UIMA_TPRINT("Comparing fs of type " << heap.getTypeSystem().getTypeName( heap.getType(fs1)));
      UIMA_TPRINT("   with fs of type " << heap.getTypeSystem().getTypeName( heap.getType(fs2)));
      bool isGreater = false;
      bool isLess = false;
      size_t i;
      const size_t uiOffsetsSize = iv_offsets.size();
      TyFeatureOffset utCurrentOffset;
      // for each feature
      for (i=0; i <uiOffsetsSize; ++i) {
        UIMA_TPRINT("Comparing feature " << i);
        utCurrentOffset = iv_offsets[i];
        // if type priority
        if (utCurrentOffset == 0) {
          assert( iv_features[i] == uima::lowlevel::TypeSystem::INVALID_FEATURE );

          uima::lowlevel::TyFSType t1 = heap.getType(fs1);
          uima::lowlevel::TyFSType t2 = heap.getType(fs2);

          uima::lowlevel::TypeSystem const & crTypeSystem = heap.getTypeSystem();
          if (t1 == t2) {
            isLess = false;
            isGreater = false;
          } else if (crTypeSystem.hasPriorityOver(t1, t2)) {
            isLess = true;
            isGreater = false;
          } else {
            isLess = false;
            isGreater = true;
          }
        } else {
          TyFS val1 = heap.getFeatureWithOffset(fs1, utCurrentOffset);
          TyFS val2 = heap.getFeatureWithOffset(fs2, utCurrentOffset);
          switch (iv_appropTypes[i]) {
          case BUILTIN_TYPE_INTEGER: {
            int i1 = FSHeap::getFSAsInt(val1);
            int i2 = FSHeap::getFSAsInt(val2);
            UIMA_TPRINT("  val1: " << i1 << ", val2: " << i2);
            isLess = (i1 < i2);
            isGreater = (i1 > i2);
            break;
          }
          case BUILTIN_TYPE_FLOAT: {
            float f1 = FSHeap::getFSAsFloat(val1);
            float f2 = FSHeap::getFSAsFloat(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }
          case BUILTIN_TYPE_STRING: {
            UnicodeStringRef us1 = heap.getFSAsString(val1);
            UnicodeStringRef us2 = heap.getFSAsString(val2);
            int iCmp = inline_strCompare(us1.getBuffer(), us1.length(),
                                         us2.getBuffer(), us2.length());
            isLess    = (iCmp < 0);
            isGreater = (iCmp > 0);
            break;
          }
          case BUILTIN_TYPE_BOOLEAN: {
            bool f1 = FSHeap::getFSAsBoolean(val1);
            bool f2 =  FSHeap::getFSAsBoolean(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }
          case BUILTIN_TYPE_BYTE: {
            char f1 = FSHeap::getFSAsByte(val1);
            char f2 =  FSHeap::getFSAsByte(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }
          case BUILTIN_TYPE_SHORT: {
            short f1 = FSHeap::getFSAsShort(val1);
            short f2 = FSHeap::getFSAsShort(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }
          case BUILTIN_TYPE_LONG: {
            INT64 f1 = heap.getFSAsLong(val1);
            INT64 f2 = heap.getFSAsLong(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }
          case BUILTIN_TYPE_DOUBLE: {
            double f1 = heap.getFSAsDouble(val1);
            double f2 = heap.getFSAsDouble(val2);
            isLess = (f1 < f2);
            isGreater = (f1 > f2);
            break;
          }

          default:
//                  UIMA_TPRINT("Unsupported type: " << heap.getTypeSystem().getTypeName(appropTypes[i]));
            assertWithMsg(false, "Unsupported built-in type");
          }
        }
        UIMA_TPRINT("   isLess: " << isLess);
        UIMA_TPRINT("   isGreater: " << isGreater);
        assert( ! (isLess && isGreater) );

        switch (iv_comparators[i]) {
        case STANDARD_COMPARE: {
          if (isLess) {
            return 1;
          } else {
            if (isGreater) {
              return -1;
            }
          }
          break;
        }
        case REVERSE_STANDARD_COMPARE: {
          if (isLess) {
            return -1;
          } else {
            if (isGreater) {
              return 1;
            }
          }
          break;
        }
        default:
          assert(false);
        };
      }
      return 0;
    }