Get the maximum attribute processing value from the default mode and
from all the modes specified in the contexts.
@return The attribute processing value.
187118
int getAttributeProcessing() {
    if (attributeProcessing == -1) {
      attributeProcessing = resolve(mode).getAttributeProcessing();
      if (modeMap != null) {
        for (Enumeration e = modeMap.values();
             e.hasMoreElements()
             && attributeProcessing != Mode.ATTRIBUTE_PROCESSING_FULL;)
          attributeProcessing = Math.max(resolve((Mode)e.nextElement()).getAttributeProcessing(),
                                         attributeProcessing);
      }
    }
    return attributeProcessing;
  }
1096487
public Optional<Integer> getMaxlength() {
        if (property instanceof StringProperty) {
            StringProperty stringProperty = (StringProperty) property;
            return Optional.ofNullable(stringProperty.getMaxLength());
        } else if (property instanceof UUIDProperty) {
            UUIDProperty uuidProperty = (UUIDProperty) property;
            return Optional.ofNullable(uuidProperty.getMaxLength());
        }
        return Optional.empty();
    }
1256099
int[] getValue() {
    int maxConfidence = -1;
    Collection<Integer> result = new ArrayList<>();
    for (Entry<Integer,Integer> entry : values.entrySet()) {
      if (entry.getValue() > maxConfidence) {
        maxConfidence = entry.getValue();
        result.clear();
        result.add(entry.getKey());
      } else if (entry.getValue() == maxConfidence) {
        result.add(entry.getKey());
      }
    }
    return PDF417Common.toIntArray(result);
  }
1365612
public Integer getMaxStatements()
   {
      if (childNode.getTextValueForPatternName("max-statements") != null && !childNode.getTextValueForPatternName("max-statements").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("max-statements"));
      }
      return null;
   }
1368940
public int getSplittingAttribute()
    {
        //TODO refactor the splittingAttribute to just be in this order already
        if(splittingAttribute < catAttributes.length)//categorical feature
            return numNumericFeatures+splittingAttribute;
        //else, is Numerical attribute
        int numerAttribute = splittingAttribute - catAttributes.length;
        return numerAttribute;
    }
1016126
public long getMax() {
		int lastBin = hits.length() - 1;
		if (hits.get(lastBin) > 0) {
			return Long.MAX_VALUE;
		}

		for (int i = lastBin - 1; i >= 0; i--) {
			if (hits.get(i) > 0) {
				return bins[i];
			}
		}
		return 0;
	}
1213626
def get_best_splitting_attr(self):
        
        best = (-1e999999, None)
        for attr in self.attributes:
            best = max(best, (self.get_gain(attr), attr))
        best_gain, best_attr = best
        return best_attr
478524
public int getMaxlength() {
        return (java.lang.Integer) getStateHelper().eval(PropertyKeys.maxlength, Integer.MIN_VALUE);

    }
965274
public Attribute getIdAttribute() {
    Attribute idAttr = getOwnIdAttribute();
    if (idAttr == null) {
      EntityType extend = getExtends();
      if (extend != null) {
        idAttr = extend.getIdAttribute();
      }
    }
    return idAttr;
  }
235876
Integer getMaxScaleAct() {

        switch (type) {

            case Types.SQL_DECIMAL :
            case Types.SQL_NUMERIC :
                return ValuePool.getInt(Integer.MAX_VALUE);

            default :
                return getMaxScale();
        }
    }
468142
public T max() {
        TObjectIntIterator<T> iter = counts.iterator();
        int maxCount = -1;
        T max = null;
        while (iter.hasNext()) {
            iter.advance();
            int count = iter.value();
            if (count > maxCount) {
                max = iter.key();
                maxCount = count;
            }
        }
        return max;
    }
971130
public AiBlendMode getBlendMode() {
        Property p = getProperty(PropertyKey.BLEND_MODE.m_key);
        
        if (null == p || null == p.getData()) {
            return (AiBlendMode) m_defaults.get(PropertyKey.BLEND_MODE);
        }
        
        return AiBlendMode.fromRawValue((Integer) p.getData());
    }
