Class loading - Revision history

Hzwakenberg at 12:24, 30 July 2024

2024-07-30T12:24:49Z

← Older revision		Revision as of 14:24, 30 July 2024
Line 22:		Line 22:
	To look for a supplier class, Liberty starts from its client. It tries to look for the "closest" class with the good name. It allows one to have many classes with the same name in the system. The algorithm is the following:		To look for a supplier class, Liberty starts from its client. It tries to look for the "closest" class with the good name. It allows one to have many classes with the same name in the system. The algorithm is the following:
	# try to look for a class with the good name in a sub-cluster of the client. The less deep, the better.		# try to look for a class with the good name in a sub-cluster of the client. The less deep, the better.
−	# try again starting from the parent cluster of the client.	+	# try again, starting from the parent cluster of the client.
	# and so on, until the universe (the tree root) is reached.		# and so on, until the universe (the tree root) is reached.

Hzwakenberg at 12:24, 30 July 2024

2024-07-30T12:24:12Z

← Older revision		Revision as of 14:24, 30 July 2024
Line 5:		Line 5:
	The algorithm used by Liberty to look for an Eiffel source file is the following:		The algorithm used by Liberty to look for an Eiffel source file is the following:
	# Lower case filenames - Liberty looks all along the loading path (see below) using the class name in lower case as prefix. If needed, the Eiffel suffix (".e") is added automatically. Liberty only looks for suffixed files on the disk. Only the first file encountered according to the order of the path is taken in account. An Eiffel file is always supposed to have the same name as the inside class definition.		# Lower case filenames - Liberty looks all along the loading path (see below) using the class name in lower case as prefix. If needed, the Eiffel suffix (".e") is added automatically. Liberty only looks for suffixed files on the disk. Only the first file encountered according to the order of the path is taken in account. An Eiffel file is always supposed to have the same name as the inside class definition.
−	# Upper case filenames - When the previous step did not find the required Eiffel class file, Liberty looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all and that a lower case file name may hide some upper case name.	+	# Upper case filenames - When the previous step did not find the required Eiffel class file, Liberty looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all, and that a lower case file name may hide some upper case name.
		+
−
	== How is the loading path built? ==		== How is the loading path built? ==

Hzwakenberg: /* Internals */

2014-09-14T17:14:16Z

Internals

← Older revision		Revision as of 19:14, 14 September 2014
Line 61:		Line 61:
	= Internals =		= Internals =

−	~~Those~~ are gory details on how the "universe" tree is managed.	+	Here are the gory details on how the "universe" tree is managed:

	The tree itself is a bunch of classes situated in the <code>smarteiffel/tools/ace</code> cluster. It is a Composite which abstract class is [[tool class:CLASSES\|<code>CLASSES</code>]]; most of the parent-children handling is done by concrete features in the [[tool class:CLUSTERS\|<code>CLUSTERS</code>]] class.		The tree itself is a bunch of classes situated in the <code>smarteiffel/tools/ace</code> cluster. It is a Composite which abstract class is [[tool class:CLASSES\|<code>CLASSES</code>]]; most of the parent-children handling is done by concrete features in the [[tool class:CLUSTERS\|<code>CLUSTERS</code>]] class.

Ramack at 21:01, 4 March 2013

2013-03-04T21:01:47Z

Ramack: 5 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

2013-03-03T21:04:27Z

5 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

← Older revision	Revision as of 23:04, 3 March 2013
(No difference)

Cadrian: /* `loadpath.se` files */ UNIX -> POSIX

2007-07-12T13:52:46Z

<code>loadpath.se</code> files: UNIX -> POSIX

← Older revision		Revision as of 15:52, 12 July 2007
Line 54:		Line 54:

	Those path names may be written using		Those path names may be written using
−	- either a ~~UNIX~~ notation	+	- either a POSIX notation
	- or your local system notation		- or your local system notation

