Method that JAX-RS container calls to deserialize given value.
548086
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders,
			InputStream entityStream) throws IOException, WebApplicationException {
		String input = null;
		try {
			input = IOUtils.inputStreamToString(entityStream);
		} catch (Exception e) {
			
		}
		if (input == null) {
            return null;
        }
		if (fastJsonConfig.features == null)
			return JSON.parseObject(input, type, fastJsonConfig.parserConfig, JSON.DEFAULT_PARSER_FEATURE);
		else
			return JSON.parseObject(input, type, fastJsonConfig.parserConfig, JSON.DEFAULT_PARSER_FEATURE, fastJsonConfig.features);
	}
1013495
public static Axiom deserialise(String s) {
        if(unmarshaller == null) init();
        try {
            Object res = unmarshaller.unmarshal(new ByteArrayInputStream(s.getBytes()));
            return (Axiom) res;
        } catch(JAXBException e) {
            log.error("There was a problem deserialising an axiom. JAXB threw an exception.", e);
            throw new RuntimeException(e);
        }
    }
668970
def serialize(self, value, primitive=False):
        """"""
        if hasattr(value, 'serialize'):
            # i.e. value is a nested model
            return value.serialize(primitive=primitive)
        else:
            return value
75928
static XARecoveryWrapper deserialize(byte[] serializedWrapper)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "deserialize");

        XARecoveryWrapper wrapper = null;
            
        try
        {
            final ByteArrayInputStream bis = new ByteArrayInputStream(serializedWrapper);
            final ObjectInputStream oin = new ObjectInputStream(bis);
            wrapper = (XARecoveryWrapper) oin.readObject();
            oin.close();
        }
        catch (ClassNotFoundException e)
        {
            FFDCFilter.processException(e, "com.ibm.ws.Transaction.JTA.XARecoveryWrapper.deserialize", "298");
            if (tc.isDebugEnabled()) Tr.debug(tc, "Unable to deserialize an object from byte stream", e);
            String notfound = e.getMessage ();
            final int index = notfound.indexOf (":");
            notfound = notfound.substring (index + 1);
            Tr.error(tc, "WTRN0002_UNABLE_TO_FIND_RESOURCE_CLASS", notfound);
        }
        catch (Throwable t)
        {
            FFDCFilter.processException(t, "com.ibm.ws.Transaction.JTA.XARecoveryWrapper.deserialize", "306");
            if (tc.isDebugEnabled()) Tr.debug(tc, "Unable to deserialize an object from byte stream", t);
            Tr.error(tc, "WTRN0040_OBJECT_DESERIALIZE_FAILED", t);
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "deserialize", wrapper);
        return wrapper;
    }
1348187
def deserialize(self, value, **kwargs):
        """"""
        kwargs.update({'trusted': kwargs.get('trusted', False)})
        if self.deserializer is not None:
            return self.deserializer(value, **kwargs)
        if value is None:
            return None
        output_list = [self.prop.deserialize(val, **kwargs)
                       for val in value]
        return self._class_container(output_list)
1249439
def _deserialize_value(cls, types, value):
        

        if types.main == list and value is not None:
            return cls._deserialize_list(types.sub, value)
        else:
            return cls.deserialize(types.main, value)
1058426
private Object _deserialize(Element element) throws ConverterException {
	String nodeName = element.getNodeName().toLowerCase();

	// NULL
	if (nodeName.equals("null")) {
	    return null;
	}
	// String
	else if (nodeName.equals("string")) {
	    return _deserializeString(element);
	    /*
	     * Node data=element.getFirstChild(); if(data==null) return "";
	     * 
	     * String value=data.getNodeValue();
	     * 
	     * if(value==null) return ""; return XMLUtil.unescapeXMLString(value);
	     */
	}
	// Number
	else if (nodeName.equals("number")) {
	    try {
		Node data = element.getFirstChild();
		if (data == null) return new Double(0);
		return Caster.toDouble(data.getNodeValue());
	    }
	    catch (Exception e) {
		throw toConverterException(e);
	    }
	}
	// Boolean
	else if (nodeName.equals("boolean")) {
	    try {
		return Caster.toBoolean(element.getAttribute("value"));
	    }
	    catch (PageException e) {
		throw toConverterException(e);

	    }
	}
	// Array
	else if (nodeName.equals("array")) {
	    return _deserializeArray(element);
	}
	// Component
	else if (nodeName.equals("component") || nodeName.equals("class")) {
	    return _deserializeComponent(element);
	}
	// Struct
	else if (nodeName.equals("struct")) {
	    return _deserializeStruct(element);
	}
	// Query
	else if (nodeName.equals("recordset")) {
	    return _deserializeQuery(element);
	}
	// DateTime
	else if (nodeName.equalsIgnoreCase("dateTime")) {
	    try {
		return DateCaster.toDateAdvanced(element.getFirstChild().getNodeValue(), timeZone);
	    }
	    catch (Exception e) {
		throw toConverterException(e);
	    }
	}
	// Query
	else if (nodeName.equals("binary")) {
	    return _deserializeBinary(element);
	}
	else throw new ConverterException("can't deserialize Element of type [" + nodeName + "] to a Object representation");

    }
