Re: Subclass or member variable?
I'm afraid, I still don't really understand what you are trying todo.
could you provide a concrete example of this?
If there's only one MyType-class, there's no need to send anything
just make it static final or skip it at all
on the other hand, if you try to group several of your B-classes by
type, it may be better implementing interfaces and then
code against these interfaces on the client-side.
On Sep 24, 6:49 pm, Lemao wrote:
> The use case is dynamic dispatching of actions sent from the client to
> the server.
>
> Yes, in both cases MyType.cass will need to be created but its a
> single class, a constant overhead in JS as you pointed out.
>
> In case 1, there is A.class and any number of B.class'es in addition
> to one MyType.class and no additional MyType.class overhead in the RPC
> serialized format (i.e. sending MyType.class id/name).
>
> In case 2, there is one A.class and one MyType.class and there is an
> extra payload in the RPC serialized format.
>
> Whether you want to use one of the other depends on many factors and
> for most cases it probably doesnt matter. But if you have many
> B.class'es (large app) and the app is data intensive (many send/
> receive over the wire) the question becomes more important.
>
> My initial approach is to choose case 1. Although the JS is larger its
> a one time hit since the JS, afaik, is aggressively cached on the
> browser and I have the added benefit of not having to pay the price
> for sending the extra bytes everytime B.class, or C.class, etc is sent/
> received. I also like the fact that the code becomes more type checked
> etc.
>
> On Sep 24, 11:18 am, mars1412 wrote:
>
> > this looks very strange - what is your use case for this?
>
> > anyway - if you really want/need this: I don't think, that example 1
> > will produce larger JS than 2, because in both cases you need to know
> > MyType.class, don't you?
>
> > On Sep 24, 3:23 pm, Lemao wrote:
>
> > > Based on how JS is generated and how GWT-RPC encodes objects on the
> > > wire and serializes them, what would be a better course of action:
> > > Should I prefer a pattern of adding static members to a subclass or
> > > parameterize a class by using a member variable?
>
> > > For instance, should I prefer this:
>
> > > abstract class A{
> > > Class getType();}
>
> > > class B extends A {
> > > Class getType(){
> > > return MyType.class;
> > > }
> > > {
>
> > > OR this:
>
> > > class A {
> > > A type;
> > > A(Class type){
> > > this.type = type;
> > > }
>
> > > Class getType(){
> > > return type;
> > > }
>
> > > }
>
> > > Its a compromise between larger on the wire object size and JS size. I
> > > am tempted to stick with the static approach to reduce on the wire
> > > size but wanted to double check here for any words of wisdom.
>
>
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the Google Groups
"Google Web Toolkit" group.
To post to this group, send email to google-web-toolkit@googlegroups.com
To unsubscribe from this group, send email to
google-web-toolkit+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/google-web-toolkit?hl=en
-~--~~~~--~~--~--~---
Re: Subclass or member variable?
The use case is dynamic dispatching of actions sent from the client to
the server.
Yes, in both cases MyType.cass will need to be created but its a
single class, a constant overhead in JS as you pointed out.
In case 1, there is A.class and any number of B.class'es in addition
to one MyType.class and no additional MyType.class overhead in the RPC
serialized format (i.e. sending MyType.class id/name).
In case 2, there is one A.class and one MyType.class and there is an
extra payload in the RPC serialized format.
Whether you want to use one of the other depends on many factors and
for most cases it probably doesnt matter. But if you have many
B.class'es (large app) and the app is data intensive (many send/
receive over the wire) the question becomes more important.
My initial approach is to choose case 1. Although the JS is larger its
a one time hit since the JS, afaik, is aggressively cached on the
browser and I have the added benefit of not having to pay the price
for sending the extra bytes everytime B.class, or C.class, etc is sent/
received. I also like the fact that the code becomes more type checked
etc.
On Sep 24, 11:18 am, mars1412 wrote:
> this looks very strange - what is your use case for this?
>
> anyway - if you really want/need this: I don't think, that example 1
> will produce larger JS than 2, because in both cases you need to know
> MyType.class, don't you?
>
> On Sep 24, 3:23 pm, Lemao wrote:
>
>
>
> > Based on how JS is generated and how GWT-RPC encodes objects on the
> > wire and serializes them, what would be a better course of action:
> > Should I prefer a pattern of adding static members to a subclass or
> > parameterize a class by using a member variable?
>
> > For instance, should I prefer this:
>
> > abstract class A{
> > Class getType();}
>
> > class B extends A {
> > Class getType(){
> > return MyType.class;
> > }
> > {
>
> > OR this:
>
> > class A {
> > A type;
> > A(Class type){
> > this.type = type;
> > }
>
> > Class getType(){
> > return type;
> > }
>
> > }
>
> > Its a compromise between larger on the wire object size and JS size. I
> > am tempted to stick with the static approach to reduce on the wire
> > size but wanted to double check here for any words of wisdom.
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the Google Groups
"Google Web Toolkit" group.
To post to this group, send email to google-web-toolkit@googlegroups.com
To unsubscribe from this group, send email to
google-web-toolkit+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/google-web-toolkit?hl=en
-~--~~~~--~~--~--~---
Re: Subclass or member variable?
this looks very strange - what is your use case for this?
anyway - if you really want/need this: I don't think, that example 1
will produce larger JS than 2, because in both cases you need to know
MyType.class, don't you?
On Sep 24, 3:23 pm, Lemao wrote:
> Based on how JS is generated and how GWT-RPC encodes objects on the
> wire and serializes them, what would be a better course of action:
> Should I prefer a pattern of adding static members to a subclass or
> parameterize a class by using a member variable?
>
> For instance, should I prefer this:
>
> abstract class A{
> Class getType();}
>
> class B extends A {
> Class getType(){
> return MyType.class;
> }
> {
>
> OR this:
>
> class A {
> A type;
> A(Class type){
> this.type = type;
> }
>
> Class getType(){
> return type;
> }
>
> }
>
> Its a compromise between larger on the wire object size and JS size. I
> am tempted to stick with the static approach to reduce on the wire
> size but wanted to double check here for any words of wisdom.
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the Google Groups
"Google Web Toolkit" group.
To post to this group, send email to google-web-toolkit@googlegroups.com
To unsubscribe from this group, send email to
google-web-toolkit+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/google-web-toolkit?hl=en
-~--~~~~--~~--~--~---
