Support pattern - Revision history

Thomas Linder Puls: xxxSite -> xxxSupportSite

2016-02-20T12:32:37Z

xxxSite -> xxxSupportSite

← Older revision		Revision as of 14:32, 20 February 2016
Line 12:		Line 12:
	*The <vp>target</vp> interface, which defines the <vp>target</vp>'s public interface.		*The <vp>target</vp> interface, which defines the <vp>target</vp>'s public interface.
	*The <vp>targetSupport</vp> interface, which defines the <vp>target</vp>'s view of the <vp>targetSupport</vp>.		*The <vp>targetSupport</vp> interface, which defines the <vp>target</vp>'s view of the <vp>targetSupport</vp>.
	*The <vp>~~targetSite~~</vp> interface, which defines the <vp>targetSupport</vp>'s view of the <vp>target</vp>.		*The <vp>targetSupportSite</vp> interface, which defines the <vp>targetSupport</vp>'s view of the <vp>target</vp>.

	[[PFC]] has many of uses the support pattern.		[[PFC]] has many of uses the support pattern.
Line 46:		Line 46:
	The <vp>targetSupport</vp> and <vp>target</vp> classes are in symbiosis with one and other:		The <vp>targetSupport</vp> and <vp>target</vp> classes are in symbiosis with one and other:

	* The <vp>~~targetSite~~</vp> interface contains entities that the <vp>targetSupport</vp> class will need from the <vp>target</vp>.		* The <vp>targetSupportSite</vp> interface contains entities that the <vp>targetSupport</vp> class will need from the <vp>target</vp>.
	* And the <vp>targetSupport</vp> interface contains entities that the <vp>targetSupport</vp> class provides to the <vp>target</vp>.		* And the <vp>targetSupport</vp> interface contains entities that the <vp>targetSupport</vp> class provides to the <vp>target</vp>.

	The exact contents of these interfaces will depend on how the <vp>targetSupport</vp> class is supposed to support the construction of the <vp>target</vp> classes. For the the description we have added a predicate predicate to the ~~targetSite~~:		The exact contents of these interfaces will depend on how the <vp>targetSupport</vp> class is supposed to support the construction of the <vp>target</vp> classes. For the the description we have added a predicate predicate to the targetSupportSite:

	<vip>interface ~~targetSite~~		<vip>interface targetSupportSite
	predicates		predicates
	sitePredicate : ().		sitePredicate : ().
	end interface ~~targetSite~~</vip>		end interface targetSupportSite</vip>

	For the description we will assume that the targetSupport class will directly implement the <vp>targetProperty</vp> and provide a support predicate, <vp>supportPredicate</vp>, which the target class can use to implement the <vp>targetPredicate</vp>.		For the description we will assume that the targetSupport class will directly implement the <vp>targetProperty</vp> and provide a support predicate, <vp>supportPredicate</vp>, which the target class can use to implement the <vp>targetPredicate</vp>.
Line 68:		Line 68:
	end interface targetSupport</vip>		end interface targetSupport</vip>

	<vp>targetSupport</vp>'c constructor will (at least) take a <vp>~~targetSite~~</vp> as parameter, here we have also chosen that it should have an initial value for the <vp>targetProperty</vp>:		<vp>targetSupport</vp>'c constructor will (at least) take a <vp>targetSupportSite</vp> as parameter, here we have also chosen that it should have an initial value for the <vp>targetProperty</vp>:

	<vip>class targetSupport : targetSupport		<vip>class targetSupport : targetSupport
	constructors		constructors
	new : (~~targetSite~~ Site, string TargetPropertyInit).		new : (targetSupportSite Site, string TargetPropertyInit).
	end class targetSupport</vip>		end class targetSupport</vip>

Line 80:		Line 80:

	facts		facts
	site : ~~targetSite~~.		site : targetSupportSite.
	targetProperty : string.		targetProperty : string.