660509
def _deserialize(self, value, attr, data, **kwargs):
        """"""
        if not value:  # falsy values are invalid
            self.fail('invalid')
        try:
            return utils.from_iso_time(value)
        except (AttributeError, TypeError, ValueError):
            self.fail('invalid')
1025906
@Override
	public Calendar deserialize(Long value) {
		if (value != null) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTimeInMillis(value);
			return calendar;
		}
		return null;
	}
838217
public static Concept deserialiseConcept(String s) {
        if(unmarshaller == null) init();
        try {
            Object res = unmarshaller.unmarshal(new ByteArrayInputStream(s.getBytes()));
            return (Concept) res;
        } catch(JAXBException e) {
            log.error("There was a problem deserialising a concept. JAXB threw an exception.", e);
            throw new RuntimeException(e);
        }
    }
1274215
def _deserialize_value(val, raw: false)
      val = val.pack('C*')
      val = @desc.post_process(val) if !raw && @desc.read_processors?
      val
    end
1301217
private void tryToSetParsedValue(String value) throws Exception {

        JSONObject json = JSONParser.parseStrict(value).isObject();
        JSONValue val = json.get(JsonKey.START);
        setStart(readOptionalDate(val));
        val = json.get(JsonKey.END);
        setEnd(readOptionalDate(val));
        setWholeDay(readOptionalBoolean(json.get(JsonKey.WHOLE_DAY)));
        JSONObject patternJson = json.get(JsonKey.PATTERN).isObject();
        readPattern(patternJson);
        setExceptions(readDates(json.get(JsonKey.EXCEPTIONS)));
        setSeriesEndDate(readOptionalDate(json.get(JsonKey.SERIES_ENDDATE)));
        setOccurrences(readOptionalInt(json.get(JsonKey.SERIES_OCCURRENCES)));
        setDerivedEndType();
        setCurrentTillEnd(readOptionalBoolean(json.get(JsonKey.CURRENT_TILL_END)));
        setParentSeriesId(readOptionalUUID(json.get(JsonKey.PARENT_SERIES)));

    }
1091314
def _deserialize(self, value, attr, obj):
        """"""
        if not self.context.get('convert_dates', True) or not value:
            return value

        value = super(PendulumField, self)._deserialize(value, attr, value)
        timezone = self.get_field_value('timezone')
        target = pendulum.instance(value)

        if (timezone and (text_type(target) !=
                          text_type(target.in_timezone(timezone)))):
            raise ValidationError(
                "The provided datetime is not in the "
                "{} timezone.".format(timezone)
            )

        return target
447594
@Override
    public Object convert(Object value) {
       if(value instanceof Element) {
           return parseXmlElement((Element) value);
       }
       if(value instanceof CompositeData) {
           return toMap((CompositeData)value);
       }
       return value;
    }
757533
def deserialize(self, value, **kwargs):
        
        kwargs.update({'trusted': kwargs.get('trusted', False)})
        if self.deserializer is not None:
            return self.deserializer(value, **kwargs)
        if value is None:
            return None
        instance_props = [
            prop for prop in self.props if isinstance(prop, Instance)
        ]
        kwargs = kwargs.copy()
        kwargs.update({
            'strict': kwargs.get('strict') or self.strict_instances,
            'assert_valid': self.strict_instances,
        })
        if isinstance(value, dict) and value.get('__class__'):
            clsname = value.get('__class__')
            for prop in instance_props:
                if clsname == prop.instance_class.__name__:
                    return prop.deserialize(value, **kwargs)
        for prop in self.props:
            try:
                out_val = prop.deserialize(value, **kwargs)
                prop.validate(None, out_val)
                return out_val
            except GENERIC_ERRORS:
                continue
        return self.from_json(value, **kwargs)
80062
function deserializeField (value, type, prefix) {
  if (!value) return ''
  switch (type) {
    case FIELD_TYPES.int:
      return readInt(value)
    case FIELD_TYPES.id:
      return readId(value)
    case FIELD_TYPES.ids:
      return value.map(readId)
    case FIELD_TYPES.bool:
      return value[0] === 1
    case FIELD_TYPES.binary:
      return encode(value, prefix)
    case FIELD_TYPES.string:
      return value.toString()
    case FIELD_TYPES.pointers:
      return readPointers(value)
    case FIELD_TYPES.rlpBinary:
      return unpackTx(value, true)
    case FIELD_TYPES.rlpBinaries:
      return value.map(v => unpackTx(v, true))
    case FIELD_TYPES.rawBinary:
      return value
    case FIELD_TYPES.hex:
      return value.toString('hex')
    case FIELD_TYPES.offChainUpdates:
      return value.map(v => unpackTx(v, true))
    case FIELD_TYPES.callStack:
      // TODO: fix this
      return [readInt(value)]
    case FIELD_TYPES.mptree:
      return value.map(mpt.deserialize)
    case FIELD_TYPES.callReturnType:
      switch (readInt(value)) {
        case '0': return 'ok'
        case '1': return 'error'
        case '2': return 'revert'
        default: return value
      }
    default:
      return value
  }
}
1180180
def default(self, value):
        """"""
        if isinstance(value, ObjectId):
            return str(value)
        return super(ElasticJSONSerializer, self).default(value)