> On 04/01/2011 05:24 AM, Benoît Minisini wrote:
> > Using a structure just allow you to directly use the READ/WRITE
> > instruction because they have a build-in serialization support. But as
> > you noticed, handling a lot of different structures is not handy!
>
> Yes, because I need to keep a transaction history of all the structures
> but there's no easy way to store different structures en masse.
>
> > Hopefully, you don't have to use structures. You can create one class for
> > each packet type, and let them inherit the same parent class. Each class
> > will have its own write method (and read) that will
> > serialize/unserialize the packet to/from a given stream (that should be
> > a Socket).
>
> This sounds good, but I'm a guy whose programming skills evolved from a
> BASIC dialect in GEM on an Amstrad PC-1512 to GW-BASIC, QBasic,
> QuickBASIC 4.5, VB 6 and now GAMBAS. While some build simple projects
> using advanced tools, I build advanced projects using simple tools (not
> that gb is simple!). Inheritance, classes and objects are a little alien
> to me despite reading the documentation. If anyone has an explanation of
> these things that even a newbie could understand, I'd be grateful.
>
Here is an explanation, but not a real example :
1) You define a class named "Packet", that will be the parent class of all
real packet classes. That class has an ID field, and three methods: Send,
Receive, and _Receive (with an underscore before).
The Receive methods is static. That means it is a normal procedure. Receive
will call _Receive to do the real job.
Send and _Receive are "dynamic". That means they act on real objects. To
understand that, look at the following equivalence:
AnObject.Method(X, Y) <=> Method(AnObject, X, Y)
The first one is the "objet-oriented programming" syntax.
The second one is the classic programming syntax. That is what is really done
internally.
Packet.class:
' Gambas class
Static Private $aType As String[256]
Private $iId As Integer
Public Sub _init()
$aType[1] = "PacketType1"
$aType[2] = "PacketType2"
$aType[3] = "PacketType3"
...
End
Public Sub Send(hStream As Stream)
End
Static Public Sub Receive(hStream As Stream)
Dim iType As Integer
Dim hPacket as Packet
' Read the packet type as a Byte
iType = Read #hStream As Byte
' All real packet class names are stored in the $aType array
hPacket = Object.New($aType[iType])
' The _Receive method of the specific class will be called, not
' the void one in the Packet class.
hPacket._Receive(hStream)
End
Public Sub _Receive(hStream As Stream)
End
2) For each different packet, you define a new class. That class will redefine
the _Receive method, to do the real job. And the Send method also.
PacketType1.class:
' Gambas class
Public Sub Send(hStream As Stream, aData As Variant[])
' aData is any array that will include the specific packet fields
' You can use a Collection also, or you can define public variables
' in the class, fill them, and use them directly there instead of
using
' an 'aData' argument.
Write #hStream, 1 As Byte
Write #hStream, aData[0] As ...
Write #hStream, aData[1] As ...
...
End
Public Sub _Receive(hStream As Stream)
Dim Field1 As ...
Dim Field2 As ...
...
Field1 = Read #hStream As ...
Field2 = Read #hStream As ...
...
' Now you have the packets contents, you can do the real job.
End
PacketType2.class:
' Gambas class
...
PacketType3.class:
' Gambas class
...
I hope it is more clear for you now.
Regards,
--
Benoît Minisini
------------------------------------------------------------------------------
Create and publish websites with WebMatrix
Use the most popular FREE web apps or write code yourself;
WebMatrix provides all the features you need to develop and
publish your website. http://p.sf.net/sfu/ms-webmatrix-sf
_______________________________________________
Gambas-user mailing list
Gambas-user@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/gambas-user
