[protege-owl] kazuki Classes generated through protégé

classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

[protege-owl] kazuki Classes generated through protégé

Camila bezerra
I have been some problems with the Kauki classes, generated through protégé 3.2. However, I didn´t find any document explain the Kazuki usage.

For example, methods like:

        public boolean canWrap(com.hp.hpl.jena.graph.Node n, com.hp.hpl.jena.enhanced.EnhGraph eg) {}
        public com.hp.hpl.jena.enhanced.EnhNode wrap(com.hp.hpl.jena.graph.Node n, com.hp.hpl.jena.enhanced.EnhGraph eg) {}
        protected static class ObjectMapper implements com.hp.hpl.jena.util.iterator.Map1 {}


What´s the matter?


If anybody has material (or example) about the use of kazuki classes generated through protégé, please, inform us the link.


Thank you,

Camila Bezerra

Reply | Threaded
Open this post in threaded view
|

[protege-owl] Re: [protege-owl] kazuki Classes generated through protégé

Nikolaj Berntsen
Camila bezerra wrote:
> I have been some problems with the Kauki classes, generated through protégé
> 3.2. However, I didn´t find any document explain the Kazuki usage.

I wanted to do code generation from an .owl file. I investigated
protege-owl, emf, kazuki. None of them suited me. My requirement was a
full roundtrip: make instances in  java, export to rdf, read in rdf and
get out java instances.

        protege-owl I could not wrestle to make a the roundtrip. I think it may
be possible, but I gave up. There was also this frames and slots stuff
underneat which I never really got.
        EMF generation was broken.
        Kazuki seemed to be able to work, but the documentation suggested that
is was not really polished for users that just wanted generated code
fast, so I dropped it.

Then I got jastor http://jastor.sourceforge.net/ recommended by Holger
Knublauch, and it works great for me. Jastor is backed by jena, so when
the generated is not good enough, you can always fall back to jena
models. Jastor is open source and lead by some ibm guys. They are pretty
responsive to suggestions and bugs on the mailing list, so I feel that
is definitely the way to go, at least for me. The round trip works for me.

Good luck,
/\/

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

[protege-owl] RE: [protege-owl] Re: [protege-owl] kazuki Classes generated through protégé

Schmitz, Jeffrey A
Thanks for the pointer to jastor.  It seems (to me) a whole lot easier to work with than the Protégé generated code, although I'd like to hear what the advantages are of each as far as capabilities.

One question I have about using these ontology classes is, when programatically creating instances of OWL classes, is there a "best practices" way of making sure the instance names of each class are unique in your model?  Also, how do you decide whether a new instance of something is really even required?  For example, using the Pizza ontology, if I create a new American Hot Pizza instance, should I create new instances of each of its toppings?  Should I create a single instance of each topping and all new pizza's just point to the same instance?  Or should pizza instances just point to the topping type?

i.e.
http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoTopping1234
Or
http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoToppingInstance
Or
http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://pizzas#jalapenoTopping


-----Original Message-----
From: Nikolaj Berntsen [mailto:[hidden email]]
Sent: Wednesday, August 30, 2006 6:05 AM
To: [hidden email]
Subject: [protege-owl] Re: [protege-owl] kazuki Classes generated through protégé

Camila bezerra wrote:
> I have been some problems with the Kauki classes, generated through
> protégé 3.2. However, I didn´t find any document explain the Kazuki usage.

I wanted to do code generation from an .owl file. I investigated protege-owl, emf, kazuki. None of them suited me. My requirement was a full roundtrip: make instances in  java, export to rdf, read in rdf and get out java instances.

        protege-owl I could not wrestle to make a the roundtrip. I think it may be possible, but I gave up. There was also this frames and slots stuff underneat which I never really got.
        EMF generation was broken.
        Kazuki seemed to be able to work, but the documentation suggested that is was not really polished for users that just wanted generated code fast, so I dropped it.

Then I got jastor http://jastor.sourceforge.net/ recommended by Holger Knublauch, and it works great for me. Jastor is backed by jena, so when the generated is not good enough, you can always fall back to jena models. Jastor is open source and lead by some ibm guys. They are pretty responsive to suggestions and bugs on the mailing list, so I feel that is definitely the way to go, at least for me. The round trip works for me.

Good luck,
/\/

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

[protege-owl] Re: [protege-owl] RE: [protege-owl] Re: [protege-owl] kazuki Classes generated through protégé

Nikolaj Berntsen
Schmitz, Jeffrey A wrote:

> Thanks for the pointer to jastor.  It seems (to me) a whole lot easier to work with than the Protégé generated code, although I'd like to hear what the advantages are of each as far as capabilities.
>
> One question I have about using these ontology classes is, when programatically creating instances of OWL classes, is there a "best practices" way of making sure the instance names of each class are unique in your model?  Also, how do you decide whether a new instance of something is really even required?  For example, using the Pizza ontology, if I create a new American Hot Pizza instance, should I create new instances of each of its toppings?  Should I create a single instance of each topping and all new pizza's just point to the same instance?  Or should pizza instances just point to the topping type?
>
> i.e.
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoTopping1234
> Or
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoToppingInstance
> Or
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://pizzas#jalapenoTopping

Not really an expert here, but my common sense tells me to go with no 3.
 At least if you do not have any wish to talk about the topping on an
instance of a pizza alone, it should be fint to just say what type the
topping is.


I think they use the pattern 'value-partition' in the pizza ontology.
There is also another owl-pattern, enum, which could be used. I am not
sure of the difference semantically, but I can see they are implemented
differently. Probably a matter of reading some article somewhere, but
you have to start in a corner and work your way pragmatically towards
your goal.

Cheers,
/\/
-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html

Reply | Threaded
Open this post in threaded view
|

[protege-owl] Re: [protege-owl] Re: [protege-owl] RE: [protege-owl] Re: [protege-owl] kazuki Classes generated through protégé

Camila bezerra
Many thanks for the hint the Jastor, I will analyse it, I hope to resolve my doubts . It seems simple to work. Thanks

On 8/31/06, Nikolaj Berntsen <[hidden email]> wrote:
Schmitz, Jeffrey A wrote:

> Thanks for the pointer to jastor.  It seems (to me) a whole lot easier to work with than the Protégé generated code, although I'd like to hear what the advantages are of each as far as capabilities.
>
> One question I have about using these ontology classes is, when programatically creating instances of OWL classes, is there a "best practices" way of making sure the instance names of each class are unique in your model?  Also, how do you decide whether a new instance of something is really even required?  For example, using the Pizza ontology, if I create a new American Hot Pizza instance, should I create new instances of each of its toppings?  Should I create a single instance of each topping and all new pizza's just point to the same instance?  Or should pizza instances just point to the topping type?
>
> i.e.
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoTopping1234
> Or
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://mypizzas#jalapenoToppingInstance
> Or
> http://mypizzas#myNewAmHotPizza http://pizzas#hasTopping http://pizzas#jalapenoTopping

Not really an expert here, but my common sense tells me to go with no 3.
At least if you do not have any wish to talk about the topping on an
instance of a pizza alone, it should be fint to just say what type the
topping is.


I think they use the pattern 'value-partition' in the pizza ontology.
There is also another owl-pattern, enum, which could be used. I am not
sure of the difference semantically, but I can see they are implemented
differently. Probably a matter of reading some article somewhere, but
you have to start in a corner and work your way pragmatically towards
your goal.

Cheers,
/\/
-------------------------------------------------------------------------
To unsubscribe go to http://protege.stanford.edu/community/subscribe.html