Line 95:		Line 95:
	end implement targetSupport</vip>		end implement targetSupport</vip>

	The implementation of the target classes (here <vp>target_1</vp>) we will inherit from <vp>targetSupport</vp> to get access to the shared functionality, it will also have to support and implement the <vp>~~targetSite~~</vp> interface and privide itself (i.e. <vp>This</vp>) as site:		The implementation of the target classes (here <vp>target_1</vp>) we will inherit from <vp>targetSupport</vp> to get access to the shared functionality, it will also have to support and implement the <vp>targetSupportSite</vp> interface and privide itself (i.e. <vp>This</vp>) as site:

	<vip>implement target_1 inherits targetSupport % access to shared functionality by inheritance		<vip>implement target_1 inherits targetSupport % access to shared functionality by inheritance
	supports ~~targetSite~~ % support the site so that the targetSupport can access functionality here		supports targetSupportSite % support the site so that the targetSupport can access functionality here

	clauses		clauses
Line 156:		Line 156:
	So the site will have to supply <vp>getAll_nd</vp> predicate:		So the site will have to supply <vp>getAll_nd</vp> predicate:

	<vip>interface ~~collectionSite~~{@Type}		<vip>interface collectionSupportSite{@Type}

	predicates from collection{@Type}		predicates from collection{@Type}
	getAll_nd/0->		getAll_nd/0->

	end interface ~~collectionSite~~</vip>		end interface collectionSupportSite</vip>

	And then the support class will implement all the rest:		And then the support class will implement all the rest:
Line 180:		Line 180:

	facts		facts
	site : ~~collectionSite~~{@Type}.		site : collectionSupportSite{@Type}.

	clauses		clauses

Thomas Linder Puls: initial

2015-02-13T09:59:37Z

initial

New page

The purpose of the ''support pattern'' is to implement a number of <vp>target</vp> classes all supporting a common interface <vp>target</vp>, using a <vp>targetSupport</vp> class to implement common functionality. The pattern is a more explicit version of some common less structured inheritance patterns.

Even though the purpose of the pattern it so create many target classes, the pattern is described for one of these target classes. In that context there are two actors:

;Target
:The <vp>target</vp>s are the class we want to implement.
;Support
:The <vp>targetSupport</vp> is a class that implement those parts of the target that is to be reused/shared for other <vp>target</vp>'s.

There are three contracts in the pattern:

*The <vp>target</vp> interface, which defines the <vp>target</vp>'s public interface.
*The <vp>targetSupport</vp> interface, which defines the <vp>target</vp>'s view of the <vp>targetSupport</vp>.
*The <vp>targetSite</vp> interface, which defines the <vp>targetSupport</vp>'s view of the <vp>target</vp>.

[[PFC]] has many of uses the support pattern.

The contents of the target interface solely depend on overall problem, and does not contain anything that have to do with the design patters. For the the description we have added a property and a predicate:

<vip>interface target

properties
targetProperty : string.

predicates
targetPredicate : ().

end interface target</vip>

Likewise the class declaration of the target (here <vp>target_1</vp>) solely depends on the overall problem:

<vip>class target_1 : target
...
end interface target_1</vip>

It will either construct objects of the <vp>target</vp> type (as above), or of a type that supports <vp>target</vp> as here:

<vip>interface target_2 supports target
% additional special target_2 functionality
end interface target_2

class target_2 : target_2
...
end interface target_2</vip>

The <vp>targetSupport</vp> and <vp>target</vp> classes are in symbiosis with one and other:

* The <vp>targetSite</vp> interface contains entities that the <vp>targetSupport</vp> class will need from the <vp>target</vp>.
* And the <vp>targetSupport</vp> interface contains entities that the <vp>targetSupport</vp> class provides to the <vp>target</vp>.

The exact contents of these interfaces will depend on how the <vp>targetSupport</vp> class is supposed to support the construction of the <vp>target</vp> classes. For the the description we have added a predicate predicate to the targetSite:

<vip>interface targetSite
predicates
sitePredicate : ().
end interface targetSite</vip>

