Element Hierarchy Extension Point & Library - Revision history

imported>Laurent: /* B - API to declare and test the element/attribute relations and traverse them */

2012-10-12T13:17:57Z

B - API to declare and test the element/attribute relations and traverse them

← Older revision		Revision as of 13:17, 12 October 2012
Line 70:		Line 70:

	boolean canParent(IInternalElementType<?> childType);		boolean canParent(IInternalElementType<?> childType);
	boolean ~~isElementOf~~(IAttributeType attrType);		boolean canCarry(IAttributeType attrType);

	* interface IAttributeType is extended with methods		* interface IAttributeType is extended with methods

imported>Tommy at 16:19, 26 September 2012

2012-09-26T16:19:44Z

← Older revision		Revision as of 16:19, 26 September 2012
Line 17:		Line 17:

	= Some identified difficulties =		= Some identified difficulties =



	== Correspondence between UI manipulation and "core" elements ==		== Correspondence between UI manipulation and "core" elements ==
Line 26:		Line 24:

	= Proposal =		= Proposal =

	~~== Hierarchy between elements ==~~

	The part concerning element definition and hierarchy will go to a dedicated extension point in the database.		The part concerning element definition and hierarchy will go to a dedicated extension point in the database.
Line 85:		Line 81:
	{{ident\|isAncestorOf}} if this proves useful.		{{ident\|isAncestorOf}} if this proves useful.

			=== D - Compatibility with the upgrade mechanism ===

			Things start with the org.rodinp.core.conversion extension point.<br>
			The modifications are done in XPATH there is no incompatibility introduced here.

	== UI related information ==		== UI related information ==
Line 91:		Line 90:
	Relationships will disappear from the editorItems extension point.		Relationships will disappear from the editorItems extension point.

	~~=== D - Compatibility with the upgrade mechanism ===~~

	~~Things start with the org.rodinp.core.conversion extension point.<br>~~
	~~The modifications are done in XPATH there is no incompatibility introduced here.~~

	[[Category:Design_proposal]]		[[Category:Design_proposal]]

imported>Tommy: /* UI related information */

2012-09-26T16:08:03Z

UI related information

@@ Line 90: / Line 90: @@
 The part concerning how to display elements and UI related info will stay in the editorItems extension point and shall point to an element definition and hierachy.<br>
 Relationships will disappear from the editorItems extension point.
 === D - Compatibility with the upgrade mechanism ===

imported>Tommy: /* Operation on elements shall be enforced */

2012-09-26T16:06:34Z

Operation on elements shall be enforced

← Older revision		Revision as of 16:06, 26 September 2012
Line 23:		Line 23:
	If some element or attribute relationship is declared at the database level, but there is no corresponding {{ident\|editorItem}} for it, it will be ignored by the UI. This is similar to the previous situation where some elements or attributes could be present in the database but not in the user interface hierarchy.		If some element or attribute relationship is declared at the database level, but there is no corresponding {{ident\|editorItem}} for it, it will be ignored by the UI. This is similar to the previous situation where some elements or attributes could be present in the database but not in the user interface hierarchy.

	~~== Operation on elements shall be enforced ==~~

	~~private <T extends IInternalElement> OperationCreateElement getCreateElement(~~
	~~IInternalElement parent, IInternalElementType<T> type,~~
	~~IInternalElement sibling, IAttributeValue[] values) {~~
	~~OperationCreateElement op = new OperationCreateElement(~~
	~~createDefaultElement(parent, type, sibling));~~
	~~op.addSubCommande(new ChangeAttribute(values));~~
	~~return op;~~
	}

	~~''The Operation model similar to a kind of transaction mechanism, should be made available from the DB layer.''<br>~~
	~~''The relations when using such layer shall be enforced and any invalid operation could be rejected.''~~

	= Proposal =		= Proposal =

imported>Tommy: /* Initialization of elements from non UI components */

2012-09-26T16:05:53Z

Initialization of elements from non UI components

