Re: Reading a C struct in java
On Thu, 01 Oct 2009 10:42:44 +0100, RedGrittyBrick wrote:
markspace wrote:
Mark wrote:
On Tue, 29 Sep 2009 11:27:06 -0400, Eric Sosman <Eric.Sosman@sun.com>
What you "have" to do is decide what kind of a Java object (or
set of objects) you want to create from this bag of bytes. Then do
whatever's needed to create the object(s). Stop thinking about
representation, and start thinking about information, about values.
I should have phrased my question better. I know this, I just need to
know how to implement it in Java.
Well, can you tell us then? What kind of Java object do you want to
create? Also tell us what you have now (an array of bytes, I'm
guessing) and we might be able to give you some better advice.
In an earlier message Mark said that the data was indeed delivered as an
array of bytes. Presumably the byte array contains all the data from the
whole C struct that corresponds to the payload of a network message.
My main problem is not knowing the Java class library very well.
I don't think there's a library class that will do this for you. Maybe
serialization, if you wrote special methods to handle it. Dunno if
that's the best idea though.
That's an interesting idea, I wonder if it is possible to design a Java
class such that one can deserialize mark's byte array into an instance
of that class?
ObjectInputStream in = new ObjectInputStream(
new ByteArrayInputStream(bytes));
Foo foo = (javax.swing.JButton) in.readObject(); in.close();
I'm pretty sure that that would not be possible. You can't just make up a
OIS from an arbitrary sequence of bytes. An OIS has, as I understand it,
some preamble which is read from the underlying Stream when the OIS is
constructed/opened. Also, I'm pretty sure there is more to the OIS
contents than just the object members.
Surely all it requires is a class with a method which will populate the
members of that class when given the relevant byte[] (this could be the
constructor). Within that method it's just a matter of picking the right
elements from the byte[] and converting/storing them in the relevant
members of the object.
If all that's required is a quick and dirty solution to match the style
of the original C, then that ought to get the job done. But without any
information regarding what those char (which C often uses in place of
byte) fields actually represent I don't see that it's possible to provide
any better solution.
--
Nigel Wade