text:
<?php

namespace Athorrent\Ipc\Socket;

use Athorrent\Utils\ServiceUnavailableException;

class UnixSocketClient extends UnixSocket implements ClientSocketInterface
{
    public function __construct($path)
    {
        $this->socket = socket_create(AF_UNIX, SOCK_STREAM, 0);

        if (!socket_connect($this->socket, $path)) {
            throw new ServiceUnavailableException('SERVICE_NOT_RUNNING');
        }
    }

    public function read(&$buffer, $length): int
    {
        $bytesRead = socket_recv($this->socket, $buffer, $length, 0);

        if ($bytesRead === false) {
            $bytesRead = -1;
        }

        return $bytesRead;
    }

    public function write($buffer, $length): int
    {
        $bytesWritten = socket_send($this->socket, $buffer, $length, 0);

        if ($bytesWritten === false) {
            $bytesWritten = -1;
        }

        return $bytesWritten;
    }
}


text:
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**data** | [**ACActionArray***](ACActionArray.md) |  | [optional]
**ddid** | **NSString*** | Destination Device ID. | [optional]
**sdid** | **NSString*** | Destination Device ID. | [optional]
**ts** | **NSNumber*** | Timestamp (past, present or future). Defaults to current time if not provided. | [optional]
**type** | **NSString*** | Type - action. | [optional] [default to @"action"]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

redpajama_set_name: RedPajamaGithub


text:
'use strict';

// MODULES //

var dispatch = require( '@stdlib/strided/dispatch' );
var unary = require( '@stdlib/strided/base/unary' ).ndarray;
var resolve = require( '@stdlib/strided/base/dtype-resolve-enum' );
var types = require( './types.json' );
var meta = require( './meta.json' );
var data = require( './data.js' );

// VARIABLES //

var fcn = dispatch( unary, types, data, meta.nargs+meta.nin+meta.nout, meta.nin, meta.nout ); // eslint-disable-line max-len

// MAIN //

/**
* Computes the principal square root for each element in a strided array `x` and assigns the results to elements in a strided array `y`.
*
* @param {integer} N - number of indexed elements
* @param {*} dtypeX - `x` data type
* @param {Collection} x - input array
* @param {integer} strideX - `x` stride length
* @param {NonNegativeInteger} offsetX - starting `x` index
* @param {*} dtypeY - `y` data type
* @param {Collection} y - destination array
* @param {integer} strideY - `y` stride length
* @param {NonNegativeInteger} offsetY - starting `y` index
* @throws {TypeError} first argument must be an integer
* @throws {TypeError} third argument must be an array-like object
* @throws {TypeError} fourth argument must be an integer
* @throws {TypeError} fifth argument must be a nonnegative integer
* @throws {TypeError} seventh argument must be an array-like object
* @throws {TypeError} eighth argument must be an integer
* @throws {TypeError} ninth argument must be a nonnegative integer
* @throws {Error} insufficient arguments
* @throws {Error} too many arguments
* @throws {RangeError} third argument has insufficient elements based on the associated stride and the number of indexed elements
* @throws {RangeError} seventh argument has insufficient elements based on the associated stride and the number of indexed elements
* @throws {TypeError} unable to resolve a strided array function supporting the provided array argument data types
* @returns {Collection} `y`
*
* @example
* var Float64Array = require( '@stdlib/array/float64' );
*
* var x = new Float64Array( [ 0.0, 4.0, 9.0, 12.0, 24.0 ] );
* var y = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
*
* sqrt( x.length, 'float64', x, 1, 0, 'float64', y, 1, 0 );
* // y => <Float64Array>[ 0.0, 2.0, 3.0, ~3.464, ~4.899 ]
*/
function sqrt( N, dtypeX, x, strideX, offsetX, dtypeY, y, strideY, offsetY ) {
	return fcn( N, resolve( dtypeX ), x, strideX, offsetX, resolve( dtypeY ), y, strideY, offsetY ); // eslint-disable-line max-len
}

// EXPORTS //

module.exports = sqrt;


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycologia 23: 299 (1931)

#### Original name
Tilletia paspali Zundel

### Remarks
null


text:
<?php

namespace Szymon\TurniejBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Component\HttpFoundation\Request;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Szymon\TurniejBundle\Entity\Grupa;
use Szymon\TurniejBundle\Entity\Turniej;
use Szymon\TurniejBundle\Lib\NazwyGrup;

/**
 * @Route("/grupy")
 *
 * @author Szymon Habela
 */
class GrupaController extends Controller
{
	/**
	 * @Route("/", name="grupy")
	 * @Template()
	 */
	public function grupyAction()
	{
		$turniej = $this->get('turniej')->getCurrentTurniej();
		if($turniej == null) {
			return $this->redirect($this->generateUrl('SzymonTurniejBudnle:Turniej:wybierzTurniej'));
		}

		return array(
			'turniej' => $turniej
		);
	}

	/**
	 * @Route("/reset", name="reset")
	 * @Template("SzymonTurniejBundle:Grupa:grupy.html.twig")
	 */
	public function resetAction(Request $request)
	{
		$turniej = $this->get('turniej')->getCurrentTurniej();
		if($turniej == null) {
			return $this->forward('SzymonTurniejBundle:Turniej:wybierzTurniej');
		}
		if($turniej == null) {
			return $this->redirect($this->generateUrl('SzymonTurniejBudnle:Turniej:wybierzTurniej'));
		}

		if($request->isMethod('post')) {
			$em = $this->getDoctrine()->getManager();
			$grupy = $turniej->getGrupy();
			$turniej->setSposobPrzyporzadkowania(null);

			foreach($grupy as $grupa) {
				$em->remove($grupa);
			}
			$em->flush();
		}

		return array(
			'turniej' => $turniej
		);
	}

