Returns the priority of the supplied priority value code.
<p>

@param value priority value code, 0 &lt;= value &lt;= 3
@return the corresponding priority object
968711
public static Priority get(int value)
	{
		if (value == 1)
			return NORMAL;
		if (value == 0)
			return SYSTEM;
		if (value == 3)
			return LOW;
		if (value == 2)
			return URGENT;
		throw new KNXIllegalArgumentException("invalid priority value");
	}
578880
public static int getMpxField(int value)
   {
      int result = 0;

      if (value >= 0 && value < MPXJ_MPX_ARRAY.length)
      {
         result = MPXJ_MPX_ARRAY[value];
      }
      return (result);
   }
1156119
public final void put(long priority, Object value)
  {
//    if (tc.isEntryEnabled())
//      SibTr.entry(tc, "put", new Object[] { new Long(priority), value});

    PriorityQueueNode node = new PriorityQueueNode(priority,value);

    // Resize the array (double it) if we are out of space.
    if (size == elements.length)
    {
      PriorityQueueNode[] tmp = new PriorityQueueNode[2*size];
      System.arraycopy(elements,0,tmp,0,size);
      elements = tmp;
    }

    int pos = size++;
    setElement(node, pos);

    moveUp(pos);

//    if (tc.isEntryEnabled())
//      SibTr.exit(tc, "put");
  }
461403
public boolean hasValue(final T value) throws MIDDException {

        //special processing when missing attribute
        if (value == null) {
            return this.isLowerInfinite() || this.isUpperInfinite();
        }


        EndPoint<T> epValue = new EndPoint<>(value);

        int compareLow = this.lowerBound.compareTo(epValue);
        int compareUp = this.upperBound.compareTo(epValue);

        if ((compareLow < 0 || (compareLow == 0 && this.lowerBoundClosed)) &&
                (compareUp > 0 || (compareUp == 0 && this.upperBoundClosed))) {
            return true;
        }

        return false;
    }
809940
public <R extends Request<T>> R setPriority(Priority priority) {
        this.priority = priority;
        return (R) this;
    }
181648
protected int getPriority()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "getPriority");
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "getPriority", ""+priority);
      return priority;
   }
885847
public static boolean isValueReference(String value)
    {
        if (value == null)
        {
            throw new NullPointerException("value");
        }

        int start = value.indexOf("#{");
        if (start < 0)
        {
            return false;
        }

        int end = value.lastIndexOf('}');
        return (end >= 0 && start < end);
    }
410679
public final Object getValue(int varNum) {
    int index = getValueIndex(varNum);
    if (index < 0) {
      return null;
    } else {
      return values[index];
    }
  }
278568
@Override
    public int getDefaultPriority()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getDefaultPriority");

        int pri = _definition.getDefaultPriority();

        // Admin have said -1 will signal return priority from target.  At
        // some point they should provide a constant with which this magic number
        // can be replaced.
        if (pri == DestinationAliasDefinition.DEFAULT_DEFAULTPRIORITY)
        {
            pri = getTarget().getDefaultPriority();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getDefaultPriority", Integer.valueOf(pri));

        return pri;
    }
540092
public Integer cache(Object value) {
        synchronized (this) {
            Integer key = keys.get(value);
            // Already cached?
            if (key != null) return key;
            key = next;
            cache.put(key, value);
            keys.put(value, key);
            next++;
            return key;
        }
    }
1035840
public int getLocation(Object value) {
    int		result;
    int		i;
    String	valueStr;

    result = 0;

    valueStr = value.toString();
    for (i = 0; i < width(); i++) {
      if ((getValue(i)).equals(valueStr)) {
	result = ((int) m_Min) + i;
	break;
      }
    }

    return result;
  }
476796
public T defaultPriority(Double priority) {
		if (priority < 0.0 || priority > 1.0) {
			throw new InvalidPriorityException("Priority must be between 0 and 1.0");
		}
		defaultPriority = priority;
		return getThis();
	}
538917
public static <T extends Comparable<T>> T geq(T value) {
        reportMatcher(new GreaterOrEqual<T>(value));
        return null;
    }
81595
public static Integer getAsInteger(Object value) {
		Integer result = null;

		try {
			if (value instanceof String) {
				result = Integer.valueOf((String) value);
			} else if (value instanceof Number) {
				result = ((Number) value).intValue();
			} else {
				result = null;
			}
		} catch (Exception e) {
			result = null;
		}

		return result == null ? 0 : result;
	}
549468
public static Object getPrimitiveValue(String value, PrimitiveCategory primitiveCategory) {
        if (value != null) {
            try {
                switch (primitiveCategory) {
                    case BOOLEAN:
                        return Boolean.valueOf(value);
                    case BYTE:
                        return Byte.valueOf(value);
                    case DOUBLE:
                        return Double.valueOf(value);
                    case FLOAT:
                        return Float.valueOf(value);
                    case INT:
                        return Integer.valueOf(value);
                    case LONG:
                        return Long.valueOf(value);
                    case SHORT:
                        return Short.valueOf(value);
                    case STRING:
                        return value;
                    default:
                        throw new IllegalStateException(primitiveCategory.toString());
                }
            } catch (Exception ignored) {
            }
        }
        return null;
    }
197904
@Trivial
    private static int getPriority(Converter<?> converter) {
        int value = ConfigConstants.DEFAULT_CONVERTER_PRIORITY;
        //get Priority annotations from class only, not from the super-class
        Priority[] priorities = converter.getClass().getDeclaredAnnotationsByType(Priority.class);
        if (priorities != null && priorities.length > 0) {
            Priority priority = priorities[0];
            value = priority.value();
        }
        return value;
    }
207209
public static PriceTypeEnumeration findByValue(final String value) {
        if (value.equalsIgnoreCase("negotiable")) {
            return PriceTypeEnumeration.NEGOTIABLE;
        } else {
            return PriceTypeEnumeration.STARTING;
        }
    }