Perform quick transaction. Throws IOError if unsuccessful.
        :param i2c_addr: i2c address
        :type i2c_addr: int
        :param force:
        :type force: Boolean
358160
def write_quick(self, i2c_addr, force=None):
        
        self._set_address(i2c_addr, force=force)
        msg = i2c_smbus_ioctl_data.create(
            read_write=I2C_SMBUS_WRITE, command=0, size=I2C_SMBUS_QUICK)
        ioctl(self.fd, I2C_SMBUS, msg)
857534
@FFDCIgnore(NoSuchMethodException.class)
    private void setRRSTransactional() {
        try {
            ivRRSTransactional = (Boolean) activationSpec.getClass().getMethod("getRRSTransactional").invoke(activationSpec);
        } catch (NoSuchMethodException x) {
            ivRRSTransactional = false;
        } catch (Exception x) {
            ivRRSTransactional = x == null; // always false - avoid a FindBugs warning by using the value of x in some trivial way
        }
    }
194899
def jump(self, addr):
        
        self.inhibit_autoret = True
        self._exit_action(self.state, addr)
        self.successors.add_successor(self.state, addr, self.state.solver.true, 'Ijk_Boring')
843374
void prepareTransaction(HotRodHeader header, Subject subject, XidImpl xid, boolean onePhaseCommit,
         List<TransactionWrite> writes, boolean recoverable, long timeout) {
      HotRodServer.CacheInfo cacheInfo = server.getCacheInfo(header);
      AdvancedCache<byte[], byte[]> cache = server.cache(cacheInfo, header, subject);
      validateConfiguration(cache);
      executor.execute(() -> prepareTransactionInternal(header, cache, cacheInfo.versionGenerator, xid, onePhaseCommit,
                                                        writes, recoverable, timeout));
   }
763190
public <R> R withCommitTransaction(TransFunc<R> transFunc) throws IOException {
    return withTransaction(transFunc, true);
  }
291343
def logical_intf_helper(interface):
    
    if interface is None:
        return LogicalInterface.get_or_create(name='default_eth').href
    elif isinstance(interface, LogicalInterface):
        return interface.href
    elif interface.startswith('http'):
        return interface
    return LogicalInterface.get_or_create(name=interface).href
647883
async def trigger_act(self, *args, addr=None, agent=None, **kwargs):
        '''
        '''
        if agent is None and addr is None:
            raise TypeError("Either addr or agent has to be defined.")
        if agent is None:
            for a in self.get_agents(addr=False):
                if addr == a.addr:
                    agent = a
        self._log(logging.DEBUG, "Triggering agent in {}".format(agent.addr))
        ret = await agent.act(*args, **kwargs)
        return ret
27142
def _process_one_indirect_jump(self, jump):
        

        resolved = False
        resolved_by = None
        targets = None

        block = self._lift(jump.addr, opt_level=1)

        for resolver in self.indirect_jump_resolvers:
            resolver.base_state = self._base_state

            if not resolver.filter(self, jump.addr, jump.func_addr, block, jump.jumpkind):
                continue

            resolved, targets = resolver.resolve(self, jump.addr, jump.func_addr, block, jump.jumpkind)
            if resolved:
                resolved_by = resolver
                break

        if resolved:
            self._indirect_jump_resolved(jump, jump.addr, resolved_by, targets)
        else:
            self._indirect_jump_unresolved(jump)

        return set() if targets is None else set(targets)
808717
def cmp_update_bond_intf(self, bond_interface):
        
        if bond_interface != self.bond_interface:
            self.bond_interface = bond_interface
            self.bond_member_ports = sys_utils.get_member_ports(bond_interface)
            return True
        return False
482979
def transaction(self,implicit = False):
        

        class TransactionManager(object):

            def __init__(self,backend,implicit = False):
                self.backend = backend
                self.implicit =  implicit

            def __enter__(self):
                self.within_transaction = True if self.backend.current_transaction else False
                self.transaction = self.backend.begin()

            def __exit__(self,exc_type,exc_value,traceback_obj):
                if exc_type:
                    self.backend.rollback(self.transaction)
                    return False
                else:
                    #if the transaction has been created implicitly and we are not within
                    #another transaction, we leave it open (the user needs to call commit manually)
                    #if self.implicit and not self.within_transaction:
                    #    return
                    self.backend.commit(self.transaction)

        return TransactionManager(self,implicit = implicit)
