Set the logical block number for the parent.

        Parameters:
         bl - Logical block number of the parent.
        Returns:
         Nothing.
168177
def set_log_block_num(self, bl):
        # type: (int) -> None
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('PL record not yet initialized!')

        self.parent_log_block_num = bl
671532
def set_child(self, i, child):
        
        child.parent = self
        self.children[i].parent = None
        self.children[i] = child
        self.changed()
297739
def setFontFamily(self, family):
        
        self.blockSignals(True)
        self.editor().setFontFamily(family)
        self.blockSignals(False)
235202
def binary_operation_logical(self, rule, left, right, **kwargs):
        
        return self.evaluate_binop_logical(rule.operation, left, right, **kwargs)
913851
def set_parent(self, new_site):
        
        if new_site:
            if not isinstance(new_site, Site):
                raise Exception
        self.site = new_site
        self.propagate_data()
        return new_site
1223103
def setparents(self):
        """"""
        for c in self:
            if isinstance(c, AbstractElement):
                c.parent = self
                c.setparents()
368576
def _set_parent(self, parent=None):
        
        if parent is not None:
            if not isinstance(parent, Parentable):
                raise ValueError('Parent object must implement Parentable interface.')
            if parent is self or parent._contains(self):
                raise ValueError('Self references are not allowed.')
        self._parent = parent if parent is not None else None
1283436
def update_blocknumbers(blk)
      loop do
        if blk.number > 0
          @db.put_temporarily block_by_number_key(blk.number), blk.full_hash
        else
          @db.put block_by_number_key(blk.number), blk.full_hash
        end
        @db.commit_refcount_changes blk.number

        break if blk.number == 0

        blk = blk.get_parent()
        break if has_block_by_number(blk.number) && get_block_by_number(blk.number) == blk.full_hash
      end
    end
654401
def set(self, logicalId, resource):
        

        resource_dict = resource
        if isinstance(resource, SamResource):
            resource_dict = resource.to_dict()

        self.resources[logicalId] = resource_dict
996356
def setCurrentNode(self, node):
        
        self.blockSignals(True)
        self.clearSelection()
        if node:
            node.setSelected(True)
        self.blockSignals(False)
593476
def block1(self, value):
        
        option = Option()
        option.number = defines.OptionRegistry.BLOCK1.number
        num, m, size = value
        if size > 512:
            szx = 6
        elif 256 < size <= 512:
            szx = 5
        elif 128 < size <= 256:
            szx = 4
        elif 64 < size <= 128:
            szx = 3
        elif 32 < size <= 64:
            szx = 2
        elif 16 < size <= 32:
            szx = 1
        else:
            szx = 0

        value = (num << 4)
        value |= (m << 3)
        value |= szx

        option.value = value
        self.add_option(option)
970092
def set_circular(self, circular: bool, chain: List[Table] = None) -> None:
        
        self.circular = circular
        self.circular_chain = chain or []
273393
def parent(self, value):
        

        if value is not None:
            assert issubclass(value.__class__, AbstractNode), "'{0}' attribute: '{1}' is not a '{2}' subclass!".format(
                "parent", value, AbstractNode.__class__.__name__)
        self.__parent = value
926387
def set_result(self, rval: bool) -> None:
        
        self.result = rval
        if self.result:
            self.nodes = [pn for pn in self.nodes if pn.result]
570241
public BlockOrder setBlockOrder(BlockOrder order) {
		verifyTrue(order != null, "block order cannot be null");

		if (order == layout.blockOrder) {
			return order; // quick exit, already same
		}

		BlockMatrixLayout newLayout = new BlockMatrixLayout(layout.rows, layout.columns,
				layout.blockStripe, order);

		// swap order of each block
		for (int r = 0; r < layout.rows; r += layout.blockStripe) {
			for (int c = 0; c < layout.columns; c += layout.blockStripe) {

				int blockNumber = layout.getBlockNumber(r, c);
				if (data[blockNumber] == null) {
					continue;
				} else if (order == BlockOrder.ROWMAJOR) {
					data[blockNumber] = layout.toRowMajorBlock(data[blockNumber], r, c);
				} else {
					data[blockNumber] = layout.toColMajorBlock(data[blockNumber], r, c);
				}

			}
		}

		BlockOrder oldLayout = this.layout.blockOrder;
		this.layout = newLayout;
		return oldLayout;

	}
1013894
def set_bounds(self, lb, ub):
        
        if lb is not None and ub is not None and lb > ub:
            raise ValueError(
                "The provided lower bound {} is larger than the provided upper bound {}".format(lb, ub)
            )
        self._lb = lb
        self._ub = ub
        if self.problem is not None:
            self.problem._pending_modifications.var_lb.append((self, lb))
            self.problem._pending_modifications.var_ub.append((self, ub))
842637
def switch(self):
        
        base_block = self.base_block or self
        self.next_block = Block(
            self.parent, base_block=base_block, py3_wrapper=self.py3_wrapper
        )
        return self.next_block