SCons.Node.FS.Base

Package SCons :: Package Node :: Module FS :: Class Base

[show private | hide private]

Class Base

Node --+
       |
      Base

Known Subclasses:: Dir, Entry, File

A generic class for file system entries. This class is for when we don't know yet whether the entry being looked up is a file or a directory. Instances of this class can morph into either Dir or File objects by a later, more precise lookup.

Note: this class does not define __cmp__ and __hash__ for efficiency reasons. SCons does a lot of comparing of Node.FS.{Base,Entry,File,Dir} objects, so those operations must be as fast as possible, which means we want to use Python's built-in object identity comparisons.

Method Summary
	`__init__(self, name, directory, fs)` Initialize a generic Node.FS.Base object.
	`__str__(self)` A Node.FS.Base object's string representation is its path name.
	`exists(self)` Does this node exists?
	`for_signature(self)` Return a string representation of the Node that will always be the same for this particular Node, no matter what.
	`get_abspath(self)` Get the absolute path of the file.
	`get_dir(self)`
	`get_path(self, dir)` Return path relative to the current working directory of the Node.FS.Base object that owns us.
	`get_subst_proxy(self)` This method is expected to return an object that will function exactly like this Node, except that it implements any additional special features that we would like to be in effect for Environment variable substitution.
	`get_suffix(self)`
	`getmtime(self)`
	`getsize(self)`
	`is_under(self, dir)`
	`isdir(self)`
	`isfile(self)`
	`islink(self)`
	`must_be_same(self, klass)` This node, which already existed, is being looked up as the specified klass.
	`RDirs(self, pathlist)` Search for a list of directories in the Repository list.
	`rentry(self)`
	`rexists(self)` Does this node exist locally or in a repositiory?
	`rfile(self)`
	`Rfindalldirs(self, pathlist)` Return all of the directories for a given path list, including corresponding "backing" directories in any repositories.
	`rstr(self)` A Node.FS.Base object's string representation is its path name.
	`set_local(self)`
	`set_src_builder(self, builder)` Set the source code builder for this node.
	`src_builder(self)` Fetch the source code builder for this node.
	`srcnode(self)` If this node is in a build path, return the node corresponding to its source file.
	`stat(self)`
	`target_from_source(self, prefix, suffix, splitext)` Generates a target entry that corresponds to this entry (usually a source file) with the specified prefix and suffix.
	`_get_str(self)`
	`_glob1(self, pattern, ondisk, source, strings)`
	`_Rfindalldirs_key(self, pathlist)`
	`_save_str(self)`
