There's a simple example in XSDHelperTestCase.
testXSDGeneration_DynamicSDOType().
Frank.
Gerardo Corro <[EMAIL PROTECTED]> wrote on 03/31/2008 11:50:16 AM:
>
> Or even better, if you have a working example of:
>
> XSDHelper.INSTANCE.generate
>
> It will be very appreciated.
>
> Thanks in advanced.
>
> ///RG
>
>
> From: [EMAIL PROTECTED]: [EMAIL PROTECTED]:
> RE: Convert HelperContext to XSDDate: Mon, 31 Mar 2008 09:13:52 -0600
>
>
> Hi, I made an slight adaptation to an existing example of the
> distribution, however I get exceptions at runtime. Please assist:
> package org.apache.tuscany.samples.sdo.advanced;import java.util.
> ArrayList;import java.util.List;import org.apache.tuscany.samples.
> sdo.SampleBase;import org.apache.tuscany.sdo.api.SDOUtil;import
> commonj.sdo.DataObject;import commonj.sdo.Property;import commonj.
> sdo.Type;import commonj.sdo.helper.DataFactory;import commonj.sdo.
> helper.HelperContext;import commonj.sdo.helper.TypeHelper;import
> commonj.sdo.helper.XSDHelper;public class MedicalScenario1 extends
> SampleBase { private static final String sdoApiUri = "commonj.
> sdo"; private static final String peopleURI = "www.example.
> org/people"; private static final String medicalURI = "www.
> example.org/MedicalTest"; boolean typesViaAPI = false; public
> MedicalScenario1(String[] args, Integer userLevel) {
> super(userLevel, SAMPLE_LEVEL_ADVANCED); typesViaAPI = true;
> } public MedicalScenario1(Integer userLevel) {
> super(userLevel, SAMPLE_LEVEL_ADVANCED); } /** * @param
> args * @throws Exception */ public static void
> main(String[] args) throws Exception { MedicalScenario1 s =
> new MedicalScenario1(args, COMMENTARY_FOR_NOVICE); s.run();
> } /* * metadata for the sample documenting the areas of SDO
> that are explored */ public static int[] CORE_FUNCTION = {
> SDOFacets.CONTAINMENT, SDOFacets.
> CREATE_TYPES_USING_THE_SDO_API, SDOFacets.
> CREATE_TYPES_USING_XML_SCHEMA, SDOFacets.OPEN_CONTENT,
> SDOFacets.NON_CONTAINMENT }; public static int[]
> SIGNIFICANT_FUNCTION = { SDOFacets.
> CREATE_DATAOBJECTS_BY_NAME, SDOFacets.ISMANY_PROPERTIES,
> SDOFacets.GENERIC_DATA_GRAPH_TRAVERSAL, SDOFacets.
> SAVING_DATA_TO_XML }; public void runSample() throws Exception
> { HelperContext scope = SDOUtil.createHelperContext();
> commentary("In this execution of the sample we use Types created\n"
> + "using the SDO API"); createTypesViaAPI(scope);
> commentary( COMMENTARY_FOR_NOVICE,
> "The DataFactory associated with the scope that the types were
> created within\n" + "can be used to create an instance of the Person
> Type\n\n" + "DataFactory dataFactory = scope.getDataFactory();\n" +
> "DataObject person1 = dataFactory.create(\"www.example.org/people\",
> \"Person\");"); DataFactory dataFactory = scope.
> getDataFactory(); DataObject person1 = dataFactory.
> create("www.example.org/people", "Person"); commentary("The
> setString() of dataObject method is used to set the properties of
> the\n" + "new Person DataObject, including a unique identifier
> reference value\n" + "for the Person instance.\n\n" + "person1.
> setString(\"id\", \"1\");\n" + "person1.setString(\"name\", \"Joe
> Johnson Snr.\");\n" + "person1.setString(\"gender\", \"male\"););");
> person1.setString("id", "1"); person1.setString("name", "Joe
> Johnson Snr."); person1.setString("gender", "male");
> commentary("An alternative approach to using the DataFactory
> directly to create\n" + "all DataObjects is to use a top-down
> approach, where we create the\n" + "root object for a data graph,
> and then use the createDataObject(String propertyName)\n" + "method
> to create the contained DataObjects. Here we create the overall\n"
> + "medical test DataObject, and then create the contained
> \"referrals\" DataObject\n\n" + "DataObject test = dataFactory.
> create(\"www.example.org/MedicalTest\", \"Test\");\n" + "DataObject
> referrals = test.createDataObject(\"referrals\");");
> DataObject test = dataFactory.create("www.example.org/MedicalTest",
> "Test"); DataObject referrals = test.
> createDataObject("referrals"); commentary("Now we can add the
> person we created earlier into the set of people who have\n" + "been
> referred for this medical test.\n\n" + "test.set(\"referrals\",
> referrals);\n" + "referrals.getList(\"person\").add(person1);");
> test.set("referrals", referrals); referrals.
> getList("person").add(person1); commentary("Let's take a look
> at how the current state of the data" + "graph is rendered in XML
> ..."); System.out.println(scope.getXMLHelper().save(test,
> "www.example.org/MedicalTest", "test")); commentary("The
> scenario unfolds and the Joe Johnson Snr. becomes a patient\n\n" +
> "DataObject patients = test.createDataObject(\"patients\");\n" +
> "patients.getList(\"person\").add(person1);"); DataObject
> patients = test.createDataObject("patients"); patients.
> getList("person").add(person1); commentary("Having added Joe
> Johnson Snr. to the set of patients we can see\n" + "the way that
> SDO preserves a single containment hierarchy within a\n" +
> "datagraph. If we look at the XML rendering of the graph again, we
> will\n" + "see that by adding him to the set of patients he has been
> removed from the\n" + "containment property associated with the
> referrals set ..."); System.out.println(scope.getXMLHelper().
> save(test, "www.example.org/MedicalTest", "test"));
> commentary("The 'Person' Type we are making use of here has been
> designed to be\n" + "multi-purpose, in that the type has been
> declared to be 'Open'.\n" + "That means that we can make use of
> 'Open Content' Properties\n" + "(If the type system has been defined
> using an XML schema\n" + "then these properties will derive from
> global elements)\n" + "We can look up open content Properties using
> the TypeHelper\n\n" + "Property conditionProperty = scope.
> getTypeHelper().getOpenContentProperty(\n" + " \"www.example.
> org/MedicalTest\", \"condition\");"); Property
> conditionProperty = scope.getTypeHelper().getOpenContentProperty(
> "www.example.org/MedicalTest", "condition"); commentary("We
> can create a value of the appropriate Type for this open\n" +
> "content Property\n\n" + "DataObject condition = dataFactory.
> create(conditionProperty.getType());\n" + "condition.
> setString(\"name\", \"Panar Syndrome\");"); DataObject
> condition = dataFactory.create(conditionProperty.getType());
> condition.setString("name", "Panar Syndrome"); commentary("If
> you ask a DataObject that has an 'Open' Type for its list of\n" +
> "values associated with an open content Property, and the
> DataObject\n" + "doesn't currently have any values for the Property,
> it will return\n" + "an empty list. We can use the list to add
> values for the Property\n\n" + "List conditions = person1.
> getList(conditionProperty);\n" + "conditions.add(condition);");
> List conditions = person1.getList(conditionProperty);
> conditions.add(condition); commentary("A further look at the
> data graph in XML form shows\n" + "the presence of the new condition
> Property's value ..."); System.out.println(scope.
> getXMLHelper().save(test, "www.example.
> org/MedicalTest", "test")); commentary("Having looked at the
> way SDO handles Open content\n" + "We now turn our attention to
> 'non-containment' relationships.\n" + "To do this we first create
> the set of people in the test that\n" + "constitute the blood
> relatives of patients -- 'relatives'\n" + "and define a new person
> to be Joe Johnson Snr's child.\n\n" + "DataObject relatives = test.
> createDataObject(\"relatives\");\n" + "DataObject person2 =
> relatives.createDataObject(\"person\");\n" + "person2.
> setString(\"id\", \"2\");\n" + "person2.setString(\"name\", \"Joe
> Johnson Jnr.\");\n" + "person2.setString(\"gender\", \"male\");");
> DataObject relatives = test.createDataObject("relatives");
> DataObject person2 = relatives.createDataObject("person");
> person2.setString("id", "2"); person2.setString("name", "Joe
> Johnson Jnr."); person2.setString("gender", "male");
> commentary("Another quick look at the XML rendering of the graph
> confirms that\n" + "the set of relatives now includes Joe Johnson
> Jnr, but we haven't yet\n" + "defined who he is related to, or
> how."); System.out.println(scope.getXMLHelper().save(test,
> "www.example.org/MedicalTest", "test")); commentary("The
> Person type has a Property 'relative'\n" + "so we create a relative
> for Joe Johnson Snr.\n\n" + "DataObject relation = person1.
> createDataObject(\"relative\");\n" + "relation.set(\"target\",
> person2);\n" + "relation.set(\"relationship\", \"child\");");
> DataObject relation = person1.createDataObject("relative");
> relation.set("target", person2); relation.set("relationship",
> "child"); commentary("Now when we look at the XML rendering
> of the data graph\n" + "we can see that the action of setting the
> 'target' of the\n" + "relationship to Joe Johnson Jnr didn't
> displace him from the\n" + "set of 'relatives', because the
> 'target' Property is a\n" + "non-containment Property. This non-
> containment relationship\n" + "is reflected in the XML by a
> reference to the Person DataObject\n" + "describing Joe Johnson Jnr,
> \"2\" ...\n" + "If the Type system has been created from an XML
> schema then the\n" + "unique ID of the target can be used in the
> serialization.\n" + "If however the type system was defined
> dynamically, then the reference\n" + "will be represented as an
> XPath from the root of the data graph."); System.out.
> println(scope.getXMLHelper().save(test, "www.example.
> org/MedicalTest", "test")); commentary("Now that the graph is
> complete we can use the PrintDataGraph sample utility\n" +
> "to reveal the full SDO nature of the final data graph\n\n" +
> ""); PrintDataGraph printer = new
> PrintDataGraph(COMMENTARY_FOR_ADVANCED); printer.
> printDataObject(test); System.out.println(printer.getBuf());
> } /** * @throws Exception * @throws FileNotFoundException
> */ private void createTypesViaAPI(HelperContext scope) throws
> Exception { List typeDeclarations = new ArrayList();
> TypeHelper typeHelper = scope.getTypeHelper(); Type
> stringType = typeHelper.getType(sdoApiUri, "String"); Type
> dateType = typeHelper.getType(sdoApiUri, "Date"); Type
> booleanType = typeHelper.getType(sdoApiUri, "Boolean"); //
> <complexType name="Person"> // <sequence> // <element
> name="dob" type="date"/> // <element name="relative"
> maxOccurs="unbounded" type="tns:Relative"/> // <any
> namespace="##other" processContents="lax" maxOccurs="unbounded"/>
> // </sequence> // <attribute name="id" type="ID"/> //
> <attribute name="name" type="string"/> // <attribute
> name="gender" type = "tns:Gender"/> // </complexType>
> DataObject personTypeDesc = createTypeDescription(scope, peopleURI,
> "Person"); typeDeclarations.add(personTypeDesc);
> addPropertyDescription(personTypeDesc, stringType, "name");
> addPropertyDescription(personTypeDesc, dateType, "dob");
> addPropertyDescription(personTypeDesc, stringType, "id"); // set to
> unique // identifier?
> addPropertyDescription(personTypeDesc, stringType, "gender"); //
> restrict? DataObject relativeType =
> createTypeDescription(scope, peopleURI, "Relative");
> // forward declare the Relative type typeDeclarations.
> add(relativeType); DataObject rp =
> addPropertyDescription(personTypeDesc, relativeType,
> "relative"); rp.setBoolean("many", true);
> personTypeDesc.set("open", Boolean.TRUE); // <complexType
> name="Relative"> // <attribute name="target" type="IDREF"
> sdoxml:propertyType="tns:Person" // use="required"/>
> // <attribute name="relationship" type="string" /> //
> <attribute name="genetic" use="optional" type="boolean"/> //
> </complexType> addPropertyDescription(relativeType,
> stringType, "relationship");
> addPropertyDescription(relativeType, booleanType, "genetic");
> DataObject targetPersonProp = addPropertyDescription(relativeType,
> personTypeDesc, "target"); targetPersonProp.
> setBoolean("containment", false); // <complexType
> name="PersonSet"> // <sequence> // <element
> name="person" type="tns:Person" maxOccurs="unbounded"/> //
> </sequence> // </complexType> DataObject pSet =
> createTypeDescription(scope, peopleURI, "PersonSet");
> typeDeclarations.add(pSet); DataObject pSetProperty =
> addPropertyDescription(pSet, personTypeDesc,
> "person"); pSetProperty.setBoolean("many", true); //
> <complexType name="Condition"> // <sequence> //
> <element name="diagnosed" type="date" /> // </sequence>
> // <attribute name="name" type="tns:ConditionName" /> //
> </complexType> DataObject condition =
> createTypeDescription(scope, medicalURI, "Condition");
> typeDeclarations.add(condition);
> addPropertyDescription(condition, booleanType, "diagnosed");
> addPropertyDescription(condition, stringType, "name"); // constrain?
> // <complexType name="Test"> // <sequence> // <element
> name="referrals" type="people:PersonSet" /> // <element
> name="patients" type="people:PersonSet" /> // <element
> name="relatives" type="people:PersonSet" /> // </sequence>
> // </complexType> DataObject testType =
> createTypeDescription(scope, medicalURI, "Test");
> typeDeclarations.add(testType);
> addPropertyDescription(testType, pSet, "referrals");
> addPropertyDescription(testType, pSet, "patients");
> addPropertyDescription(testType, pSet, "relatives"); List
> types = typeHelper.define(typeDeclarations); DataObject p =
> scope.getDataFactory().create("commonj.sdo", "Property"); p.
> set("type", typeHelper.getType(medicalURI, "Condition")); p.
> set("name", "condition"); p.setBoolean("many", true);
> p.setBoolean("containment", true); // why is this not the default?
> typeHelper.defineOpenContentProperty(medicalURI, p); System.
> out.print("XSD create is: " + XSDHelper.INSTANCE.generate(types));
> } /** * @param uri * @param name * @return */
> private DataObject createTypeDescription(HelperContext scope, String
> uri, String name) { DataObject typeDesc = scope.
> getDataFactory().create(sdoApiUri, "Type"); typeDesc.
> set("name", name); typeDesc.set("uri", uri); return
> typeDesc; } private DataObject addPropertyDescription(
> DataObject containerTypeDescription, Object propertyType,
> String propertyName) { DataObject property =
> containerTypeDescription.createDataObject("property");
> property.set("type", propertyType); property.
> setString("name", propertyName); property.
> setBoolean("containment", true); return property; }} >
> To: [email protected]> Subject: Re: Convert HelperContext
> to XSD> From: [EMAIL PROTECTED]> Date: Mon, 31 Mar 2008 10:27:13
> -0400> > Take a look at XSDHelper.generate().> > Frank.> > Gerardo
> Corro <[EMAIL PROTECTED]> wrote on 03/31/2008 10:16:06 AM:> >
> > > > Hi, > > > > I wonder if theres a way to create a XSD DSO
> definition from a > HelperContext.> > > > I mean, the normal process
> is to setup a HelperContext from an XSD, > > from there read an XML
> file that contains the actual DSOs.> > > > I want to go the create
> Types through the API, and then persist them> > as an XSD. I wonder
> if there's a way to do that.> > > > Thanks!!!!> >
> _________________________________________________________________> >
> Connect to the next generation of MSN Messenger > > http://imagine-
> msn.com/messenger/launch80/default.aspx?locale=en-> >
> us&source=wlmailtagline> >
> --------------------------------------------------------------------->
> To unsubscribe, e-mail: [EMAIL PROTECTED]> For
> additional commands, e-mail: [EMAIL PROTECTED]>
>
> Discover the new Windows Vista Learn more!
> _________________________________________________________________
> Invite your mail contacts to join your friends list with Windows
> Live Spaces. It's easy!
> http://spaces.live.com/spacesapi.aspx?
> wx_action=create&wx_url=/friends.aspx&mkt=en-us
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
