`module Provider`

A provider that can satisfy dependencies by providing named provisions.

Definitions

`def freeze`

Freeze the provider and all its provisions and dependencies.

Implementation

def freeze
	return self if frozen?
	
	provisions.freeze
	dependencies.freeze
	
	super
end

`def priority=(value)`

Assign a priority.

Implementation

def priority= value
	@priority = value
end

`def priority`

The default priority.

Implementation

def priority
	@priority ||= 0
end

`def provisions`

Implementation

def provisions
	@provisions ||= {}
end

`def dependencies`

Signature

returns　IdentitySet<Dependency>

Implementation

def dependencies
	@dependencies ||= Set.new
end

`def filter(dependency)`

Filter provisions that match a given dependency.

Signature

parameter　dependency　Depends: The dependency to match against.
returns　Hash<String, Provision>: Provisions that match the dependency.

Implementation

def filter(dependency)
	provisions.select{|name, provision| dependency.match?(name)}
end

`def provides?(dependency)`

Does this unit provide the named thing?

Implementation

def provides?(dependency)
	provisions.key?(dependency.name)
end

`def provision_for(dependency)`

Get the provision for a given dependency.

Signature

parameter　dependency　Depends: The dependency to get the provision for.
returns　Provision, nil: The provision, or nil if not found.

Implementation

def provision_for(dependency)
	return provisions[dependency.name]
end

`def resolution_for(dependency)`

Get a resolution for a given dependency.

Signature

parameter　dependency　Depends: The dependency to get the resolution for.
returns　Resolution: The resolution combining the provision and dependency.

Implementation

def resolution_for(dependency)
	return Resolution.new(provision_for(dependency), dependency)
end

`def provides(*names, **aliases, &block)`

Add one or more provisions to the provider.

Example: A named provision.

target.provides "Compiler/clang" do
	cxx "clang"
end

Example: A symbolic provision.

target.provides compiler: "Compiler/clang"

Signature

parameter　names　Array<String>: the named provisions to add.
parameter　aliases　Hash<Symbol, Array>: the aliases to add.

Implementation

def provides(*names, **aliases, &block)
	names.each do |name|
		provisions[name] = Provision.new(name, self, block)
	end
	
	aliases.each do |name, dependencies|
		provisions[name] = Alias.new(name, self, Array(dependencies))
	end
end

`def depends(*names, **options)`

Add one or more dependencies to the provider.

Example: A named dependency.

target.depends "Compiler/clang"

Example: A symbolic dependency.

target.depends :compiler

Signature

parameter　names　Array<String>: the dependency names to add.

Implementation

def depends(*names, **options)
	names.each do |name|
		dependencies << Depends.new(name, **options)
	end
end

`def depends?(name)`

Check if this provider depends on a given name.

Signature

parameter　name　String: The name to check.
returns　Boolean: True if this provider depends on the given name.

Implementation

def depends?(name)
	dependencies.include?(name)
end