Inherited from Node
	`add_dependency(self, depend)` Adds dependencies.
	`add_ignore(self, depend)` Adds dependencies to ignore.
	`add_prerequisite(self, prerequisite)` Adds prerequisites
	`add_source(self, source)` Adds sources.
	`add_to_implicit(self, deps)`
	`add_to_waiting_parents(self, node)` Returns the number of nodes added to our waiting parents list: 1 if we add a unique waiting parent, 0 if not.
	`add_to_waiting_s_e(self, node)`
	`add_wkid(self, wkid)` Add a node to the list of kids waiting to be evaluated
	`all_children(self, scan)` Return a list of all the node's direct children.
	`alter_targets(self)` Return a list of alternate targets for this Node.
	`build(self, **kw)` Actually build the node.
	`builder_set(self, builder)`
	`built(self)` Called just after this node is successfully built.
	`call_for_all_waiting_parents(self, func)`
	`changed(self, node)` Returns if the node is up-to-date with respect to the BuildInfo stored last time it was built.
	`changed_since_last_build(self, target, prev_ni)` Must be overridden in a specific subclass to return True if this Node (a dependency) has changed since the last time it was used to build the specified target.
	`children(self, scan)` Return a list of the node's direct children, minus those that are ignored by this node.
	`children_are_up_to_date(self)` Alternate check for whether the Node is current: If all of our children were up-to-date, then this Node was up-to-date, too.
	`clear(self)` Completely clear a Node of all its cached state (so that it can be re-evaluated by interfaces that do continuous integration builds).
	`clear_memoized_values(self)`
	`Decider(self, function)`
	`del_binfo(self)` Delete the build info from this node.
	`disambiguate(self, must_exist)`
	`do_not_ignore(self, node)`
	`do_not_store_info(self)`
	`env_set(self, env, safe)`
	`executor_cleanup(self)` Let the executor clean up any cached information.
	`explain(self)`
	`get_binfo(self)` Fetch a node's build information.
	`get_build_env(self)` Fetch the appropriate Environment to build this node.
	`get_build_scanner_path(self, scanner)` Fetch the appropriate scanner path for this node.
	`get_builder(self, default_builder)` Return the set builder, or a specified default value
	`get_cachedir_csig(self)`
	`get_csig(self)`
	`get_env(self)`
	`get_env_scanner(self, env, kw)`
	`get_executor(self, create)` Fetch the action executor for this node.
	`get_found_includes(self, env, scanner, path)` Return the scanned include lines (implicit dependencies) found in this node.
	`get_implicit_deps(self, env, scanner, path)` Return a list of implicit dependencies for this node.
	`get_ninfo(self)`
	`get_source_scanner(self, node)` Fetch the source scanner for the specified node
	`get_state(self)`
	`get_stored_implicit(self)` Fetch the stored implicit dependencies
	`get_stored_info(self)`
	`get_string(self, for_signature)` This is a convenience function designed primarily to be used in command generators (i.e., CommandGeneratorActions or Environment variables that are callable), which are called with a for_signature argument that is nonzero if the command generator is being called to generate a signature for the command line, which determines if we should rebuild or not.
	`get_target_scanner(self)`
	`has_builder(self)` Return whether this Node has a builder or not.
	`has_explicit_builder(self)` Return whether this Node has an explicit builder
	`is_derived(self)` Returns true iff this node is derived (i.e.
	`is_literal(self)` Always pass the string representation of a Node to the command interpreter literally.
	`is_up_to_date(self)` Default check for whether the Node is current: unknown Node subtypes are always out of date, so they will always get built.
	`make_ready(self)` Get a Node ready for evaluation.
	`missing(self)`
	`multiple_side_effect_has_builder(self)` Return whether this Node has a builder or not.
	`new_binfo(self)`
	`new_ninfo(self)`
	`postprocess(self)` Clean up anything we don't need to hang onto after we've been built.
	`prepare(self)` Prepare for this Node to be built.
	`remove(self)` Remove this Node: no-op by default.
	`render_include_tree(self)` Return a text representation, suitable for displaying to the user, of the include tree for the sources of this node.
	`reset_executor(self)` Remove cached executor; forces recompute when needed.
	`retrieve_from_cache(self)` Try to retrieve the node's content from a cache
	`scan(self)` Scan this node's dependents for implicit dependencies.
	`scanner_key(self)`
	`select_scanner(self, scanner)` Selects a scanner for this Node.
	`set_always_build(self, always_build)` Set the Node's always_build value.
	`set_executor(self, executor)` Set the action executor for this node.
	`set_explicit(self, is_explicit)`
	`set_nocache(self, nocache)` Set the Node's nocache value.
	`set_noclean(self, noclean)` Set the Node's noclean value.
	`set_precious(self, precious)` Set the Node's precious value.
	`set_state(self, state)`
	`state_has_changed(self, target, prev_ni)`
	`store_info(self)` Make the build signature permanent (that is, store it in the .sconsign file or equivalent).
	`visited(self)` Called just after this node has been visited (with or without a build).
	`_add_child(self, collection, dict, child)` Adds 'child' to 'collection', first checking 'dict' to see if it's already present.
	`_all_children_get(self)`
	`_children_get(self)`
	`_children_reset(self)`

Class Variable Summary
`list`	`memoizer_counters` = `[<SCons.Memoize.CountValue instance ...`

Method Details

init(self, name, directory, fs)
(Constructor)

Initialize a generic Node.FS.Base object.

Call the superclass initialization, take care of setting up our relative and absolute paths, identify our parent directory, and indicate that this node should use signatures.

Overrides:: SCons.Node.Node.__init__

str(self)
(Informal representation operator)

A Node.FS.Base object's string representation is its path name.

exists(self)

Does this node exists?

Overrides:: SCons.Node.Node.exists (inherited documentation)

for_signature(self)

Return a string representation of the Node that will always be the same for this particular Node, no matter what. This is by contrast to the __str__() method, which might, for instance, return a relative path for a file Node. The purpose of this method is to generate a value to be used in signature calculation for the command line used to build a target, and we use this method instead of str() to avoid unnecessary rebuilds. This method does not need to return something that would actually work in a command line; it can return any kind of nonsense, so long as it does not change.

Overrides:: SCons.Node.Node.for_signature (inherited documentation)

get_abspath(self)

Get the absolute path of the file.

Overrides:: SCons.Node.Node.get_abspath

get_path(self, dir=None)

Return path relative to the current working directory of the Node.FS.Base object that owns us.

get_subst_proxy(self)

This method is expected to return an object that will function exactly like this Node, except that it implements any additional special features that we would like to be in effect for Environment variable substitution. The principle use is that some Nodes would like to implement a __getattr__() method, but putting that in the Node type itself has a tendency to kill performance. We instead put it in a proxy and return it from this method. It is legal for this method to return self if no new functionality is needed for Environment substitution.

Overrides:: SCons.Node.Node.get_subst_proxy (inherited documentation)

must_be_same(self, klass)

This node, which already existed, is being looked up as the specified klass. Raise an exception if it isn't.

RDirs(self, pathlist)

Search for a list of directories in the Repository list.

rexists(self)

Does this node exist locally or in a repositiory?

Overrides:: SCons.Node.Node.rexists (inherited documentation)

Rfindalldirs(self, pathlist)

Return all of the directories for a given path list, including corresponding "backing" directories in any repositories.

The Node lookups are relative to this Node (typically a directory), so memoizing result saves cycles from looking up the same path for each target in a given directory.

rstr(self)

A Node.FS.Base object's string representation is its path name.

set_src_builder(self, builder)

Set the source code builder for this node.

src_builder(self)

Fetch the source code builder for this node.

If there isn't one, we cache the source code builder specified for the directory (which in turn will cache the value from its parent directory, and so on up to the file system root).

srcnode(self)

If this node is in a build path, return the node corresponding to its source file. Otherwise, return ourself.

target_from_source(self, prefix, suffix, splitext=<function splitext at 0xa0c938>)

Generates a target entry that corresponds to this entry (usually a source file) with the specified prefix and suffix.

Note that this method can be overridden dynamically for generated files that need different behavior. See Tool/swig.py for an example.

Class Variable Details

memoizer_counters

Type:: list
Value:: [<SCons.Memoize.CountValue instance at 0xa3be60>, <SCons.Memoize.CountValue instance at 0xa3b518>, <SCons.Memoize.CountDict instance at 0xa3bb00>, <SCons.Memoize.CountValue instance at 0xa3b488>]

Generated by Epydoc 2.1 on Wed Dec 12 09:39:32 2007

http://epydoc.sf.net