Attempts to label this invoice with a status. Note that an invoice can be more than one of the choices.
			We just set a priority on which status appears.
1941
def status(self):
		

		if self.paid:
			return self.STATUS_PAID
		if self.forgiven:
			return self.STATUS_FORGIVEN
		if self.closed:
			return self.STATUS_CLOSED
		return self.STATUS_OPEN
154628
def __priority(self, pr, repo, pkg):
        
        if (pr[0] == repo and pr[1].startswith("*") and
                pr[1].endswith("*")):
            if pr[1][1:-1] in pkg:
                self.black.append(self.__add(repo, pkg))
        elif pr[0] == repo and pr[1].endswith("*"):
            if pkg.startswith(pr[1][:-1]):
                self.black.append(self.__add(repo, pkg))
        elif pr[0] == repo and pr[1].startswith("*"):
            if pkg.endswith(pr[1][1:]):
                self.black.append(self.__add(repo, pkg))
        elif pr[0] == repo and "*" not in pr[1]:
            self.black.append(self.__add(repo, pkg))
45600
def check_labels(self):
        
        for entry in self.labels:
            self.check_is_declared(entry.name, entry.lineno, CLASS.label)
698053
def add_status_line(self, label):
        
        status_line = StatusBar(label,
                                self._sep_start, self._sep_end,
                                self._fill_char)
        self._lines.append(status_line)
        return status_line
1036060
def decide(self, package):  # type: (Package) -> None
        
        # When we make a new decision after backtracking, count an additional
        # attempted solution. If we backtrack multiple times in a row, though, we
        # only want to count one, since we haven't actually started attempting a
        # new solution.
        if self._backtracking:
            self._attempted_solutions += 1

        self._backtracking = False
        self._decisions[package.name] = package

        self._assign(
            Assignment.decision(package, self.decision_level, len(self._assignments))
        )
293584
def ok(self, *msg):
        
        label = colors.green("OK")
        self._msg(label, *msg)
321242
function (args) {
                args.HasError = false;
                args.ErrorMessage = "";

                if (this.Items !== undefined && this.Items.length === 0) {
                    args.HasError = true;
                    args.ErrorMessage = "At least one item must be on invoice.";
                    args.TranslateArgs = { TranslateId: "AnyItem", MessageArgs: undefined };
                    return;
                }
            }
572971
protected void setPriority(int priority)
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "setPriority", ""+priority);
      this.priority = priority;
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "setPriority");      
   }
243928
def set_status(self, name, text='', row=0, fg='black', bg='white'):
        ''''''
        if self.is_alive():
            self.parent_pipe_send.send(Value(name, text, row, fg, bg))
1339454
public void addSort(Object object, int sort, int priority) {
        key.addPrimitiveValue(String.format(SORT_LABEL, priority), object, sort, priority);
    }
888834
def status
      {
        :extended   => get_if_handleable(raw[:extended_status_message]),
        :code       => raw[:status_code].to_i,
        :message    => get_if_handleable(raw[:status_message]),
        :updated_at => get_if_handleable(raw[:status_update_date])
      }.reject { |k, v| v.nil? }
    end
1072904
def set_status(self, new_status, notes=None):
        ''''''
        self.status_id = new_status
        try:
            self.status['id'] = self.status_id
            # We don't have the id to name mapping, so blank the name
            self.status['name'] = None
        except:
            pass
        self.save(notes)
186374
void checkPinBoxesAvailableOrder() {

        int index = -1;
        for (int i = 0; i < mNumberPinBoxes; i++) {
            if (pinBoxIsEmpty(i)) {
                index = i;
                break;
            }
        }
        chooseNextAction(index);
    }
895732
def check_stoplimit_prices(price, label):
    
    try:
        if not isfinite(price):
            raise BadOrderParameters(
                msg="Attempted to place an order with a {} price "
                    "of {}.".format(label, price)
            )
    # This catches arbitrary objects
    except TypeError:
        raise BadOrderParameters(
            msg="Attempted to place an order with a {} price "
                "of {}.".format(label, type(price))
        )

    if price < 0:
        raise BadOrderParameters(
            msg="Can't place a {} order with a negative price.".format(label)
        )
449829
def get_choice_status(self):
        
        if 'choiceInfo' not in self.dto[self.name]:
            raise GPException('not a choice parameter')

        status = self.dto[self.name]['choiceInfo']['status']
        return status['message'], status['flag']
29675
def p_labelled_statement(self, p):
        """"""
        p[0] = self.asttypes.Label(identifier=p[1], statement=p[3])
        p[0].setpos(p, 2)
899205
def admin_line_item_status_options
      arr = ['pending', 'ready to ship', 'shipped', 'backordered', 'canceled']
      options = []
      arr.each do |status|
        options << {
          :value => status,
          :text  => status
        }
      end
      render :json => options
    end