859137
def _translate_addr(self, a): #pylint:disable=no-self-use
        
        if isinstance(a, claripy.ast.Base) and not a.singlevalued:
            raise SimFastMemoryError("address not supported")
        return self.state.solver.eval(a)
1251997
def post(self):
        
        parser = reqparse.RequestParser()
        parser.add_argument('mode', type=parameters.valid_mode,
                            default='broadcast_tx_async')
        args = parser.parse_args()
        mode = str(args['mode'])

        pool = current_app.config['bigchain_pool']

        # `force` will try to format the body of the POST request even if the
        # `content-type` header is not set to `application/json`
        tx = request.get_json(force=True)

        try:
            tx_obj = Transaction.from_dict(tx)
        except SchemaValidationError as e:
            return make_error(
                400,
                message='Invalid transaction schema: {}'.format(
                    e.__cause__.message)
            )
        except ValidationError as e:
            return make_error(
                400,
                'Invalid transaction ({}): {}'.format(type(e).__name__, e)
            )

        with pool() as bigchain:
            try:
                bigchain.validate_transaction(tx_obj)
            except ValidationError as e:
                return make_error(
                    400,
                    'Invalid transaction ({}): {}'.format(type(e).__name__, e)
                )
            else:
                status_code, message = bigchain.write_transaction(tx_obj, mode)

        if status_code == 202:
            response = jsonify(tx)
            response.status_code = 202
            return response
        else:
            return make_error(status_code, message)
966928
def quartus_add_interface_port(self, buff: List[str], intfName: str, signal,
                                   logicName: str, packager: "IpCorePackager"):
        
        d = signal._direction
        if d == INTF_DIRECTION.MASTER:
            dir_ = "Output"
        elif d == INTF_DIRECTION.SLAVE:
            dir_ = "Input"
        else:
            raise ValueError(d)

        _, width, _ = packager.getTypeWidth(packager.getInterfaceType(signal), do_eval=True)

        buff.append("add_interface_port %s %s %s %s %s" % (
            intfName,
            packager.getInterfacePhysicalName(signal),
            logicName,
            dir_,
            width
        ))
1321818
def i2c_slave_read(self):
        
        data = array.array('B', (0,) * self.BUFFER_SIZE)
        status, addr, rx_len = api.py_aa_i2c_slave_read_ext(self.handle,
                self.BUFFER_SIZE, data)
        _raise_i2c_status_code_error_if_failure(status)

        # In case of general call, actually return the general call address
        if addr == 0x80:
            addr = 0x00
        del data[rx_len:]
        return (addr, bytes(data))
847
def buildTransaction(self, transaction=None):
        
        if transaction is None:
            built_transaction = {}
        else:
            built_transaction = dict(**transaction)

        if 'data' in built_transaction:
            raise ValueError("Cannot set data in build transaction")

        if not self.address and 'to' not in built_transaction:
            raise ValueError(
                "When using `ContractFunction.buildTransaction` from a contract factory "
                "you must provide a `to` address with the transaction"
            )
        if self.address and 'to' in built_transaction:
            raise ValueError("Cannot set to in contract call build transaction")

        if self.address:
            built_transaction.setdefault('to', self.address)

        if 'to' not in built_transaction:
            raise ValueError(
                "Please ensure that this contract instance has an address."
            )

        return build_transaction_for_function(
            self.address,
            self.web3,
            self.function_identifier,
            built_transaction,
            self.contract_abi,
            self.abi,
            *self.args,
            **self.kwargs
        )
98736
def i2c_write_request(self, address, args):
        
        task = asyncio.ensure_future(self.core.i2c_write_request(address, args))
        self.loop.run_until_complete(task)
1127873
public void forceConnect(SIBUuid8 meUuid) 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "forceConnect", meUuid);
    
    if(_routingManager!=null)
      _routingManager.connectToME(meUuid);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "forceConnect");
  }