After retrieving the attribute from the attributes map.

@param value the retrieved value
@return the restored value
328222
public Object restore(final Object value) {
        if (value != null && value instanceof String) {
            final String sValue = (String) value;
            if (sValue.startsWith(PREFIX)) {
                if (sValue.startsWith(PREFIX_BOOLEAN)) {
                    return Boolean.parseBoolean(sValue.substring(PREFIX_BOOLEAN.length()));
                } else if (sValue.startsWith(PREFIX_INT)) {
                    return Integer.parseInt(sValue.substring(PREFIX_INT.length()));
                } else if (sValue.startsWith(PREFIX_LONG)) {
                    return Long.parseLong(sValue.substring(PREFIX_LONG.length()));
                } else if (sValue.startsWith(PREFIX_DATE)) {
                    final String d = sValue.substring(PREFIX_DATE.length());
                    try {
                        return newSdf().parse(d);
                    } catch (final ParseException e) {
                        logger.warn("Unable to parse stringified date: {}", d, e);
                    }
                } else if (sValue.startsWith(PREFIX_URI)) {
                    final String uri = sValue.substring(PREFIX_URI.length());
                    try {
                        return new URI(uri);
                    } catch (final URISyntaxException e) {
                        logger.warn("Unable to parse stringified URI: {}", uri, e);
                    }
                } else if (sValue.startsWith(PREFIX_SB64)) {
                    return serializationHelper.deserializeFromBase64(sValue.substring(PREFIX_SB64.length()));
                }
            }
        }
        return value;
    }
1130983
def restore(self, value, context=None):
        
        context = context or orb.Context()
        value = super(ReferenceColumn, self).restore(value, context=context)

        # check to make sure that we're processing the right values
        if self.testFlag(self.Flags.I18n) and context.locale == 'all':
            return {locale: self._restore(val, context) for locale, val in value.items()}
        else:
            return self._restore(value, context)
1343108
public static MountStatus fromValue(int value) {
        MountStatus mountStatus = VALUES.get(value);
        if (mountStatus == null) {
            mountStatus = new MountStatus(value);
            VALUES.put(value, mountStatus);
        }
        return mountStatus;
    }
329744
public String setAttribute(final String name, final String value) {
        if(null!=value){
            return getAttributes().put(name, value);
        }else{
            getAttributes().remove(name);
            return value;
        }
    }
102618
@Override
    public String getValue(int index) {
        if (index < 0 || index >= attributesList.size()) {
            return null;
        }
        return attributesList.get(index).value;
    }
721019
public String set(String value)
    {
        String prevValue = setString(value);
        if (prevValue == null) {
            prevValue = getDefaultValue();
        }
        return prevValue;
    }
298332
public synchronized String set(String value)
    {
        final String prevValue = super.set(value);

        if (!storageInitialized) {
            storageInitialized = true;

            if (propertyFileLocation.get() == null) {
                tracer.warning(
                    "Cannot store property '" + getPath()
                    + "' because storage location is not set");
                return prevValue;
            }
            try {
                storage =
                    PersistentPropertyStorage.newPersistentPropertyStorage(
                        propertyFileLocation.get());
            } catch (IOException e) {
                tracer.warning(
                    "Unable to initialize persistent property storage for '"
                    + getPath() + "'");
                tracer.throwing("PersistentPropertyStorage", "<init>", e);
                return prevValue;
            }
        }

        if (storage != null) {
            try {
                storage.storeProperty(this);
            } catch (IOException e) {
                tracer.warning(
                    "Unable to persist property '" + getPath() + "'");
                tracer.throwing("PersistentPropertyStorage", "set(String)", e);
            }
        }
        return prevValue;
    }
252908
@Override
    public Object getAttribute(final String name) {
        return ProfileHelper.getInternalAttributeHandler().restore(this.attributes.get(name));
    }
1053019
public BaseBo setAttribute(String attrName, Object value) {
        return setAttribute(attrName, value, true);
    }
1105397
@Override
    public String convertTo(final Object value) {
        if (value == null) return "null";
        return convertTo(value.getClass(), value);
    }
288172
@Override
    public boolean containsValue(Object value) {
        if (value == null) {
            throw new NullPointerException();
        }

        for (Map.Entry<K, CachedValue<K, V>> entry : map.entrySet()) {
            CachedValue<K, V> cachedValue = entry.getValue();
            if (cachedValue.getValue().equals(value)) {
                if (isValueExpired(cachedValue)) {
                    if (map.remove(cachedValue.getKey(), cachedValue)) {
                        onValueRemove(cachedValue);
                    }
                } else {
                    readValue(cachedValue);
                    return true;
                }
            }
        }
        return false;
    }
525665
public Node attribute(final String name, final Object value) {
        return attribute(name, String.valueOf(value));
    }
303672
public <T> B attr(AttributeKey<T> key, T value) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        if (value == null) {
            synchronized (attrs) {
                attrs.remove(key);
            }
        } else {
            synchronized (attrs) {
                attrs.put(key, value);
            }
        }
        return self();
    }
583460
public static CharSequence toParameterValue(final Boolean value) {
        return value != null ? Boolean.toString(value) : Attr.nullValue();
    }
588304
public B attr(String name, String value) {
        get().setAttribute(name, value);
        return that();
    }
1282552
public static String decodeToStr(String value) {
        byte[] decodedValue = delegate.decode(value);
        return new String(decodedValue, UTF_8);
    }
1241768
public static Map<String, Object> toMap(String value) {
		Map<String, Object> result = toNullableMap(value);
		return result != null ? result : new HashMap<String, Object>();
	}