Returns a C{DWORD} from a given offset. 
        
        @type offset: int
        @param offset: The offset to get the C{DWORD} from.
        
        @rtype: L{DWORD}
        @return: The L{DWORD} obtained at the given offset.
968370
def getDwordAtOffset(self, offset):
        
        return datatypes.DWORD.parse(utils.ReadData(self.getDataAtOffset(offset,  4)))
818647
def get_offset_with_default(cursor=None, default_offset=0):
    '''
    
    '''
    if not is_str(cursor):
        return default_offset

    offset = cursor_to_offset(cursor)
    try:
        return int(offset)
    except:
        return default_offset
580111
def getQwordAtOffset(self, offset):
        
        return datatypes.QWORD.parse(utils.ReadData(self.getDataAtOffset(offset,  8)))
1118587
def offset_to_line(self, offset):
    
    offset = max(0, min(self._text_len, offset))
    line_index = bisect.bisect_right(self._line_offsets, offset) - 1
    return (line_index + 1, offset - self._line_offsets[line_index])
585398
def seek(self, offset: int = 0, *args, **kwargs):
        

        return self.fp.seek(offset, *args, **kwargs)
1179732
def offset(self, offset: int) -> "QuerySet":
        
        queryset = self._clone()
        queryset._offset = offset
        if self.capabilities.requires_limit and queryset._limit is None:
            queryset._limit = 1000000
        return queryset
458429
private int readNext(byte[] dest, int offset, int len)
            throws IOException
    {
        int readBytes = 0;
        while (readBytes < len) {
            int ret = in.read(dest, readBytes + offset, len - readBytes);
            if (ret == -1) {
                finishedReading = true;
                return readBytes;
            }
            readBytes += ret;
        }
        return readBytes;
    }
1072314
@Override
    public V get(String s, int offset, int len) {
        int t = 0;
        for (int i = 0; i < len; i++) {
            char c = s.charAt(offset + i);
            int index = __lookup[c & 0x7f];
            if (index >= 0) {
                int idx = t * ROW_SIZE + index;
                t = _rowIndex[idx];
                if (t == 0)
                    return null;
            } else {
                char[] big = _bigIndex == null ? null : _bigIndex[t];
                if (big == null)
                    return null;
                t = big[c];
                if (t == 0)
                    return null;
            }
        }
        return _value[t];
    }
889894
def get(i)
      check_range(i)
      w = self.word_index(i)

      (@words[w] & (1 << i % BITS_PER_WORD)) != 0
    end
911761
private static char decodeChar(char c, int offset) {
		int position = (table.indexOf(c) - offset) % 52;
		if (position < 0) {
			position += 52;
		}
		return table.charAt(position);
	}
1205099
def parse(cls, buff, offset):
        
        primitive_struct = struct.Struct("!" + cls.fmt)

        value = primitive_struct.unpack_from(buff, offset)[0]
        offset += primitive_struct.size

        return value, offset
74719
def match_string(self, string, word=0, offset=0):
        
        if word:
            return self.get_string(offset) == string
        return self.get_length(len(string), offset) == string
620515
def _get_offset(self):
        
        sx, sxy, syx, sy, ox, oy = self.transformation
        return (ox, oy)
103327
public synchronized long lookup(long offset) {
    Map.Entry<Long, Long> entry = terms.floorEntry(offset);
    return entry != null ? entry.getValue() : 0;
  }
224258
def readWord(self):
        
        word = unpack(self.endianness + ('H' if not self.signed else 'h'), self.readAt(self.offset, 2))[0]
        self.offset += 2
        return word
943710
def from_offset(tu, file, offset):
        
        return conf.lib.clang_getLocationForOffset(tu, file, offset)
387092
public static boolean parseReturningKeyword(final char[] query, int offset) {
    if (query.length < (offset + 9)) {
      return false;
    }

    return (query[offset] | 32) == 'r'
        && (query[offset + 1] | 32) == 'e'
        && (query[offset + 2] | 32) == 't'
        && (query[offset + 3] | 32) == 'u'
        && (query[offset + 4] | 32) == 'r'
        && (query[offset + 5] | 32) == 'n'
        && (query[offset + 6] | 32) == 'i'
        && (query[offset + 7] | 32) == 'n'
        && (query[offset + 8] | 32) == 'g';
  }