*
@param value
@return PagSeguroShippingType the PagSeguroShippingType corresponding to the informed value
968680
public function getTypeFromValue($value = null)
    {
        $value = ($value === null ? $this->value : $value);
        return array_search($value, self::$typeList);
    }
456403
@Override
	public boolean containsValue(Object value) {
		return this.groupedMap.containsValue(DEFAULT_GROUP, Convert.toStr(value));
	}
32158
public function setRecipientGatewayId($value)
    {
        if ($value === null || $value === '') {
            $this->_recipientGatewayId = null;
        } elseif (TypeCast::canCastToString($value)) {
            $this->_recipientGatewayId = (string)$value;
        } else {
            throw new InvalidPropertyValueTypeException(
                'Invalid recipientGatewayId value type in PaymentsRequest', 0, 'PaymentsRequest.recipientGatewayId',
                $value
            );
        }
    }
1069832
private String getDataType(final Value value) {
        if (value instanceof BigDecimalValue) {
            return DataType.TYPE_NUMERIC_BIGDECIMAL;
        } else if (value instanceof BigIntegerValue) {
            return DataType.TYPE_NUMERIC_BIGINTEGER;
        } else if (value instanceof BooleanValue) {
            return DataType.TYPE_BOOLEAN;
        } else if (value instanceof ByteValue) {
            return DataType.TYPE_NUMERIC_BYTE;
        } else if (value instanceof DateValue) {
            return DataType.TYPE_DATE;
        } else if (value instanceof DoubleValue) {
            return DataType.TYPE_NUMERIC_DOUBLE;
        } else if (value instanceof FloatValue) {
            return DataType.TYPE_NUMERIC_FLOAT;
        } else if (value instanceof IntegerValue) {
            return DataType.TYPE_NUMERIC_INTEGER;
        } else if (value instanceof LongValue) {
            return DataType.TYPE_NUMERIC_LONG;
        } else if (value instanceof ShortValue) {
            return DataType.TYPE_NUMERIC_SHORT;
        } else if (value instanceof EnumValue) {
            return DataType.TYPE_COMPARABLE;
        }

        return DataType.TYPE_STRING;
    }
777936
public static <T extends V, V> Value<V> just(T value) {

        LettuceAssert.notNull(value, "Value must not be null");

        return new Value<V>(value);
    }
661609
int addType(final String value) {
    int hashCode = hash(Symbol.TYPE_TAG, value);
    Entry entry = get(hashCode);
    while (entry != null) {
      if (entry.tag == Symbol.TYPE_TAG && entry.hashCode == hashCode && entry.value.equals(value)) {
        return entry.index;
      }
      entry = entry.next;
    }
    return addType(new Entry(typeCount, Symbol.TYPE_TAG, value, hashCode));
  }
134940
@VisibleForTesting
  static TypedValue createTypedValue(Value value) {
    return value.match(
        typedValueDoubleFunction,
        typedValueLongFunction,
        typedValueDistributionFunction,
        typedValueSummaryFunction,
        Functions.<TypedValue>throwIllegalArgumentException());
  }
393099
public T getAndSet(T value) {
        T t = this.value;
        this.value = value;
        return t;
    }
1105397
@Override
    public String convertTo(final Object value) {
        if (value == null) return "null";
        return convertTo(value.getClass(), value);
    }
166045
public static Object toExternalObject( Object value)
    {
    return
      Optional.ofNullable(
        toExternalNumber( value))
      .orElse(
        toObject( String.valueOf( value)));
    }
928331
public static TypeCode toTypeCode(Object value) {
		if (value == null)
			return TypeCode.Unknown;

		return toTypeCode(value.getClass());
	}
526705
public static function getType($value)
    {
        if (preg_match(self::REGEXP_TCP, $value)) {
            return self::TYPE_TCP;
        }

        if (preg_match(self::REGEXP_SSL, $value)) {
            return self::TYPE_SSL;
        }

        if (preg_match(self::REGEXP_UNIX, $value)) {
            return self::TYPE_UNIX;
        }

        return null;
    }
786262
public static function fromValue($value) : Type
    {
        switch (gettype($value)) {
            case 'string':
                return Text::long();

            case 'integer':
                return Integer::big();

            case 'double':
                return new Decimal(30, 15);

            case 'boolean':
                return new Boolean();

            case $value instanceof \DateTimeInterface:
                return new DateTime();

            default:
                throw InvalidArgumentException::format(
                        'Invalid call to %s: unknown value type \'%s\' given',
                        __METHOD__, gettype($value)
                );
        }
    }
926717
protected static Object toSafeJsonValue(Object value) {
        if (value == null) {
            return null;
        } else {
            if (value instanceof Boolean || value instanceof String || value instanceof Number) {
                return value;
            }
            if (value instanceof Iterable) {
                Iterable iterable = (Iterable) value;
                List answer = new ArrayList<>();
                for (Object item : iterable) {
                    Object itemJson = toSafeJsonValue(item);
                    if (itemJson != null) {
                        answer.add(itemJson);
                    }
                }
                return answer;
            }
            if (value instanceof ProjectProvider) {
                ProjectProvider projectProvider = (ProjectProvider) value;
                return projectProvider.getType();
            }
            if (value instanceof ProjectType) {
                ProjectType projectType = (ProjectType) value;
                return projectType.getType();
            }
            if (value instanceof StackFacet) {
                StackFacet stackFacet = (StackFacet) value;
                Stack stack = stackFacet.getStack();
                if (stack != null) {
                    return stack.getName();
                } else {
                    return null;
                }
            }
            value = Proxies.unwrap(value);
            if (value instanceof ProjectProvider) {
                ProjectProvider projectProvider = (ProjectProvider) value;
                return projectProvider.getType();
            }
            if (value instanceof ProjectType) {
                ProjectType projectType = (ProjectType) value;
                return projectType.getType();
            }
            if (value instanceof StackFacet) {
                StackFacet stackFacet = (StackFacet) value;
                Stack stack = stackFacet.getStack();
                if (stack != null) {
                    return stack.getName();
                } else {
                    return null;
                }
            }
            if (isJsonObject(value)) {
                return value;
            }
            return value.toString();
        }
    }
760835
protected final int getNodeType( Object value )
    {   	
        if (value instanceof String)
            return SelectorNodeType.STRING;
            
        if (value instanceof Boolean)
            return SelectorNodeType.BOOLEAN;
        
        return SelectorNodeType.NUMBER;
    }
787795
public T convert(Object value)
    {
        T result = null;
        if (value != null)
        {
            if (getValueClass().isInstance(value))
                result = getValueClass().cast(value);
            else
                result = convertFromString(value.toString());
        }
        return result;
    }
276820
public function asValue($value)
        {
            $endPoint =& $this->_getEndPoint();
            $endPoint['lookupType'] = self::TYPE_VALUE;
            $endPoint['value'] = $value;

            return $this;
        }