caruby-core 1.5.5 → 2.1.1

data/lib/caruby/domain/attributes.rb

@@ -1,628 +0,0 @@
-require 'enumerator'
-require 'caruby/util/collection'
-require 'caruby/domain/merge'
-require 'caruby/domain/attribute'
-
-module CaRuby
-  module Domain
-    # Meta-data mix-in for attribute accessors.
-    module Attributes
-      # @return [<Symbol>] this class's attributes
-      attr_reader :attributes
-      
-      # @return [Hashable] the default attribute => value associations
-      attr_reader :defaults
-  
-      # Returns whether this class has an attribute with the given symbol.
-      #
-      # @param [Symbol] symbol the potential attribute
-      # @return [Boolean] whether there is a corresponding attribute
-      def attribute_defined?(symbol)
-        unless Symbol === symbol then
-          raise ArgumentError.new("Attribute argument #{symbol.qp} of type #{symbol.class.qp} is not a symbol")
-        end
-        @attr_md_hash.has_key?(symbol)
-      end
-  
-      # Adds the given attribute to this Class.
-      #
-      # @param [Symbol] attribute the attribute to add
-      # @param [Class] type (see Attribute#initialize)
-      # @param flags (see Attribute#initialize)
-      # @return [Attribute] the attribute meta-data
-      def add_attribute(attribute, type, *flags)
-        attr_md = Attribute.new(attribute, self, type, *flags)
-        add_attribute_metadata(attr_md)
-        attr_md
-      end
-  
-      # @return [(Symbol)] the +[:identifier]+ primary key attribute singleton array
-      def primary_key_attributes
-        IDENTIFIER_ATTR_ARRAY
-      end
-  
-      # Returns this class's secondary key attribute array.
-      # If this class's secondary key is not set, then the secondary key is the Metadata superclass
-      # secondary key, if any.
-      #
-      # @return [<Symbol>] the secondary key attributes
-      def secondary_key_attributes
-        @scndy_key_attrs or superclass < Resource ? superclass.secondary_key_attributes : Array::EMPTY_ARRAY
-      end
-  
-      # Returns this class's alternate key attribute array.
-      # If this class's secondary key is not set, then the alternate key is the {Metadata} superclass
-      # alternate key, if any.
-      #
-      # @return [<Symbol>] the alternate key attributes
-      def alternate_key_attributes
-        @alt_key_attrs or superclass < Resource ? superclass.alternate_key_attributes : Array::EMPTY_ARRAY
-      end
-  
-      def each_attribute_metadata(&block)
-        @attr_md_hash.each_value(&block)
-      end
-  
-      # @return the Attribute for the given attribute symbol or alias
-      # @raise [NameError] if the attribute is not recognized
-      def attribute_metadata(attribute)
-        # Simple and predominant case is that attribute is a standard attribute.
-        # Otherwise, resolve attribute to the standard symbol.
-        attr_md = @attr_md_hash[attribute] || @attr_md_hash[standard_attribute(attribute)]
-        # If not found, then delegate to handler which will either make the new
-        # attribute or raise a NameError.
-        attr_md || (attribute_missing(attribute) && @local_attr_md_hash[attribute])
-      end
-  
-      # @param [Symbol, String] name_or_alias the attribute name or alias
-      # @return [Symbol] the standard attribute symbol for the given name or alias
-      # @raise [ArgumentError] if the attribute name or alias argument is missing
-      # @raise [NameError] if the attribute is not found
-      def standard_attribute(name_or_alias)
-        if name_or_alias.nil? then
-          raise ArgumentError.new("#{qp} standard attribute call is missing the attribute name/alias parameter")
-        end
-        @alias_std_attr_map[name_or_alias.to_sym] or raise NameError.new("#{self} attribute not found: #{name_or_alias}")
-      end
-  
-      ## Metadata ATTRIBUTE FILTERS ##
-  
-      # @return [<Symbol>] the domain attributes which wrap a java property
-      # @see Attribute#java_property?
-      def java_attributes
-        @java_attrs ||= attribute_filter { |attr_md| attr_md.java_property? }
-      end
-
-      alias :printable_attributes :java_attributes
-  
-      # @return [<Symbol>] the domain attributes
-      def domain_attributes
-        @dom_attrs ||= attribute_filter { |attr_md| attr_md.domain? }
-      end
-  
-      # @return [<Symbol>] the non-domain Java attributes
-      def nondomain_attributes
-        @nondom_attrs ||= attribute_filter { |attr_md| attr_md.java_property? and attr_md.nondomain? }
-      end
-  
-      # @return [<Symbol>] the non-domain Java property wrapper attributes
-      def nondomain_java_attributes
-        @nondom_java_attrs ||= nondomain_attributes.compose { |attr_md| attr_md.java_property? }
-      end
-  
-      # @return [<Symbol>] the standard attributes which can be merged into an instance of the subject class.
-      #   The default mergeable attributes consist of the {#nondomain_java_attributes}.
-      # @see Mergeable#mergeable_attributes
-      alias :mergeable_attributes :nondomain_java_attributes
-  
-      # @param [Boolean, nil] inc_super flag indicating whether to include dependents defined in the superclass
-      # @return [<Symbol>] the dependent attributes
-      def dependent_attributes(inc_super=true)
-        if inc_super then
-          @dep_attrs ||= attribute_filter { |attr_md| attr_md.dependent? }
-        else
-          @local_dep_attrs ||= dependent_attributes.compose { |attr_md| attr_md.declarer == self }
-        end
-      end
-  
-      # @return [<Symbol>] the dependent attributes
-      def autogenerated_dependent_attributes
-        @ag_dep_attrs ||= dependent_attributes.compose { |attr_md| attr_md.autogenerated? }
-      end
-  
-      # @return [<Symbol>] the autogenerated logical dependent attributes
-      # @see #logical_dependent_attributes
-      # @see Attribute#autogenerated?
-      def autogenerated_logical_dependent_attributes
-        @ag_log_dep_attrs ||= dependent_attributes.compose { |attr_md| attr_md.autogenerated? and attr_md.logical? }
-      end
-      
-      # @return [<Symbol>] the {Attribute#saved_fetch?} attributes
-      def saved_fetch_attributes
-        @svd_ftch_attrs ||= domain_attributes.compose { |attr_md| attr_md.saved_fetch? }
-      end
-      
-      # @return [<Symbol>] the logical dependent attributes
-      # @see Attribute#logical?
-      def logical_dependent_attributes
-        @log_dep_attrs ||= dependent_attributes.compose { |attr_md| attr_md.logical? }
-      end
-      
-      # @return [<Symbol>] the unidirectional dependent attributes
-      # @see Attribute#unidirectional?
-      def unidirectional_dependent_attributes
-        @uni_dep_attrs ||= dependent_attributes.compose { |attr_md| attr_md.unidirectional? }
-      end
-  
-      # @return [<Symbol>] the auto-generated attributes
-      # @see Attribute#autogenerated?
-      def autogenerated_attributes
-        @ag_attrs ||= attribute_filter { |attr_md| attr_md.autogenerated? }
-      end
-      
-      # @return [<Symbol>] the auto-generated non-domain attributes
-      # @see Attribute#nondomain?
-      # @see Attribute#autogenerated?
-      def autogenerated_nondomain_attributes
-        @ag_nd_attrs ||= attribute_filter { |attr_md| attr_md.autogenerated? and attr_md.nondomain? }
-      end
-      
-      # @return [<Symbol>] the {Attribute#volatile?} non-domain attributes
-      def volatile_nondomain_attributes
-        @unsvd_nd_attrs ||= attribute_filter { |attr_md| attr_md.volatile? and attr_md.nondomain? }
-      end
-  
-      # @return [<Symbol>] the domain attributes which can serve as a query parameter
-      # @see Attribute#searchable?
-      def searchable_attributes
-        @srchbl_attrs ||= attribute_filter { |attr_md| attr_md.searchable? }
-      end
-  
-      # @return [<Symbol>] the create/update cascaded domain attributes
-      # @see Attribute#cascaded?
-      def cascaded_attributes
-        @cscd_attrs ||= domain_attributes.compose { |attr_md| attr_md.cascaded? }
-      end
-  
-      # @return [<Symbol>] the {#cascaded_attributes} which are saved with a proxy
-      #   using the dependent saver_proxy method
-      def proxied_savable_template_attributes
-        @px_cscd_attrs ||= savable_template_attributes.compose { |attr_md| attr_md.proxied_save? }
-      end
-  
-      # @return [<Symbol>] the {#cascaded_attributes} which do not have a
-      #   #{Attribute#proxied_save?}
-      def unproxied_savable_template_attributes
-        @unpx_sv_tmpl_attrs ||= savable_template_attributes.compose { |attr_md| not attr_md.proxied_save? }
-      end
-  
-      # @return [<Symbol>] the {#domain_attributes} to {Attribute#include_in_save_template?}
-      def savable_template_attributes
-        @sv_tmpl_attrs ||= domain_attributes.compose { |attr_md| attr_md.include_in_save_template? }
-      end
-      
-      # Returns the physical or auto-generated logical dependent attributes that can
-      # be copied from a save result to the given save argument object.
-      #
-      # @return [<Symbol>] the attributes that can be copied from a save result to a
-      #  save argument object
-      # @see Attribute#autogenerated?
-      def copyable_saved_attributes
-        @cp_sv_attrs ||= dependent_attributes.compose { |attr_md| attr_md.autogenerated? or not attr_md.logical? }
-      end
-  
-      # Returns the subject class's required attributes, determined as follows:
-      # * An attribute marked with the :mandatory flag is mandatory.
-      # * An attribute marked with the :optional or :autogenerated flag is not mandatory.
-      # * Otherwise, A secondary key or owner attribute is mandatory.
-      def mandatory_attributes
-        @mndtry_attrs ||= collect_mandatory_attributes
-      end
-  
-      # @return [<Symbol>] the attributes which are {Attribute#creatable?}
-      def creatable_attributes
-        @cr_attrs ||= attribute_filter { |attr_md| attr_md.creatable? }
-      end
-  
-      # @return [<Symbol>] the attributes which are {Attribute#updatable?}
-      def updatable_attributes
-        @upd_attrs ||= attribute_filter { |attr_md| attr_md.updatable? }
-      end
-  
-      def fetched_dependent_attributes
-        @ftchd_dep_attrs ||= (fetched_domain_attributes & dependent_attributes).to_a
-      end
-      
-      def nonowner_attributes
-        @nownr_atts ||= attribute_filter { |attr_md| not attr_md.owner? }
-      end
-      
-      # @return [<Symbol>] the saved dependent attributes
-      # @see Attribute#dependent?
-      # @see Attribute#saved?
-      def saved_dependent_attributes
-        @svd_dep_attrs ||= attribute_filter { |attr_md| attr_md.dependent? and attr_md.saved? }
-      end
-      
-      # @return [<Symbol>] the saved independent attributes
-      # @see Attribute#independent?
-      # @see Attribute#saved?
-      def saved_independent_attributes
-        @svd_ind_attrs ||= attribute_filter { |attr_md| attr_md.independent? and attr_md.saved? }
-      end
-  
-      # @return [<Symbol>] the domain {Attribute#saved?} attributes
-      def saved_domain_attributes
-        @svd_dom_attrs ||= domain_attributes.compose { |attr_md| attr_md.saved? }
-      end
-  
-      # @return [<Symbol>] the non-domain {Attribute#saved?} attributes
-      def saved_nondomain_attributes
-        @svd_nondom_attrs ||= nondomain_attributes.compose { |attr_md| attr_md.saved? }
-      end
-  
-      # @return [<Symbol>] the {Attribute#volatile?} {#nondomain_attributes}
-      def volatile_nondomain_attributes
-        @vlt_nondom_attrs ||= nondomain_attributes.compose { |attr_md| attr_md.volatile? }
-      end
-  
-      # @return [<Symbol>] the domain {#creatable_attributes}
-      def creatable_domain_attributes
-        @cr_dom_attrs ||= domain_attributes.compose { |attr_md| attr_md.creatable? }
-      end
-  
-      # @return [<Symbol>] the domain {#updatable_attributes}
-      def updatable_domain_attributes
-        @upd_dom_attrs ||= domain_attributes.compose { |attr_md| attr_md.updatable? }
-      end
-  
-      # @return [<Symbol>] the domain attributes whose referents must exist before an instance of this
-      #   metadata's subject class can be created
-      # @see Attribute#storable_prerequisite?
-      def storable_prerequisite_attributes
-        @stbl_prereq_dom_attrs ||= attribute_filter { |attr_md| attr_md.storable_prerequisite? }
-      end
-  
-      # @return [<Symbol>] the attributes which are populated from the database
-      # @see Attribute#fetched?
-      def fetched_attributes
-        @ftchd_attrs ||= attribute_filter { |attr_md| attr_md.fetched? }
-      end
-  
-      # Returns the domain attributes which are populated in a query on the given fetched instance of
-      # this metadata's subject class. The domain attribute is fetched if it satisfies the following 
-      # conditions:
-      # * the attribute is a dependent attribute or of abstract domain type
-      # * the attribute is not specified as unfetched in the configuration
-      #
-      # @return [<Symbol>] the attributes which are {Attribute#fetched?}
-      def fetched_domain_attributes
-        @ftchd_dom_attrs ||= domain_attributes.compose { |attr_md| attr_md.fetched? }
-      end
-  
-      #@return [<Symbol>] the #domain_attributes which are not #fetched_domain_attributes
-      def unfetched_attributes
-        @unftchd_attrs ||= domain_attributes.compose { |attr_md| not attr_md.fetched? }
-      end
-      
-      alias :toxic_attributes :unfetched_attributes
-  
-      # @return [<Symbol>] the Java property non-abstract {#unfetched_attributes}
-      def loadable_attributes
-        @ld_attrs ||= unfetched_attributes.compose { |attr_md| attr_md.java_property? and not attr_md.type.abstract? }
-      end
-  
-      # @param [Symbol] attribute the attribute to check
-      # @return [Boolean] whether attribute return type is a domain object or collection thereof
-      def domain_attribute?(attribute)
-        attribute_metadata(attribute).domain?
-      end
-  
-      # @param [Symbol] attribute the attribute to check
-      # @return [Boolean] whether attribute is not a domain attribute
-      def nondomain_attribute?(attribute)
-        not domain_attribute?(attribute)
-      end
-  
-      # @param [Symbol] attribute the attribute to check
-      # @return [Boolean] whether attribute is an instance of a Java domain class
-      def collection_attribute?(attribute)
-        attribute_metadata(attribute).collection?
-      end
-  
-      protected
-      
-      # @return [{Symbol => Attribute}] the attribute => metadata hash
-      def attribute_metadata_hash
-        @attr_md_hash
-      end
-  
-      # @return [{Symbol => Symbol}] the attribute alias => standard hash
-      def alias_standard_attribute_hash
-        @alias_std_attr_map
-      end
-  
-      private
-  
-      IDENTIFIER_ATTR_ARRAY = [:identifier]
-  
-      # A filter on the standard attribute symbol => metadata hash that yields
-      # each attribute which satisfies the attribute metadata condition.
-      class Filter
-        include Enumerable
-  
-        # @param [Class] the class whose attributes are filtered
-        # @param [{Symbol => Attribute}] hash the attribute symbol => metadata hash
-        # @yield [attr_md] condition which determines whether the attribute is selected
-        # @yieldparam [Attribute] the metadata for the standard attribute
-        # @raise [ArgumentError] if a parameter is missing 
-        def initialize(klass, hash, &filter)
-          raise ArgumentError.new("#{klass.qp} attribute filter missing hash argument") if hash.nil?
-          raise ArgumentError.new("#{klass.qp} attribute filter missing filter block") unless block_given?
-          @hash = hash
-          @filter = filter
-        end
-  
-        # @yield [attribute, attr_md] the block to apply to the filtered attribute metadata and attribute
-        # @yieldparam [Symbol] attribute the attribute
-        # @yieldparam [Attribute] attr_md the attribute metadata
-        def each_pair
-          @hash.each { |attr, attr_md| yield(attr, attr_md) if @filter.call(attr_md) }
-        end
-        
-        # @return [<(Symbol, Attribute)>] the (symbol, attribute) enumerator
-        def enum_pairs
-          enum_for(:each_pair)
-        end
-        
-        # @yield [attribute] block to apply to each filtered attribute
-        # @yieldparam [Symbol] the attribute which satisfies the filter condition
-        def each_attribute(&block)
-          each_pair { |attr, attr_md| yield(attr) }
-        end
-        
-        alias :each :each_attribute
-  
-        # @yield [attr_md] the block to apply to the filtered attribute metadata
-        # @yieldparam [Attribute] attr_md the attribute metadata
-        def each_metadata
-          each_pair { |attr, attr_md| yield(attr_md) }
-        end
-        
-        # @return [<Attribute>] the attribute metadata enumerator
-        def enum_metadata
-          enum_for(:each_metadata)
-        end
-        
-        # @yield [attribute] the block to apply to the attribute
-        # @yieldparam [Symbol] attribute the attribute
-        # @return [Attribute] the first attribute metadata satisfies the block
-        def detect_metadata
-          each_pair { |attr, attr_md| return attr_md if yield(attr) }
-          nil
-        end
-        
-        # @yield [attr_md] the block to apply to the attribute metadata
-        # @yieldparam [Attribute] attr_md the attribute metadata
-        # @return [Symbol] the first attribute whose metadata satisfies the block
-        def detect_with_metadata
-          each_pair { |attr, attr_md| return attr if yield(attr_md) }
-          nil
-        end
-  
-        # @yield [attr_md] the attribute selection filter
-        # @yieldparam [Attribute] attr_md the candidate attribute metadata
-        # @return [Filter] a new Filter which applies the filter block given to this
-        #   method with the Attribute enumerated by this filter
-        def compose
-          Filter.new(self, @hash) { |attr_md| @filter.call(attr_md) and yield(attr_md) }
-        end
-      end
-      
-      # Returns an Enumerable on this Resource class's attributes which iterates on each attribute whose
-      # corresponding Attribute satisfies the given filter block.
-      #
-      # @yield [attr_md] the attribute selector
-      # @yieldparam [Attribute] attr_md the candidate attribute
-      def attribute_filter(&filter)
-        # initialize the attributes on demand
-        unless introspected? then introspect end
-        # make the attribute filter
-        Filter.new(self, @attr_md_hash, &filter)
-      end
-  
-      # Initializes the attribute meta-data structures.
-      def init_attributes
-        @local_std_attr_hash = {}
-        @alias_std_attr_map = append_ancestor_enum(@local_std_attr_hash) { |par| par.alias_standard_attribute_hash }
-        @local_attr_md_hash = {}
-        @attr_md_hash = append_ancestor_enum(@local_attr_md_hash) { |par| par.attribute_metadata_hash }
-        @attributes = Enumerable::Enumerator.new(@attr_md_hash, :each_key)
-        @local_mndty_attrs = Set.new
-        @local_defaults = {}
-        @defaults = append_ancestor_enum(@local_defaults) { |par| par.defaults }
-      end
-      
-      # Detects the first attribute with the given type.
-      #
-      # @param [Class] klass the target attribute type
-      # @return [Symbol, nil] the attribute with the given type
-      def detect_attribute_with_type(klass)
-        attribute_metadata_hash.detect_key_with_value { |attr_md| attr_md.type == klass }
-      end
-      
-      # Creates the given attribute alias. If the attribute metadata is registered with this class, then
-      # this method overrides {Class#alias_attribute} to create a new alias reader (writer) method
-      # which delegates to the attribute reader (writer, resp.). This aliasing mechanism differs from
-      # {Class#alias_attribute}, which directly aliases the existing reader or writer method.
-      # Delegation allows the alias to pick up run-time redefinitions of the aliased reader and writer.
-      # If the attribute metadata is not registered with this class, then this method delegates to
-      # {Class#alias_attribute}.
-      #
-      # @param [Symbol] aliaz the attribute alias
-      # @param [Symbol] attribute the attribute to alias
-      def alias_attribute(aliaz, attribute)
-        if attribute_defined?(attribute) then
-          add_attribute_aliases(aliaz => attribute)
-        else
-          super
-        end
-      end
-  
-      # Creates the given aliases to attributes.
-      #
-      # @param [{Symbol => Symbol}] hash the alias => attribute hash
-      # @see #attribute_alias
-      def add_attribute_aliases(hash)
-        hash.each { |aliaz, attr| delegate_to_attribute(aliaz, attr) }
-      end
-  
-      # Sets this class's secondary key attributes to the given attributes.
-      # If attributes is set to nil, then the secondary key is cleared.
-      def set_secondary_key_attributes(*attributes)
-        attributes.compact!
-        @scndy_key_attrs = attributes.map { |attr| standard_attribute(attr) }
-      end
-  
-      # Sets this class's alternate key attributes to the given attributes.
-      # If attributes is set to nil, then the alternate key is cleared.
-      def set_alternate_key_attributes(*attributes)
-        attributes.compact!
-        @alt_key_attrs = attributes.map { |attr| standard_attribute(attr) }
-      end
-  
-      # Sets the given attribute type to klass. If attribute is defined in a superclass,
-      # then klass must be a subclass of the superclass attribute type.
-      #
-      # Raises ArgumentError if klass is incompatible with the current attribute type.
-      def set_attribute_type(attribute, klass)
-        attr_md = attribute_metadata(attribute)
-        # If this class is the declarer, then simply set the attribute type.
-        # Otherwise, if the attribute type is unspecified or is a superclass of the given class,
-        # then make a new attribute metadata for this class.
-        if attr_md.declarer == self then
-          logger.debug { "Set #{qp}.#{attribute} type to #{klass.qp}." }
-          attr_md.type = klass
-        elsif attr_md.type.nil? or klass < attr_md.type then
-          new_attr_md = attr_md.restrict_type(self, klass)
-          logger.debug { "Restricted #{attr_md.declarer.qp}.#{attribute}(#{attr_md.type.qp}) to #{qp} with return type #{klass.qp}." }
-          add_attribute_metadata(new_attr_md)
-        elsif klass != attr_md.type then
-          raise ArgumentError.new("Cannot reset #{qp}.#{attribute} type #{attr_md.type} to incompatible #{klass.qp}")
-        end
-      end
-  
-      def add_attribute_defaults(hash)
-        hash.each { |attr, value| @local_defaults[standard_attribute(attr)] = value }
-      end
-  
-      def add_mandatory_attributes(*attributes)
-        attributes.each { |attr| @local_mndty_attrs << standard_attribute(attr) }
-      end
-  
-      # Marks the given attribute with flags supported by {Attribute#qualify}.
-      def qualify_attribute(attribute, *flags)
-        attr_md = attribute_metadata(attribute)
-        if attr_md.declarer == self then
-          attr_md.qualify(*flags)
-        else
-          logger.debug { "Restricting #{attr_md.declarer.qp}.#{attribute} to #{qp} with additional flags #{flags.to_series}" }
-          new_attr_md = attr_md.restrict_flags(self, *flags)
-          add_attribute_metadata(new_attr_md)
-        end
-      end
-  
-      # Removes the given attribute from this Resource.
-      # An attribute declared in a superclass Resource is hidden from this Resource but retained in
-      # the declaring Resource.
-      def remove_attribute(attribute)
-        std_attr = standard_attribute(attribute)
-        # if the attribute is local, then delete it, otherwise filter out the superclass attribute
-        attr_md = @local_attr_md_hash.delete(std_attr)
-        if attr_md then
-          # clear the inverse, if any
-          attr_md.inverse = nil
-          # remove from the mandatory attributes, if necessary
-          @local_mndty_attrs.delete(std_attr)
-          # remove from the attribute => metadata hash
-          @local_std_attr_hash.delete_if { |aliaz, attr| attr == std_attr }
-        else
-          # Filter the superclass hashes.
-          anc_md_hash = @attr_md_hash.components[1]
-          @attr_md_hash.components[1] = anc_md_hash.filter_on_key { |attr| attr != attribute }
-          anc_alias_hash = @alias_std_attr_map.components[1]
-          @alias_std_attr_map.components[1] = anc_alias_hash.filter_on_key { |attr| attr != attribute }
-        end
-      end
-  
-      def add_attribute_metadata(attr_md)
-        attr = attr_md.to_sym
-        @local_attr_md_hash[attr] = attr_md
-        # map the attribute symbol to itself in the alias map
-        @local_std_attr_hash[attr] = attr
-      end
-  
-      # Records that the given aliaz aliases a standard attribute.
-      def add_alias(aliaz, attribute)
-        std_attr = standard_attribute(attribute)
-        raise ArgumentError.new("#{self} attribute not found: #{attribute}") if std_attr.nil?
-        @local_std_attr_hash[aliaz.to_sym] = std_attr
-      end
-  
-      # Appends to the given enumerable the result of evaluating the block given to this method
-      # on the superclass, if the superclass is in the same parent module as this class.
-      #
-      # @param [Enumerable] enum the base collection
-      # @return [Enumerable] the {Enumerable#union} of the base collection with the superclass
-      #   collection, if applicable 
-      def append_ancestor_enum(enum)
-        return enum unless superclass.parent_module == parent_module
-        anc_enum = yield superclass
-        if anc_enum.nil? then raise MetadataError.new("#{qp} superclass #{superclass.qp} does not have required metadata") end
-        enum.union(anc_enum)
-      end
-  
-      # Collects the {Attribute#fetched_dependent?} and {Attribute#fetched_independent?}
-      # standard domain attributes.
-      #
-      # @return [<Symbol>] the fetched attributes
-      def collect_default_fetched_domain_attributes
-        attribute_filter do |attr_md|
-          if attr_md.domain? then
-            attr_md.dependent? ? fetched_dependent?(attr_md) : fetched_independent?(attr_md)
-          end
-        end
-      end
-  
-      # Merges the secondary key, owner and additional mandatory attributes defined in the properties.
-      #
-      # @see #mandatory_attributes
-      def collect_mandatory_attributes
-        mandatory = Set.new
-        # add the secondary key
-        mandatory.merge(secondary_key_attributes)
-        # add the owner attribute, if any
-        oattr = mandatory_owner_attribute
-        mandatory << oattr if oattr
-        # remove autogenerated or optional attributes
-        mandatory.delete_if { |attr| attribute_metadata(attr).autogenerated? or attribute_metadata(attr).optional? }
-        @local_mndty_attrs.merge!(mandatory)
-        append_ancestor_enum(@local_mndty_attrs) { |par| par.mandatory_attributes }
-      end
-      
-      # @return [Symbol, nil] the unique non-self-referential owner attribute, if one exists
-      def mandatory_owner_attribute
-        attr = owner_attribute || return
-        attr_md = attribute_metadata(attr)
-        attr if attr_md.java_property? and attr_md.type != self
-      end
-  
-      # Raises a NameError. Domain classes can override this method to dynamically create a new reference attribute.
-      #
-      # @raise [NameError] always
-      def attribute_missing(attribute)
-        raise NameError.new("#{name.demodulize} attribute not found: #{attribute}")
-      end
-    end
-  end
-end