---------------------------------------------------------------- ICE action handers ----------------------------------------------------------------
10715
function (opts, candidate) {
        this._log('info', 'Discovered new ICE candidate', candidate.jingle);
        this.send('transport-info', candidate.jingle);
        if (opts.signalEndOfCandidates) {
            this.lastCandidate = candidate;
        }
    }
380537
function(action) {
		this._updates.filter(function(update) {
			return (
				update.type === edbml.Update.TYPE_HARD ||
				Object.keys(update.ids).every(function(id) {
					return !this._hardupdates[id];
				}, this)
			);
		}, this).forEach(function(update) {
			action(update);
		});
	}
1017452
private JointParsingState.Action getAction(int l, int r, Target targets) {
		if (targets.getHead(l) == r && modifierNumOf(l, targets) == 0)
			return JointParsingState.Action.RIGHT;
		if (targets.getHead(r) == l && modifierNumOf(r, targets) == 0)
			return JointParsingState.Action.LEFT;
		return JointParsingState.Action.SHIFT;
	}
1066687
private List<Action> actionsOf(JsonNode actionNodes) {
        List<Action> actions = new LinkedList<Action>();

        if (actionNodes.isArray()) {
            for (JsonNode action : actionNodes) {
                actions.add(new NamedAction(action.asText()));
            }
        } else {
            actions.add(new NamedAction(actionNodes.asText()));
        }
        return actions;
    }
613583
function reducer() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var action = arguments[1];

    // add initial state
    if (action.type === (0, _.generateType)(_.types.add, (0, _get2.default)(action, 'payload.name'))) {
        return _extends({}, state, _defineProperty({}, action.payload.name, action.payload.state));
    }

    // delete state
    if (action.type === (0, _.generateType)(_.types.delete, (0, _get2.default)(action, 'payload.name'))) {
        var tempState = _extends({}, state);
        delete tempState[action.payload.name];
        return tempState;
    }

    // reset to initial state
    if (action.type === (0, _.generateType)(_.types.reset, (0, _get2.default)(action, 'payload.name'))) {
        return _extends({}, state, _defineProperty({}, action.payload.name, action.payload.state));
    }

    // shallow merge for state updates
    if (action.type === (0, _.generateType)(_.types.set, (0, _get2.default)(action, 'payload.name'))) {
        return (0, _immutabilityHelper2.default)(state,
        // if store not created with combinedReducers, assume state is top-level
        state[action.payload.name] ? _defineProperty({}, action.payload.name, { $merge: action.payload.state }) : { $merge: action.payload.state });
    }

    return state;
}
643570
function callReducers(actionName, actionData) {
    this.reducers.forEach(item => {
        this.state[item.stateKey] = item.reducer(this.state[item.stateKey], actionName, actionData);
    });
}
1131639
function mergeActions(actions, userActions) {
  const overrides = {};
  for (const key in userActions) {
    if (userActions.hasOwnProperty(key) && actions.hasOwnProperty(key)) {
      overrides[key] = userActions[key];
    }
  }

  return {...actions, ...overrides};
}
1212245
private void doAction(List<ActionBlock> actions) throws ActionException {
        try {
            actions.get(nextStep).execute();
        } catch (ActionException e) {
            throw e;
        } catch (Exception e) {
            throw new ActionException("Exception raised by step: " + nextStep, e);
        }
    }
1300885
function createActionArgs (args, action, state, isAsync) {
  var stateMethods = getStateMutatorsAndAccessors(state, action, isAsync);
  return [ args, stateMethods ];
}
573990
function _appendActionToUpdaters(node, actionMap) {
  if (node.members && node.members.static.length) {
    node.members.static = node.members.static.map(nd => _appendActionToUpdaters(nd, actionMap));
  }

  const updater = node.name;

  const action = Object.values(actionMap)
    .find(action => action.updaters.find(up => up.name === updater));

  if (!action) {
    return node;
  }
  const actionName = action.name;

  const mdContent = `
  * __Action__: [${BT}${actionName}${BT}](../actions/actions.md#${actionName.toLowerCase()})
  `;

  return _appendListToDescription(node, mdContent);
}
15306
def hand(opts = {})
      range = Args::CardRange.new(opts[:range], deck_size: size)
      hand  = Args::HandSpecial.new(height).load!(opts, expand_by: size, layout: layout, dpi: dpi)
      sheet = Args::Sheet.new(custom_colors, { file: 'hand.png', trim_radius: 0 }).load!(opts, expand_by: size, layout: layout, dpi: dpi)
      render_hand(range, sheet, hand)
    end
