Gets the last code that was received.
 @return [Array<String>] returns the last code, or raises an error.
 @return [Integer] returns the data length, or raises an error.
 @return [Object] returns the bit count, or raises an error.
160146
def last_code
		data_ffi = ::FFI::MemoryPointer.new(:uchar, 16)
		
		data_length = ::FFI::MemoryPointer.new(:int)
		data_length.write_int(16)

		bit_count = ::FFI::MemoryPointer.new(:int)
		
		Klass.getLastCode(@handle, data_ffi, data_length, bit_count)

		data = []
		
		data_length.get_int(0).times { |i|
			 data << data_ffi[i].get_uchar(0).to_s(16)
		}
		
      [data, data_length.get_int(0), bit_count.get_int(0)]

    end
1135262
def result
      line = @sock.gets
      debug "< #{line}" if @debug
      raise Errno::ECONNRESET, "No response" unless line
      chr = line[0]
      if chr == '+'
        line[1..-1].strip
      elsif chr == '$'
        count = line[1..-1].strip.to_i
        return nil if count == -1
        data = @sock.read(count) if count > 0
        line = @sock.gets # read extra linefeeds
        data
      elsif chr == '-'
        # Server can respond with:
        #
        # -ERR Something unexpected
        # We raise a CommandError
        #
        # -NOTUNIQUE Job not unique
        # We return ["NOTUNIQUE", "Job not unique"]
        err = line[1..-1].split(" ", 2)
        raise CommandError, err[1] if err[0] == "ERR"
        err
      else
        # this is bad, indicates we need to reset the socket
        # and start fresh
        raise ParseError, line.strip
      end
    end
1261134
def split_get_last(str_to_split, character, index = 0)
      arrtmp = str_to_split.split(character)
      if index == -1
        arrtmp
      else
        index = index == 0 ? arrtmp.length - 1 : index
        strtmp = arrtmp[index]
        strtmp
      end
    end
12745
def get_byte_length(self, decoded=True) -> int:
        
        end = len(self.decoded_bits) if decoded else len(self.__plain_bits)
        end = self.convert_index(end, 0, 2, decoded=decoded)[0]
        return int(end)
880419
public function get_last_error() {
        $error = false;
        // First look for any previously saved stmt error
        if (!empty($this->last_stmt_error)) {
            $error = $this->last_stmt_error;
            $this->last_stmt_error = null;
        } else { // Now try connection error
            $e = oci_error($this->oci);
            if ($e !== false) {
                $error = $e['message'];
            }
        }
        return $error;
    }
606623
public function getLastMessage()
    {
        $filename = $this->getTempFilename();

        if (file_exists($filename)) {
            $result = unserialize(file_get_contents($filename));
        } else {
            throw new Swift_IoException('No last message found in "' . $filename . '" - did you call send()?');
        }

        return $result;
    }
488048
public int getLast()
  {
    if (isEmpty()) {
      return -1;
    }

    int last = 0;
    for (int i = 0; i <= lastWordIndex; i++) {
      int w = words.get(i);
      if (ConciseSetUtils.isLiteral(w)) {
        last += ConciseSetUtils.MAX_LITERAL_LENGTH;
      } else {
        last += ConciseSetUtils.maxLiteralLengthMultiplication(ConciseSetUtils.getSequenceCount(w) + 1);
      }
    }

    int w = words.get(lastWordIndex);
    if (ConciseSetUtils.isLiteral(w)) {
      last -= Integer.numberOfLeadingZeros(ConciseSetUtils.getLiteralBits(w));
    } else {
      last--;
    }
    return last;
  }
