class Puppet::Pops::Loader::Loader

@param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance

   # File lib/puppet/pops/loader/loader.rb
36 def initialize(loader_name, environment)
37   @loader_name = loader_name.freeze
38   @environment = environment
39 end

Produces the value associated with the given name if defined **in this loader**, or nil if not defined. This lookup does not trigger any loading, or search of the given name. An implementor of this method may not search or look up in any other loader, and it may not define the name.

@param typed_name [TypedName] - the type, name combination to lookup

@api private

    # File lib/puppet/pops/loader/loader.rb
115 def [](typed_name)
116   found = get_entry(typed_name)
117   if found
118     found.value
119   else
120     nil
121   end
122 end

Search all places where this loader would find values of a given type and return a list the found values for which the given block returns true. All found entries will be returned if no block is given.

Errors that occur function discovery will either be logged as warnings or collected by the optional `error_collector` array. When provided, it will receive {Puppet::DataTypes::Error} instances describing each error in detail and no warnings will be logged.

@param type [Symbol] the type of values to search for @param error_collector [Array<Puppet::DataTypes::Error>] an optional array that will receive errors during load @param name_authority [String] the name authority, defaults to the pcore runtime @yield [typed_name] optional block to filter the results @yieldparam [TypedName] typed_name the typed name of a found entry @yieldreturn [Boolean] `true` to keep the entry, `false` to discard it. @return [Array<TypedName>] the list of names of discovered values

   # File lib/puppet/pops/loader/loader.rb
56 def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)
57   return EMPTY_ARRAY
58 end

Searches for the given name in this loader's context (parents should already have searched their context(s) without producing a result when this method is called). An implementation of find typically caches the result.

@param typed_name [TypedName] the type, name combination to lookup @return [NamedEntry, nil] the entry for the loaded entry, or nil if not found

@api private

    # File lib/puppet/pops/loader/loader.rb
133 def find(typed_name)
134   raise NotImplementedError, "Class #{self.class.name} must implement method #find"
135 end

Produces a NamedEntry if a value is bound to the given name, or nil if nothing is bound.

@param typed_name [TypedName] the type, name combination to lookup @return [NamedEntry, nil] the value bound in an entry

@api private

    # File lib/puppet/pops/loader/loader.rb
177 def get_entry(typed_name)
178   raise NotImplementedError.new
179 end

Loaders may contain references to the environment they load items within. Consequently, calling Kernel#inspect may return strings that are large enough to cause OutOfMemoryErrors on some platforms.

We do not call alias_method here as that would copy the content of to_s at this point to inspect (ie children would print out `loader_name` rather than their version of to_s if they chose to implement it).

    # File lib/puppet/pops/loader/loader.rb
201 def inspect
202   self.to_s
203 end

Produces the value associated with the given name if already loaded, or available for loading by this loader, one of its parents, or other loaders visible to this loader. This is the method an external party should use to “get” the named element.

An implementor of this method should first check if the given name is already loaded by self, or a parent loader, and if so return that result. If not, it should call `find` to perform the loading.

@param type [:Symbol] the type to load @param name [String, Symbol] the name of the entity to load @return [Object, nil] the value or nil if not found

@api public

   # File lib/puppet/pops/loader/loader.rb
73 def load(type, name)
74   synchronize do
75     result = load_typed(TypedName.new(type, name.to_s))
76     if result
77       result.value
78     end
79   end
80 end

Loads the given typed name, and returns a NamedEntry if found, else returns nil. This the same a `load`, but returns a NamedEntry with origin/value information.

@param typed_name [TypedName] - the type, name combination to lookup @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found

@api public

   # File lib/puppet/pops/loader/loader.rb
90 def load_typed(typed_name)
91   raise NotImplementedError, "Class #{self.class.name} must implement method #load_typed"
92 end

A loader is by default a loader for all kinds of loadables. An implementation may override if it cannot load all kinds.

@api private

    # File lib/puppet/pops/loader/loader.rb
185 def loadables
186   LOADABLE_KINDS
187 end

Returns an already loaded entry if one exists, or nil. This does not trigger loading of the given type/name.

@param typed_name [TypedName] - the type, name combination to lookup @param check_dependencies [Boolean] - if dependencies should be checked in addition to here and parent @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found @api public

    # File lib/puppet/pops/loader/loader.rb
102 def loaded_entry(typed_name, check_dependencies = false)
103   raise NotImplementedError, "Class #{self.class.name} must implement method #loaded_entry"
104 end

Returns the parent of the loader, or nil, if this is the top most loader. This implementation returns nil.

    # File lib/puppet/pops/loader/loader.rb
138 def parent
139   nil
140 end

Produces the private loader for loaders that have a one (the visibility given to loaded entities). For loaders that does not provide a private loader, self is returned.

@api private

    # File lib/puppet/pops/loader/loader.rb
146 def private_loader
147   self
148 end

Binds a value to a name. The name should not start with '::', but may contain multiple segments.

@param type [:Symbol] the type of the entity being set @param name [String, Symbol] the name of the entity being set @param origin [URI, uri, String] the origin of the set entity, a URI, or provider of URI, or URI in string form @return [NamedEntry, nil] the created entry

@api private

    # File lib/puppet/pops/loader/loader.rb
166 def set_entry(type, name, value, origin = nil)
167   raise NotImplementedError.new
168 end

Lock around a block This exists so some subclasses that are set up statically and don't actually load can override it

    # File lib/puppet/pops/loader/loader.rb
153 def synchronize(&block)
154   @environment.lock.synchronize(&block)
155 end

A loader may want to implement its own version with more detailed information.

    # File lib/puppet/pops/loader/loader.rb
190 def to_s
191   loader_name
192 end