Get the offsets as an integer
963644
function getOffset(offset) {

            var symbol = offset.charAt(0);
            var time = offset.substring(1).split(':');
            var hours = Number.parseInt(time[0], 10) * 60;
            var minutes = Number.parseInt(time[1], 10);
            var total = Number.parseInt(symbol + (hours + minutes));

            return total;

        }
480822
function getOffsetValues(start, length, correction) {
    var adapter = this.adapter;
    var values = [];

    correction += (start * 2); // offset the positioning query

    for (var i = 0; i < length; i++) {
      values.push(adapter.at((i * 2) + correction));
    }

    return values;
  }
893880
function getOffset(state) {
    const { items, index } = state;
    if (!items.length) {
        return 0;
    }
    return Math.min(items[index].left, getMaxOffset(state)) || 0;
}
500713
def offset(self):
    """"""
    if not self._registry_key and self._registry:
      self._GetKeyFromRegistry()

    if not self._registry_key:
      return None

    return self._registry_key.offset
759598
private int getOffset(int x, int y) {
    return (y < x) ? (triangleSize(x) + y) : (triangleSize(y) + x);
  }
962935
def get_offset(cls, info):
        

        assert info.layer == 3

        if info.version == 1:
            if info.mode != 3:
                return 36
            else:
                return 21
        else:
            if info.mode != 3:
                return 21
            else:
                return 13
854165
function getOffset() {
      var indentation = []
      var pos = line + 1

      // Done.  Called when the last character is eaten to retrieve the range’s
      // offsets.
      return function() {
        var last = line + 1

        while (pos < last) {
          indentation.push((offset[pos] || 0) + 1)

          pos++
        }

        return indentation
      }
    }
1213458
def p_reference_variable_array_offset(p):
    ''
    p[0] = ast.ArrayOffset(p[1], p[3], lineno=p.lineno(2))
1256823
def _get_offset(cmd):
    """"""
    dict_offset = cmd.dictionary_page_offset
    data_offset = cmd.data_page_offset
    if dict_offset is None or data_offset < dict_offset:
        return data_offset
    return dict_offset
1260757
def offset(self, offset):
        
        query = self._copy()
        query._offset = offset
        return query
505021
def width_at_offset(self, n):
        """"""
        #TODO make more efficient?
        width = wcswidth(self.s[:n])
        assert width != -1
        return width
1007081
def offset(self, n):
        

        idx = self.index
        if idx is not None:
            sibling = idx + n
            container = self.container
            if 0 <= sibling < len(container):
                return container[sibling]
187036
private function parseOffset($offset)
    {
        if ($offset === 'null') {
            $offset = 0;
        } elseif (is_numeric($offset)) {
            $offset = (int) $offset;
        }

        return $offset;
    }
1301085
def leftAt(self, offset=0):
        
        return Location(self.getX() + offset, self.getY() + (self.getH() / 2))
1261127
public static int getIntLE(final byte[] array, final int offset) {
    return  ( array[offset    ] & 0XFF       )
          | ((array[offset + 1] & 0XFF) <<  8)
          | ((array[offset + 2] & 0XFF) << 16)
          | ((array[offset + 3] & 0XFF) << 24);
  }
1325389
def set_offset(self, offset):
        

        if not isinstance(offset, int) or offset < 0:
            raise DaftException("Offset should be a positive integer.")

        self._offset = str(offset)
869525
def p_encaps_var_dollar_curly_array_offset(p):
    ''
    p[0] = ast.ArrayOffset(ast.Variable('$' + p[2], lineno=p.lineno(2)), p[4],
                           lineno=p.lineno(3))