text:
MyCookieJar::MyCookieJar(QObject *parent)

    : QNetworkCookieJar(parent)

{

}

MyCookieJar::~MyCookieJar()

{

}

QList<QNetworkCookie> MyCookieJar::mycookies()

{

    return  this->allCookies();

}

void MyCookieJar::setCookies(const QList<QNetworkCookie>& cookieList)

{

    if(this == NULL)

        return;

    this->setAllCookies(cookieList);

}

redpajama_set_name: RedPajamaGithub


text:
git ec0cd0cb5bf4594b3a8759c0eff12b9b8aee68f7

---

# База данных · Построитель запросов

- [Введение](#introduction)
- [Выполнение запросов к базе данных](#running-database-queries)
    - [Разбиение результатов](#chunking-results)
    - [Отложенная потоковая передача результатов](#streaming-results-lazily)
    - [Агрегатные функции](#aggregates)
- [Выражения (select)](#select-statements)
- [Необрабатываемые (сырые) SQL-выражения](#raw-expressions)
- [Соединения (join)](#joins)
- [Объединения результатов (union)](#unions)
- [Основные выражения Where](#basic-where-clauses)
    - [Выражения Where](#where-clauses)
    - [Выражения Or Where](#or-where-clauses)
    - [Выражения Where и JSON](#json-where-clauses)
    - [Дополнительные выражения Where](#additional-where-clauses)
    - [Логическая группировка](#logical-grouping)
- [Расширенные выражения Where](#advanced-where-clauses)
    - [Выражения Where Exists](#where-exists-clauses)
    - [Подзапросы выражений Where](#subquery-where-clauses)
- [Сортировка, группировка, ограничение и смещение](#ordering-grouping-limit-and-offset)
    - [Сортировка](#ordering)
    - [Группировка](#grouping)
    - [Ограничение и смещение](#limit-and-offset)
- [Условные выражения](#conditional-clauses)
- [Вставка](#insert-statements)
    - [Обновления-вставки](#upserts)
- [Обновление](#update-statements)
    - [Обновление столбцов JSON](#updating-json-columns)
    - [Увеличение и уменьшение отдельных значений](#increment-and-decrement)
- [Удаление](#delete-statements)
- [Пессимистическая блокировка](#pessimistic-locking)
- [Отладка](#debugging)

## Введение

Построитель запросов к базе данных Laravel предлагает удобный и гибкий интерфейс для создания и выполнения запросов к базе данных. Его можно использовать для выполнения большинства операций с базой данных в вашем приложении и он отлично работает со всеми поддерживаемыми Laravel системами баз данных.

Построитель запросов Laravel использует связывание параметров PDO для защиты приложения от SQL-инъекций. Нет необходимости чистить строки, передаваемые как связываемые параметры.

> {note} PDO не поддерживает связывание имен столбцов. Поэтому, вы никогда не должны использовать какие-либо входящие от пользователя данные в качестве имен столбцов, используемые вашими запросами, включая столбцы в запросах `order by` и т.д.

## Выполнение запросов к базе данных

#### Получение всех строк из таблицы

Вы можете использовать метод `table` фасада `DB`, чтобы начать запрос. Метод `table` возвращает текущий экземпляр построителя запросов для данной таблицы, позволяя вам связать больше ограничений к запросу и, наконец, получить результаты, используя метод `get`:

    <?php

    namespace App\Http\Controllers;

    use App\Http\Controllers\Controller;
    use Illuminate\Support\Facades\DB;

    class UserController extends Controller
    {
        /**
         * Показать список всех пользователей приложения.
         *
         * @return \Illuminate\Http\Response
         */
        public function index()
        {
            $users = DB::table('users')->get();

            return view('user.index', ['users' => $users]);
        }
    }

Метод `get` возвращает экземпляр `Illuminate\Support\Collection`, содержащий результаты запроса, где каждый результат является экземпляром объекта `stdClass` PHP. Вы можете получить доступ к значению каждого столбца, обратившись к столбцу как к свойству объекта:

    use Illuminate\Support\Facades\DB;

    $users = DB::table('users')->get();

    foreach ($users as $user) {
        echo $user->name;
    }

> {tip} Коллекции Laravel содержат множество чрезвычайно мощных методов для работы с наборами данных. Для получения дополнительной информации о коллекциях Laravel ознакомьтесь с [их документацией](/docs/{{version}}/collections).

#### Получение одной строки / столбца из таблицы

Если вам просто нужно получить одну строку из таблицы базы данных, вы можете использовать метод `first` фасада `DB`. Этот метод вернет единственный объект `stdClass`:

    $user = DB::table('users')->where('name', 'John')->first();

    return $user->email;

Если вам не нужна вся строка, вы можете извлечь одно значение из записи с помощью метода `value`. Этот метод вернет значение столбца напрямую:

    $email = DB::table('users')->where('name', 'John')->value('email');

Чтобы получить одну строку по значению столбца `id`, используйте метод `find`:

    $user = DB::table('users')->find(3);

#### Получение списка значений столбца

Если вы хотите получить экземпляр `Illuminate\Support\Collection`, содержащий значения одного столбца, вы можете использовать метод `pluck`. В этом примере мы получим коллекцию из названий пользователей:

    use Illuminate\Support\Facades\DB;

    $titles = DB::table('users')->pluck('title');

    foreach ($titles as $title) {
        echo $title;
    }

Вы можете указать столбец, который результирующая коллекция должна использовать в качестве ключей, указав второй аргумент методу `pluck`:

    $titles = DB::table('users')->pluck('title', 'name');

    foreach ($titles as $name => $title) {
        echo $title;
    }

### Разбиение результатов

Если вам нужно работать с тысячами записей базы данных, рассмотрите возможность использования метода `chunk` фасада `DB`. Этот метод извлекает за раз небольшой фрагмент результатов и передает каждый фрагмент в функцию-аргумент для обработки. Например, давайте извлечем всю таблицу `users` фрагментами по 100 записей за раз:

    use Illuminate\Support\Facades\DB;

    DB::table('users')->orderBy('id')->chunk(100, function ($users) {
        foreach ($users as $user) {
            //
        }
    });

Вы можете остановить обработку последующих фрагментов, вернув из функции обработки `false`:

    DB::table('users')->orderBy('id')->chunk(100, function ($users) {
        // Обрабатываем записи ...

        return false;
    });

Если вы обновляете записи базы данных во время фрагментирования результатов, то результаты ваших фрагментов могут измениться неожиданным образом. Если вы планируете обновлять полученные записи при фрагментировании, всегда лучше использовать вместо этого метод `chunkById`. Этот метод автоматически разбивает результаты на фрагменты на основе первичного ключа записи:

    DB::table('users')->where('active', false)
        ->chunkById(100, function ($users) {
            foreach ($users as $user) {
                DB::table('users')
                    ->where('id', $user->id)
                    ->update(['active' => true]);
            }
        });

> {note} При обновлении или удалении записей внутри функции-аргумента, любые изменения первичного или внешних ключей могут повлиять на запрос очередного фрагмента. Это может потенциально привести к тому, что записи могут не быть включены в последующие результаты выполнения функции.

### Отложенная потоковая передача результатов

Метод `lazy` работает аналогично [методу `chunk`](#chunking-results) в том смысле, что он выполняет запрос по частям. Однако вместо передачи каждого фрагмента непосредственно в функцию-обработчик, метод `lazy()` возвращает экземпляр [`LazyCollection`](/docs/{{version}}/collections#lazy-collections), что позволяет вам взаимодействовать с результатами как с единым потоком:

```php
use Illuminate\Support\Facades\DB;

DB::table('users')->lazy()->each(function ($user) {
    //
});
```

Еще раз, если вы планируете обновлять полученные записи во время их итерации, лучше вместо этого использовать методы `lazyById` или `lazyByIdDesc`. Эти методы автоматически разбивают результаты «постранично» на основе первичного ключа записи:

```php
DB::table('users')->where('active', false)
    ->lazyById()->each(function ($user) {
        DB::table('users')
            ->where('id', $user->id)
            ->update(['active' => true]);
    });
```

> {note} При обновлении или удалении записей во время их итерации любые изменения первичного ключа или внешних ключей могут повлиять на запрос фрагмента. Это может потенциально привести к тому, что записи не будут включены в результирующий набор.

### Агрегатные функции

Построитель запросов также содержит множество методов для получения агрегированных значений, таких как `count`, `max`, `min`, `avg`, и `sum`. После создания запроса вы можете вызвать любой из этих методов:

    use Illuminate\Support\Facades\DB;

    $users = DB::table('users')->count();

    $price = DB::table('orders')->max('price');

Конечно, вы можете комбинировать эти методы с другими выражениями, чтобы уточнить способ вычисления вашего совокупного значения:

    $price = DB::table('orders')
                    ->where('finalized', 1)
                    ->avg('price');

#### Определение наличия записей

Вместо использования метода `count` для определения существования каких-либо записей, соответствующих ограничениям вашего запроса, используйте методы `exists` и `doesntExist`:

    if (DB::table('orders')->where('finalized', 1)->exists()) {
        // ...
    }

    if (DB::table('orders')->where('finalized', 1)->doesntExist()) {
        // ...
    }

## Выражения Select

#### Уточнения выражения Select

Возможно, вам не всегда нужно выбирать все столбцы из таблицы базы данных. Используя метод `select`, вы можете указать собственное выражение `SELECT` для запроса:

    use Illuminate\Support\Facades\DB;

    $users = DB::table('users')
                ->select('name', 'email as user_email')
                ->get();

Метод `distinct` позволяет вам заставить запрос возвращать уникальные результаты:

    $users = DB::table('users')->distinct()->get();

Если у вас уже есть экземпляр построителя запросов, и вы хотите добавить столбец к существующему выражению `SELECT`, то вы можете использовать метод `addSelect`:

    $query = DB::table('users')->select('name');

    $users = $query->addSelect('age')->get();

## Сырые SQL-выражения

Иногда вам может понадобиться вставить в запрос произвольную строку, содержащую часть SQL-запроса. Для этого вы можете использовать метод `raw` фасада `DB`:

    $users = DB::table('users')
                 ->select(DB::raw('count(*) as user_count, status'))
                 ->where('status', '<>', 1)
                 ->groupBy('status')
                 ->get();

> {note} Сырые выражения будут вставлены в запрос в виде строк, поэтому следует проявлять особую осторожность, чтобы не создавать уязвимости для SQL-инъекций.

### Сырые sql-выражения

Вместо использования метода `DB::raw`, вы также можете использовать следующие методы для вставки произвольного SQL-выражения в различные части вашего запроса. **Помните, Laravel не может гарантировать, что любой запрос, использующий сырые SQL-выражения, защищен от уязвимостей SQL-инъекций.**

#### `selectRaw`

Метод `selectRaw` можно использовать вместо `addSelect(DB::raw(...))`. Этот метод принимает необязательный массив параметров для подстановки в качестве второго аргумента:

    $orders = DB::table('orders')
                    ->selectRaw('price * ? as price_with_tax', [1.0825])
                    ->get();

#### `whereRaw / orWhereRaw`

Методы `whereRaw` и `orWhereRaw` можно использовать для вставки сырого SQL-выражения `WHERE` в ваш запрос. Эти методы принимают необязательный массив параметров в качестве второго аргумента:

    $orders = DB::table('orders')
                    ->whereRaw('price > IF(state = "TX", ?, 100)', [200])
                    ->get();

#### `havingRaw / orHavingRaw`

Методы `havingRaw` и `orHavingRaw` могут использоваться для вставки необработанной строки в качестве значения выражения `HAVING`. Эти методы принимают необязательный массив параметров в качестве второго аргумента:

    $orders = DB::table('orders')
                    ->select('department', DB::raw('SUM(price) as total_sales'))
                    ->groupBy('department')
                    ->havingRaw('SUM(price) > ?', [2500])
                    ->get();

#### `orderByRaw`

Метод `orderByRaw` используется для предоставления необработанной строки в качестве значения выражения `ORDER BY`:

    $orders = DB::table('orders')
                    ->orderByRaw('updated_at - created_at DESC')
                    ->get();

#### `groupByRaw`

Метод `groupByRaw` используется для предоставления необработанной строки в качестве значения выражения `GROUP BY`:

    $orders = DB::table('orders')
                    ->select('city', 'state')
                    ->groupByRaw('city, state')
                    ->get();

## Соединения Joins

#### Inner Join

Построитель запросов также может использоваться для добавления выражений соединения (join) к вашим запросам. Чтобы выполнить базовое «внутреннее соединение» (inner join), вы можете использовать метод `join`. Первым аргументом, передаваемым методу `join`, является имя таблицы, к которой вам нужно присоединиться, а остальные аргументы определяют ограничения столбца для соединения. Вы даже можете соединить несколько таблиц в один запрос:

    use Illuminate\Support\Facades\DB;

    $users = DB::table('users')
                ->join('contacts', 'users.id', '=', 'contacts.user_id')
                ->join('orders', 'users.id', '=', 'orders.user_id')
                ->select('users.*', 'contacts.phone', 'orders.price')
                ->get();

#### Left Join / Right Join

Если вы хотите выполнить «левое соединение» или «правое соединение» вместо «внутреннего соединения», используйте методы `leftJoin` или `rightJoin`. Эти методы имеют ту же сигнатуру, что и метод `join`:

    $users = DB::table('users')
                ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
                ->get();

    $users = DB::table('users')
                ->rightJoin('posts', 'users.id', '=', 'posts.user_id')
                ->get();

#### Cross Join

Вы можете использовать метод `crossJoin` для выполнения «перекрестного соединения». Перекрестные соединения генерируют декартово произведение между первой таблицей и соединяемой таблицей:

    $sizes = DB::table('sizes')
                ->crossJoin('colors')
                ->get();

#### Расширенные выражения соединения

Вы также можете указать более сложные выражения соединения. Для начала передайте функцию в качестве второго аргумента методу `join`. Функция получит экземпляр `Illuminate\Database\Query\JoinClause`, который позволяет вам указать ограничения `JOIN`:

    DB::table('users')
            ->join('contacts', function ($join) {
                $join->on('users.id', '=', 'contacts.user_id')->orOn(...);
            })
            ->get();

Если вы хотите использовать выражение `WHERE` в своих соединениях, вы можете использовать методы `where` и `orWhere` экземпляра `JoinClause`. Вместо сравнения двух столбцов эти методы будут сравнивать столбец со значением:

    DB::table('users')
            ->join('contacts', function ($join) {
                $join->on('users.id', '=', 'contacts.user_id')
                     ->where('contacts.user_id', '>', 5);
            })
            ->get();

#### Подзапросы соединений

Вы можете использовать методы `joinSub`, `leftJoinSub`, и `rightJoinSub`, чтобы присоединить запрос к подзапросу. Каждый из этих методов получает три аргумента: подзапрос, псевдоним таблицы и функцию, определяющую связанные столбцы. В этом примере мы получим коллекцию пользователей, где каждая запись пользователя также содержит временную метку `created_at` последнего опубликованного поста пользователя в блоге:

    $latestPosts = DB::table('posts')
                       ->select('user_id', DB::raw('MAX(created_at) as last_post_created_at'))
                       ->where('is_published', true)
                       ->groupBy('user_id');

    $users = DB::table('users')
            ->joinSub($latestPosts, 'latest_posts', function ($join) {
                $join->on('users.id', '=', 'latest_posts.user_id');
            })->get();

## Объединения результатов Unions

Построитель запросов также содержит удобный метод «объединения» двух или более запросов вместе. Например, вы можете создать первый запрос и использовать метод `union` для объединения его с другими запросами:

    use Illuminate\Support\Facades\DB;

    $first = DB::table('users')
                ->whereNull('first_name');

    $users = DB::table('users')
                ->whereNull('last_name')
                ->union($first)
                ->get();

В дополнение к методу `union`, построитель запросов содержит метод `unionAll`. Запросы, объединенные с использованием метода `unionAll`, не будут удалять повторяющиеся результаты. Метод `unionAll` имеет ту же сигнатуру, что и метод `union`.

## Основные выражения Where

### Выражения Where

Вы можете использовать метод `where` построителя запросов, чтобы добавить в запрос выражения `WHERE`. Самый простой вызов метода `where` требует трех аргументов. Первый аргумент – это имя столбца. Второй аргумент – это оператор, который может быть любым из поддерживаемых базой данных операторов. Третий аргумент – это значение, которое нужно сравнить со значением столбца.

Например, следующий запрос извлекает пользователей, у которых значение столбца `votes` равно `100`, а значение столбца `age` больше, чем `35`:

    $users = DB::table('users')
                    ->where('votes', '=', 100)
                    ->where('age', '>', 35)
                    ->get();

Для удобства, если вы хотите убедиться, что столбец соответствует `=` переданному значению, то вы можете передать это значение в качестве второго аргумента в метод `where`. Laravel будет предполагать, что вы хотите использовать оператор `=`:

    $users = DB::table('users')->where('votes', 100)->get();

Как упоминалось ранее, вы можете использовать любой оператор, который поддерживается вашей системой баз данных:

    $users = DB::table('users')
                    ->where('votes', '>=', 100)
                    ->get();

    $users = DB::table('users')
                    ->where('votes', '<>', 100)
                    ->get();

    $users = DB::table('users')
                    ->where('name', 'like', 'T%')
                    ->get();

Вы также можете передать массив условий методу `where`. Каждый элемент массива должен быть массивом, содержащим три аргумента, как и обычно передаваемых методу `where`:

    $users = DB::table('users')->where([
        ['status', '=', '1'],
        ['subscribed', '<>', '1'],
    ])->get();

> {note} PDO не поддерживает привязку имен столбцов. Поэтому вы никогда не должны брать из пользовательского ввода имена столбцов для совершения запросов, включая столбцы "order by".

### Выражения Or Where

При объединении в цепочку вызовов метода `where` построителя запросов выражения `WHERE` будут объединены вместе с помощью оператора `AND`. Однако, вы можете использовать метод `orWhere` для добавления выражения к запросу с помощью оператора `OR`. Метод `orWhere` принимает те же аргументы, что и метод `where`:

    $users = DB::table('users')
                        ->where('votes', '>', 100)
                        ->orWhere('name', 'John')
                        ->get();

Если вам нужно сгруппировать условие `OR` в круглых скобках, вы можете передать функцию в качестве первого аргумента методу `orWhere`:

    $users = DB::table('users')
                ->where('votes', '>', 100)
                ->orWhere(function($query) {
                    $query->where('name', 'Abigail')
                          ->where('votes', '>', 50);
                })
                ->get();

В приведенном выше примере будет получен следующий SQL:

```sql
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
```

> {note} Вы всегда должны группировать вызовы `orWhere`, чтобы избежать неожиданного поведения при применении [глобальных диапазонов](/docs/{{version}}/eloquent#query-scopes).

### Выражения Where и JSON

Laravel также поддерживает запросы в базах данных, которые обеспечивают поддержку JSON-типов столбцов. В настоящее время это MySQL 5.7+, PostgreSQL, SQL Server 2016 и SQLite 3.9.0 (с [расширением JSON1](https://www.sqlite.org/json1.html)). Чтобы запросить столбец JSON, используйте оператор `->`:

    $users = DB::table('users')
                    ->where('preferences->dining->meal', 'salad')
                    ->get();

Вы можете использовать `whereJsonContains` для запроса массивов JSON. Эта функция не поддерживается базой данных SQLite:

    $users = DB::table('users')
                    ->whereJsonContains('options->languages', 'en')
                    ->get();

Если ваше приложение использует базы данных MySQL или PostgreSQL, вы можете передать массив значений методу `whereJsonContains`:

    $users = DB::table('users')
                    ->whereJsonContains('options->languages', ['en', 'de'])
                    ->get();

Вы можете использовать метод `whereJsonLength` для запроса массивов JSON по их длине:

    $users = DB::table('users')
                    ->whereJsonLength('options->languages', 0)
                    ->get();

    $users = DB::table('users')
                    ->whereJsonLength('options->languages', '>', 1)
                    ->get();

### Дополнительные выражения Where

**whereBetween / orWhereBetween**

Метод `whereBetween` проверяет, находится ли значение столбца между двумя значениями:

    $users = DB::table('users')
               ->whereBetween('votes', [1, 100])
               ->get();

**whereNotBetween / orWhereNotBetween**

Метод `whereNotBetween` проверяет, что значение столбца находится вне двух значений:

    $users = DB::table('users')
                        ->whereNotBetween('votes', [1, 100])
                        ->get();

**whereIn / whereNotIn / orWhereIn / orWhereNotIn**

Метод `whereIn` проверяет, что значение переданного столбца содержится в указанном массиве:

    $users = DB::table('users')
                        ->whereIn('id', [1, 2, 3])
                        ->get();

Метод `whereNotIn` проверяет, что значение переданного столбца не содержится в указанном массиве:

    $users = DB::table('users')
                        ->whereNotIn('id', [1, 2, 3])
                        ->get();

> {note} Если вы добавляете в свой запрос большой массив связываемых целочисленных параметров, то методы `whereIntegerInRaw` или `whereIntegerNotInRaw` могут использоваться для значительного сокращения потребляемой памяти.

**whereNull / whereNotNull / orWhereNull / orWhereNotNull**

Метод `whereNull` проверяет, что значение переданного столбца равно `NULL`:

    $users = DB::table('users')
                    ->whereNull('updated_at')
                    ->get();

Метод `whereNotNull` проверяет, что значение переданного столбца не равно `NULL`:

    $users = DB::table('users')
                    ->whereNotNull('updated_at')
                    ->get();

**whereDate / whereMonth / whereDay / whereYear / whereTime**

Метод `whereDate` используется для сравнения значения столбца с датой:

    $users = DB::table('users')
                    ->whereDate('created_at', '2016-12-31')
                    ->get();

Метод `whereMonth` используется для сравнения значения столбца с конкретным месяцем:

    $users = DB::table('users')
                    ->whereMonth('created_at', '12')
                    ->get();

Метод `whereDay` используется для сравнения значения столбца с определенным днем месяца:

    $users = DB::table('users')
                    ->whereDay('created_at', '31')
                    ->get();

Метод `whereYear` используется для сравнения значения столбца с конкретным годом:

    $users = DB::table('users')
                    ->whereYear('created_at', '2016')
                    ->get();

Метод `whereTime` используется для сравнения значения столбца с определенным временем:

    $users = DB::table('users')
                    ->whereTime('created_at', '=', '11:20:45')
                    ->get();

**whereColumn / orWhereColumn**

Метод `whereColumn` используется для проверки равенства двух столбцов:

    $users = DB::table('users')
                    ->whereColumn('first_name', 'last_name')
                    ->get();

Вы также можете передать оператор сравнения методу `whereColumn`:

    $users = DB::table('users')
                    ->whereColumn('updated_at', '>', 'created_at')
                    ->get();

Вы также можете передать массив сравнений столбцов методу `whereColumn`. Эти условия будут объединены с помощью оператора `AND`:

    $users = DB::table('users')
                    ->whereColumn([
                        ['first_name', '=', 'last_name'],
                        ['updated_at', '>', 'created_at'],
                    ])->get();

### Логическая группировка

Иногда требуется сгруппировать несколько выражений `WHERE` в круглых скобках, чтобы добиться желаемой логической группировки вашего запроса. Фактически, вы должны всегда группировать вызовы метода `orWhere` в круглых скобках, чтобы избежать неожиданного поведения запроса. Для этого вы можете передать функцию методу `where`:

    $users = DB::table('users')
               ->where('name', '=', 'John')
               ->where(function ($query) {
                   $query->where('votes', '>', 100)
                         ->orWhere('title', '=', 'Admin');
               })
               ->get();

Как вы можете видеть, передача функции в метод `where` инструктирует построитель запросов начать группу ограничений. Функция получит экземпляр построителя запросов, который вы можете использовать для задания ограничений, которые должны содержаться в группе скобок. В приведенном выше примере будет получен следующий SQL:

```sql
select * from users where name = 'John' and (votes > 100 or title = 'Admin')
```

> {note} Вы всегда должны группировать вызовы `orWhere`, чтобы избежать неожиданного поведения при применении [глобальных диапазонов](/docs/{{version}}/eloquent#query-scopes).

### Расширенные выражения Where

### Выражения Where Exists

Метод `whereExists` позволяет писать выражения `WHERE EXISTS` SQL. Метод `whereExists` принимает функцию, которая получит экземпляр построителя запросов, позволяя вам определить запрос, который должен быть помещен внутри выражения `EXISTS`:

    $users = DB::table('users')
               ->whereExists(function ($query) {
                   $query->select(DB::raw(1))
                         ->from('orders')
                         ->whereColumn('orders.user_id', 'users.id');
               })
               ->get();

В приведенном выше примере будет получен следующий SQL:

```sql
select * from users
where exists (
    select 1
    from orders
    where orders.user_id = users.id
)
```

### Подзапросы выражений Where

Иногда требуется создать выражение `WHERE`, которое сравнивает результаты подзапроса с переданным значением. Вы можете добиться этого, передав функцию и значение методу `where`. Например, следующий запрос будет извлекать всех пользователей, недавно имевших «членство» указанного типа:

    use App\Models\User;

    $users = User::where(function ($query) {
        $query->select('type')
            ->from('membership')
            ->whereColumn('membership.user_id', 'users.id')
            ->orderByDesc('membership.start_date')
            ->limit(1);
    }, 'Pro')->get();

Или вам может потребоваться создать выражение "where", которое сравнивает столбец с результатами подзапроса. Вы можете сделать это, передав методу `where` столбец, оператор и функцию. Например, следующий запрос будет извлекать все записи о доходах, где сумма меньше средней:

    use App\Models\Income;

    $incomes = Income::where('amount', '<', function ($query) {
        $query->selectRaw('avg(i.amount)')->from('incomes as i');
    })->get();

## Сортировка, группировка, ограничение и смещение

### Сортировка

#### Метод `orderBy`

Метод `orderBy` позволяет вам сортировать результаты запроса по конкретному столбцу. Первый аргумент, принимаемый методом `orderBy`, должен быть столбцом, по которому вы хотите выполнить сортировку, а второй аргумент определяет направление сортировки и может быть либо `asc`, либо `desc`:

    $users = DB::table('users')
                    ->orderBy('name', 'desc')
                    ->get();

Для сортировки по нескольким столбцам вы можете просто вызывать `orderBy` столько раз, сколько необходимо:

    $users = DB::table('users')
                    ->orderBy('name', 'desc')
                    ->orderBy('email', 'asc')
                    ->get();

#### Методы `latest` и `oldest`

Методы `latest` и `oldest` позволяют легко упорядочивать результаты по дате. По умолчанию результат будет упорядочен по столбцу `created_at` таблицы. Или вы можете передать имя столбца, по которому хотите сортировать:

    $user = DB::table('users')
                    ->latest()
                    ->first();

#### Случайный порядок

Метод `inRandomOrder` используется для случайной сортировки результатов запроса. Например, вы можете использовать этот метод для выборки случайного пользователя:

    $randomUser = DB::table('users')
                    ->inRandomOrder()
                    ->first();

#### Удаление существующих сортировок

Метод `reorder` удаляет все выражения `ORDER BY`, которые ранее были применены к запросу:

    $query = DB::table('users')->orderBy('name');

    $unorderedUsers = $query->reorder()->get();

Вы можете передать столбец и направление при вызове метода `reorder`, чтобы удалить все существующие выражения `ORDER BY` и применить к запросу совершенно новый порядок:

    $query = DB::table('users')->orderBy('name');

    $usersOrderedByEmail = $query->reorder('email', 'desc')->get();

### Группировка

#### Методы `groupBy` и `having`

Как и следовало ожидать, для группировки результатов запроса могут использоваться методы `groupBy` и `having`. Сигнатура метода `having` аналогична сигнатуре метода `where`:

    $users = DB::table('users')
                    ->groupBy('account_id')
                    ->having('account_id', '>', 100)
                    ->get();

Вы можете использовать метод `havingBetween` для фильтрации результатов в заданном диапазоне:

    $report = DB::table('orders')
                    ->selectRaw('count(id) as number_of_orders, customer_id')
                    ->groupBy('customer_id')
                    ->havingBetween('number_of_orders', [5, 15])
                    ->get();

Вы можете передать несколько аргументов методу `groupBy` для группировки по нескольким столбцам:

    $users = DB::table('users')
                    ->groupBy('first_name', 'status')
                    ->having('account_id', '>', 100)
                    ->get();

Чтобы создать более сложные операторы `having`, см. метод [`havingRaw`](#raw-methods).

### Ограничение и смещение

#### Методы `skip` и `take`

Вы можете использовать методы `skip` и `take`, чтобы ограничить количество результатов, возвращаемых запросом, или пропустить указанное количество результатов из запроса:

    $users = DB::table('users')->skip(10)->take(5)->get();

Как вариант, вы можете использовать методы `limit` и `offset`. Эти методы функционально эквивалентны методам `take` и `skip` соответственно:

    $users = DB::table('users')
                    ->offset(10)
                    ->limit(5)
                    ->get();

## Условные выражения

Иногда может потребоваться, чтобы определенные выражения запроса применялись к запросу на основании другого условия. Например, бывает необходимо применить оператор `WHERE` только в том случае, если переданное входящее значение присутствует в HTTP-запросе. Вы можете сделать это с помощью метода `when`:

    $role = $request->input('role');

    $users = DB::table('users')
                    ->when($role, function ($query, $role) {
                        return $query->where('role_id', $role);
                    })
                    ->get();

Метод `when` выполняет переданную функцию-аргумент только тогда, когда первый аргумент равен `true`. Если первый аргумент – `false`, функция не будет выполнена. Итак, в приведенном выше примере функция метода `when` будет вызываться только в том случае, если поле `role` присутствует во входящем запросе и оценивается как `true`.

Вы можете передать другую функцию в качестве третьего аргумента методу `when`. Это функция будет выполнена только в том случае, если первый аргумент оценивается как `false`. Чтобы проиллюстрировать этот функционал, определим порядок вывода записей по умолчанию для запроса:

    $sortByVotes = $request->input('sort_by_votes');

    $users = DB::table('users')
                    ->when($sortByVotes, function ($query, $sortByVotes) {
                        return $query->orderBy('votes');
                    }, function ($query) {
                        return $query->orderBy('name');
                    })
                    ->get();

## Вставка

Построитель запросов также содержит метод `insert`, который можно использовать для вставки записей в таблицу базы данных. Метод `insert` принимает массив имен и значений столбцов:

    DB::table('users')->insert([
        'email' => 'kayla@example.com',
        'votes' => 0
    ]);

Вы можете вставить сразу несколько записей, передав массив массивов. Каждый из массивов представляет собой запись, которую нужно вставить в таблицу:

    DB::table('users')->insert([
        ['email' => 'picard@example.com', 'votes' => 0],
        ['email' => 'janeway@example.com', 'votes' => 0],
    ]);

Метод `insertOrIgnore` будет игнорировать ошибки повторяющихся записей при вставке записей в базу данных:

    DB::table('users')->insertOrIgnore([
        ['id' => 1, 'email' => 'sisko@example.com'],
        ['id' => 2, 'email' => 'archer@example.com'],
    ]);

> {note} `insertOrIgnore` будет игнорировать дубликаты записей, а также может игнорировать другие типы ошибок в зависимости от движка базы данных. Например, `insertOrIgnore` будет [обходить строгий режим MySQL](https://dev.mysql.com/doc/refman/en/sql-mode.html#ignore-effect-on-execution).

#### Автоинкрементирование идентификаторов

Если таблица имеет автоинкрементный идентификатор, то используйте метод `insertGetId`, чтобы вставить запись и затем получить идентификатор этой записи:

    $id = DB::table('users')->insertGetId(
        ['email' => 'john@example.com', 'votes' => 0]
    );

> {note} При использовании PostgreSQL метод `insertGetId` ожидает, что автоинкрементный столбец будет называться `id`. Если вы хотите получить идентификатор из другой «последовательности», вы можете передать имя столбца в качестве второго параметра методу `insertGetId`.

### Обновления-вставки

Метод `upsert` вставляет записи, которые не существуют, и обновляет записи, которые уже существуют, новыми значениями, которые вы можете указать. Первый аргумент метода состоит из значений для вставки или обновления, а второй аргумент перечисляет столбцы, которые однозначно идентифицируют записи в связанной таблице. Третий и последний аргумент метода – это массив столбцов, который следует обновить, если соответствующая запись уже существует в базе данных:

    DB::table('flights')->upsert([
        ['departure' => 'Oakland', 'destination' => 'San Diego', 'price' => 99],
        ['departure' => 'Chicago', 'destination' => 'New York', 'price' => 150]
    ], ['departure', 'destination'], ['price']);

В приведенном выше примере Laravel попытается вставить две записи. Если запись уже существует с такими же значениями столбцов `departure` и `destination`, то Laravel обновит столбец `price` этой записи.

> {note} Все базы данных, кроме SQL Server, требуют, чтобы столбцы во втором аргументе метода `upsert` имели «первичный» или «уникальный» индекс. Вдобавок, драйвер базы данных MySQL игнорирует второй аргумент метода `upsert` и всегда использует «первичный» и «уникальный» индексы таблицы для обнаружения существующих записей.

## Обновление

Помимо вставки записей в базу данных, построитель запросов также может обновлять существующие записи с помощью метода `update`. Метод `update`, как и метод `insert`, принимает массив пар столбцов и значений, указывающих столбцы, которые нужно обновить. Вы можете ограничить запрос `update` с помощью выражений `WHERE`:

    $affected = DB::table('users')
                  ->where('id', 1)
                  ->update(['votes' => 1]);

#### Обновление или вставка

Иногда требуется обновить существующую запись в базе данных или создать ее, если соответствующей записи не существует. В этом сценарии может использоваться метод `updateOrInsert`. Метод `updateOrInsert` принимает два аргумента: массив условий, по которым нужно найти запись, и массив пар столбцов и значений, указывающих столбцы, которые нужно обновить.

Метод `updateOrInsert` попытается найти соответствующую запись в базе данных, используя пары столбец и значение первого аргумента. Если запись существует, она будет обновлена значениями второго аргумента. Если запись не может быть найдена, будет вставлена новая запись с объединенными атрибутами обоих аргументов:

    DB::table('users')
        ->updateOrInsert(
            ['email' => 'john@example.com', 'name' => 'John'],
            ['votes' => '2']
        );

### Обновление столбцов JSON

При обновлении столбца JSON вы должны использовать синтаксис `->` для обновления соответствующего ключа в объекте JSON. Эта операция поддерживается в MySQL 5.7+ и PostgreSQL 9.5+:

    $affected = DB::table('users')
                  ->where('id', 1)
                  ->update(['options->enabled' => true]);

### Увеличение и уменьшение отдельных значений

Конструктор запросов также содержит удобные методы увеличения или уменьшения значения конкретного столбца. Оба метода принимают по крайней мере один аргумент: столбец, который нужно изменить. Может быть указан второй аргумент, определяющий величину, на которую следует увеличить или уменьшить столбец:

    DB::table('users')->increment('votes');

    DB::table('users')->increment('votes', 5);

    DB::table('users')->decrement('votes');

    DB::table('users')->decrement('votes', 5);

Вы также можете указать дополнительные столбцы для обновления во время выполнения запроса:

    DB::table('users')->increment('votes', 1, ['name' => 'John']);

## Удаление

Метод `delete` построителя запросов может использоваться для удаления записей из таблицы. Вы можете ограничить операторы `delete`, добавив метод `where` перед вызовом метода `delete`:

    DB::table('users')->delete();

    DB::table('users')->where('votes', '>', 100)->delete();

Если вы хотите очистить всю таблицу, что приведет к удалению всех записей из таблицы и сбросу автоинкрементного идентификатора на ноль, вы можете использовать метод `truncate`:

    DB::table('users')->truncate();

#### Очистка таблицы и PostgreSQL

При очистке базы данных PostgreSQL будет применено поведение `CASCADE`. Это означает, что все связанные с внешним ключом записи в других таблицах также будут удалены.

## Пессимистическая блокировка

Построитель запросов также включает несколько функций, которые помогут вам достичь «пессимистической блокировки» при выполнении ваших операторов `SELECT`. Чтобы выполнить оператор с «совместной блокировкой», вы можете вызвать метод `sharedLock` в запросе. Совместная блокировка предотвращает изменение выбранных строк до тех пор, пока ваша транзакция не будет зафиксирована:

    DB::table('users')
            ->where('votes', '>', 100)
            ->sharedLock()
            ->get();

В качестве альтернативы вы можете использовать метод `lockForUpdate`. Блокировка «для обновления» предотвращает изменение выбранных записей или их выбор с помощью другой совместной блокировки:

    DB::table('users')
            ->where('votes', '>', 100)
            ->lockForUpdate()
            ->get();

## Отладка

Вы можете использовать методы `dd` или `dump` при построении запроса, чтобы отобразить связанные параметры запроса и сам SQL-запрос. Метод `dd` отобразит отладочную информацию и затем прекратит выполнение запроса. Метод `dump` отобразит информацию об отладке, но позволит продолжить выполнение запроса:

    DB::table('users')->where('votes', '>', 100)->dd();

    DB::table('users')->where('votes', '>', 100)->dump();


text:
PhpSpecRunExtension
===================

[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/richardmiller/PhpSpecRunExtension/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/richardmiller/PhpSpecRunExtension/?branch=master)
[![Build Status](https://scrutinizer-ci.com/g/richardmiller/PhpSpecRunExtension/badges/build.png?b=master)](https://scrutinizer-ci.com/g/richardmiller/PhpSpecRunExtension/build-status/master)

PhpSpec extension that adds running run command after describe command

Installation
------------

This extension requires:

* PhpSpec 3.0+
* PHP 5.6+

The easiest way to install it is to use Composer

```
$ composer require --dev rmiller/phpspec-run-extension:^0.5
```

Activate the extension by specifying its class in your ``phpspec.yml``:

```yaml
# phpspec.yml
extensions:
  RMiller\BehatSpec\Extension\PhpSpecRunExtension\PhpSpecRunExtension: ~
```

It defaults to `bin/phpspec` for the path of phpspec and to run after the describe command.
These can be overridden as follows:

```yaml
# phpspec.yml
extensions:
  RMiller\BehatSpec\Extension\PhpSpecRunExtension\PhpSpecRunExtension: ~
rerunner:
  path: vendor/bin/phpspec
  commands: [describe, exemplify]
  config: path/to/phpspec.yml #optional
```

This will now also execute the run command after the exemplify command added by the
[ExemplifyExtension](https://github.com/richardmiller/ExemplifyExtension).


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;
use yii\helpers\Url;
/* @var $this yii\web\View */
/* @var $model backend\models\IntegralGoods */

$this->title = '积分规则';
$this->params['breadcrumbs'][] = ['label' => 'Integral Goods', 'url' => ['index']];
$this->params['breadcrumbs'][] = 'Update';
?>

                    <?php $form = ActiveForm::begin([
                        'fieldConfig' => [
                            'template' => '{label}
{input}{error}
',
                            'labelOptions' => ['class' => 'col-sm-1 control-label'],
                            'inputOptions' => ['class' => 'form-control']
                        ]
                    ]); ?>

                    <?= $form->field($model, 'integral_rule')->widget('cliff363825\kindeditor\KindEditorWidget', ['clientOptions' => [
                        //'langType' => 'zh_CN',
                        'items' => [
                            'source', '|', 'undo', 'redo', '|', 'preview', 'print', 'template', 'code', 'cut', 'copy', 'paste',
                            'plainpaste', 'wordpaste', '|', 'justifyleft', 'justifycenter', 'justifyright',
                            'justifyfull', 'insertorderedlist', 'insertunorderedlist', 'indent', 'outdent', 'subscript',
                            'superscript', 'clearhtml', 'quickformat', 'selectall', '|', 'fullscreen', '/',
                            'formatblock', 'fontname', 'fontsize', '|', 'forecolor', 'hilitecolor', 'bold',
                            'italic', 'underline', 'strikethrough', 'lineheight', 'removeformat', '|', 'image', 'multiimage',
                            'insertfile', 'table', 'hr', 'emoticons', 'baidumap', 'pagebreak',
                            'anchor', 'link', 'unlink', '|', 'about'
                        ],
                        'uploadJson' => Url::to(['/igoods/Kupload']),
                    ]]) ?>

                        <?= Html::submitButton('保存', ['class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary']) ?>
                        <?= Html::a('返回列表', '#', ['class' =>  'btn btn-default' ]) ?>

                    <?php ActiveForm::end(); ?>

<?php
$this->registerJs("
    menuheight('igoods-rule');
");
?>


text:
from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('core', '0008_auto_20161124_1713'),
    ]

    operations = [
        migrations.AddField(
            model_name='workertype',
            name='status',
            field=models.CharField(choices=[('STATUS_OFFLINE', 'Offline'), ('STATUS_ONLINE', 'Online'), ('STATUS_UNKNOWN', 'Unknown')], default='unknown', max_length=255),
        ),
    ]


text:
package com.twu.biblioteca.library;

import com.twu.biblioteca.exceptions.FormatException;
import com.twu.biblioteca.exceptions.LibraryException;

import static com.twu.biblioteca.common.Language.YEAR_REGEX;

/**
 * Created by jolsen on 13/1/17.
 */
public abstract class LibraryItem implements Comparable {
    protected String _title, _year, _owner;

    public LibraryItem(String title, String year, String owner) throws LibraryException {
        _title = title;
        setYear(year);
        _owner = owner;
    }

    public String getTitle() {
        return _title;
    }

    private void setYear(String year) throws FormatException {
        if (year.matches(YEAR_REGEX)) {
            _year = year;
        } else {
            throw new FormatException("Year is not in the correct format");
        }
    }
}


text:
@(message: String)

@Main("Rabbit Kekai") {

Rabbit Kekai

From Waikiki beach boys to groundbreaking surfer to North Shore Beach Marshall, Rabbit Kekai has crossed
        paths with Duke Kahanamoku, John Florence and everyone in between. Now in his ninth decade, his enthusiasm for
        talking story, telling jokes and surfing are as strong as ever. One of five children born to a Waikiki
        machinist, Albert Kekai was a part of the beach scene by age three. His uncle was a lifeguard at Publics, and he
        had young Kekai surfing by age five. Active in every sport under the sun, his remarkable speed on the field
        earned the boy the nickname "Rabbit." Of his early days, he remembers, "I would play football, come back surf,
        play basketball, come back surf, run track, always going." At 10, he was taken under the wing of Duke Kahanamoku
        who paid his entries into canoe races and had him teaching surf lessons. An excellent student at Kamehameha
        High, Rabbit sought an athletic scholarship but was hampered by his small stature. Despite academic scholarship
        offers, he decided to earn a living from the beach. To supplement his beachboy lifestyle, he earned wages as a
        caddy at Ala Wai Golf Course, a construction worker, a stevedore, a bit actor and a successful beachside
        gambler. A pioneer of North Shore surfing in the '30s with George Downing, Wally Froiseth, Woody Brown and Henry
        Lum, Rabbit became known as an innovator of drop-knee turns on short, finless boards. He practically invented
        hotdogging, inspiring the likes of Phil Edwards, Matt Kivlin, Joe Quigg, Miki Dora and Donald Takayama (who
        shapes Rabbit's boards today). He also had a direct part in the development of surfers such as Joey Cabell, Jeff
        Hakman and Randy Rarick. He made his own redwood and balsa boards prior to World War II, at which time he served
        as an army frogman in the South Pacific. He was one of four from his 12-man platoon to return from action.

A winner of the Peruvian and Makaha International titles during the '50s, Rabbit competed worldwide and
        remains an avid competitor to this day, routinely winning the over-50 division. As for remembering his
        accomplishments, he responds, "When you pass 500 trophies, years and years ago, you lose count." Each winter
        season, he can be found at every Triple Crown event, doling out singlets, wisecracks and advice as Beach
        Marshall, a position he has held since the first Pipe Masters in 1971. Regardless of nationality, he calls all
        the surfers by name and has a pleasant word for all. Now a great-grandfather, Rabbit resides just down the road
        from his Waikiki stomping grounds. His wife Lynn is a schoolteacher in Palos Verdes, California, and he makes
        several trips to the mainland each year. He remains the most in-demand surf instructor at Baby Queens and
        contends that the ocean is the key to eternal youth. "The water is so good," he says thoughtfully. "It keeps me
        young while my friends are so old. I tell them to get in the water. It calms you -- no stress -- and brings you
        back to earth."-- Jason Borte

}


text:
using Newtonsoft.Json;
using System;
using System.Collections.Generic;

namespace VkApi.Wrapper.Objects
{
    public class AdsPromotedPostReach
    {
        ///
        /// Hides amount
        ///
        [JsonProperty("hide")]
        public int Hide { get; set; }

        ///
        /// Object ID from 'ids' parameter
        ///
        [JsonProperty("id")]
        public int Id { get; set; }

        ///
        /// Community joins
        ///
        [JsonProperty("join_group")]
        public int JoinGroup { get; set; }

        ///
        /// Link clicks
        ///
        [JsonProperty("links")]
        public int Links { get; set; }

        ///
        /// Subscribers reach
        ///
        [JsonProperty("reach_subscribers")]
        public int ReachSubscribers { get; set; }

        ///
        /// Total reach
        ///
        [JsonProperty("reach_total")]
        public int ReachTotal { get; set; }

        ///
        /// Reports amount
        ///
        [JsonProperty("report")]
        public int Report { get; set; }

        ///
        /// Community clicks
        ///
        [JsonProperty("to_group")]
        public int ToGroup { get; set; }

        ///
        /// 'Unsubscribe' events amount
        ///
        [JsonProperty("unsubscribe")]
        public int Unsubscribe { get; set; }

        ///
        /// Video views for 100 percent
        ///
        [JsonProperty("video_views_100p")]
        public int VideoViews100p { get; set; }

        ///
        /// Video views for 25 percent
        ///
        [JsonProperty("video_views_25p")]
        public int VideoViews25p { get; set; }

        ///
        /// Video views for 3 seconds
        ///
        [JsonProperty("video_views_3s")]
        public int VideoViews3s { get; set; }

        ///
        /// Video views for 50 percent
        ///
        [JsonProperty("video_views_50p")]
        public int VideoViews50p { get; set; }

        ///
        /// Video views for 75 percent
        ///
        [JsonProperty("video_views_75p")]
        public int VideoViews75p { get; set; }

        ///
        /// Video starts
        ///
        [JsonProperty("video_views_start")]
        public int VideoViewsStart { get; set; }
    }
}


text:
require 'test_helper'

class MicropostDecoratorTest < Draper::TestCase
end


text:
name             'chefdk_bootstrap'
maintainer       'Nordstrom, Inc.'
maintainer_email 'techcheftm@nordstrom.com'
license          'Apache-2.0'
description      'Bootstrap a developer workstation for local Chef development using the ChefDK'
version          '2.4.8'

supports         'windows'
supports         'mac_os_x'

depends          'atom', '0.3.1'
depends          'chef_ca', '~> 0.2'
depends          'chocolatey', '~> 2.0'
depends          'git', '~> 10.0'
depends          'line', '~> 2.0'
depends          'vagrant', '~> 2.0'

source_url       'https://github.com/Nordstrom/chefdk_bootstrap'
issues_url       'https://github.com/Nordstrom/chefdk_bootstrap/issues'
chef_version     '> 12.5.0'


text:
#include "rpi-systimer.h"
#include "rpi-armtimer.h"
#include "rpi-led.h"
#include "rpi-interrupts.h"
#include "asm-functions.h"

#include <time.h>

//
// Timer struct
//
typedef struct sys_timer_t
{
	sys_time_t			interval;
	sys_time_t			deadline;
	uint32_t			count;
	sys_timer_proc_t	callback;
} sys_timer_t;

//
// Timers
//
#define MAX_TIMERS 32
static sys_timer_t timers[MAX_TIMERS];
static uint32_t num_timers = 0;

//
// System timer interval
//
static uint32_t sys_timer_interval = 0x1000;

//
// Retrieve 64-bit system clock
//
// Note: since the clock is read in two consecutive cycles, it's not safe to read
// it without ensuring they are in sync. This function addresses that concern.
//
sys_time_t sys_timer_get_time()
{
	uint32_t hi, lo;

	do {
		hi = rpi_sys_timer->chi;
		lo = rpi_sys_timer->clo;
	} while (hi != rpi_sys_timer->chi);

	return ((uint64_t)hi << 32) | lo;
}

//
// Wait for the system timer
//
void sys_timer_wait_usec(uint32_t microseconds)
{
    volatile uint32_t ts = rpi_sys_timer->clo;
    while((rpi_sys_timer->clo - ts) < microseconds)
		;
}

//
// Wait for the system timer
//
void sys_timer_wait_msec(uint32_t milliseconds)
{
	sys_timer_wait_usec(milliseconds * 1000);
}

//
// Install a timer
//
uint32_t sys_timer_install(uint32_t interval, uint32_t count, sys_timer_proc_t callback)
{
	// Check timer count
	if (num_timers >= MAX_TIMERS)
		led_error_pulse(2);

	// Ensure we're not interrupted
	_disable_interrupts();

	// Clear pending interrupts
	rpi_sys_timer->cs = SYS_TIMER_1;

	// Find a timer slot
	int timer_id = 0;
	for (; timer_id < MAX_TIMERS; timer_id++)
	{
		if (timers[timer_id].callback == NULL)
		{
			sys_timer_t* timer = &timers[timer_id];
			timer->interval = interval;
			timer->count = count;
			timer->callback = callback;
			timer->deadline = sys_timer_get_time() + timer->interval;
			num_timers++;
			break;
		}
	}

	// Re-enable interrupts
	_enable_interrupts();

	// Return the timer id
	return timer_id;
}

//
// Invoke registered timers
//
void invoke_timers()
{
	// If there's no timers, early out
	if (num_timers == 0)
		return;

	// Take current time for all timers
	sys_time_t time = sys_timer_get_time();

	// Check timers
	for (int i = 0; i < MAX_TIMERS; i++)
	{
		// Check whether the timer is enabled and elapsed
	if (timers[i].callback != NULL)
		{
			if (timers[i].deadline < time)
			{
				// Determine new deadline before processing the timer
				timers[i].deadline = sys_timer_get_time() + timers[i].interval;

				// Invoke the callback
				timers[i].callback(i);

				// If there's a counter and the decrement goes to zero, uninstall it
				if (timers[i].count && --timers[i].count == 0)
				{
					timers[i].interval = 0;
					timers[i].count = 0;
					timers[i].deadline = 0;
					timers[i].callback = NULL;
					--num_timers;
				}
			}
		}
	}
}

//
// Set next compare value
//
static inline void sys_timer_set_compare()
{
	// Initialize previous interrupt time with current time
	static sys_time_t prev_time = 0;
	if (prev_time == 0)
		prev_time = rpi_sys_timer->clo;

	// Set next time as previous time plus interval
	sys_time_t next_time = prev_time + sys_timer_interval;
	rpi_sys_timer->c1 = next_time;

	// Store scheduled time as previous time
	prev_time = next_time;
}

//
// Interrupt called for the system timer
//
void sys_timer_interrupt()
{
	// Clear the interrupt bit
	rpi_sys_timer->cs = (1 << 1);

	// Invoke the timers
	invoke_timers();

	// Set next compare value
	sys_timer_set_compare();
}

//
// Enable the system timer
//
void sys_timer_enable()
{
	TRACE("Enabling system timer at %u us", sys_timer_interval);

	// Disable interrupts
	_disable_interrupts();

	// Set initial compare value
	sys_timer_set_compare();

	// Register handler for timer
	register_irq_handler(1, &sys_timer_interrupt);

	// Enable interrupts
	_enable_interrupts();
}


text:
module Hookit
  module Resource
    class Directory < Base

      field :path
      field :recursive
      field :mode
      field :owner
      field :group

      actions :create, :delete
      default_action :create

      def initialize(name)
        path name unless path
        super
      end

      def run(action)
        case action
        when :create
          create!
          chown!
          chmod!
        when :delete
          delete!
        end
      end

      protected

      def create!
        return if ::File.exists? path
        cmd = "mkdir #{"-p " if recursive}#{path}"
        `#{cmd}`
        code = $?.exitstatus
        if code != 0
          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
        end
      end

      def delete!
        return if not ::File.exists? path
        cmd = "rm -rf #{path}"
        `#{cmd}`
        code = $?.exitstatus
        if code != 0
          raise Hookit::Error::UnexpectedExit, "#{cmd} failed with exit code '#{code}'"
        end
      end

      def chown!
        return unless owner or group
        if ::File.exists? path
          `chown #{(group.nil?) ? owner : "#{owner}:#{group}"} #{path}`
        end
      end

      def chmod!
        if ::File.exists? path and mode
          ::File.chmod(mode, path)
        end
      end

    end
  end
end


text:
__source__ = 'https://leetcode.com/problems/word-ladder/tabs/description'
# https://github.com/kamyu104/LeetCode/blob/master/Python/word-ladder.py
# Time:  O(n * d), n is length of string, d is size of dictionary
# Space: O(d)
# BFS
#
# Description: Leetcode # 127. Word Ladder
#
# Given two words (start and end), and a dictionary,
# find the length of shortest transformation sequence from start to end, such that:
#
# Only one letter can be changed at a time
# Each intermediate word must exist in the dictionary
# For example,
#
# Given:
# start = "hit"
# end = "cog"
# dict = ["hot","dot","dog","lot","log"]
# As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
# return its length 5.
#
# Note:
# Return 0 if there is no such transformation sequence.
# All words have the same length.
# All words contain only lowercase alphabetic characters.
# You may assume no duplicates in the word list.
# You may assume beginWord and endWord are non-empty and are not the same.
# UPDATE (2017/1/20):
# The wordList parameter had been changed to a list of strings (instead of a set of strings).
# Please reload the code definition to get the latest changes.
#
# Companies
# Amazon LinkedIn Snapchat Facebook Yelp
#
import unittest
#DFS #OT # not a goodway as it is asking for shortest path
class SolutionDFS(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: Set[str]
        :rtype: int
        """
        if beginWord == endWord:
            return 1;

        cnt = float("INF")
        for i in xrange(len(beginWord)):
            for j in 'abcdefghijklmnopqrstuvwxyz':
                can = beginWord[:i]+j+beginWord[i+1:]
                if can == endWord:
                    return 2
                elif can in wordList:
                    wordList.remove(can)
                    cnt = min(cnt, 1 + self.ladderLength(can, endWord, wordList))
                    wordList.add(can)
        return cnt if cnt != float("INF") else 0

# below BFS
# 185 ms
class SolutionFatest(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: Set[str]
        :rtype: int
        """
        cnt = 2
        begin = [beginWord]
        end = [endWord]
        visited = set([beginWord])

        while begin and end:
            if len(begin) > len(end):
                begin , end = end, begin

            cur = []
            for word in begin:
                for i in xrange(len(word)):
                    for j in "abcdefghijklmnopqrstuvwxyz":
                        can = word[:i] + j + word[i+1:]
                        if can in end:
                            return cnt
                        elif can not in visited and can in wordList:
                            cur.append(can)
                            visited.add(can)
            begin = cur
            cnt += 1
        return 0

class Solution:
    # @param start, a string
    # @param end, a string
    # @param dict, a set of string
    # @return an integer
    def ladderLength(self, start, end, dict):
        distance, cur, visited = 0, [start], set([start])
        dict.add(end)

        while cur:
            next = []
            for word in cur:
                if word == end:
                    return distance + 1
                for i in xrange(len(word)):
                    for j in 'abcdefghijklmnopqrstuvwxyz':
                        candidate = word[:i] + j + word[i + 1:]
                        if candidate not in visited and candidate in dict:
                            next.append(candidate)
                            visited.add(candidate)
            distance += 1
            cur = next
        return 0

class Solution2(object):
    def ladderLength(self, beginWord, endWord, wordList):
        wordList.add(endWord)
        q= []
        q.append([beginWord, 1])
        while q:
            currword, currlen  = q.pop(0)
            if currword == endWord:
                return currlen
            for i in range(len(currword)):
                part1 = currword[:i]
                part2 = currword[i+1:]
                for j in 'abcdefghijklmnopqrstuvwxyz':
                    if currword[i] != j:
                        nextword = part1 + j + part2
                        if nextword in wordList:
                            q.append((nextword, currlen+1))
                            wordList.remove(nextword)
        return 0

#http://www.programcreek.com/2012/12/leetcode-word-ladder/
# when start = hit -> hot, need to start from i loop instead of continue i loop
class Naive: #wrong answer
    # @param start, a string
    # @param end, a string
    # @param dict, a set of string
    # @return an integer
    def ladderLength(self, start, end, dict):
        ans = 0
        dict.add(end)
        for i in xrange(len(start)):
            for j in 'abcdefghijklmnopqrstuvwxyz':
                if start[i] == j :
                    continue
                candidate = start[:i] + j + start[i+1:]
                if candidate in dict:
                    ans += 1
                    start = candidate
                    if candidate == end:
                        return ans
        return ans

#test
class TestMethods(unittest.TestCase):
    def test_Local(self):
        self.assertEqual(1, 1)
        test = Solution()
        dict1 = {"hot","dot","dog","lot","log"}
        #print test.ladderLength("hit", "cog", dict1)

        print Solution().ladderLength("hit", "cog", set(["hot","dot","dog","lot","log"]))
        print Solution2().ladderLength("hit", "cog", set(["hot","dot","dog","lot","log"]))
        print Naive().ladderLength("hit", "cog", set(["ait","dot","dog","lot","log"]))

if __name__ == '__main__':
    unittest.main()

Java = '''
#Thought:

# Java Solution using Dijkstra's algorithm, with explanation
# 82.77% 63ms
class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) return 0;

        Set<String> reached = new HashSet<String>();
        Set<String> wordDict = new HashSet<String>(wordList);
        reached.add(beginWord);
        wordDict.add(endWord);
        int distance = 1;
        while (!reached.contains(endWord)) {
            Set<String> toAdd = new HashSet<String>();
            for (String each : reached) {
                for (int i = 0; i < each.length(); i++) {
                    char[] chars = each.toCharArray();
                    for (char ch = 'a'; ch <= 'z'; ch++) {
                        if (chars[i] == ch) continue;
                        chars[i] = ch;
                        String word = new String(chars);
                        if (wordDict.contains(word)) {
                            toAdd.add(word);
                            wordDict.remove(word);
                        }
                    }
                }
            }
            distance++;
            if (toAdd.size() == 0) return 0;
            reached = toAdd;
        }
        return distance;
    }
}

# 93.86 % 26ms
class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> dict = new HashSet<>(wordList);
        if (!dict.contains(endWord)) return 0;
        Set<String> startSet = new HashSet<String>() {{ add(beginWord); }};
        Set<String> endSet = new HashSet<String>() {{ add(endWord); }};
        return helper(dict, startSet, endSet, 1);
    }

     private int helper(Set<String> dict, Set<String> startSet, Set<String> endSet, int level) {
        if (startSet.isEmpty()) return 0;

        if (startSet.size() > endSet.size()) return helper(dict, endSet, startSet, level);

        // remove words from both ends
        for (String word : startSet) { dict.remove(word); };
        for (String word : endSet) { dict.remove(word); };

        // the set for next level
        Set<String> set = new HashSet<>();

        // for each string in the current level
        for (String str: startSet) {
            for (int i = 0; i < str.length(); i++) {
                char[] chars = str.toCharArray();

                for (char ch = 'a'; ch <= 'z'; ch++) {
                    if (chars[i] == ch) continue;
                    chars[i] = ch;
                    String word = new String(chars);
                     // found the word in other end(set)
                    if (endSet.contains(word)) return level + 1;
                    // if not, add to the next level
                    if (dict.contains(word)) set.add(word);
                }
            }
        }
        return helper(dict, endSet, set, level + 1);
     }

}

#14ms 99.93%
class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> wordset = new HashSet<String>(wordList);
        Set<String> start = new HashSet<String>();
        Set<String> end = new HashSet<String>();

        if(!wordset.contains(endWord)) {
            return 0;
        }
        start.add(beginWord);
        end.add(endWord);
        return helper(start, end, wordset, 1);
    }

    public int helper(Set<String> start, Set<String> end, Set<String> wordset, int level) {
        if(start.size() > end.size()) {
            return helper(end, start, wordset, level);
        }
        wordset.removeAll(start);
        wordset.removeAll(end);
        Set<String> next = new HashSet<String>();
        for(String s : start) {
            char[] arr = s.toCharArray();
            for(int i = 0; i< arr.length; i++){
                char temp = arr[i];
                for(char c = 'a'; c <= 'z';c++) {
                    if(c == arr[i]) {
                        continue;
                    }
                    arr[i] = c;
                    String newWord = new String(arr);
                    if(end.contains(newWord)) {
                        return level+1;
                    }
                    if(wordset.contains(newWord)) {
                        next.add(newWord);

                    }
                    arr[i] = temp;
                }
            }
        }
        if(next.isEmpty()) {
            return 0;
        }
        return helper(end, next, wordset, level+1);

    }
}
'''


text:
import {removeItem} from '#core/types/array';

import {installAmpdocServicesForInabox} from '#inabox/inabox-services';

import {AmpDocSingle} from '#service/ampdoc-impl';
import {installAmpdocServices} from '#service/core-services';

import * as Service from '../../src/service-helpers';

describes.sandboxed('amp-inabox', {}, () => {
  describes.realWin('installAmpdocServicesForInabox', {amp: false}, (env) => {
    it('should install same services for inabox', () => {
      let installedServices = [];
      const ampdoc = new AmpDocSingle(env.win);
      env.sandbox
        .stub(Service, 'registerServiceBuilderForDoc')
        .callsFake((ampdoc, id) => {
          installedServices.push(id);
        });
      env.sandbox
        .stub(Service, 'rejectServicePromiseForDoc')
        .callsFake((ampdoc, id) => {
          installedServices.push(id);
        });
      env.sandbox.stub(Service, 'getServiceForDoc').returns({});
      installAmpdocServices(ampdoc);

      const installedServicesByRegularAmp = installedServices.slice(0);
      // The inabox mode does not need the loading indicator.
      removeItem(installedServicesByRegularAmp, 'loadingIndicator');
      installedServices = [];
      installAmpdocServicesForInabox(ampdoc);
      expect(installedServices).to.deep.equal(installedServicesByRegularAmp);
    });
  });
});


text:
<!DOCTYPE html>

    <title>web starter app</title>
    <link rel="icon" type="image/png" href="/img/favicon.ico">
    <link rel="stylesheet" href="/css/bootstrap.min.css"/>
    <meta http-equiv="content-type" content="text/html; charset=UTF8">
    <link rel="stylesheet" href="/css/main.css"/>


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:fab="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <include
        android:id="@+id/layout_main_head"
        layout="@layout/header_back" />

    <FrameLayout
        android:id="@+id/wall_ad"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true" />

    <FrameLayout
        android:id="@+id/wall_ly"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_above="@+id/wall_ad"
        android:layout_below="@+id/layout_main_head" >

        <ListView
            android:id="@+id/wall_list"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />

        <com.melnykov.fab.FloatingActionButton
            android:id="@+id/button_floating_action"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="bottom|right"
            android:layout_margin="16dp"
            android:src="@drawable/ic_action_content_new"
            fab:fab_colorNormal="@color/primary"
            fab:fab_colorPressed="@color/primary_pressed" />
    </FrameLayout>

</RelativeLayout>


text:
package net.ripe.db.whois.update.dao;

import net.ripe.db.whois.common.rpsl.ObjectType;
import net.ripe.db.whois.common.domain.PendingUpdate;
import org.joda.time.LocalDateTime;

import java.util.List;

public interface PendingUpdateDao {
    List<PendingUpdate> findByTypeAndKey(ObjectType type, String key);

    void store(PendingUpdate pendingUpdate);

    void remove(PendingUpdate pendingUpdate);

    List<PendingUpdate> findBeforeDate(LocalDateTime date);
}


text:
using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using SFA.DAS.EmployerAccounts.Configuration;
using SFA.DAS.EmployerAccounts.Data;
using SFA.DAS.EmployerAccounts.Models;
using SFA.DAS.EmployerAccounts.Models.Account;
using SFA.DAS.EmployerAccounts.Models.AccountTeam;
using SFA.DAS.NLog.Logger;
using SFA.DAS.Sql.Client;
using SFA.DAS.Testing.Helpers;

namespace SFA.DAS.EmployerAccounts.IntegrationTests.Data
{
    [TestFixture]
    public class EmployerAccountTeamRepositoryTests
    {
        [Test]
        public async Task Constructor_Valid_ShouldNotThrowException()
        {
            var fixtures = new EmployerAccountTeamRepositoryTestFixtures();

            await fixtures.CheckEmployerAccountTeamRepository(repo => Task.CompletedTask);

            Assert.Pass("Did not get an exception");
        }

        [Test]
        public Task GetMember_ForActiveUser_ShouldExecuteQueryWithoutExecption()
        {
            // Arrange
            string email = $"{Guid.NewGuid().ToString()}@foo.com";

            var fixtures = new EmployerAccountTeamRepositoryTestFixtures()
                .WithNewAccountAndActiveUser(email, Role.Owner, out var hashedId);

            return fixtures.CheckEmployerAccountTeamRepository(async repo =>
            {
                var member = await repo.GetMember(hashedId, email, true);
                Assert.IsNotNull(member);
                Assert.AreEqual(email, member.Email);
            });
        }

        [TestCase(InvitationStatus.Pending, 5)]
        [TestCase(InvitationStatus.Deleted, 5)]
        [TestCase(InvitationStatus.Expired, -1)]
        public Task GetMember_ForNonActiveUser_ShouldExecuteQueryWithoutExecption(InvitationStatus status, int daysUntilExpiry)
        {
            // Arrange
            string email = $"{Guid.NewGuid().ToString()}@foo.com";

            var fixtures = new EmployerAccountTeamRepositoryTestFixtures()
                .WithInvitation(status, DateTime.Now.AddDays(daysUntilExpiry), email, out var hashedId);

            return fixtures.CheckEmployerAccountTeamRepository(async repo =>
            {
                var member = await repo.GetMember(hashedId, email, true);
                Assert.IsNull(member);
            });
        }
    }

    class EmployerAccountTeamRepositoryTestFixtures
    {
        public EmployerAccountTeamRepositoryTestFixtures()
        {
            EmployerAccountsConfiguration = ConfigurationTestHelper.GetConfiguration<EmployerAccountsConfiguration>(ConfigurationKeys.EmployerAccounts);

            LoggerMock = new Mock<ILog>();
        }

        public EmployerAccountsConfiguration EmployerAccountsConfiguration { get; }

        public Mock<ILog> LoggerMock { get; private set; }
        public ILog Logger => LoggerMock.Object;

        public EmployerAccountTeamRepositoryTestFixtures WithNewAccountAndActiveUser(string email, Role role, out string hashedId)
        {
            using (var db = CreateDbContext())
            {
                var account = CreateAccount(db);
                hashedId = account.HashedId;

                var user = db.Users.Create();
                user.FirstName = email;
                user.LastName = "User created for unit test";
                user.Email = email;
                user.Ref = Guid.NewGuid();

                var membership = db.Memberships.Create();
                membership.Account = account;
                membership.User = user;
                membership.Role = role;
                membership.CreatedDate = DateTime.Now;

                db.Users.Add(user);
                db.Memberships.Add(membership);
                db.SaveChanges();
            }

            return this;
        }

        public EmployerAccountTeamRepositoryTestFixtures WithInvitation(
            InvitationStatus status,
            DateTime expiryDate,
            string email,
            out string hashedId)
        {
            using (var db = CreateDbContext())
            {
                var account = CreateAccount(db);
                hashedId = account.HashedId;

                db.SaveChanges();

                var invitation = new Invitation
                {
                    AccountId = account.Id,
                    Status = status,
                    ExpiryDate = expiryDate,
                    Email = email
                };

                CheckInvitationRepository(repo => repo.Create(invitation));
            }

            return this;
        }

        public Task CheckEmployerAccountTeamRepository(Func<EmployerAccountTeamRepository, Task> action)
        {
            return RunWithTransaction(
                repositoryCreator: db => new EmployerAccountTeamRepository(EmployerAccountsConfiguration, Logger,
                    new Lazy<EmployerAccountsDbContext>(() => db)),
                action: action);
        }

        public Task CheckInvitationRepository(Func<InvitationRepository, Task> action)
        {
            return RunWithTransaction(
                repositoryCreator: db => new InvitationRepository(EmployerAccountsConfiguration, Logger,
                    new Lazy<EmployerAccountsDbContext>(() => db)),
                action: action);
        }

        private async Task RunWithTransaction<TRepository>(
            Func<EmployerAccountsDbContext, TRepository> repositoryCreator,
            Func<TRepository, Task> action) where TRepository : BaseRepository
        {
            using (var db = CreateDbContext())
            {
                db.Database.BeginTransaction();

                try
                {
                    var repo = repositoryCreator(db);
                    await action(repo);

                    db.Database.CurrentTransaction.Commit();
                }
                catch (Exception)
                {
                    db.Database.CurrentTransaction.Rollback();
                    throw;
                }
            }
        }

        private Account CreateAccount(EmployerAccountsDbContext db)
        {
            var hashedId = GetNextHashedIdForTests(db);
            var account = db.Accounts.Create();
            account.CreatedDate = DateTime.Now;
            account.HashedId = hashedId;
            account.Name = $"Account created for unit test {hashedId}";
            db.Accounts.Add(account);

            return account;
        }

        private string GetNextHashedIdForTests(EmployerAccountsDbContext dbContext)
        {
            var regex = new Regex("ZZ[0-9]{4}");

            var maxHashedId = dbContext.Accounts
                .Where(ac => ac.HashedId.StartsWith("ZZ"))
                .AsEnumerable()
                .Where(ac => regex.IsMatch(ac.HashedId))
                .Max(ac => ac.HashedId);

            if (string.IsNullOrWhiteSpace(maxHashedId))
            {
                return "ZZ0001";
            }
            else
            {
                var intPart = int.Parse(maxHashedId.Substring(2, 4)) + 1;
                return $"ZZ{intPart:D4}";
            }
        }

        private EmployerAccountsDbContext CreateDbContext()
        {
            return new EmployerAccountsDbContext(EmployerAccountsConfiguration.DatabaseConnectionString);
        }
    }
}


text:
#pragma once

#include "SYCL/detail/common.h"
#include "SYCL/detail/debug.h"
#include <type_traits>

namespace cl {
namespace sycl {

// Forward declaration
template <int dimensions>
struct id;

namespace detail {

// Forward declaration
void kernel_add(string_class line);

/**
 * Data reference wrappers
 */
class data_ref {
 public:
  enum class type_t {
    general,
    numeric,
    id_global,
    id_local,
    range_global,
    range_local,
    expression,
  };

  static const string_class open_parenthesis;
  string_class name;
  type_t type;

  static string_class get_name(const data_ref& dref) {
    return dref.name;
  }

  template <typename T, typename std::enable_if<
                            std::is_arithmetic<T>::value>::type* = nullptr>
  static string_class get_name(const T& n) {
    return get_string<T>::get(n);
  }

  template <typename T,
            typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
  static string_class get_name(const T& n) {
    auto value = static_cast<typename std::underlying_type<T>::type>(n);
    return get_string<decltype(value)>::get(value);
  }

  data_ref(string_class name) : name(name) {}

  data_ref(char* name) : name(name) {}

  data_ref(const char* name) : name(name) {}

  template <class T>
  data_ref(T&& type) : name(get_name(type)) {}

  data_ref(const data_ref& copy) = default;
#if MSVC_2013_OR_LOWER
  data_ref(data_ref&& move) : SYCL_MOVE_INIT(name), SYCL_MOVE_INIT(type) {}
  friend void swap(data_ref& first, data_ref& second) {
    using std::swap;
    SYCL_SWAP(name);
    SYCL_SWAP(type);
  }
#else
  data_ref(data_ref&&) = default;
#endif
  ~data_ref() = default;

  // We need to generate a new line, no matter whether moving or copying
  data_ref& operator=(const data_ref& dref) {
    kernel_add(name + " = " + dref.name);
    return *this;
  }
  data_ref& operator=(data_ref&& dref) noexcept {
    kernel_add(name + " = " + dref.name);
    return *this;
  }

  // TODO(progtx):
  // https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/operators.html

#define SYCL_ASSIGNMENT_OPERATOR(op)              \
  template <class T>                              \
  data_ref& operator op(const T& n) {             \
    kernel_add(name + " " #op " " + get_name(n)); \
    return *this;                                 \
  }

#define SYCL_DATA_REF_OPERATOR(op)                                             \
  template <class T>                                                           \
  data_ref operator op(const T& n) const {                                     \
    return data_ref(open_parenthesis + name + " " #op " " + get_name(n) +      \
                    ')');                                                      \
  }                                                                            \
  template <typename T,                                                        \
            typename std::enable_if<std::is_arithmetic<T>::value>::type* =     \
                nullptr>                                                       \
  friend data_ref operator op(const T& n, const data_ref& dref) {              \
    return data_ref(open_parenthesis + get_name(n) + " " #op " " + dref.name + \
                    ')');                                                      \
  }

  SYCL_ASSIGNMENT_OPERATOR(=);

  // Arithmetic operatos
  SYCL_DATA_REF_OPERATOR(+);
  SYCL_ASSIGNMENT_OPERATOR(+=);
  SYCL_DATA_REF_OPERATOR(-);
  SYCL_ASSIGNMENT_OPERATOR(-=);
  SYCL_DATA_REF_OPERATOR(*);
  SYCL_ASSIGNMENT_OPERATOR(*=);
  SYCL_DATA_REF_OPERATOR(/);
  SYCL_ASSIGNMENT_OPERATOR(/=);
  SYCL_DATA_REF_OPERATOR(%);
  SYCL_ASSIGNMENT_OPERATOR(%=);

  // Comparison operators
  SYCL_DATA_REF_OPERATOR(==);
  SYCL_DATA_REF_OPERATOR(!=);
  SYCL_DATA_REF_OPERATOR(<);
  SYCL_DATA_REF_OPERATOR(<=);
  SYCL_DATA_REF_OPERATOR(>);
  SYCL_DATA_REF_OPERATOR(>=);

  // Boolean operators
  SYCL_DATA_REF_OPERATOR(||);
  SYCL_DATA_REF_OPERATOR(&&);

  // Bit operators
  SYCL_DATA_REF_OPERATOR(&);
  SYCL_ASSIGNMENT_OPERATOR(&=);
  SYCL_DATA_REF_OPERATOR(|);
  SYCL_ASSIGNMENT_OPERATOR(|=);
  SYCL_DATA_REF_OPERATOR (^);
  SYCL_ASSIGNMENT_OPERATOR(^=);

  // Shifts
  SYCL_DATA_REF_OPERATOR(>>);
  SYCL_ASSIGNMENT_OPERATOR(>>=);
  SYCL_DATA_REF_OPERATOR(<<);
  SYCL_ASSIGNMENT_OPERATOR(<<=);

#undef SYCL_ASSIGNMENT_OPERATOR
#undef SYCL_DATA_REF_OPERATOR

  // TODO(progtx): Increment and decrement can be either a statement or an
  // expression
  // But there is no way to distinguish it
  // Here presume an expression
  data_ref operator++() const {
    return data_ref(open_parenthesis + "++" + name + ')');
  }
  data_ref operator++(int) const {
    return data_ref(open_parenthesis + name + "++" + ')');
  }
  data_ref operator--() const {
    return data_ref(open_parenthesis + "--" + name + ')');
  }
  data_ref operator--(int) const {
    return data_ref(open_parenthesis + name + "--" + ')');
  }

  data_ref operator!() const {
    return data_ref(open_parenthesis + '!' + name + ')');
  }
};

}  // namespace detail

}  // namespace sycl
}  // namespace cl


text:
Docker build file for Team City server. You need to have [Docker](https://www.docker.com/) installed and running to make this useful.
Container is exposing default Teamcity port `8111` and data volume is at `/data/teamcity`

## Build from source

### How to build

```
git clone https://github.com/gabrianoo/docker-teamcity.git
docker build -t docker-teamcity docker-teamcity
docker build -t docker-teamcity-data
```

### How to run

```
# Running the teamcity data volume
docker run -d --name docker-teamcity-data docker-teamcity-data
# Running the teamcity server
docker run -d --name docker-teamcity --volumes-from docker-teamcity-data -p 8111:8111 docker-teamcity
# Running the teamcity agent
docker run -d --name docker-teamcity-agent -e TEAMCITY_SERVER=http://<TC_SERVER_IP>:<TC_SERVER_PORT> \
-p 9090:9090 docker-teamcity-agent
```

### Checking everything is OK

Go to the docker engine URL [I assume it is localhost] `http://localhost:8111/tc`

## Versions

### Teamcity Latest

#### What is inside

1. Ubuntu 14.04
2. Oracle Java 8 Latest
3. Teamcity Latest

#### How to run

```
docker run -d --name teamcity-data otasys/teamcity-data
docker run -d --name teamcity -p 8111:8111 --volumes-from teamcity-data otasys/teamcity
```

### Teamcity [9.1.4](https://github.com/gabrianoo/docker-teamcity/releases/tag/9.1.4)

#### What is inside

1. Ubuntu 14.04
2. Java 1.8.0_66
3. Teamcity 9.1.4

#### How to run

```
docker run -d --name teamcity-data otasys/teamcity-data
docker run -d --name teamcity -p 8111:8111 --volumes-from teamcity-data otasys/teamcity:9.1.4
```

### Teamcity [9.1.3](https://github.com/gabrianoo/docker-teamcity/releases/tag/9.1.3)

#### What is inside

1. Ubuntu 14.04
2. Java 1.8.0_66
3. Teamcity 9.1.3

#### How to run

```
docker run -d --name teamcity-data otasys/teamcity-data
docker run -d --name teamcity -p 8111:8111 --volumes-from teamcity-data otasys/teamcity:9.1.3
```


text:
package javax.persistence;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static javax.persistence.FetchType.LAZY;

/**
 * Defines a many-valued association with one-to-many multiplicity.
 *
 *
 If the collection is defined using generics to specify the
 * element type, the associated target entity type need not be
 * specified; otherwise the target entity class must be specified.
 * If the relationship is bidirectional, the
 *  mappedBy element must be used to specify the relationship field or
 * property of the entity that is the owner of the relationship.
 *
 *
 The OneToMany annotation may be used within an embeddable class
 * contained within an entity class to specify a relationship to a
 * collection of entities. If the relationship is bidirectional, the
 *  mappedBy element must be used to specify the relationship field or
 * property of the entity that is the owner of the relationship.
 *
 * When the collection is a java.util.Map, the cascade
 * element and the orphanRemoval element apply to the map value.
 *
 *

 *
 *    Example 1: One-to-Many association using generics
 *
 *    // In Customer class:
 *
 *    @OneToMany(cascade=ALL, mappedBy="customer")
 *    public Set<Order> getOrders() { return orders; }
 *
 *    In Order class:
 *
 *    @ManyToOne
 *    @JoinColumn(name="CUST_ID", nullable=false)
 *    public Customer getCustomer() { return customer; }
 *
 *
 *    Example 2: One-to-Many association without using generics
 *
 *    // In Customer class:
 *
 *    @OneToMany(targetEntity=com.acme.Order.class, cascade=ALL,
 *                mappedBy="customer")
 *    public Set getOrders() { return orders; }
 *
 *    // In Order class:
 *
 *    @ManyToOne
 *    @JoinColumn(name="CUST_ID", nullable=false)
 *    public Customer getCustomer() { return customer; }
 *
 *
 *    Example 3: Unidirectional One-to-Many association using a foreign key mapping
 *
 *    // In Customer class:
 *
 *    @OneToMany(orphanRemoval=true)
 *    @JoinColumn(name="CUST_ID") // join column is in table for Order
 *    public Set<Order> getOrders() {return orders;}
 *
 *

 *
 * @since Java Persistence 1.0
 */
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface OneToMany {

    /**
     * (Optional) The entity class that is the target
     * of the association. Optional only if the collection
     * property is defined using Java generics.
     * Must be specified otherwise.
     *
     *
 Defaults to the parameterized type of
     * the collection when defined using generics.
     */
    Class targetEntity() default void.class;

    /**
     * (Optional) The operations that must be cascaded to
     * the target of the association.
     *
 Defaults to no operations being cascaded.
     *
     *
 When the target collection is a {@link java.util.Map
     * java.util.Map}, the cascade element applies to the
     * map value.
     */
    CascadeType[] cascade() default {};

    /** (Optional) Whether the association should be lazily loaded or
     * must be eagerly fetched. The EAGER strategy is a requirement on
     * the persistence provider runtime that the associated entities
     * must be eagerly fetched.  The LAZY strategy is a hint to the
     * persistence provider runtime.
     */
    FetchType fetch() default LAZY;

    /**
     * The field that owns the relationship. Required unless
     * the relationship is unidirectional.
     */
    String mappedBy() default "";

    /**
     * (Optional) Whether to apply the remove operation to entities that have
     * been removed from the relationship and to cascade the remove operation to
     * those entities.
     * @since Java Persistence 2.0
     */
    boolean orphanRemoval() default false;
}


text:
package org.knowm.sundial.ee;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.knowm.sundial.SundialJobScheduler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A ServletContextListner that can be used to initialize Sundial.
 *
 *
The init parameter 'quartz:shutdown-on-unload' can be used to specify whether you want
 * scheduler.shutdown() called when the listener is unloaded (usually when the application server is
 * being shutdown). Possible values are "true" or "false". The default is "true".
 *
 *
The init parameter 'quartz:wait-on-shutdown' has effect when 'quartz:shutdown-on-unload' is
 * specified "true", and indicates whether you want scheduler.shutdown(true) called when the
 * listener is unloaded (usually when the application server is being shutdown). Passing "true" to
 * the shutdown() call causes the scheduler to wait for existing jobs to complete. Possible values
 * are "true" or "false". The default is "false".
 *
 *
The init parameter 'quartz:start-on-load' can be used to specify whether you want the
 * scheduler.start() method called when the listener is first loaded. If set to false, your
 * application will need to call the start() method before the scheduler begins to run and process
 * jobs. Possible values are "true" or "false". The default is "true", which means the scheduler is
 * started.
 *
 *
The init parameter 'quartz:start-delay-seconds' can be used to specify the amount of time to
 * wait after initializing the scheduler before scheduler.start() is called.
 *
 * @author James House
 * @author Chuck Cavaness
 * @author John Petrocik
 * @author timmolter
 */
public class SundialInitializerListener implements ServletContextListener {

  private boolean performShutdown = true;

  private boolean waitOnShutdown = false;

  private final Logger logger = LoggerFactory.getLogger(getClass());

  @Override
  public void contextInitialized(ServletContextEvent servletContextEvent) {

    logger.info("Sundial Initializer Servlet loaded, initializing Scheduler...");

    ServletContext servletContext = servletContextEvent.getServletContext();
    try {

      String shutdownPrefString = servletContext.getInitParameter("shutdown-on-unload");

      if (shutdownPrefString != null) {
        performShutdown = Boolean.valueOf(shutdownPrefString).booleanValue();
      }
      String shutdownWaitPrefString = servletContext.getInitParameter("wait-on-shutdown");
      if (shutdownPrefString != null) {
        waitOnShutdown = Boolean.valueOf(shutdownWaitPrefString).booleanValue();
      }

      // THREAD POOL SIZE
      int threadPoolSize = 10; // ten is default
      String threadPoolSizeString = servletContext.getInitParameter("thread-pool-size");

      try {
        if (threadPoolSizeString != null && threadPoolSizeString.trim().length() > 0) {
          threadPoolSize = Integer.parseInt(threadPoolSizeString);
        }
      } catch (Exception e) {
        logger.error(
            "Cannot parse value of 'thread-pool-size' to an integer: "
                + threadPoolSizeString
                + ", defaulting to 10 threads.");
      }

      // JOBS PACKAGE NAME
      String packageName = servletContext.getInitParameter("annotated-jobs-package-name");

      // Always want to get the scheduler, even if it isn't starting,
      // to make sure it is both initialized and registered.
      SundialJobScheduler.createScheduler(threadPoolSize, packageName);

      // Give a reference to the servletContext so jobs can access "global" webapp objects
      SundialJobScheduler.setServletContext(servletContext);

      // Should the Scheduler being started now or later
      String startOnLoadString = servletContext.getInitParameter("start-scheduler-on-load");

      int startDelay = 0;
      String startDelayString = servletContext.getInitParameter("start-delay-seconds");

      try {
        if (startDelayString != null && startDelayString.trim().length() > 0) {
          startDelay = Integer.parseInt(startDelayString);
        }
      } catch (Exception e) {
        logger.error(
            "Cannot parse value of 'start-delay-seconds' to an integer: "
                + startDelayString
                + ", defaulting to 5 seconds.");
        startDelay = 5;
      }

      if (startOnLoadString == null || (Boolean.valueOf(startOnLoadString).booleanValue())) {
        if (startDelay <= 0) {
          // Start now
          SundialJobScheduler.getScheduler().start();
          logger.info("Sundial Scheduler has been started...");
        } else {
          // Start delayed
          SundialJobScheduler.getScheduler().startDelayed(startDelay);
          logger.info("Sundial Scheduler will start in " + startDelay + " seconds.");
        }
      } else {
        logger.info("Sundial Scheduler has not been started. Use scheduler.start()");
      }

      String globalLockOnLoadString = servletContext.getInitParameter("global-lock-on-load");
      boolean globalLockOnLoad = false;
      if (globalLockOnLoadString != null) {
        globalLockOnLoad = Boolean.valueOf(globalLockOnLoadString).booleanValue();
        if (globalLockOnLoad) {
          SundialJobScheduler.lockScheduler();
          logger.info("Sundial Scheduler has been locked.");
        }
      }

    } catch (Exception e) {
      logger.error("Sundial Scheduler failed to initialize: ", e);
    }
  }

  @Override
  public void contextDestroyed(ServletContextEvent sce) {

    if (!performShutdown) {
      return;
    }

    try {
      if (SundialJobScheduler.getScheduler() != null) {
        SundialJobScheduler.getScheduler().shutdown(waitOnShutdown);
      }
    } catch (Exception e) {
      logger.error("Sundial Scheduler failed to shutdown cleanly: ", e);
    }

    logger.info("Sundial Scheduler successful shutdown.");
  }
}