−	Note that for a library to be portable, you should prefer the ~~UNIX~~ notation.	+	Note that for a library to be portable, you should prefer the POSIX notation.

	= Internals =		= Internals =

Cadrian: /* Internals */ bug fix

2007-01-04T14:22:34Z

Internals: bug fix

← Older revision		Revision as of 16:22, 4 January 2007
Line 71:		Line 71:
	parent \| \| \|		parent \| \| \|
	`--> CLUSTERS ---'		`--> CLUSTERS ---'
−	1 ^	+	0-1 ^
	\|		\|
	+----------+-------------+		+----------+-------------+

Cadrian: gore

2007-01-04T14:20:23Z

gore

@@ Line 1: / Line 1: @@
 The algorithm used by SmartEiffel to look for an Eiffel source file is the following:
@@ Line 5: / Line 7: @@
 # Upper case filenames - When the previous step did not find the required Eiffel class file, SmartEiffel looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all and that a lower case file name may hide some upper case name.
-= How is the loading path built? =
+== How is the loading path built? ==
 As described above, SmartEiffel looks for classes in <code>.e</code> files. But where should those files be situated? The answer is, in the loading path. The thing is, how is the loading path built, what are the default values, and how can it be changed?
@@ Line 47: / Line 49: @@
 </pre>
-= <code>loadpath.se</code> files =
+== <code>loadpath.se</code> files ==
 Those files contain directories (clusters: the leaves of the "universe" tree) and references to other <code>loadpath.se</code> files (nodes of the "universe" tree).
@@ Line 56: / Line 58: @@
 Note that for a library to be portable, you should prefer the UNIX notation.

Cadrian: note on loadpath.se paths

2007-01-04T14:04:47Z

note on loadpath.se paths

← Older revision		Revision as of 16:04, 4 January 2007
Line 46:		Line 46:
	\|		\|
	</pre>		</pre>
		+
		+	= <code>loadpath.se</code> files =
		+
		+	Those files contain directories (clusters: the leaves of the "universe" tree) and references to other <code>loadpath.se</code> files (nodes of the "universe" tree).
		+
		+	Those path names may be written using
		+	- either a UNIX notation
		+	- or your local system notation
		+
		+	Note that for a library to be portable, you should prefer the UNIX notation.

Cadrian: first draft

2007-01-04T13:59:50Z

first draft

New page

= How must the source files be named? =

The algorithm used by SmartEiffel to look for an Eiffel source file is the following:
# Lower case filenames - SmartEiffel looks all along the loading path (see below) using the class name in lower case as prefix. If needed, the Eiffel suffix (".e") is added automatically. SmartEiffel only looks for suffixed files on the disk. Only the first file encountered according to the order of the path is taken in account. An Eiffel file is always supposed to have the same name as the inside class definition.
# Upper case filenames - When the previous step did not find the required Eiffel class file, SmartEiffel looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all and that a lower case file name may hide some upper case name.

= How is the loading path built? =

As described above, SmartEiffel looks for classes in <code>.e</code> files. But where should those files be situated? The answer is, in the loading path. The thing is, how is the loading path built, what are the default values, and how can it be changed?

SmartEiffel builds a "universe" where it looks for all the classes. This "universe" is a tree of clusters. The root of the tree is the universe. This universe is either made of clusters and <code>loadpath.se</code> files provided by:
* either the ACE file
* or a combination of the following:
** the command line (<code>-loadpath</code> arguments)
** the current directory (a <code>loadpath.se</code> file in the current directory if it exists, the cluster represented by the current directory otherwise)
** the [[configuration file]]

Each <code>loadpath.se</code> file is a node of the tree. It contains other nodes (referenced <code>loadpath.se</code> files), and clusters (directories). Note that ''all the clusters in a <code>loadpath.se</code> file are direct children of the node''. It means that, even if directories are arborescent this is not reflected in SmartEiffel's universe.