1170367
public float getMaxHeight() {
		boolean pivoted = (getRotation() == 90 || getRotation() == 270);
		Image img = getImage();
		if (img != null) {
			img.scalePercent(100);
			float refWidth = pivoted ? img.getScaledHeight() : img.getScaledWidth();
			float scale = (getRight() - getEffectivePaddingRight()
                    - getEffectivePaddingLeft() - getLeft()) / refWidth;
			img.scalePercent(scale * 100);
			float refHeight = pivoted ? img.getScaledWidth() : img.getScaledHeight();
			setBottom(getTop() - getEffectivePaddingTop() - getEffectivePaddingBottom() - refHeight);
		}
		else {
			if ((pivoted && hasFixedHeight()) || getColumn() == null)
				setBottom(getTop() - getFixedHeight());
			else {
				ColumnText ct = ColumnText.duplicate(getColumn());
				float right, top, left, bottom;
				if (pivoted) {
					right = PdfPRow.RIGHT_LIMIT;
					top = getRight() - getEffectivePaddingRight();
					left = 0;
					bottom = getLeft() + getEffectivePaddingLeft();
				}
				else {
					right = isNoWrap() ? PdfPRow.RIGHT_LIMIT : getRight() - getEffectivePaddingRight();
					top = getTop() - getEffectivePaddingTop();
					left = getLeft() + getEffectivePaddingLeft();
					bottom = hasFixedHeight() ? getTop() + getEffectivePaddingBottom() - getFixedHeight() : PdfPRow.BOTTOM_LIMIT;
				}
				PdfPRow.setColumn(ct, left, bottom, right, top);
				try {
					ct.go(true);
				} catch (DocumentException e) {
					throw new ExceptionConverter(e);
				}
				if (pivoted)
					setBottom(getTop() - getEffectivePaddingTop() - getEffectivePaddingBottom() - ct.getFilledWidth());
				else {
					float yLine = ct.getYLine();
					if (isUseDescender())
						yLine += ct.getDescender();
					setBottom(yLine - getEffectivePaddingBottom());
				}
			}
		}
		float height = getHeight();
		if (hasFixedHeight())
			height = getFixedHeight();
		else if (height < getMinimumHeight())
			height = getMinimumHeight();
		return height;
	}
932619
@Pure
	public VisualizationType getVisualizationType() {
		if (this.vizualizationType == null) {
			final AttributeValue val = getAttributeCollection().getAttribute(ATTR_VISUALIZATION_TYPE);
			if (val != null) {
				try {
					this.vizualizationType = val.getJavaObject();
				} catch (Exception e) {
					//
				}
			}
			if (this.vizualizationType == null) {
				this.vizualizationType = VisualizationType.SHAPE_ONLY;
			}
		}
		return this.vizualizationType;
	}
964839
Long getPrecisionAct() {

        Integer temp = getPrecision();

        if (temp == null) {
            return ValuePool.getLong(Long.MAX_VALUE);
        } else {
            return ValuePool.getLong(temp.longValue());
        }
    }
398700
public final int getMaxValue(int which) {
        int max;

        max=indexes[IX_MAX_VALUES];
        switch(which) {
        case UProperty.BIDI_CLASS:
            return (max&CLASS_MASK);
        case UProperty.JOINING_GROUP:
            return (max&MAX_JG_MASK)>>MAX_JG_SHIFT;
        case UProperty.JOINING_TYPE:
            return (max&JT_MASK)>>JT_SHIFT;
        case UProperty.BIDI_PAIRED_BRACKET_TYPE:
            return (max&BPT_MASK)>>BPT_SHIFT;
        default:
            return -1; /* undefined */
        }
    }
62654
public int getMaximumDigits() {
        String value = Optional.fromNullable(getParameter(SignalParameters.MAXIMUM_NUM_DIGITS.symbol())).or("1");
        return Integer.parseInt(value);
    }