Returns tru if another round depends on a round using this export code

@param string $exportCode
@param array $roundsData
@return boolean
343153
protected function checkRequired($exportCode, array $roundsData)
    {
        // First find rounds using this export code
        $rounds = array();
        foreach ($roundsData as $roundData) {
            if ($roundData['survey_export_code'] == $exportCode) {
                $rounds[$roundData['gro_id_order']] = $roundData['gro_id_order'];
            }
        }

        if (! $rounds) {
            return false;
        }

        // The check for any round using such a round
        foreach ($roundsData as $roundData) {
            if (isset($roundData['gro_valid_after_source'], $roundData['valid_after'])) {
                if ($this->checkSourceRequired(
                        $roundData['gro_valid_after_source'],
                        $roundData['valid_after'],
                        $rounds
                        )) {
                    return true;
                }
            }
            if (isset($roundData['gro_valid_after_source'], $roundData['valid_for'])) {
                if ($this->checkSourceRequired(
                        $roundData['gro_valid_for_source'],
                        $roundData['valid_for'],
                        $rounds
                        )) {
                    return true;
                }
            }
        }
        return false;
    }
303050
public function getRoundChangedEvent($roundId)
    {
        $this->_ensureRounds();

        if (isset($this->_rounds[$roundId]['gro_changed_event']) && $this->_rounds[$roundId]['gro_changed_event']) {
            return $this->events->loadRoundChangedEvent($this->_rounds[$roundId]['gro_changed_event']);
        }
    }
626639
public static function getSubUnit($currencyCode)
    {
        $subunits = static::getCurrencyData($currencyCode)['sub_unit'];
        if (!is_int($subunits)) {
            throw new UnexpectedValueException(sprintf(
                'The currency sub-units value must be an integer; "%s" given',
                is_object($subunits) ? get_class($subunits) : gettype($subunits)
            ));
        }
        if ($subunits < 1) {
            throw new UnexpectedValueException(sprintf(
                'The currency sub-units value must be greater than 1; "%s" given',
                $subunits
            ));
        }
        return $subunits;
    }
41428
public final void roundsd(XMMRegister dst, XMMRegister src, Immediate imm8)
  {
    emitX86(INST_ROUNDSD, dst, src, imm8);
  }
758636
public function hasDataGrid(string $code): bool
    {
        return array_key_exists($code, $this->dataGrids) || array_key_exists($code, $this->dataGridConfigurations);
    }
1363733
public function execute($lineNr = null, $forRoundOrder = null, $usesRoundRound = null, $roundField = null)
    {
        $batch  = $this->getBatch();
        $import = $batch->getVariable('import');

        if (! (isset($import['trackId']) && $import['trackId'])) {
            // Do nothing
            return;
        }

        if (isset($import['roundOrders'][$usesRoundRound]) &&
                $import['roundOrders'][$usesRoundRound]) {

            $this->db->update(
                    'gems__rounds',
                    array($roundField => $import['roundOrders'][$usesRoundRound]),
                    $this->db->quoteInto("gro_id_order = ? AND ", $forRoundOrder) .
                        $this->db->quoteInto("gro_id_track = ?", $import['trackId'])
                    );
        }
    }
929824
private function round($amount, $rounding_mode)
    {
        $this->assertRoundingMode($rounding_mode);

        if ($rounding_mode === self::ROUND_UP) {
            return $this->getCalculator()->ceil($amount);
        }

        if ($rounding_mode === self::ROUND_DOWN) {
            return $this->getCalculator()->floor($amount);
        }

        return $this->getCalculator()->round($amount, $rounding_mode);
    }
529351
public function getRounds()
    {
        $this->_ensureRounds();

        foreach ($this->_rounds as $roundId => $roundData) {
            if (! isset($this->_roundObjects[$roundId])) {
                $this->_roundObjects[$roundId] = $this->tracker->createTrackClass('Round', $roundData);
            }
        }
        return $this->_roundObjects;
    }