For the description we will assume that the targetSupport class will directly implement the <vp>targetProperty</vp> and provide a support predicate, <vp>supportPredicate</vp>, which the target class can use to implement the <vp>targetPredicate</vp>.

Since <vp>targetProperty</vp> is to be exposed directly as <vp>target::targetProperty</vp> it must be declared as coming from the <vp>target</vp> interface:

<vip>interface targetSupport
properties from target
targetProperty

predicates
supportPredicate : ().
end interface targetSupport</vip>

<vp>targetSupport</vp>'c constructor will (at least) take a <vp>targetSite</vp> as parameter, here we have also chosen that it should have an initial value for the <vp>targetProperty</vp>:

<vip>class targetSupport : targetSupport
constructors
new : (targetSite Site, string TargetPropertyInit).
end class targetSupport</vip>

The implementation of the <vp>targetSupport</vp> class will store the site in a fact so that the site can be accessed where required. This code also contains example implementation of the <vp>targetSupport</vp> interface

<vip>implement targetSupport

facts
site : targetSite.
targetProperty : string.

clauses
new(Site, TargetPropertyInit) :-
site := Site,
targetProperty := TargetPropertyInit.

clauses
supportPredicate(...) :-
...
site:sitePredicate(), % site functionality can be used where required
...
end implement targetSupport</vip>

The implementation of the target classes (here <vp>target_1</vp>) we will inherit from <vp>targetSupport</vp> to get access to the shared functionality, it will also have to support and implement the <vp>targetSite</vp> interface and privide itself (i.e. <vp>This</vp>) as site:

<vip>implement target_1 inherits targetSupport % access to shared functionality by inheritance
supports targetSite % support the site so that the targetSupport can access functionality here

clauses
new(...) :-
targetSupport::new(This, "target_1_property"). % initialization of the base class

% The targetProperty is directly inherited from the targetSupport
% but this class will have to implement targetPredicate
clauses
targetPredicate() :-
...
supportPredicate(), % we can use the inherited supportPredicate in the target class
...

clauses
sitePredicate() :- % The target class must implement the sitePredicate
...
end implement target_1</vip>

The support pattern very explicitly express what functionality the support class provides to the target classes and vice versa.

{{Example|The <vp>collectionSupport</vp> class in PFC is an example of the the support pattern. (Here it is shown in the Visual Prolog 7.5 version.)

A collection must implement this interface:

<vip>interface collection{@Type}

predicates
isEmpty : () determ.
% @short Succeeds if the collection is empty.
% @end

predicates
contains : (@Type Value) determ.
% @short Succeeds if the collection contains the value @Type
% @end

predicates
tryGetFirst : () -> @Type Value determ.
% @short @Type is the first element in the collection; fails if the collection is empty.
% @end

predicates
getAll_nd : () -> @Type Value nondeterm.
% @short @Type is nondeterministic iteration of the elements in the collection.
% @end

properties
asList : @Type* (o).
% @short All the elements in the collection as a list.
% @end

end interface collection</vip>

If the support class have access to the <vp>getAll_nd</vp> predicate, it can implement all the other predicates in terms of it.

So the site will have to supply <vp>getAll_nd</vp> predicate:

<vip>interface collectionSite{@Type}

predicates from collection{@Type}
getAll_nd/0->

end interface collectionSite</vip>

And then the support class will implement all the rest:

<vip>interface collectionSupport{@Type}

predicates from collection{@Type}
isEmpty, tryGetFirst

properties from collection{@Type}
asList

end interface collectionSupport</vip>

The implementation of the <vp>collectionSupport</vp> looks like this (here commented additionally):

<vip>implement collectionSupport{@Type}

facts
site : collectionSite{@Type}.

clauses
new(Site) :-
site := Site.

clauses
isEmpty() :-
not(_ = site:getAll_nd()).

clauses
tryGetFirst() = First :-
First = site:getAll_nd(),
!.

clauses
asList() = [ V || V = site:getAll_nd() ].

end implement collectionSupport</vip>
}}

[[Category:Design Pattern]]