Reads an anonymous object from the data stream.

        @rtype: L{ASObject<pyamf.ASObject>}
541811
def readObject(self):
        
        obj = pyamf.ASObject()
        self.context.addObject(obj)

        obj.update(self.readObjectAttributes(obj))

        return obj
343906
@Override
    public <T> T readDataAsObject() throws IOException {
        Data data = readData();
        return data == null ? null : (T) serializationService.toObject(data);
    }
1078087
private void readObject(java.io.ObjectInputStream in) 
                 throws IOException, ClassNotFoundException
    {
        in.defaultReadObject();

        if (_elemDesc == null)  // element is a Class
            _annotElem = _elemClass;
        else
        {
            int argsIndex = _elemDesc.indexOf('(');
            if (argsIndex < 0)  // element is a Field
            {
                try
                {
                    _annotElem = _elemClass.getDeclaredField(_elemDesc);
                }
                catch (NoSuchFieldException nsfe)
                {
                    throw new IOException("Unable to locate field " + nsfe);
                }
            }
            else // element is a method
            {
                String methodName = _elemDesc.substring(0, argsIndex);
                if (_elemDesc.charAt(argsIndex+1) == ')')
                {
                    // At least handle the null args case quickly
                    try
                    {
                        _annotElem = _elemClass.getDeclaredMethod(methodName, new Class [] {});
                    }
                    catch (NoSuchMethodException nsme)
                    {
                        throw new IOException("Unable to locate method " +_elemDesc);
                    }
                }
                else
                {
                    // Linear search for the rest :(
                    String methodArgs = _elemDesc.substring(argsIndex+1, _elemDesc.length()-1);
                    Method [] methods = _elemClass.getDeclaredMethods();
                    for (int i = 0; i < methods.length; i++)
                    {
                        if (methods[i].getName().equals(methodName) &&
                            getMethodArgs(methods[i]).equals(methodArgs))
                        {
                            _annotElem = methods[i];
                            break;
                        }
                    }

                    if (_annotElem == null)
                    {
                        throw new IOException("Unable to locate method " +  _elemDesc);
                    }
                }
            }
        }
    }
811135
public <T> T readObject(final Object object, final DataTypeDescriptor<T> descriptor) {
		try {
			return objectFormat.read(object, descriptor);
		} catch (Exception e) {
			throw propagate(e);
		}
	}
237105
@Trivial
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        GetField fields = in.readFields();
        failure = (Throwable) fields.get(FAILURE, null);
        previousResult = (byte[]) fields.get(PREVIOUS_RESULT, null);
    }
114614
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in (and discard) array length
        s.readInt();

        queue = new Object[size];

        // Read in all elements.
        for (int i = 0; i < size; i++)
            queue[i] = s.readObject();

        // Elements are guaranteed to be in "proper order", but the
        // spec has never explained what that might be.
        heapify();
    }
637231
def read(self, n):
        
        buf = self._read_buf
        pos = self._read_pos
        end = pos + n

        if end <= len(buf):
            # Fast path: the data to read is fully buffered.
            self._read_pos += n
            return self._update_pos(buf[pos:end])

        # Slow path: read from the stream until enough bytes are read,
        # or until an EOF occurs or until read() would block.
        wanted = max(self.buffer_size, n)
        while len(buf) < end:
            chunk = self.raw.read(wanted)
            if not chunk:
                break
            buf += chunk

        self._read_buf = buf[end:]  # Save the extra data in the buffer.
        self._read_pos = 0
        return self._update_pos(buf[pos:end])
1183038
public Object internalReadObject() throws JMSException
    {
        if (!bodyIsReadOnly)
            throw new MessageNotReadableException("Message body is write only");
            
        if (readPos >= body.size())
            throw new MessageEOFException("End of stream reached");
        
        if (currentByteInputStream != null)
            throw new MessageFormatException("Cannot read another object before the end of the byte array");
        
        return body.get(readPos++);
    }
