class Sheet implements BeanFactoryAware, BeanNameAware {
    @SuppressWarnings("unused")
    private static final long serialVersionUID = 9129011082185864377L;
    
    /**
     * unique name of this Sheet; if Sheet has a beanName from original
     * configuration, that is always the name -- but the name might 
     * also be another string, in the case of Sheets added after 
     * initial container wiring
     */
    protected String name; 
    protected BeanFactory beanFactory; 
    /** map of full property-paths (from BeanFactory to individual 
     * property) and their changed value when this Sheet of overrides
     * is in effect
     */
    protected Map<String,Object> map = new ConcurrentHashMap<String, Object>(); 
    
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
    public void setBeanName(String name) {
        this.name = name; 
    }
    public void setName(String name) {
        this.name = name; 
    }
    public String getName() {
        return name; 
    }

    /**
     * Return map of full bean-path (starting with a target bean-name)
     * to the alternate value for that targeted property
     */
    public Map<String, Object> getMap() {
        return map;
    }
    /**
     * Set map of property full bean-path (starting with a target 
     * bean-name) to alternate values. Note: provided map is copied 
     * into a local concurrent map, rather than used directly. 
     * @param m
     */
    @Required
    public void setMap(Map<String, Object> m) {
        this.map.clear();
        this.map.putAll(m);
    }
    
    /**
     * Ensure any properties targeted by this Sheet know to
     * check the right property paths for overrides at lookup time,
     * and that the override values are compatible types for their 
     * destination properties. 
     * 
     * Should be done as soon as all possible targets are 
     * constructed (ApplicationListener ContextRefreshedEvent)
     * 
     * TODO: consider if  an 'un-priming' also needs to occur to 
     * prevent confusing side-effects. 
     * TODO: consider if priming should move to another class
     */
    public void prime() {<FILL_FUNCTION_BODY>}
}

        for (String fullpath : map.keySet()) {
            int lastDot =  fullpath.lastIndexOf(".");
            String beanPath = fullpath.substring(0,lastDot);
            String terminalProp = fullpath.substring(lastDot+1);
            Object value = map.get(fullpath); 
            int i = beanPath.indexOf(".");
            Object bean; 
            HasKeyedProperties hkp;
            if (i < 0) {
                bean = beanFactory.getBean(beanPath);
            } else {
                String beanName = beanPath.substring(0,i);
                String propPath = beanPath.substring(i+1);
                BeanWrapperImpl wrapper = new BeanWrapperImpl(beanFactory.getBean(beanName));
                bean = wrapper.getPropertyValue(propPath);  
            }
            try {
                hkp = (HasKeyedProperties) bean;
            } catch (ClassCastException cce) {
                // targeted bean has no overridable properties
                throw new TypeMismatchException(bean,HasKeyedProperties.class,cce);
            }
            // install knowledge of this path 
            hkp.getKeyedProperties().addExternalPath(beanPath);
            // verify type-compatibility
            BeanWrapperImpl wrapper = new BeanWrapperImpl(hkp);
            Class<?> requiredType = wrapper.getPropertyType(terminalProp);
            try {
                // convert for destination type
                map.put(fullpath, wrapper.convertForProperty(value,terminalProp));
            } catch(TypeMismatchException tme) {
                TypeMismatchException tme2 = 
                    new TypeMismatchException(
                            new PropertyChangeEvent(
                                    hkp,
                                    fullpath,
                                    wrapper.getPropertyValue(terminalProp),
                                    value), requiredType, tme);
                throw tme2;
            }
        }
    
<no_super_class>