To look for a supplier class, SmartEiffel starts from its client. It tries to look for the "closest" class with the good name. It allows one to have many classes with the same name in the system. The algorithm is the following:
# try to look for a class with the good name in a sub-cluster of the client. The less deep, the better.
# try again starting from the parent cluster of the client.
# and so on, until the universe (the tree root) is reached.

If there is no client (e.g. a class given on the command line) the universe is searched and the class nearest to the root is selected.

If more than one class have the smallest distance, the compiler will bail because it cannot decide which to use. In the future, an extension to ACE files will allow someone to provide custom distances (a "distance" is the amount of depth to add from a cluster to a child; it defaults to 1)

'''For example:'''

<code>/my/loadpath.se</code>
<pre>
./
internal/
</pre>

This <code>loadpath.se</code> file represents a node with two children: the cluster in the directory of the <code>loadpath.se</code> file, and the cluster in the directory named "internal" in the former directory. Both have a distance equal to one, meaning that if there are two classes named <code>FOO</code> in both <code>./</code> and <code>internal/</code> then the compiler will emit an error.

The tree will be the following:
<pre>
+ <Universe>
+ "/my/loadpath.se"
| + /my/
| + /my/internal/
+ . . .
|
</pre>

← Older revision		Revision as of 23:01, 4 March 2013
Line 3:		Line 3:
	== How must the source files be named? ==		== How must the source files be named? ==

−	The algorithm used by ~~SmartEiffel~~ to look for an Eiffel source file is the following:	+	The algorithm used by Liberty to look for an Eiffel source file is the following:
−	# Lower case filenames - ~~SmartEiffel~~ looks all along the loading path (see below) using the class name in lower case as prefix. If needed, the Eiffel suffix (".e") is added automatically. ~~SmartEiffel~~ only looks for suffixed files on the disk. Only the first file encountered according to the order of the path is taken in account. An Eiffel file is always supposed to have the same name as the inside class definition.	+	# Lower case filenames - Liberty looks all along the loading path (see below) using the class name in lower case as prefix. If needed, the Eiffel suffix (".e") is added automatically. Liberty only looks for suffixed files on the disk. Only the first file encountered according to the order of the path is taken in account. An Eiffel file is always supposed to have the same name as the inside class definition.
−	# Upper case filenames - When the previous step did not find the required Eiffel class file, ~~SmartEiffel~~ looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all and that a lower case file name may hide some upper case name.	+	# Upper case filenames - When the previous step did not find the required Eiffel class file, Liberty looks along the loading path (see below) for a file bearing the class name upper in upper case letters. If needed, the Eiffel suffix ".e" is added automatically. One must note that the overhead to find an upper case file name is not negligible at all and that a lower case file name may hide some upper case name.

	== How is the loading path built? ==		== How is the loading path built? ==

−	As described above, ~~SmartEiffel~~ looks for classes in <code>.e</code> files. But where should those files be situated? The answer is, in the loading path. The thing is, how is the loading path built, what are the default values, and how can it be changed?	+	As described above, Liberty looks for classes in <code>.e</code> files. But where should those files be situated? The answer is, in the loading path. The thing is, how is the loading path built, what are the default values, and how can it be changed?

−	~~SmartEiffel~~ builds a "universe" where it looks for all the classes. This "universe" is a tree of clusters. The root of the tree is the universe. This universe is either made of clusters and <code>loadpath.se</code> files provided by:	+	Liberty builds a "universe" where it looks for all the classes. This "universe" is a tree of clusters. The root of the tree is the universe. This universe is either made of clusters and <code>loadpath.se</code> files provided by:
	* either the ACE file		* either the ACE file
	* or a combination of the following:		* or a combination of the following:
Line 18:		Line 18:
	** the [[configuration file]]		** the [[configuration file]]