88059
public void readObject (ObjectInputStream in)
        throws IOException, ClassNotFoundException
    {
        int ecount = in.readInt();
        ensureCapacity(ecount);
        for (int ii = 0; ii < ecount; ii++) {
            int key = in.readInt();
            put(key, in.readInt());
        }
    }
1027167
def readTypedObject(self):
        
        class_alias = self.readString()

        try:
            alias = self.context.getClassAlias(class_alias)
        except pyamf.UnknownClassAlias:
            if self.strict:
                raise

            alias = pyamf.TypedObjectClassAlias(class_alias)

        obj = alias.createInstance(codec=self)
        self.context.addObject(obj)

        attrs = self.readObjectAttributes(obj)
        alias.applyAttributes(obj, attrs, codec=self)

        return obj
125960
private void readObject(ObjectInputStream in) throws ClassNotFoundException, NoSuchMethodException, IOException {
        type = ClassRef.read(in);
        name = in.readUTF();
        val = in.readObject();
    }
1372448
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();

		// the nested serializer will be null if this was read from a savepoint taken with versions
		// lower than Flink 1.7; in this case, we explicitly create instance for the nested serializer.
		if (versionSerializer == null || nodeIdSerializer == null || eventIdSerializer == null) {
			this.versionSerializer = DeweyNumber.DeweyNumberSerializer.INSTANCE;
			this.eventIdSerializer = EventId.EventIdSerializer.INSTANCE;
			this.nodeIdSerializer = new NodeId.NodeIdSerializer();
		}
	}
805073
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		if (this.nicosep != null) {
			this.nicosep.setParentNodeReference(toN(), false);
		}
	}
1191535
protected void doReadObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException {
        final GetField readFields = stream.readFields();

        for (final String fieldName : getFieldNamesInAdditionToId()) {
            final Object value = readFields.get(fieldName, null);
            setField(fieldName, value);
        }

        // fix issue of deserializing _rowNumber in it's previous int form
        final long rowNumber;
        final ObjectStreamField legacyRowNumberField =
                readFields.getObjectStreamClass().getField(getFieldNameForOldId());
        if (legacyRowNumberField != null) {
            rowNumber = readFields.get(getFieldNameForOldId(), -1);
        } else {
            rowNumber = readFields.get(getFieldNameForNewId(), -1L);
        }

        setField(getFieldNameForNewId(), rowNumber);
    }
45726
private void readObject(java.io.ObjectInputStream in)
        throws java.io.IOException {

        // read the description in from the stream
        String description = in.readUTF();
        ULocale loc;

        try {
            loc = (ULocale) in.readObject();
        } catch (Exception e) {
            loc = ULocale.getDefault(Category.FORMAT);
        }
        try {
            roundingMode = in.readInt();
        } catch (Exception ignored) {
        }

        // build a brand-new RuleBasedNumberFormat from the description,
        // then steal its substructure.  This object's substructure and
        // the temporary RuleBasedNumberFormat drop on the floor and
        // get swept up by the garbage collector
        RuleBasedNumberFormat temp = new RuleBasedNumberFormat(description, loc);
        ruleSets = temp.ruleSets;
        ruleSetsMap = temp.ruleSetsMap;
        defaultRuleSet = temp.defaultRuleSet;
        publicRuleSetNames = temp.publicRuleSetNames;
        decimalFormatSymbols = temp.decimalFormatSymbols;
        decimalFormat = temp.decimalFormat;
        locale = temp.locale;
        defaultInfinityRule = temp.defaultInfinityRule;
        defaultNaNRule = temp.defaultNaNRule;
    }
232104
def read(self, n=None):
        
        response = b""
        while n is None or n > 0:
            c = self.stream.read(1)
            if c == b"":
                break
            elif c == b"<":
                c += self.stream.read(1)
                if c == b"<?":
                    while True:
                        q = self.stream.read(1)
                        if q == b">":
                            break
                else:
                    response += c
                    if n is not None:
                        n -= len(c)
            else:
                response += c
                if n is not None:
                    n -= 1
        return response
431304
def get_object(offset)
      io = to_shm_io
      io.seek(offset)
      Marshal.load(io)
    end