15:50:15 <sebersole> #startmeeting
15:50:15 <jbott> Meeting started Tue Feb 11 15:50:15 2014 UTC.  The chair is sebersole. Information about MeetBot at http://wiki.debian.org/MeetBot.
15:50:15 <jbott> Useful Commands: #action #agreed #help #info #idea #link #topic.
15:50:55 <sebersole> #topic annotation processing in metamodel
15:51:12 <hardy> sebersole: here I have something you should change while on it - AnnotationBindingContextImpl
15:51:25 <sebersole> hardy: so like i said, lots of places in here (EntityHierarchyBuilder) tht loads Class references to build the hierarchy
15:51:32 <hardy> private static final TypeResolver TYPE_RESOLVER = new TypeResolver();
15:51:42 <sebersole> to keep a cache?
15:52:00 <hardy> this should probably not be static
15:52:11 <sebersole> true
15:52:14 <hardy> Classmate keeps its own internal cache
15:52:25 <sebersole> sure
15:52:28 <hardy> mapping between Class and some internal data strucutre
15:52:35 <sebersole> ah
15:52:39 <sebersole> so it needs Class ?
15:52:39 <hardy> you basically introduce a class loader leak
15:52:54 <sebersole> we may need to delay that then
15:53:09 <hardy> yes, at some level you pass classmate a class and it resolve this class and members
15:53:26 <sebersole> the whole idea here (1st phase bootstrapping) is to delay ClassLoader access if at all possible
15:54:00 <sebersole> i'll play with it and see
15:54:23 <hardy> ok
15:54:37 <sebersole> just wanted to get your thoughts on it
15:54:49 <hardy> not sure how long you can delay it
15:55:13 <hardy> at some stage you will need to build/extract the metadata you need
15:55:27 <sebersole> well iiuc this code does it in all cases whether it needs that info or not
15:55:36 <sebersole> so i'd say thats the first step
15:55:52 <sebersole> hardy: sure
15:55:53 <sebersole> but
15:55:53 <hardy> right, there is probably room for optimizations
15:56:05 <sebersole> if you load classes, you lose the ability to enhance those classes
15:56:18 <sebersole> loaded class defs cannot be changed
15:56:33 <sebersole> its the whole reason we use libs like jandex
15:56:59 <sebersole> heck, otherwise, just access the annotations directly
15:57:05 <hardy> interesting, I did not know that this was one of the reasons for Jandex
15:57:08 <hardy> makes sense though
15:57:41 <hardy> hmm, not true. Jandex offers a much more flexible API to parse/process annotations
15:57:54 <sebersole> flexible?
15:57:54 <hardy> that's a win in itself
15:57:56 <sebersole> not so sure about that
15:58:19 <sebersole> it certainly provides the ability to *alter* annotations
15:58:26 <sebersole> which we also use it for
15:58:32 <hardy> well, at least you can ask for "does an annotation X exist" or "give me all annotations of type X"
15:58:44 <sebersole> but again, its that was it then jandex itself would just load the class
15:58:50 <hardy> with reflection you need to keep iterating everytihng
15:58:56 <sebersole> sure, its a cache
15:59:02 <hardy> right
15:59:03 <sebersole> no...
15:59:06 <sebersole> its an *index*
15:59:08 <sebersole> :)
15:59:13 <hardy> repository I call it
15:59:34 <sebersole> anyway
15:59:37 <sebersole> like i said..
15:59:40 <hardy> but now I get why Jandex is reading byte code
15:59:46 <sebersole> ok
15:59:52 <sebersole> thats what i was going to get back too
16:00:01 <sebersole> because wildfly has the same concern
16:00:31 <sebersole> they need access to the annotations, but in a way that does not load the Class so as to define the Class bytes int eh loader
16:00:59 <hardy> sure
16:01:02 <sebersole> yes, thats why it reads the .class files directly
16:01:30 <sebersole> anyway, i'll look to build the hierarchy info using jandex then
16:01:35 <sebersole> thanks
16:01:39 <hardy> the problem here is unfortunately also, that by reading the byte code the default values are lost
16:02:12 <sebersole> its not been a real problem yet
16:02:19 <sebersole> yes i understand it CAN be
16:02:20 <hardy> meaning when reading an annotation from Jandex and the annotation's default value is used, it is not avaiable
16:02:29 <hardy> sebersole: it will be
16:02:37 <sebersole> like what
16:02:44 <hardy> ahh, hang on
16:02:52 <sebersole> bearing in mind we already added some handling for defaults
16:02:56 <hardy> I was about to say that you need to load the annotation classes to get the defaults
16:03:01 <hardy> but I guess that's ok
16:03:08 <hardy> you just cannot load user classes
16:03:08 <sebersole> the annotation class is ok
16:03:10 <sebersole> yes
16:03:12 <sebersole> right
16:03:18 <sebersole> use *model* classes
16:03:24 <sebersole> some user classes are ok
16:03:26 <sebersole> types
16:03:27 <hardy> model classes then
16:03:28 <sebersole> etc
16:03:32 <hardy> even better
16:03:38 <sebersole> yep
16:03:42 <hardy> I guess "model types" is the more accurate one
16:04:15 <gbadner> does it make sense then to put the "model type" in o.h.metamodel.spi.domain.JavaType?
16:04:28 <sebersole> uh, it is
16:04:46 <sebersole> org.hibernate.metamodel.spi.domain.JavaType#classReference
16:04:48 <gbadner> it has a ValueHolder<Class>
16:04:52 <sebersole> yep
16:05:00 <sebersole> look...
16:05:07 <sebersole> a user has a class name User
16:05:12 <sebersole> that is an entiyt
16:05:18 <sebersole> that is a model class
16:05:24 <sebersole> its part of their domain model
16:06:02 <sebersole> if there is a JavaType for User, yes, it has access to User.class
16:06:07 <gbadner> ok, I thought maybe you meant some other type of object than a Class
16:06:09 <sebersole> via classReference
16:06:24 <gbadner> yeah, I understand about JavaType
16:06:35 <gbadner> I was confused about "model type"
16:07:02 <sebersole> hardy: fyi, as you finish BV intg you will start getting lots of failures
16:07:11 <hardy> ?
16:07:18 <sebersole> "failure expected by passed" type errors
16:07:24 <sebersole> "failure expected but passed" type errors
16:07:45 <sebersole> well quite a few tests rely on BV we found
16:07:59 <sebersole> all these tests are failing currently
16:08:04 <sebersole> because BV is not integrated
16:08:09 <hardy> ok, I'll check the full build for sure
16:08:19 <sebersole> so we marked them as @FailureExpected(WithNewMetamodel)
16:08:21 <hardy> atm, I just run single test, e.g DDLTest
16:08:26 <hardy> got you
16:08:29 <sebersole> k
16:08:35 <hardy> on a tangent
16:08:55 <hardy> when I run 'gradlew clean build'
16:09:03 <hardy> I keep getting stuck in the test suite
16:09:15 <hardy> somewhere around test 475 or so
16:09:19 <sebersole> funny
16:09:24 <hardy> I have not digged any deeper
16:09:26 <sebersole> it usually runs fine for me
16:09:28 <sebersole> but
16:09:40 <sebersole> every so often it gets stuck for me too
16:09:44 <hardy> it does not happen all the time
16:09:44 <sebersole> alwasy on the same number
16:09:49 <sebersole> 1127 iirc
16:09:50 <hardy> right
16:09:57 <hardy> no, mine is lower I think
16:09:58 <sebersole> its all the failure expected
16:10:09 <sebersole> well i assure you mine is 1127 :)
16:10:17 <sebersole> i did not say yours and mine would be the same
16:10:17 <hardy> I was actually planning to configure the build to print out the test name, this way I would know which test it is
16:10:47 <hardy> anyways, just wanted to hear whether anyone else have the same problem
16:10:58 <sebersole> yep
16:11:04 <sebersole> like i said, its all the failure expected
16:11:14 <sebersole> they add lots of strain to the test suite
16:11:24 <hardy> right, we discussed this in Rome
16:11:27 <sebersole> yep
16:11:45 <hardy> hopefully the build will speed up agin once we have a clean build with actual passing tests
16:11:52 <sebersole> yep
16:12:00 <hardy> yet another question ;-)
16:12:02 <sebersole> k
16:12:10 <hardy> I tried the Idea Gradle plugin
16:12:17 <hardy> since I upgraded to Idea 13
16:12:41 <sebersole> yep, thats what i use
16:12:50 <hardy> to make the import work, I had to comment out the matrix plugin from core, entity-manager and evers
16:13:02 <hardy> anything I am doing wrong
16:13:08 <sebersole> dunno, i dont have to do anything
16:13:19 <sebersole> just tell intellij to import it
16:13:44 <hardy> I do, but it keeps dripping over the apply 'blabla-matrix'
16:13:58 <hardy> if I comment it out, the import works
16:13:58 <sebersole> i dont know what that means
16:14:10 <sebersole> not sure what to say hardy
16:14:15 <sebersole> it works for me
16:14:20 <hardy> ok
16:14:25 <sebersole> hard for me to debug a failure i cannot reproduce ;)
16:14:44 <hardy> and you did not add additional class paths or changed some other gradle plugin settings
16:14:50 <sebersole> does it give you a decent error message?
16:15:04 <sebersole> [10:23] <sebersole> just tell intellij to import it
16:15:14 <sebersole> thats it, literally
16:15:21 <hardy> odd
16:15:23 <sebersole> now i do have to tweak the imported project a little
16:15:29 <hardy> sure
16:15:32 <hardy> same here
16:15:36 <sebersole> it messes up excludes
16:15:41 <hardy> exactly
16:15:48 <hardy> got that part
16:15:51 <brmeyer> hardy: what did you mean by "matrix plugin"?
16:15:58 <hardy> apply plugin: 'hibernate-matrix-testing'
16:16:24 <hardy> the import complains that it cannot find the plugin artefacts I guess
16:16:35 <sebersole> they are there
16:16:35 <brmeyer> hrm, I thought we ripped that out so that the modules wouldn't need to know about it
16:16:44 <brmeyer> must have misunderstood
16:16:51 <sebersole> https://repository.jboss.org/nexus/content/groups/public/org/hibernate/build/gradle/hibernate-matrix-testing/
16:17:13 <sebersole> uh, you still need to apply the plugin
16:17:23 <hardy> ?
16:17:32 <sebersole> not sure how modules could not know about it brmeyer
16:17:52 <brmeyer> misunderstood the architecture
16:18:48 <hardy> I got it to work for now. When I have a minute I can try another clean import. Then I can hopefully provide a better error message as well
16:18:50 <sebersole> hardy: if you can get a better error message i can try to help
16:18:55 <hardy> :-)
16:19:25 <sebersole> anything anyone else wants to discuss?
16:20:01 <hardy> not me
16:20:42 <gbadner> sebersole, I have another question about the classloading
16:20:45 <sebersole> ok
16:21:26 <gbadner> I also did not realize until you mentioned a couple days ago about why we are avoiding it
16:21:53 <gbadner> does Jandex provide a way to get class names without loading the class?
16:21:57 <sebersole> ok, but to be fair smarlow and i have mentioned this for over a year now ;)
16:22:04 <sebersole> gbadner: yep
16:22:25 <sebersole> in fact thats one of jandex's main uses
16:22:35 <sebersole> to avoid loading Class
16:22:36 <gbadner> is there a way to get a field/method class name?
16:22:58 <gbadner> ^^^ w/o loading the Class?
16:23:03 <sebersole> yes
16:23:19 <gbadner> ok, what is the object that you query for that?
16:23:28 <sebersole> for which
16:23:35 <sebersole> and given what
16:23:59 <gbadner> suppose we have: A.b
16:24:05 <sebersole> as what
16:24:16 <sebersole> A.b is nothing
16:24:23 <sebersole> you have:
16:24:27 <sebersole> 1) "A.b" ?
16:24:29 <sebersole> 2) ??
16:24:46 <gbadner> Product.description
16:24:52 <sebersole> you are missing tghe point
16:24:57 <sebersole> is that a string?
16:24:59 <gbadner> no
16:25:04 <sebersole> then what?
16:25:38 <gbadner> you have a Product class that is annotated with @Entity
16:25:53 <gbadner> description is a String field
16:25:57 <sebersole> :)
16:26:13 <sebersole> and how do you know about Product?
16:26:21 <sebersole> what is the form of knowledge you have?
16:26:35 <gbadner> my question is, what is the Jandex object that gets queried to find out the name of class ("Product")?
16:27:00 <sebersole> you dont
16:27:26 <gbadner> hmm; makes associations kinda hard
16:27:27 <sebersole> so youre asking what method to call to get the name of a class you knwo the name of?
16:28:03 <sebersole> associations are easy
16:28:25 <sebersole> you'd know about @ManyToOne e.g
16:28:29 <gbadner> no, when Binder is creating an EntityBinding, it needs a class name
16:28:37 <gbadner> yes, that would be true about associations
16:28:49 <sebersole> gbadner: you just asked how to get the name of a class baed on the name of a clas
16:29:00 <sebersole> i mean you have the name of the class
16:29:06 <gbadner> that's not what I'm asking
16:29:13 <sebersole> [10:37] <gbadner> my question is, what is the Jandex object that gets queried to find out the name of class ("Product")?
16:29:24 <sebersole> this is why i am asking you how and where
16:29:33 <gbadner> I put ("Product") in parens because that's that answer I want
16:29:43 <sebersole> stop
16:29:50 <sebersole> let me explain something first
16:29:58 <sebersole> so...
16:30:03 <sebersole> [10:38] <sebersole> you'd know about @ManyToOne e.g
16:30:23 <sebersole> in Jandex terms that would equate to a AnnotationInstance
16:30:35 <hardy> gbadner: http://jbossas.github.io/jandex/org/jboss/jandex/package-tree.html
16:30:39 <sebersole> which is a particulare instance of AnnotationInstance
16:30:46 <sebersole> which is a particulare instance of an anotation
16:30:46 <hardy> check the Javadocs - there are only a few classes
16:31:27 <gbadner> ok, that's something *in* an annotation
16:31:32 <sebersole> AnnotationInstance.getTarget() give you access to the thing the annotation was attached to
16:31:37 <sebersole> no
16:31:39 <sebersole> its not
16:31:49 <gbadner> ok, so @Entity
16:31:58 <sebersole> yep
16:32:05 <sebersole> AnnotationInstance.getTarget() -> the class
16:32:06 <hardy> the classes we are after are annotated with @Entity, we ask Index#getAnnotations("javax.persistence.Entity")
16:32:21 <sebersole> as ClassInfo
16:32:24 <gbadner> actually, it's AnnotationTarget (not sure what that is yet...)
16:32:41 <sebersole> :)
16:32:45 <hardy> the construct the annotation is placed on
16:32:45 <gbadner> ok, I see; yes, a ClassInfo
16:33:00 <hardy> it could be a CLassInfo, FieldInfo, MethodInfo ...
16:33:11 <sebersole> its java.lang.annotation.Target\
16:33:13 <gbadner> ok, ClassInfo.name is the entity class naem
16:33:14 <gbadner> name
16:33:29 <sebersole> as DotName
16:33:38 <sebersole> jandex uses DotName rather than string
16:33:47 <gbadner> ok
16:33:50 <smarlow> Should the WildFly 8.0 release notes link to http://in.relation.to/Bloggers/HibernateORM430FinalRelease + http://in.relation.to/Bloggers/HibernateORM431FinalRelease?
16:34:41 <gbadner> I'm looking at ClassInfo, and I don't see a way to query a field to get its ClassInfo
16:34:57 * smarlow will ask in wildfly-dev :)
16:35:33 <sebersole> because you are looking at it wrong
16:35:37 <hardy> it does not work like this
16:35:47 <sebersole> you 'd get its annotations
16:35:48 <hardy> you would ask for an association annotation
16:35:58 <hardy> @OneToMany for example
16:36:03 <gbadner> ok, what about Product.description
16:36:12 <hardy> in this case you get a Field/MethodInfo
16:36:46 <sebersole> gbadner: again you are looking at it wrong
16:37:03 <sebersole> you dont ask it for a field or a method
16:37:09 <sebersole> you look up annotations
16:37:27 <sebersole> this is why we pre-process them in "annotation source"
16:37:28 <gbadner> ok, how is this done if there is no annotation on description?
16:37:39 <sebersole> this is why we pre-process them in "annotation source"
16:38:35 <gbadner> I'm still not following how we know description is a String without loading Product.class
16:39:12 <sebersole> well annotation source is in fact loading the Class
16:39:24 <sebersole> i have not gotten to fixing that yet
16:39:26 <gbadner> currently it is
16:39:31 <sebersole> uh
16:39:38 <sebersole> yeah thats what i just said :)
16:39:43 <gbadner> I understand that is going to be fixed
16:40:02 <gbadner> when it is fixed, will there be a way to get the field class name without loading the class
16:40:05 <gbadner> ?
16:40:19 <sebersole> thats the idea yes
16:40:50 <gbadner> so it will be possible; any idea how?
16:41:18 <sebersole> considering i have not gotten there...
16:41:27 <gbadner> ok, so it's unknown
16:41:41 <sebersole> for now
16:41:59 <sebersole> it will happen
16:42:00 <gbadner> whatever that object ends up being, I think it would be good to put that object in JavaType
16:42:15 <sebersole> i dont understand
16:42:25 <sebersole> whatever what object
16:42:31 <gbadner> sec
16:42:46 <sebersole> the field/method representation?
16:42:53 <sebersole> if so, absolutely not
16:43:08 <gbadner> I've added this locally: JavaType.getPropertyJavaType(final String propertyName)
16:43:13 <gbadner> to encapsulate it
16:43:32 <sebersole> i have to tell yu i am not at all a fan of that
16:43:45 <gbadner> ok, it can be changed
16:43:59 <sebersole> JavaType(Integer).getPropertyJavaType( "something" )
16:44:01 <sebersole> makes no sense
16:44:42 <sebersole> this is why i was saying that i think Type is a better alternative
16:44:56 <gbadner> if JavaType holds a ClassInfo (or whatever is needed to query the class for a field)
16:45:08 <sebersole> org.hibernate.metamodel.spi.domain.Type
16:46:03 <hardy> sebersole: when is it ok to load model types?
16:46:19 <hardy> at which stage would class enhancement occur
16:46:50 <hardy> I am trying to picture how long you can/have to delay the loading of the class
16:46:52 <sebersole> ideally after org.hibernate.metamodel.Metadata is built
16:47:25 <sebersole> hardy: one thing already swirling in my mind is a fork/extension of classmate to use jandex
16:47:31 <hardy> in the end you will have to, be it to determine basic types (I think that is what gbadner is after) or to do the generic resolution)
16:47:47 <gbadner> hardy, yes
16:47:52 <sebersole> no
16:47:58 <sebersole> you will as stuff is now
16:48:24 <sebersole> or talking to jason about extensions to jandex
16:49:30 <hardy> sebersole: don't know, I have a hard time seeing classmate work with Jandex
16:49:39 <sebersole> why?
16:49:50 <hardy> it is heavily reflection based and I doubt you can even do what it does w/o it
16:50:33 <sebersole> ultimately you need correctness
16:50:48 <sebersole> so if that is needed for generics then so be it
16:50:49 <hardy> Jandex does not even provide any generic informaiton
16:51:13 <sebersole> my qualm with how that is done today is that it loads the class to resolved generics even if its not needed
16:51:38 <sebersole> if you need to load the class, fine
16:52:01 <gbadner> how would we even find out about basic attributes if there is no annotation?
16:52:01 <hardy> as said, there is see room for improvement
16:52:02 <sebersole> for certain you dont have to load the class to know its fields/methods
16:52:36 <gbadner> how do you get its fields/methods w/o loading the class?
16:52:39 <sebersole> gbadner: well, again, annotation source today loads the Class to know
16:52:49 <sebersole> for the 3rd time :)
16:52:49 <gbadner> right, I know it will change
16:52:58 <sebersole> [10:58] <sebersole> or talking to jason about extensions to jandex
16:53:03 <gbadner> I know how it's done now (for the 3rd time)
16:53:17 <sebersole> no, for the 3rd time that it will change
16:53:26 <sebersole> you keep asking how
16:53:39 <sebersole> thats kind of the meaning of "i have not gotten there yet"
16:53:39 <gbadner> if you don't know yet, it's fine
16:53:44 <sebersole> I dont knwo yet
16:53:46 <gbadner> ok
16:53:46 <hardy> if you want to get the information from Jandex you will need to extend it
16:53:54 <sebersole> hardy: :)
16:53:55 <sebersole> yes
16:54:25 <hardy> not sure how much of this is already there or needs to be written
16:54:27 <sebersole> in fact we really can just limit it to bean properties
16:54:46 <sebersole> although the more generic solution is fields and methods
16:55:50 <sebersole> i asked jason how much work that would be
16:55:51 <hardy> I guess you have to find out how this is encoded in the class file
16:55:59 <hardy> what did he say?
16:56:12 <sebersole> i'll let you know when he responds
16:56:16 <hardy> :-)
16:56:24 <sebersole> i literally just asked him
16:56:32 <hardy> if you can get this information into Jandex you win a lot
16:56:40 <sebersole> yes
16:56:54 <sebersole> it becomes even more of a general replacement for Class
16:57:03 <hardy> then you might only have to load the class for generic resolution (which might be optimisable)
16:57:03 <sebersole> reflection
16:57:09 <hardy> right
16:57:52 <hardy> I like the idea, but there is a fair amount of ground to cover to make it work
16:58:20 <sebersole> there is a fair amount of unkown to make it work
16:58:27 <sebersole> you dont know how much work there is
16:58:35 <sebersole> so lets find out
16:58:48 <hardy> lol
16:58:52 <hardy> gtg
16:58:59 <hardy> sebersole: keep me posted on this one
16:59:04 <hardy> interesting stuff
16:59:04 <sebersole> of course
16:59:08 <sebersole> yep
16:59:41 <hardy> Jandex could become a very general purpose library if this works out
17:00:00 <hardy> good that it has such a great project site and docs ;-)
17:01:03 <sebersole> hardy: ...
17:01:15 <sebersole> [11:10] <Nihility> sebersole: i have wondered though if really this project should evolve to be an offline reflection library
17:01:34 <sebersole> he is quite accepting of the idea
17:01:40 <hardy> nice
17:02:04 <hardy> would make sense
17:02:33 <hardy> and a requirement for deferring class loading even further
17:03:30 <hardy> anyways, gtg
17:06:32 <gbadner> sebersole, I think I have a handle now on what is known and what we would like to do
17:06:40 <gbadner> to fix things I mean
17:07:03 <sebersole> well, we'll have to see what jason decides on priority
17:07:09 <sebersole> i guess thats the next bit
17:07:34 <sebersole> would be nice to localize all these lookups
17:07:42 <sebersole> to make it easier to swap
17:07:53 <sebersole> if/when he does provide that via jandex
17:08:38 <gbadner> the reason I was asking about looking up a field class is because I found several places where this is done by Binder, and I wanted to encapsulate that somewhere
17:08:53 <gbadner> so I put it in JavaType just to have it all in one place
17:10:07 <gbadner> anyhow, I have a better understanding of the problem now
17:11:14 <sebersole> the problerm like i said is that JavaType is not the right place
17:12:27 <sannegrinovero_> DavideD: not seen you in the office today ;-)
17:13:38 <sebersole> anything else?
17:13:43 <gbadner> nope
17:13:50 <sebersole> still chatting with jason
17:14:24 <DavideD> sannegrinovero_, I've thought there were the strike
17:14:32 <sebersole> one thing i would like to mention is the idea of service registries and closing
17:15:00 <DavideD> sannegrinovero_, I didn't notice the've suspendeded it
17:15:02 <sebersole> wouold be great if folks could give some thought to that
17:15:25 <gbadner> sebersole, in tests?
17:15:35 <sebersole> the basic idea is that as initially designed service registries were designed to be "shared"
17:15:40 <sebersole> gbadner:  no
17:15:55 <sebersole> so consider the basic registry set up in orm
17:16:06 <sebersole> SF reg -> Standard reg -> boot reg
17:16:22 <sebersole> when the SF shuts down its SF reg is closed
17:16:32 <sebersole> but the other remain open
17:16:37 <gbadner> ah, ok
17:16:51 <sebersole> (actually the standard reg may get closed too)
17:17:04 <sebersole> but the question is more about the generic idea
17:17:40 <sebersole> sanne brings up the point of other hibernate projects using those registries as the parents for theirs
17:17:59 <sebersole> Search reg -> SF reg -> Standard reg -> ...
17:18:12 <sebersole> something like that
17:18:49 <sebersole> ultimately we just need to know how to safely make sure all of them get closed
17:19:15 <sebersole> *when nothing any longer references them*
17:19:31 <sebersole> ideally staying away from reference counters
17:19:53 <gbadner> looking at the email thread...
17:20:19 <sebersole> you found one?
17:20:29 <sebersole> sannegrinovero_ was asking me about that yesterday
17:20:41 <gbadner> well, not exactly about that (at least not at the start)
17:20:41 <sebersole> i could not remember if i sent it as email
17:20:47 <sebersole> ah
17:20:48 <gbadner> "Getting notified when session factory is completely	set up"
17:20:53 <gbadner> is that related?
17:21:02 <sebersole> not really
17:24:38 <sebersole> so i guess i'll send an email on the subject
17:24:48 <sebersole> i know gmorling will at least respond nowadays ;)
17:25:02 <sebersole> thanks Gunnar!
17:25:09 <sannegrinovero_> reference counters aren't too bad :)
17:25:37 <sebersole> sannegrinovero_: if done right yes
17:25:52 <sebersole> if done right.. they work
17:26:24 <sebersole> but i think this will have to be up to the child to register
17:26:29 <sebersole> and unregister
17:26:42 <sebersole> Search reg for example
17:26:50 <sebersole> or an custom user reg
17:27:06 <sebersole> and if they do not do it right...
17:27:26 <sebersole> i guess some of that could be done in the base reg
17:28:13 <sebersole> well i'll look at that too
17:28:19 <sebersole> #endmeeting