Lifts the construction node above and updates the order comparators
165500
private IQTree liftChildConstructionNode(ConstructionNode newChildRoot, UnaryIQTree newChild, IQProperties liftedProperties) {

        UnaryIQTree newOrderByTree = iqFactory.createUnaryIQTree(
                applySubstitution(newChildRoot.getSubstitution()),
                newChild.getChild(),
                liftedProperties);

        return iqFactory.createUnaryIQTree(newChildRoot, newOrderByTree, liftedProperties);
    }
54470
def shift_ordering_up(cls, parent_id, position, db_session=None, *args, **kwargs):
        
        db_session = get_db_session(db_session)
        query = db_session.query(cls.model)
        query = query.filter(cls.model.parent_id == parent_id)
        query = query.filter(cls.model.ordering >= position)
        query.update(
            {cls.model.ordering: cls.model.ordering + 1}, synchronize_session=False
        )
        db_session.flush()
547268
static void applyLowerPrecedence(List<NodeInfo> order) {
        for (int i = 0; i < order.size(); i++) {
            NodeInfo ni = order.get(i);
            if (ni.getNode().getAttribute(Constants.ATT_MOVE_ALLOWED).equals("false")) {
                for (int j = 0; j < i; j++) {
                    NodeInfo lefty = order.get(j);
                    if (lefty.getPrecedence() == null
                            || lefty.getPrecedence().isLessThan(ni.getPrecedence())) {
                        order.remove(j);
                        order.add(i, lefty);
                    }
                }
            }
        }
    }
1224886
def update(self, milliseconds):
        """"""
        self.__sort_up()
        for obj in self.__up_objects:
            obj.update(milliseconds)
1290715
private IQTree liftSliceChild(SliceNode newChildRoot, IQTree newChild, IQProperties currentIQProperties) {
        return iqFactory.createUnaryIQTree(this, newChild, currentIQProperties.declareLifted());
    }
501993
public void addComparator(Comparator<T> comparator, boolean ascending) {
		this.comparators.add(new InvertibleComparator<T>(comparator, ascending));
	}
1213767
protected function updateStatusOrder()
    {
        $this->controlAccess('order_edit');

        $submitted = array('status' => $this->getSubmitted('status'));

        if ($this->order->update($this->data_order['order_id'], $submitted)) {
            $submitted['notify'] = $this->setNotificationUpdateOrder($this->data_order['order_id']);
            $this->logUpdateStatusOrder($submitted);
            $messages = $this->getMassagesUpdateOrder();
            list($severity, $text) = $messages[$submitted['notify']];
            $this->redirect('', $this->text($text), $severity);
        }

        $this->redirect('', $this->text('Order has not been updated'), 'warning');
    }
107721
def ascending(self, name):
        ''' 
        '''
        self.components.append((name, Index.ASCENDING))
        return self
381121
def update_priority(self, tree_idx_list, priority_list):
        
        for tree_idx, priority, segment_tree in zip(tree_idx_list, priority_list, self.segment_trees):
            segment_tree.update(tree_idx, priority)
784409
def visit_raise(self, node, parent):
        """"""
        newnode = nodes.Raise(node.lineno, node.col_offset, parent)
        # pylint: disable=too-many-function-args
        newnode.postinit(
            _visit_or_none(node, "type", self, newnode),
            _visit_or_none(node, "inst", self, newnode),
            _visit_or_none(node, "tback", self, newnode),
        )
        return newnode
1178539
def update_node(self, node, diff=None):
        """"""
        lb = node.parent
        if not lb:
            raise exc.UnattachedNode("No parent Load Balancer for this node "
                    "could be determined.")
        if diff is None:
            diff = node._diff()
        req_body = {"node": diff}
        resp, body = self.api.method_put("/loadbalancers/%s/nodes/%s" %
                (lb.id, node.id), body=req_body)
        return resp, body
289066
public void sortChildrenByNode(Comparator<TreeNode<T>> comparator) {
		Collections.sort(children, comparator);
		for (TreeNode<T> child : children) {
			child.sortChildrenByNode(comparator);
		}
	}
1350958
protected function updateOrderFieldOnRestore()
    {
        static::orderModel()
            ->where($this->getOrderField(), '>', $this->getOrderValue())
            ->increment($this->getOrderField());
    }
278038
def __sort_up(self):
        """"""
        if self.__do_need_sort_up:
            self.__up_objects.sort(self.__up_cmp)
            self.__do_need_sort_up = False
1008527
protected void updateLocaleNodeSorting() {

        // check if the locale nodes require sorting
        List<Locale> locales = new ArrayList<Locale>(m_locales);
        Collections.sort(locales, new Comparator<Locale>() {

            public int compare(Locale o1, Locale o2) {

                return o1.toString().compareTo(o2.toString());
            }
        });
        List<Element> localeNodes = new ArrayList<Element>(m_document.getRootElement().elements());
        boolean sortRequired = false;
        if (localeNodes.size() != locales.size()) {
            sortRequired = true;
        } else {
            int i = 0;
            for (Element el : localeNodes) {
                if (!locales.get(i).toString().equals(el.attributeValue("language"))) {
                    sortRequired = true;
                    break;
                }
                i++;
            }
        }

        if (sortRequired) {
            // do the actual node sorting, by removing the nodes first
            for (Element el : localeNodes) {
                m_document.getRootElement().remove(el);
            }

            Collections.sort(localeNodes, new Comparator<Object>() {

                public int compare(Object o1, Object o2) {

                    String locale1 = ((Element)o1).attributeValue("language");
                    String locale2 = ((Element)o2).attributeValue("language");
                    return locale1.compareTo(locale2);
                }
            });
            // re-adding the nodes in alphabetical order
            for (Element el : localeNodes) {
                m_document.getRootElement().add(el);
            }
        }
    }
1030515
def _update_priority(self, task, prio, worker):
        
        task.priority = prio = max(prio, task.priority)
        for dep in task.deps or []:
            t = self._state.get_task(dep)
            if t is not None and prio > t.priority:
                self._update_priority(t, prio, worker)
660304
def visit_raise(self, node):
        """"""
        if node.exc:
            if node.inst:
                if node.tback:
                    return "raise %s, %s, %s" % (
                        node.exc.accept(self),
                        node.inst.accept(self),
                        node.tback.accept(self),
                    )
                return "raise %s, %s" % (node.exc.accept(self), node.inst.accept(self))
            return "raise %s" % node.exc.accept(self)
        return "raise"