368690
protected function getSurveyId($roundId)
    {
       $this->_ensureRounds();
       if (isset($this->_rounds[$roundId]['gro_id_survey'])) {
           return $this->_rounds[$roundId]['gro_id_survey'];
       }

       throw new \Gems_Exception_Coding("Requested non existing survey id for round $roundId.");
    }
593188
public function getSeconds($round_method = null)
    {
        $result = $this->interval / 1000;

        return $this->round($result, $round_method);
    }
1331864
public static function isValidCode($code)
    {
        if (array_key_exists($code, self::getInfoForCurrencies())) {
            return true;
        } elseif (array_key_exists($code, self::getInfoForCurrenciesWithoutCurrencyCode())) {
            return true;
        } elseif (array_key_exists($code, self::getInfoForCurrenciesWithUnofficialCode())) {
            return true;
        } elseif (array_key_exists($code, self::getInfoForCurrenciesWithHistoricalCode())) {
            return true;
        } else {
            return false;
        }
    }
495859
public function execute($roundId = null, $roundDescription = null)
    {
        $batch  = $this->getBatch();

        if ($batch->hasVariable('trackEngine')) {
            $trackEngine = $batch->getVariable('trackEngine');
            if ($trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) {

                $model = $trackEngine->getRoundModel(true, 'delete');

                $roundData['gro_id_round'] = $roundId;
                $roundData['gro_active']   = 0;
                $roundData = $model->save($roundData);

                $batch->addMessage(sprintf(
                        $this->_('Deactivated round %s.'),
                        ($roundDescription ? $roundDescription : $roundId)
                        ));
            }
        }
    }
868340
function getMinWlByRoundIndex(conn, roundIndex, callback){
    conn.query(
		"SELECT min_wl FROM round where round_index=?", 
        [roundIndex],
		function(rows){
			if (rows.length !== 1)
                throw Error("Can not find the right round index");
            callback(rows[0].min_wl);
		}
	);
}
555160
private function _binaryXor($left, $round)
    {
        $xOr = gmp_xor(
            gmp_init($left, 2),
            gmp_init($round, 2)
        );

        $bin = gmp_strval($xOr, 2);

        return str_pad($bin, $this->sideSize, '0', STR_PAD_LEFT);
    }
719608
public function getUsedQuotaMB($round = 2) {
		$size = 0;

		foreach($this->Environments() as $environment) {
			foreach($environment->DataArchives()->filter('IsBackup', 0) as $archive) {
				$size += $archive->ArchiveFile()->getAbsoluteSize();
			}
		}

		// convert bytes to megabytes and round
		return round(($size / 1024) / 1024, $round);
	}
1032524
function (a, b, bounds, useLastCode) {
		var codeA = useLastCode ? this._lastCode : this._getBitCode(a, bounds),
		    codeB = this._getBitCode(b, bounds),

		    codeOut, p, newCode;

		// save 2nd code to avoid calculating it on the next segment
		this._lastCode = codeB;

		while (true) {
			// if a,b is inside the clip window (trivial accept)
			if (!(codeA | codeB)) {
				return [a, b];
			// if a,b is outside the clip window (trivial reject)
			} else if (codeA & codeB) {
				return false;
			// other cases
			} else {
				codeOut = codeA || codeB;
				p = this._getEdgeIntersection(a, b, codeOut, bounds);
				newCode = this._getBitCode(p, bounds);

				if (codeOut === codeA) {
					a = p;
					codeA = newCode;
				} else {
					b = p;
					codeB = newCode;
				}
			}
		}
	}
973660
public function getRoundCode($roundId)
    {
        $this->_ensureRounds();
        $roundCode = null;

        if (array_key_exists($roundId, $this->_rounds) && array_key_exists('gro_code', $this->_rounds[$roundId])) {
            $roundCode = $this->_rounds[$roundId]['gro_code'];
        }

        return $roundCode;
    }