@param LoadingContext $context
@param ParentChildMap $map

@return void
512269
public function load(LoadingContext $context, ParentChildMap $map)
    {
        $filteredParentMap = new ParentChildMap();
        $parentItemMap     = new \SplObjectStorage();
        $relatedEntityMap  = $context->getIdentityMap($this->mapper->getObjectType());

        foreach ($map->getItems() as $item) {
            $relatedId = $item->getParent()->getColumn($this->foreignKeyToRelated);

            if ($relatedId === null) {
                $item->setChild(null);
            } elseif ($this->reference instanceof RelationIdentityReference) {
                $item->setChild((int)$relatedId);
            } elseif ($relatedEntityMap->has($relatedId)) {
                $item->setChild($relatedEntityMap->get($relatedId));
            } else {
                $filteredParentMap->add($item->getParent(), null);
                $parentItemMap[$item->getParent()] = $item;
            }
        }

        if ($filteredParentMap->getAllChildren()) {
            parent::load($context, $filteredParentMap);

            foreach ($filteredParentMap->getItems() as $item) {
                /** @var ParentChildItem $originalItem */
                $originalItem = $parentItemMap[$item->getParent()];
                $originalItem->setChild($item->getChild());
            }
        }
    }
714132
static void releaseContext(SeaGlassContext context) {
        synchronized (contextMap) {
            List instances = (List) contextMap.get(context.getClass());

            if (instances == null) {
                instances = new ArrayList(5);
                contextMap.put(context.getClass(), instances);
            }

            instances.add(context);
        }
    }
776206
function Context(view, parentContext) {
        this.view = view;
        this.cache = {
            '.': this.view,
            '@each': function each() {
                var returns = [];
                for (var k in this) {
                    returns.push({ '@key': k, '@value': this[k] });
                }
                return returns;
            }
        };
        this.parent = parentContext;
    }
1104596
private function initHooks(array $map, $hookkey)
    {
        foreach ($map as $hook) {
            $this->initHook($hook, $hookkey);
        }
    }
138040
public function reset(Map $map)
    {
        $this->pluginManager->reset($map);
        $this->dataProviderManager->reset($this->pluginManager, $map);
    }
1182177
public Map<String, Object> createContext(final Map<String, Object> parent, Map<String, Object> current) {
        return new DelegateMap<String, Object>(parent, current) {
            private static final long serialVersionUID = 1L;

            @Override
            public Object get(Object key) {
                Object value = super.get(key);
                if (value == null && parent == null
                        && resolver != null) {
                    return resolver.get((String) key);
                }
                return value;
            }
        };
    }
156804
protected function addChild (ContextInterface $child)
	{
		$length = count($this->stack);
		$this->stack[$length-1]->addChild ($child);
	}
1250055
public function addContext(Context $context) {
    $contexts = $this->get('contextOut');
    $contexts[] = $context;
    $this->add('contextOut', $contexts);
  }
843203
public void binding(Map map)
	{
		Map<String, Object> values = map;
		if(values==null) return ;
		for (Entry<String,Object> entry : values.entrySet())
		{
			this.binding(entry.getKey(), entry.getValue());
		}
		
	}
732293
public static function mapDescendantsArray(Tree $parent, Array $map)
    {
        foreach ($map as $item) {
            $node = new static($item);
            $node->setChildOf($parent);
            if (isset($item['children'])) {
                static::mapDescendantsArray($node, $item['children']);
            }
        }

    }
970880
public function initializeContext(Context $context)
    {
        if (!$context instanceof MinkAwareContext) {
            return;
        }

        $context->setMink($this->mink);
        $context->setMinkParameters($this->parameters);
    }
308267
@Override
	public void setup(AbstractInvokable parent) {
		@SuppressWarnings("unchecked")
		final GenericCollectorMap<IT, OT> mapper =
			RegularPactTask.instantiateUserCode(this.config, userCodeClassLoader, GenericCollectorMap.class);
		this.mapper = mapper;
		mapper.setRuntimeContext(getUdfRuntimeContext());
	}
639737
protected function _setContext($context)
    {
        $this->context = ($context !== null)
            ? $this->_normalizeContainer($context)
            : null;
    }
498653
public function load(LoadingContext $context, ParentChildMap $map)
    {
        /** @var Row[] $parentRows */
        $parentRows = [];
        /** @var ParentChildItem[] $items */
        $items = [];

        $requiredColumnLookup = $this->getRequiredColumnLookup();

        foreach ($map->getItems() as $key => $item) {
            $parentRow = $item->getParent();

            if ($this->objectIssetColumnName) {
                $objectIssetValue = $parentRow->getColumn($this->objectIssetColumnName);
                if ($this->isWithinValueObject && $objectIssetValue === null) {
                    continue;
                } elseif (!$this->isWithinValueObject && !$objectIssetValue) {
                    continue;
                }
            } else {
                // In case this relation was loaded via a LEFT JOIN the columns may be null
                // even if they are not nullable hence we must only load the object if all the non nullable columns
                // does not contain a null value.
                foreach ($this->parentColumnsToLoad as $requiredColumn) {
                    if (isset($requiredColumnLookup[$requiredColumn]) && $parentRow->getColumn($requiredColumn) === null) {
                        continue 2;
                    }
                }
            }

            $parentRows[$key] = $parentRow;
            $items[$key]      = $item;
        }

        $objects = $this->mapper->loadAll($context, $parentRows);

        foreach ($objects as $key => $object) {
            $items[$key]->setChild($object);
        }
    }
797056
function(map) {
        if (this.pane && this.pane.parentNode) {
            this.pane.parentNode.removeChild(this.pane);
        }
        OpenLayers.Layer.prototype.removeMap.apply(this, arguments);
    }
221051
private static function setViewContext($parentActionViewContext, $viewContext) {
        InternalHelper::setStaticPropertyValue('\\PhpMvc\\View', 'viewContext', $viewContext);
        InternalHelper::setStaticPropertyValue('\\PhpMvc\\Html', 'viewContext', $viewContext);
        InternalHelper::setStaticPropertyValue('\\PhpMvc\\Html', 'parentActionViewContext', $parentActionViewContext);
    }
983131
private function renderParentBlock(Template $parent, $blockName, Context $context)
    {
        while ($parent->parentTemplate) {
            $parent = $this->environment->load($parent->parentTemplate);
            if (isset($parent->blocks[ $blockName ])) {
                $parent->blocks[$blockName]($context);

                return;
            }
        }

        throw new \RuntimeException("Block {$blockName} was not found.");
    }