get used wrapping

@return oxWrapping
349203
public function getWrapping()
    {
        if ($this->oxorderarticles__oxwrapid->value) {
            $oWrapping = oxNew(\OxidEsales\Eshop\Application\Model\Wrapping::class);
            if ($oWrapping->load($this->oxorderarticles__oxwrapid->value)) {
                return $oWrapping;
            }
        }

        return null;
    }
658671
protected function getCsvEnclosure()
    {
        if ($this->hasOption(self::CSV_ENCLOSURE_OPTION)) {
            return $this->getOption(self::CSV_ENCLOSURE_OPTION);
        }

        return self::CSV_ENCLOSURE;
    }
450959
protected Object getUnwrapped(Object name) {
        try {
            return DeepUnwrap.unwrap(get(name));
        } catch (TemplateException e){
            throw new ViewException(e);
        }
    }
1077796
public function decorate()
    {
        $classname = $this->model->owner_type;
        $return    = '';
        if ($this->hasMethod($classname, 'getLogTitle')) {
            $return = $classname::getLogTitle($this->model->owner_id, $this->model);
        }
        if (strlen($return)) {
            return $return;
        }
        list($operation, $params) = $this->getOperationWithParams();
        return $this->translate($operation, $params);
    }
167790
public static Object unwrap(Object o) {
        Wrapper w = (Wrapper) o;
        return w.unwrap();
    }
89207
public function getExtension()
    {
        if (is_null($this->extension) === true) {
            $filename = parent::getFilename();
            $str = new StringWrapper($filename);
            $this->extension = $str->getFirstEndMatch($this->predefinedExtensions);
            $this->hasPredefinedExt = true;

            if ($this->extension === '') {
                $this->hasPredefinedExt = false;
                $this->extension = parent::getExtension();
            }
        }

        return $this->extension;
    }
785519
public function getWidthOptions()
    {
        $markup = '<option value="">' . __('Inherit', 'modularity') . '</option>' . "\n";

        foreach (self::widthOptions() as $key => $value) {
            $markup .= '<option value="' . $key . '">' . $value . '</option>' . "\n";
        }

        return $markup;
    }
1346610
private function getHandle()
    {
        // make sure to clean up old handles
        if ($this->handle !== null && feof($this->handle)) {
            $this->resetHandle();
        }

        // provision new handle
        if ($this->handle == null) {
            $params = $this->params;
            if (!empty($this->getResourceVersion())) {
                $params['resourceVersion'] = $this->getResourceVersion();
            }
            $query = http_build_query($params);
            $base = $this->getClient()->getConfig()->getServer().$this->endpoint;
            $url = $base;

            if (!empty($query)) {
                $parsed = parse_url($base);
                if (key_exists('query', $parsed) || substr($base, -1) == "?") {
                    $url .= '&'.$query;
                } else {
                    $url .= '?'.$query;
                }
            }
            $handle = @fopen($url, 'r', false, $this->getClient()->getStreamContext());
            if ($handle === false) {
                $e = error_get_last();
                throw new \Exception($e['message'], $e['type']);
            }
            stream_set_timeout($handle, 0, $this->getStreamTimeout());
            $this->handle = $handle;
        }

        return $this->handle;
    }
547262
private function useBlock() {
    $node = new UseDeclarationBlockNode();
    $node->addChild($this->_use());
    while ($this->currentType === T_USE) {
      $this->matchHidden($node);
      $node->addChild($this->_use());
    }
    return $node;
  }
1276011
public function getHandle()
    {
        $delegate = $this->getDelegate();

        if($delegate instanceof KObjectHandlable) {
            $handle = $delegate->getHandle();
        } else {
            $handle = spl_object_hash($this);
        }

        return $handle;
    }
30487
function unwrap() {
                var nodes = Array.prototype.slice.call(el.childNodes),
                    wrapper = void 0;

                nodes.forEach(function (node) {
                    wrapper = node.parentNode;
                    dom(node).insertBefore(node.parentNode);
                    dom(wrapper).remove();
                });

                return nodes;
            }
453203
public function wrap()
    {
        $this->importNodes(\func_get_args(), function ($node, $imported_node) {
            if ($node->parentNode instanceof \DOMDocument) {
                throw new \Exception('Can not wrap inside root element '.$node->tagName.' of document');
            }

            // replace node with imported wrapper
            $old = $node->parentNode->replaceChild($imported_node, $node);
            // old node goes inside the most inner child of wrapper
            $target = $imported_node;
            while ($target->hasChildNodes()) {
                $target = $target->childNodes[0];
            }
            $target->appendChild($old);
        });

        return $this;
    }
103673
public function getWrapper(): EiPropWrapper {
		if ($this->wrapper !== null) {
			return $this->wrapper;
		}
		
		throw new IllegalStateException(get_class($this) . ' is not assigned to a Wrapper.');
	}
831205
protected static function serializeHandlers()
    {
        $hooks = (array) self::getTask()->handlers;
        foreach ($hooks as &$handlers) {
            foreach (array_keys($handlers) as $key) {
                self::toggleSerializeClosure($handlers, $key);
            }
        }

        return $hooks;
    }
439531
public function getWrapperPrototype()
    {
        if (!$this->wrapperPrototype) {
            $this->wrapperPrototype = \Nette\Utils\Html::el('th')
                ->setClass(['grid-filter-' . $this->getName()]);
        }

        return $this->wrapperPrototype;
    }
283095
public function getAndWrap($path = null)
    {
        // There are some cases where the $path is a ProtectedContext, especially when doing s.th. like
        // foo()[myOffset]. In this case we need to unwrap it.
        if ($path instanceof ProtectedContext) {
            $path = $path->unwrap();
        }

        $context = parent::getAndWrap($path);
        if ($context instanceof ProtectedContext && isset($this->whitelist[$path]) && is_array($this->whitelist[$path])) {
            $context->whitelist = $this->whitelist[$path];
        }
        return $context;
    }
1096865
public function wrapLength($length = null) {
		if ($length === null) {
			return $this->getWrapLength();
		}

		return $this->setWrapLength($length);
	}