	/**
	 * @Route("/recznie", name="recznie")
	 * @Template("SzymonTurniejBundle:Grupa:rozmiesc.html.twig")
	 */
	public function recznieAction(Request $request) {
		$turniej = $this->get('turniej')->getCurrentTurniej();
		if($turniej == null) {
			return $this->forward('SzymonTurniejBundle:Turniej:wybierzTurniej');
		}

		if($request->isMethod('post')) {
			if($turniej->getRunda() == 0) {
				$grupa = $request->request->get('grupa');

				$em = $this->getDoctrine()->getManager();
				$zr = $this->getDoctrine()->getRepository('SzymonTurniejBundle:Zawodnik');
				foreach($grupa as $zawodnikId => $grupaId) {
					$zawodnik = $zr->find($zawodnikId);
					$zawodnik->setGrupa($em->getReference('SzymonTurniejBundle:Grupa', $grupaId));
				}
				$em->flush();
			} else {
				$this->get('session')->getFlashBag()->add('info', 'Nie można poprawić grup ponieważ turniej jest już w toku.');
			}
		}

		return array(
				'turniej' => $turniej
		);
	}

	/**
	 * @Route("/rozmiesc", name="rozmiesc")
	 * @Template("SzymonTurniejBundle:Grupa:rozmiesc.html.twig")
	 */
	public function rozmiescAction(Request $request)
	{
		$turniej = $this->get('turniej')->getCurrentTurniej();
		if($turniej == null) {
			return $this->forward('SzymonTurniejBundle:Turniej:wybierzTurniej');
		}

		if($request->isMethod('post')) {
			$iloscGrup = $request->get('group_amount');

			if($request->get('sort') == 'kat_szachowa') {
			  $this->rozmiescWgKategoriiSzachowej($turniej, $iloscGrup);
			} else if($request->get('sort') == 'wiek') {
				$this->rozmiescWgWieku($turniej, $iloscGrup);
			} else if($request->get('sort') == 'recznie') {
				$turniej->setSposobPrzyporzadkowania(3);
				$this->stworzGrupy($iloscGrup, $turniej);
			} else if($request->get('sort') == 'losowo') {
				$this->rozmiescLosowo($turniej, $iloscGrup);
			}
		}

		return array(
				'turniej' => $turniej
		);
	}

	private function rozmiescWgKategoriiSzachowej($turniej, $iloscGrup, $runda = 0) {
		$em = $this->getDoctrine()->getManager();
		$zawodnicy = $this->getDoctrine()->getRepository('SzymonTurniejBundle:Zawodnik')->findByTurniejOrderByKategoria($turniej);

		$grupy = $this->stworzGrupy($iloscGrup, $turniej);
		$turniej->setSposobPrzyporzadkowania(1);

		//Rozmieść zawodników
		$tmp = 0;
		foreach($zawodnicy as $zawodnik) {
			$zawodnik->setGrupa($grupy[$tmp]);

			($tmp < $iloscGrup - 1) ? $tmp++:	$tmp = 0;
		}
		$em->flush();
	}

	private function rozmiescWgWieku($turniej, $iloscGrup, $runda = 0) {
		$em = $this->getDoctrine()->getManager();
		$zawodnicy = $this->getDoctrine()->getRepository('SzymonTurniejBundle:Zawodnik')->findByTurniejOrderByRokUrodzenia($turniej);

		$grupy = $this->stworzGrupy($iloscGrup, $turniej);
		$turniej->setSposobPrzyporzadkowania(2);
		$zawodnicyLength = count($zawodnicy);

		//Rozmieść zawodników
		$tmp = 0;
		$g = 0;
		for($i = 0; $i < $zawodnicyLength; $i++) {
			if($tmp >= $zawodnicyLength/$iloscGrup) {
				if($g < $iloscGrup-1) {
					$g++;
					$tmp = 0;
				}
			}
			$zawodnicy[$i]->setGrupa($grupy[$g]);
			$tmp++;
		}

		$em->flush();
	}

	private function rozmiescLosowo($turniej, $iloscGrup, $runda = 0) {
		$em = $this->getDoctrine()->getManager();
		$zawodnicy = $this->getDoctrine()->getRepository('SzymonTurniejBundle:Zawodnik')->findByTurniej($turniej);
		shuffle($zawodnicy);

		$grupy = $this->stworzGrupy($iloscGrup, $turniej);
		$turniej->setSposobPrzyporzadkowania(4);

		//Rozmieść zawodników
		$tmp = 0;
		foreach($zawodnicy as $zawodnik) {
			$zawodnik->setGrupa($grupy[$tmp]);

			($tmp < $iloscGrup - 1) ? $tmp++:	$tmp = 0;
		}
		$em->flush();
	}

	private function stworzGrupy($ilosc, $turniej) {
		$em = $this->getDoctrine()->getManager();
		$grupy = array();

		for($i = 0; $i < $ilosc; $i++) {
			$grupa = new Grupa();
			$grupa->setRunda(Turniej::TURNIEJ_ROZGRYWKI);
			$grupa->setNumerGrupy($i+1);
			$grupa->setTurniej($turniej);
			$grupa->setNazwaGrupy(NazwyGrup::getNazwaGrupy($i + 1));
			$grupy[] = $grupa;
			$em->persist($grupa);
		}

		return $grupy;
	}
}