← Older revision		Revision as of 16:05, 26 September 2012
Line 18:		Line 18:
	= Some identified difficulties =		= Some identified difficulties =

	~~== Initialization of elements from non UI components ==~~

	~~The following ElementDescRegistry method, shows the dependency between an element creation and the initialization of its attributes with default values.~~

	~~public <T extends IInternalElement> T createElement(~~
	~~final IInternalElement root, IInternalElement parent,~~
	~~final IInternalElementType<T> type, final IInternalElement sibling)~~
	~~throws RodinDBException {~~
	~~final T newElement = parent.createChild(type, sibling, null);~~
	~~final IAttributeDesc[] attrDesc = getAttributes(type);~~
	~~for (IAttributeDesc desc : attrDesc) {~~
	~~desc.getManipulation().setDefaultValue(newElement, null); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<~~
	}
	~~return newElement;~~
	}

	~~The protocol shall be changed to take into account this initialization outside from the graphical manipulation.~~
	~~Doing the initialization at org.eventb.core level is possible by registering a special "attribute initializer". <br>~~
	~~WARNING : Only "choice" attributes can be marked as mandatory ({{ident\|required}} attribute of the extension). Can't it be available for all kind of attributes?~~

	== Correspondence between UI manipulation and "core" elements ==		== Correspondence between UI manipulation and "core" elements ==

imported>Tommy: /* C - Data model operations (enforced) */

2012-09-26T16:04:29Z

C - Data model operations (enforced)

← Older revision		Revision as of 16:04, 26 September 2012
Line 115:		Line 115:
	{{ident\|isAncestorOf}} if this proves useful.		{{ident\|isAncestorOf}} if this proves useful.

	~~=== C - Data model operations (enforced) ===~~
	~~The ElementManipulationFacade, support for modifications over the Database, should be provided by the Event-B Core plug-in.<br>~~
	~~The IAttributeManipulation interface should be also provided by the Event-B Core plug-in as it concerns the manipulation done on the attribute in the DB.~~

	The information about the rendering of an element or an attribute, should not be deduced from the attribute itself (e.g. choiceAttribute vs. toggleAttribute vs. textAttribute), it should be given in the UI.

	~~It seems that the ElementManipulationFacade can be used as protocol, but hiercharchy between elements and elements, or between elements and attributes shall be enforced.~~
	~~''Proposition : add Exceptions to methods of the protocol.''~~

	== UI related information ==		== UI related information ==

imported>Tommy at 16:04, 26 September 2012

2012-09-26T16:04:12Z

← Older revision		Revision as of 16:04, 26 September 2012
Line 13:		Line 13:
	B - API to test these relations and traverse them		B - API to test these relations and traverse them
	C - Enforcement of the authorized relations when modifying the DB		C - Enforcement of the authorized relations when modifying the DB
	D ~~- Behaviour while loading a file (including a file with invalid parent-child relations occurrences)~~		D- What about the compatibilty with the file upgrade mechanism?
	E- What about the compatibilty with the file upgrade mechanism?
	----		----

Line 165:		Line 164:
	}		}

	~~=== D - Behaviour while loading a file ===~~
	~~This is including a file with invalid parent-child relations occurrences.~~

	~~The elements or attributes shall be let in place, and not be displayed.~~		=== D - Compatibility with the upgrade mechanism ===

	~~The test wether a child as an incorrect parent shall be provided, <br>~~		Things start with the org.rodinp.core.conversion extension point.<br>
	~~or if a parent is valid for a given child :<br>~~		The modifications are done in XPATH there is no incompatibility introduced here.
	~~HOW?~~

	~~> One possibility : checking the relationship from the element desc:~~

	~~ElementDescRegistry.getElementDesc(element).isValidChildOf(IInternalElement parent);~~

	~~ElementDescRegistry.getElementDesc(element).isValidParentOf(IInternalElement child);~~

	~~=== E - Compatibility with the upgrade mechanism ===~~

	Things start with the org.rodinp.core.conversion ~~extensions~~ point.<br>
	The ~~hierarchy (element/element and element/attributes)~~ is ~~implicit in the extensions,~~
	~~but does not appear in code~~.

	[[Category:Design_proposal]]		[[Category:Design_proposal]]

