SCons.Node.FS.File

Package SCons :: Package Node :: Module FS :: Class File

[show private | hide private]

Class File

Node --+    
       |    
    Base --+
           |
          File

A class for files in a file system.

Method Summary
	`__init__(self, name, directory, fs)` Initialize a generic Node.FS.Base object.
	`alter_targets(self)` Return any corresponding targets in a build directory.
	`builder_set(self, builder)`
	`built(self)` Called just after this node is successfully built.
	`changed_content(self, target, prev_ni)`
	`changed_since_last_build(self, target, prev_ni)`
	`changed_state(self, target, prev_ni)`
	`changed_timestamp_match(self, target, prev_ni)`
	`changed_timestamp_newer(self, target, prev_ni)`
	`changed_timestamp_then_content(self, target, prev_ni)`
	`convert_old_entry(self, old_entry)`
	`decide_source(self, target, prev_ni)`
	`decide_target(self, target, prev_ni)`
	`Dir(self, name, create)` Create a directory node named 'name' relative to the SConscript directory of this file.
	`Dirs(self, pathlist)` Create a list of directories relative to the SConscript directory of this file.
	`diskcheck_match(self)`
	`do_duplicate(self, src)`
	`Entry(self, name)` Create an entry node named 'name' relative to the SConscript directory of this file.
	`exists(self)` Does this node exists?
	`File(self, name)` Create a file node named 'name' relative to the SConscript directory of this file.
	`find_src_builder(self)`
	`get_cachedir_bsig(self)`
	`get_cachedir_csig(self)` Fetch a Node's content signature for purposes of computing another Node's cachesig.
	`get_contents(self)`
	`get_csig(self)` Generate a node's content signature, the digested signature of its content.
	`get_found_includes(self, env, scanner, path)` Return the included implicit dependencies in this file.
	`get_size(self)`
	`get_stored_implicit(self)` Fetch the stored implicit dependencies
	`get_stored_info(self)`
	`get_timestamp(self)`
	`has_src_builder(self)` Return whether this Node has a source builder or not.
	`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.
	`prepare(self)` Prepare for this file to be created.
	`rel_path(self, other)`
	`remove(self)` Remove this file.
	`retrieve_from_cache(self)` Try to retrieve the node's content from a cache
	`rfile(self)`
	`rstr(self)` A Node.FS.Base object's string representation is its path name.
	`scanner_key(self)`
	`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).
	`_createDir(self)`
	`_get_found_includes_key(self, env, scanner, path)`
	`_morph(self)` Turn a file system node into a File object.
	`_rmv_existing(self)`
Inherited from Base
	`__str__(self)` A Node.FS.Base object's string representation is its path name.
	`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?
	`Rfindalldirs(self, pathlist)` Return all of the directories for a given path list, including corresponding "backing" directories in any repositories.
	`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.
	`build(self, **kw)` Actually build the node.
	`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.
	`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_env(self)`
	`get_env_scanner(self, env, kw)`
	`get_executor(self, create)` Fetch the action executor for 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_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.
	`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.
	`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.
	`scan(self)` Scan this node's dependents for implicit dependencies.
	`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)`
	`_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
`classobj`	`BuildInfo` = `SCons.Node.FS.FileBuildInfo`
`list`	`convert_copy_attrs` = `['bsources', 'bimplicit', 'bdepends...`
`list`	`convert_sig_attrs` = `['bsourcesigs', 'bimplicitsigs', 'bd...`
`list`	`memoizer_counters` = `[<SCons.Memoize.CountValue instance ...`
`classobj`	`NodeInfo` = `SCons.Node.FS.FileNodeInfo`

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.FS.Base.__init__ (inherited documentation)

alter_targets(self)

Return any corresponding targets in a build directory.

Overrides:: SCons.Node.Node.alter_targets

built(self)

Called just after this node is successfully built.

Overrides:: SCons.Node.Node.built

Dir(self, name, create=True)

Create a directory node named 'name' relative to the SConscript directory of this file.

Dirs(self, pathlist)

Create a list of directories relative to the SConscript directory of this file.

Entry(self, name)

Create an entry node named 'name' relative to the SConscript directory of this file.

exists(self)

Does this node exists?

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

File(self, name)

Create a file node named 'name' relative to the SConscript directory of this file.

get_cachedir_csig(self)

Fetch a Node's content signature for purposes of computing another Node's cachesig.

This is a wrapper around the normal get_csig() method that handles the somewhat obscure case of using CacheDir with the -n option. Any files that don't exist would normally be "built" by fetching them from the cache, but the normal get_csig() method will try to open up the local file, which doesn't exist because the -n option meant we didn't actually pull the file from cachedir. But since the file does actually exist in the cachedir, we can use its contents for the csig.

Overrides:: SCons.Node.Node.get_cachedir_csig

get_csig(self)

Generate a node's content signature, the digested signature of its content.

node - the node cache - alternate node to use for the signature cache returns - the content signature

Overrides:: SCons.Node.Node.get_csig

get_found_includes(self, env, scanner, path)

Return the included implicit dependencies in this file. Cache results so we only scan the file once per path regardless of how many times this information is requested.

Overrides:: SCons.Node.Node.get_found_includes

get_stored_implicit(self)

Fetch the stored implicit dependencies

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

has_src_builder(self)

Return whether this Node has a source builder or not.

If this Node doesn't have an explicit source code builder, this is where we figure out, on the fly, if there's a transparent source code builder for it.

Note that if we found a source builder, we also set the self.builder attribute, so that all of the methods that actually build this file don't have to do anything different.

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.

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

make_ready(self)

Get a Node ready for evaluation.

This is called before the Taskmaster decides if the Node is up-to-date or not. Overriding this method allows for a Node subclass to be disambiguated if necessary, or for an implicit source builder to be attached.

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

prepare(self)

Prepare for this file to be created.

Overrides:: SCons.Node.Node.prepare

remove(self)

Remove this file.

Overrides:: SCons.Node.Node.remove

retrieve_from_cache(self)

Try to retrieve the node's content from a cache

This method is called from multiple threads in a parallel build, so only do thread safe stuff here. Do thread unsafe stuff in built().

Returns true iff the node was successfully retrieved.

Overrides:: SCons.Node.Node.retrieve_from_cache

rstr(self)

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

Overrides:: SCons.Node.FS.Base.__str__ (inherited documentation)

store_info(self)

Make the build signature permanent (that is, store it in the .sconsign file or equivalent).

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

visited(self)

Called just after this node has been visited (with or without a build).

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

_morph(self)

Turn a file system node into a File object.

Class Variable Details

convert_copy_attrs

Type:: list
Value:: ['bsources', 'bimplicit', 'bdepends', 'bact', 'bactsig', 'ninfo']

convert_sig_attrs

Type:: list
Value:: ['bsourcesigs', 'bimplicitsigs', 'bdependsigs']

memoizer_counters

Type:: list
Value:: [<SCons.Memoize.CountValue instance at 0xa3b950>, <SCons.Memoize.CountValue instance at 0xa3a1b8>, <SCons.Memoize.CountValue instance at 0xa3a950>, <SCons.Memoize.CountDict instance at 0xa3a200>, <SCons.Memoize.CountValue instance at 0xa3a5a8>, <SCons.Memoize.CountValue instance at 0xa3af38>]

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

http://epydoc.sf.net