−	Each <code>loadpath.se</code> file is a node of the tree. It contains other nodes (referenced <code>loadpath.se</code> files), and clusters (directories). Note that ''all the clusters in a <code>loadpath.se</code> file are direct children of the node''. It means that, even if directories are arborescent this is not reflected in ~~SmartEiffel~~'s universe.	+	Each <code>loadpath.se</code> file is a node of the tree. It contains other nodes (referenced <code>loadpath.se</code> files), and clusters (directories). Note that ''all the clusters in a <code>loadpath.se</code> file are direct children of the node''. It means that, even if directories are arborescent this is not reflected in Liberty's universe.

−	To look for a supplier class, ~~SmartEiffel~~ starts from its client. It tries to look for the "closest" class with the good name. It allows one to have many classes with the same name in the system. The algorithm is the following:	+	To look for a supplier class, Liberty starts from its client. It tries to look for the "closest" class with the good name. It allows one to have many classes with the same name in the system. The algorithm is the following:
	# try to look for a class with the good name in a sub-cluster of the client. The less deep, the better.		# try to look for a class with the good name in a sub-cluster of the client. The less deep, the better.
	# try again starting from the parent cluster of the client.		# try again starting from the parent cluster of the client.
Line 63:		Line 63:
	Those are gory details on how the "universe" tree is managed.		Those are gory details on how the "universe" tree is managed.

−	The tree itself is a bunch of classes situated in the <code>~~SmartEiffel~~/tools/ace</code> cluster. It is a Composite which abstract class is [[tool class:CLASSES\|<code>CLASSES</code>]]; most of the parent-children handling is done by concrete features in the [[tool class:CLUSTERS\|<code>CLUSTERS</code>]] class.	+	The tree itself is a bunch of classes situated in the <code>smarteiffel/tools/ace</code> cluster. It is a Composite which abstract class is [[tool class:CLASSES\|<code>CLASSES</code>]]; most of the parent-children handling is done by concrete features in the [[tool class:CLUSTERS\|<code>CLUSTERS</code>]] class.

	<pre>		<pre>
Line 84:		Line 84:
	* [[tool class:CLASSES_TREE_FACTORY\|<code>CLASSES_TREE_FACTORY</code>]] is used to create a node or a leaf depending on whether the given path is a directory or a plain file. It creates [[tool class:CLASSES\|<code>CLASSES</code>]] objects		* [[tool class:CLASSES_TREE_FACTORY\|<code>CLASSES_TREE_FACTORY</code>]] is used to create a node or a leaf depending on whether the given path is a directory or a plain file. It creates [[tool class:CLASSES\|<code>CLASSES</code>]] objects
	* [[tool class:CLUSTER\|<code>CLUSTER</code>]] holds references to the known and loaded classes in that cluster		* [[tool class:CLUSTER\|<code>CLUSTER</code>]] holds references to the known and loaded classes in that cluster
−	* [[tool class:ACE\|<code>ACE</code>]] stays the Universe facade for the remaining of the ~~SmartEiffel~~ system and dispatches request to the [[tool class:CLASSES\|<code>CLASSES</code>]] tree (via the [[tool class:UNIVERSE\|<code>UNIVERSE</code>]])	+	* [[tool class:ACE\|<code>ACE</code>]] stays the Universe facade for the remaining of the Liberty system and dispatches request to the [[tool class:CLASSES\|<code>CLASSES</code>]] tree (via the [[tool class:UNIVERSE\|<code>UNIVERSE</code>]])

Class loading - Revision history

Hzwakenberg at 12:24, 30 July 2024

Hzwakenberg at 12:24, 30 July 2024

Hzwakenberg: /* Internals */

Ramack at 21:01, 4 March 2013

Ramack: 5 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

Cadrian: /* loadpath.se files */ UNIX -> POSIX

Cadrian: /* Internals */ bug fix

Cadrian: gore

Cadrian: note on loadpath.se paths

Cadrian: first draft

Cadrian: /* `loadpath.se` files */ UNIX -> POSIX