526991
public static function lastErrorMsg()
    {
        if (is_string(self::$error)) {
            return self::$error;
        }

        switch (self::$error) {
            case 0:
                $msg = 'No Error';
                break;

            case self::EXISTS:
                $msg = 'The target path "' . self::$target . '" already exists';
                break;

            case self::IS_LINK:
                $msg = 'The target path "' . self::$target . '" is a symbolic link';
                break;

            case self::NOT_FOUND:
                $msg = 'The target path "' . self::$target . '" does not appear to exist';
                break;

            case self::NOT_DIRECTORY:
                $msg = 'The target path "' . self::$target . '" does not appear to be a folder';
                break;

            case self::NOT_GRAV_ROOT:
                $msg = 'The target path "' . self::$target . '" does not appear to be a Grav instance';
                break;

            case self::ZIP_OPEN_ERROR:
                $msg = 'Unable to open the package file';
                break;

            case self::ZIP_EXTRACT_ERROR:
                $msg = 'Unable to extract the package. ';
                if (self::$error_zip) {
                    switch(self::$error_zip) {
                        case \ZipArchive::ER_EXISTS:
                            $msg .= 'File already exists.';
                            break;

                        case \ZipArchive::ER_INCONS:
                            $msg .= 'Zip archive inconsistent.';
                            break;

                        case \ZipArchive::ER_MEMORY:
                            $msg .= 'Memory allocation failure.';
                            break;

                        case \ZipArchive::ER_NOENT:
                            $msg .= 'No such file.';
                            break;

                        case \ZipArchive::ER_NOZIP:
                            $msg .= 'Not a zip archive.';
                            break;

                        case \ZipArchive::ER_OPEN:
                            $msg .= "Can't open file.";
                            break;

                        case \ZipArchive::ER_READ:
                            $msg .= 'Read error.';
                            break;

                        case \ZipArchive::ER_SEEK:
                            $msg .= 'Seek error.';
                            break;
                    }
                }
                break;

            case self::INVALID_SOURCE:
                $msg = 'Invalid source file';
                break;

            default:
                $msg = 'Unknown Error';
                break;
        }

        return $msg;
    }
770757
@Override
    public int last() {
        fCachedBreakPositions = null;
        fDictionaryCharCount = 0;
        fPositionInCache = 0;

        if (fText == null) {
            fLastRuleStatusIndex  = 0;
            fLastStatusIndexValid = true;
            return BreakIterator.DONE;
        }

        // t.last() returns the offset of the last character,
        // rather than the past-the-end offset
        // so a loop like for(p=it.last(); p!=DONE; p=it.previous()) ...
        // will work correctly.
        fLastStatusIndexValid = false;
        int pos = fText.getEndIndex();
        fText.setIndex(pos);
        return pos;
    }
1273906
def last(self):
        
        if self.type == HoloMap:
            last_items = [(k, v.last if isinstance(v, HoloMap) else v)
                          for (k, v) in self.data.items()]
        else:
            last_items = self.data
        return self.clone(last_items)
431173
def get_bits need
    val = @bit_bucket
    while @bit_count < need
      val |= (@input_buffer[@in_pos+=1] << @bit_count)
      @bit_count += 8
    end

    @bit_bucket = val >> need
    @bit_count -= need
    val & ((1 << need) - 1)
  end
321314
public function getLastError(): string
    {
        if ($this->isConnected() && $this->socket) {
            $err = @socket_last_error($this->socket);
            if ($err) {
                $err = socket_strerror($err);
            }
            if (!$err) {
                $err = 'Unknown error';
            }
            return $err;
        } else {
            return 'Not connected';
        }
    }
706466
def last(self):
        """"""
        with self.lock:
            try:
                return self.data[-1][0]
            except IndexError as ex:
                ex.args = ('DEPQ is empty',)
                raise
450229
public int getReturnCode() {
        long returnCode = this.stagingByteBuffer.getLong(RETURN_CODE_INDEX * 8);
        if (returnCode > Integer.MAX_VALUE) {
            AsyncException ae = new AsyncException("Return code value invalid");
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Invalid value returned for return code, exception: " + ae.getMessage());
            }
            FFDCFilter.processException(ae, getClass().getName(), "227", this);
            return Integer.MAX_VALUE;
        }
        return (int) returnCode;
    }
607447
function last(array) {
      var length = array == null ? 0 : array.length;
      return length ? array[length - 1] : undefined$1;
    }
1091352
def erlang_inspect(raw = false)
      return Erlang.inspect(Erlang::Binary.new(@data), raw: raw) if @bits == 8
      result = '<<'
      bytes = @data.bytes
      if last = bytes.pop
        result << bytes.join(',')
        result << ',' if not bytes.empty?
        if @bits == 8
          result << "#{last}"
        else
          result << "#{last}:#{@bits}"
        end
      end
      result << '>>'
      return result
    end
433907
def get_raw(self):
        
        code_raw = self.code.get_raw()
        self.insns_size = (len(code_raw) // 2) + (len(code_raw) % 2)

        buff = bytearray()
        buff += pack("<H", self.registers_size) + \
                pack("<H", self.ins_size) + \
                pack("<H", self.outs_size) + \
                pack("<H", self.tries_size) + \
                pack("<I", self.debug_info_off) + \
                pack("<I", self.insns_size) + \
                code_raw

        if self.tries_size > 0:
            if (self.insns_size % 2 == 1):
                buff += pack("<H", self.padding)

            for i in self.tries:
                buff += i.get_raw()
            buff += self.handlers.get_raw()

        return buff