Store the new start address attribute of the BFD file being
        processed.
503198
def start_address(self, _start_address):
        
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.set_start_address(self._ptr, _start_address)
1215875
def initialize_non_bfd(self, architecture=None, machine=None,
        endian=ENDIAN_UNKNOWN):
        """"""

        if None in [architecture, machine, endian]:
            return

        self.architecture = architecture
        self.machine = machine
        self.endian = endian
397605
private void setToRowStart(RowIndexEntry rowEntry, FileDataInput in) throws IOException
    {
        if (in == null)
        {
            this.file = sstable.getFileDataInput(rowEntry.position);
        }
        else
        {
            this.file = in;
            in.seek(rowEntry.position);
        }
        sstable.partitioner.decorateKey(ByteBufferUtil.readWithShortLength(file));
    }
625147
public void init(Record thisFile, String userIdFieldName, boolean bFirstTimeOnly)
    {
        super.init(thisFile);
        this.userIdFieldName = userIdFieldName;
        m_bFirstTimeOnly = bFirstTimeOnly;
    }
143537
def get_cl_start(self, addr):
        """"""
        return addr >> self.backend.cl_bits << self.backend.cl_bits
751429
def _store_account_address(self, address):
        
        address_key = address_prefix + utils.sha3(address)
        self.wb.put(address_key, address)
286011
def store_initial_arguments(request, initial_arguments=None):
    ''

    if initial_arguments is None:
        return None

    # Generate a cache id
    cache_id = "dpd-initial-args-%s" % str(uuid.uuid4()).replace('-', '')

    # Store args in json form in cache
    if initial_argument_location():
        cache.set(cache_id, initial_arguments, cache_timeout_initial_arguments())
    else:
        request.session[cache_id] = initial_arguments

    return cache_id
978883
def start(self):
        

        if os.isatty(self.fd.fileno()) and self.israw():
            self.original_attributes = termios.tcgetattr(self.fd)
            tty.setraw(self.fd)
1013825
def mark_address(self, addr, size):
        """"""
        i = 0
        while i < size:
            self._register_map[addr] = True
            i += 1
941234
def store_attribute(self, key, value):
        """"""
        if key == 'summary' or key == 'filename' or key == 'previous':
            return
        attr = key.replace('-', '_')
        if key.endswith('-time'):
            value = int(value)
        setattr(self, attr, value)
1284654
def applicable_file_flags(self):
        
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(
            self._ptr, BfdAttributes.APPLICABLE_FILE_FLAGS)
293234
def update_start_position(self):
        ""
        x_start = self.field_array.ScanFieldData.FieldXCoordinate
        y_start = self.field_array.ScanFieldData.FieldYCoordinate

        # empty template have all fields positions set to zero
        # --> avoid overwriting start position
        if x_start != 0 and y_start != 0:
            self.properties.ScanFieldStageStartPositionX = int(x_start * 1e6) # in um
            self.properties.ScanFieldStageStartPositionY = int(y_start * 1e6)
409292
protected void appendCopiesAfter(RoaringArray sa, short beforeStart) {
    int startLocation = sa.getIndex(beforeStart);
    if (startLocation >= 0) {
      startLocation++;
    } else {
      startLocation = -startLocation - 1;
    }
    extendArray(sa.size - startLocation);

    for (int i = startLocation; i < sa.size; ++i) {
      this.keys[this.size] = sa.keys[i];
      this.values[this.size] = sa.values[i].clone();
      this.size++;
    }
  }
87718
def WriteClientStartupInfo(self, client_id, startup_info):
    """"""
    if client_id not in self.metadatas:
      raise db.UnknownClientError(client_id)

    ts = rdfvalue.RDFDatetime.Now()
    self.metadatas[client_id]["startup_info_timestamp"] = ts
    history = self.startup_history.setdefault(client_id, {})
    history[ts] = startup_info.SerializeToString()
1094138
def _get_start_end(self, start=None, end=None, size=None):
        
        if (start,end) == (None,None) and self._buf == {}:
            raise EmptyIntelHexError
        if size is not None:
            if None not in (start, end):
                raise ValueError("tobinarray: you can't use start,end and size"
                                 " arguments in the same time")
            if (start, end) == (None, None):
                start = self.minaddr()
            if start is not None:
                end = start + size - 1
            else:
                start = end - size + 1
                if start < 0:
                    raise ValueError("tobinarray: invalid size (%d) "
                                     "for given end address (%d)" % (size,end))
        else:
            if start is None:
                start = self.minaddr()
            if end is None:
                end = self.maxaddr()
            if start > end:
                start, end = end, start
        return start, end
81106
def _initialise_data(self, memmap_dir=None):
        """"""

        if self.number_values == 0:
            pass
        elif self.data_type.nptype is None:
            self._data = []
        else:
            if memmap_dir:
                memmap_file = tempfile.NamedTemporaryFile(
                    mode='w+b', prefix="nptdms_", dir=memmap_dir)
                self._data = np.memmap(
                    memmap_file.file,
                    mode='w+',
                    shape=(self.number_values,),
                    dtype=self.data_type.nptype)
            else:
                self._data = np.zeros(
                    self.number_values, dtype=self.data_type.nptype)
            self._data_insert_position = 0
        if self._data is not None:
            log.debug("Allocated %d sample slots for %s", len(self._data),
                      self.path)
        else:
            log.debug("Allocated no space for %s", self.path)
209233
def _handle_start_area(self, attrs):
        
        self._curr = {
            'attributes': dict(attrs),
            'tags': {},
            'area_id': None
        }
        if attrs.get('id', None) is not None:
            self._curr['area_id'] = int(attrs['id'])
            del self._curr['attributes']['id']