1273122
@Override
    protected void extractAndTakeAction(String timestamp, JSONArray jsonAllRows, List<String> joinFields, RequestType requestType, ActionType action) {
        Map<Object,List<Object>> newBaseAllRows = new LinkedHashMap<>();
        JSONObject eachRow = null;
        for (int i = 0; i < jsonAllRows.length(); i++) {
            JSONObject jsonItem = jsonAllRows.getJSONObject(i);
            eachRow = dataItemAt(jsonItem, requestType, action);
            String actualTimestamp = timestamp;
            if (timestamp == null) {
                if (requestType == RequestType.SELECT) {
                    actualTimestamp = eachRow.optString("timestamp");
                    // Because the timestamp is within each row remove them once you extract it.
                    eachRow.remove("timestamp");
                } else {
                    actualTimestamp = jsonItem.optString("timestamp");
                }
            }
            Tuple2<Object, List<Object>> row = mapPkToRow(actualTimestamp, eachRow, joinFields);
            Object pk = row._1();// Primary key.
            List<Object> rowVal = row._2();
            if (action == ActionType.FIRST_CUT) {// First cut (no join).
                if (pk != null) {//TODO: Only non-nulls will go through. Address this later.
                    baseAllRows.put(pk, rowVal);
                }
            } else {// Some Join action.
                if (pk != null) {//TODO: Only non-nulls will go through. Address this later.
                    if (baseAllRows.containsKey(pk)) {// If any item in set B exist in set A.
                        rowVal.removeAll(splitCompositeKeys(pk.toString()));// Remove key(which is already available in baseAllRows)
                        if (!joinFields.contains("timestamp")) {// If join field is not "timestamp" then remove timestamp data value from to be joined set.
                            rowVal.remove(0);// Because the 1st field is always timestamp.(See extractKeyAndRow() method)
                        }
                        if (action == ActionType.JOIN || action == ActionType.RIGHT_JOIN) {
                            newBaseAllRows.put(pk, baseAllRows.remove(pk));// Remove from existing map and add to new map.
                            newBaseAllRows.get(pk).addAll(rowVal);// Update the new map with partial to be joined data.
                        } else if (action == ActionType.LEFT_JOIN) {// Left join
                            baseAllRows.get(pk).addAll(rowVal);
                        }
                    } else {// For right join we still need to continue with each row in set B.
                        if (action == ActionType.RIGHT_JOIN) {// Right join
                            newBaseAllRows.put(pk, rowVal);
                        }
                    }
                }
            }
            if (i == 0) {// Fill headers (only once)
                fillHeaders(eachRow, joinFields, action);
            }
        }
        if (!newBaseAllRows.isEmpty()) {// For join and right join.
            baseAllRows = newBaseAllRows;
        }
    }
1020572
function acttab_action($lookahead, $action)
    {
        if ($this->nLookahead === 0) {
            $this->aLookahead = array();
            $this->mxLookahead = $lookahead;
            $this->mnLookahead = $lookahead;
            $this->mnAction = $action;
        } else {
            if ($this->mxLookahead < $lookahead) {
                $this->mxLookahead = $lookahead;
            }
            if ($this->mnLookahead > $lookahead) {
                $this->mnLookahead = $lookahead;
                $this->mnAction = $action;
            }
        }
        $this->aLookahead[$this->nLookahead] = array(
            'lookahead' => $lookahead,
            'action' => $action);
        $this->nLookahead++;
    }
457278
def combining_successors(state, last_action=()):
        
        ((corner, edge), (L, U, F, D, R, B)) = state
        U_turns = [Formula("U"), Formula("U'"), Formula("U2")] if len(last_action) != 1 else []
        R_turns = [Formula("R U R'"), Formula("R U' R'"), Formula("R U2 R'")] if "R" not in last_action else []
        F_turns = [Formula("F' U F"), Formula("F' U' F"), Formula("F' U2 F")] if "F" not in last_action else []
        for act in (U_turns + R_turns + F_turns):
            new = (corner, edge)
            for q in act:
                new = F2LPairSolver._rotate(new, q)
            yield act, (new, (L, U, F, D, R, B))
1297888
function transformBranch (action, ...args) {
  return Array.isArray(action) ?
    transformAsyncBranch.apply(null, [action, ...args]) :
    transformSyncBranch.apply(null, [action, ...args]);
}
367789
function frozenWrapper(propType) {
  const checkFrozen = (obj, propName, componentName) => {
    if (!Object.isFrozen(obj)) {
      throw new Error(
        `the property "${propName}" provided to component ` +
        `"${componentName}" is not frozen`
      );
    }
    forEachKeyValue(obj, (name, prop) => {
      const type = typeof obj;
      if (prop !== null && (type === 'object' || type === 'function')) {
        checkFrozen(prop, `${propName}.${name}`, componentName);
      }
    });
  };

  const frozen = (props, propName, componentName, ...rest) => {
    const propValue = props[propName];
    if (!propValue) {
      return null;
    }
    try {
      checkFrozen(propValue, propName, componentName);
    } catch (err) {
      return err;
    }
    return propType(props, propName, componentName, ...rest);
  };
  frozen[SHAPE] = propType[SHAPE];
  return frozen;
}
84485
function(name, action) {
        var handlers = this.__handlers__;

        if (! handlers ||
            ! handlers[name]) {
            return false;
        }
        var hdls = handlers[name];
        for (var i = 0; i < hdls.length; i++) {
            if (hdls[i].action === action) {
                return true;
            }
        }
    }