imported>Laurent: /* B - API to declare and test the element/attribute relations and traverse them */

2012-09-26T15:25:21Z

B - API to declare and test the element/attribute relations and traverse them

← Older revision		Revision as of 15:25, 26 September 2012
Line 104:		Line 104:
	IAttributeType[] getAttributeTypes();		IAttributeType[] getAttributeTypes();

	boolean ~~isParentOf~~(IInternalElementType<?> childType);		boolean canParent(IInternalElementType<?> childType);
	~~boolean isChildOf(IInternalElementType<?> parentType~~);
	boolean isElementOf(IAttributeType attrType);		boolean isElementOf(IAttributeType attrType);

imported>Laurent: /* B - API to declare and test the element/attribute relations and traverse them */

2012-09-26T15:13:27Z

B - API to declare and test the element/attribute relations and traverse them

← Older revision		Revision as of 15:13, 26 September 2012
Line 96:		Line 96:
	=== B - API to declare and test the element/attribute relations and traverse them ===		=== B - API to declare and test the element/attribute relations and traverse them ===

	The API ~~for an element~~ : ~~IElementDesc~~		The API of the Rodin database is extended as follows:

	~~public String getID();~~		* interface IInternalElementType is extended with methods

	~~public List<IAttributeRelationship> getAttributeRelationships();~~

	~~public List<IElementRelationship> getChildRelationships();~~

	~~public List~~<~~IAttributeType~~> ~~getAttributeTypes~~();		IInternalElementType<?>[] getParentTypes();
			IInternalElementType<?>[] getChildTypes();
	~~public List~~<~~IElementType~~> getChildTypes();		IAttributeType[] getAttributeTypes();

	~~public IAttributeDesc getAutoNameAttribute~~();

	~~adding the following method to the protocol :~~		boolean isParentOf(IInternalElementType<?> childType);
			boolean isChildOf(IInternalElementType<?> parentType);
			boolean isElementOf(IAttributeType attrType);

	~~public boolean isDirectChildTypeOf(IElementDesc parentElemDesc);~~		* interface IAttributeType is extended with methods

	~~public boolean isOwnableAttribute~~(~~IAttributeDesc ownerElementDesc~~);		IInternalElementType<?>[] getElementTypes();

	~~with the same interface IElementRelationship~~		boolean isAttributeOf(IInternalElementType<?> elementType);

	~~public interface IElementRelationship extends Comparable<IElementRelationship> {~~		This list might be later extended with new methods such as
			{{ident\|isAncestorOf}} if this proves useful.
	~~public String getID();~~

	~~public IElementType<?> getParentType();~~

	~~public IInternalElementType<?> getChildType();~~

	~~public IImplicitChildProvider getImplicitChildProvider();~~

	~~public int getPriority();~~

	}

	with ~~the "~~new~~" interface IAttributeRelationship~~

	~~public interface IAttributeRelationship extends Comparable<IAttributeRelationship>~~ {

	~~public String getID();~~

	~~public IElementType<?> getOwnerType();~~

	~~public int getPriority();~~

	}

	~~''IImplicitChildProvider is moved to Event-b Core~~.''

	~~The API for an Attribute : IAttributeDesc~~

	~~public String getID();~~

	~~public IAttributeManipulation getManipulation();~~

	~~public IAttributeType getAttributeType();~~

	=== C - Data model operations (enforced) ===		=== C - Data model operations (enforced) ===

imported>Laurent: /* A - hierarchy definition */

2012-09-26T14:56:23Z

A - hierarchy definition

← Older revision		Revision as of 14:56, 26 September 2012
Line 64:		Line 64:
	=== A - hierarchy definition ===		=== A - hierarchy definition ===

	Here is the definition of ~~such an~~ extension point : org.rodinp.core.~~dataModel ??? or org.rodinp.core~~.~~internalElementHierarchy ???~~		Here is the definition of the new extension point : org.rodinp.core.itemRelations which describes the possible children and attributes of internal elements.

	Configuration Markup:		Configuration Markup: