/*
 *     Generated by class-dump 3.3.4 (64 bit).
 *
 *     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2011 by Steve Nygard.
 */

#import "NSObject.h"

@interface VKCacheNode : NSObject
{
    struct VKCacheKey _key;
    id _value;
    VKCacheNode *_next;
    VKCacheNode *_previous;
}

@property(nonatomic) VKCacheNode *previous; // @synthesize previous=_previous;
@property(retain, nonatomic) VKCacheNode *next; // @synthesize next=_next;
@property(retain, nonatomic) id value; // @synthesize value=_value;
@property(nonatomic) struct VKCacheKey key; // @synthesize key=_key;
- (id).cxx_construct;
- (void)dealloc;

@end

{'repo_name': 'MP0w/iOS-Headers', 'stars': '405', 'repo_language': 'Objective-C', 'file_name': 'IMAVChat-IMAVChatAudioAdditions.h', 'mime_type': 'text/x-objective-c', 'hash': -1824883409943533348, 'source_dataset': 'data'}


var searchData=
[
  ['join',['join',['../classnabu_1_1neuralnetworks_1_1trainers_1_1trainer_1_1ParameterServer.html#af0e95d63b397aed2114b4f0bc87a2ecf',1,'nabu::neuralnetworks::trainers::trainer::ParameterServer']]]
];

{'repo_name': 'vrenkens/nabu', 'stars': '112', 'repo_language': 'Python', 'file_name': 'validation_evaluator.cfg', 'mime_type': 'text/plain', 'hash': -5564814291627521479, 'source_dataset': 'data'}


// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
//
// MaterialX specification (c) 2017 Lucasfilm Ltd.
// http://www.materialx.org/

#include "mx_funcs.h"

shader mx_smoothstep_vector2
    [[ string help = "outputs a smooth (hermite-interpolated) remapping of input values from low-high to output 0-1."  ]]
  (
    vector2 in = {0,0}
        [[  string help = "input"  ]],
    vector2 low = {0,0}
        [[  string help = "input value of this or lower will return 0"  ]],
    vector2 high = {1,1}
        [[  string help = " an input value of this or higher will result in an output value of 1"  ]],
    output vector2 out = {0,0}
  )
{
    out = smoothstep(low, high, in);
}

{'repo_name': 'materialx/MaterialX', 'stars': '572', 'repo_language': 'C++', 'file_name': 'FindMaterialX.cmake', 'mime_type': 'text/plain', 'hash': 4364769398178738611, 'source_dataset': 'data'}


class AddWikiAttachmentsPermissions < ActiveRecord::Migration
  # model removed
  class Permission < ActiveRecord::Base; end

  def self.up
    Permission.create :controller => 'wiki', :action => 'add_attachment', :description => 'label_attachment_new', :sort => 1750, :is_public => false, :mail_option => 0, :mail_enabled => 0
    Permission.create :controller => 'wiki', :action => 'destroy_attachment', :description => 'label_attachment_delete', :sort => 1755, :is_public => false, :mail_option => 0, :mail_enabled => 0
  end

  def self.down
    Permission.find_by_controller_and_action('wiki', 'add_attachment').destroy
    Permission.find_by_controller_and_action('wiki', 'destroy_attachment').destroy
  end
end

{'repo_name': 'redmine/redmine-old', 'stars': '388', 'repo_language': 'Ruby', 'file_name': 'README', 'mime_type': 'text/plain', 'hash': 7740260985444999083, 'source_dataset': 'data'}


<?php
/**
 * OrangeHRM is a comprehensive Human Resource Management (HRM) System that captures
 * all the essential functionalities required for any enterprise.
 * Copyright (C) 2006 OrangeHRM Inc., http://www.orangehrm.com
 *
 * OrangeHRM is free software; you can redistribute it and/or modify it under the terms of
 * the GNU General Public License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * OrangeHRM is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program;
 * if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA
 */

use Orangehrm\Rest\Http\Request;
use Orangehrm\Rest\Api\Performance\PerformanceReviewAPI;
use Orangehrm\Rest\Api\Exception\NotImplementedException;

class PerformanceReviewApiAction extends baseRestAction
{

    private $apiPerformanceReview = null;

    protected function init(Request $request)
    {
        $this->apiPerformanceReview = new PerformanceReviewAPI($request);
    }

    protected function handleGetRequest(Request $request)
    {

        return $this->apiPerformanceReview->getPerformanceReviewDetails();
    }

    protected function handlePostRequest(Request $request)
    {
        throw new NotImplementedException('Not Implemented');
    }

    protected function handlePutRequest(Request $request)
    {
        throw new NotImplementedException('Not Implemented');

    }

}

{'repo_name': 'orangehrm/orangehrm', 'stars': '216', 'repo_language': 'PHP', 'file_name': 'AttendanceDao.yml', 'mime_type': 'text/plain', 'hash': -2260516346072368890, 'source_dataset': 'data'}


# Les objets Git

Git est un système de fichier adressables par contenu.
Super !
Mais qu'est-ce que ça veut dire ?
Ça veut dire que le cœur de Git est une simple base de paires clé/valeur.
Vous pouvez y insérer n'importe quelle sorte de données et il vous retournera une clé que vous pourrez utiliser à n'importe quel moment pour récupérer ces données.
Pour illustrer cela, vous pouvez utiliser la commande de plomberie `hash-object`, qui prend des données, les stocke dans votre répertoire `.git`, puis retourne la clé sous laquelle les données sont stockées.
Tout d'abord, créez un nouveau dépôt Git et vérifiez que rien ne se trouve dans le répertoire `object` :

	$ mkdir test
	$ cd test
	$ git init
	Initialized empty Git repository in /tmp/test/.git/
	$ find .git/objects
	.git/objects
	.git/objects/info
	.git/objects/pack
	$ find .git/objects -type f
	$

Git a initialisé le répertoire `objects` et y a créé les sous-répertoires `pack` et `info`, mais ils ne contiennent pas de fichier régulier.
Maintenant, stockez du texte dans votre base de données Git :

	$ echo 'test content' | git hash-object -w --stdin
	d670460b4b4aece5915caf5c68d12f560a9fe3e4

L'option `-w` spécifie à `hash-object` de stocker l'objet, sinon la commande répondrait seulement quelle serait la clé.
`--stdin` spécifie à la commande de lire le contenu depuis l'entrée standard, sinon `hash-object` s'attend à trouver un chemin vers un fichier.
La sortie de la commande est une empreinte de 40 caractères.
C'est l'empreinte SHA-1 : une somme de contrôle du contenu du fichier que vous stockez plus un en-tête, dont les détails sont un peu plus bas.
Voyez maintenant comment Git a stocké vos données :

	$ find .git/objects -type f
	.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

Vous pouvez voir un fichier dans le répertoire `objects`.
C'est comme cela que Git stocke initialement du contenu : un fichier par contenu, nommé d'après la somme de contrôle SHA-1 du contenu et de son en-tête.
Le sous-répertoire est nommé d'après les 2 premiers caractères de l'empreinte et le fichier d'après les 38 caractères restants.

Vous pouvez récupérer le contenu avec la commande `cat-file`.
Cette commande est un peu le couteau suisse pour l'inspection des objets Git.
Utiliser l'option `-p` avec `cat-file` vous permet de connaître le type de contenu et de l'afficher clairement :

	$ git cat-file -p d670460b4b4aece5915caf5c68d12f560a9fe3e4
	test content

Vous pouvez maintenant ajouter du contenu à Git et le récupérer.
Vous pouvez aussi faire ceci avec des fichiers.
Par exemple, vous pouvez mettre en œuvre une gestion de version simple d'un fichier.
D'abord, créez un nouveau fichier et enregistrez son contenu dans la base de données :

	$ echo 'version 1' > test.txt
	$ git hash-object -w test.txt
	83baae61804e65cc73a7201a7252750c76066a30

Puis, modifiez le contenu du fichier et enregistrez-le à nouveau :

	$ echo 'version 2' > test.txt
	$ git hash-object -w test.txt
	1f7a7a472abf3dd9643fd615f6da379c4acb3e3a

Votre base de données contient les 2 versions du fichier, ainsi que le premier contenu que vous avez stocké ici :

	$ find .git/objects -type f
	.git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a
	.git/objects/83/baae61804e65cc73a7201a7252750c76066a30
	.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

Vous pouvez restaurer le fichier à sa première version :

	$ git cat-file -p 83baae61804e65cc73a7201a7252750c76066a30 > test.txt
	$ cat test.txt
	version 1

ou à sa seconde version :

	$ git cat-file -p 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a > test.txt
	$ cat test.txt
	version 2

Se souvenir de la clé SHA-1 de chaque version de votre fichier n'est pas pratique.
En plus, vous ne stockez pas le fichier lui-même, mais seulement son contenu, dans votre base.
Ce type d'objet est appelé un blob (*Binary Large OBject*, soit en français : Gros Objet Binaire).
Git peut vous donner le type d'objet de n'importe quel objet Git, étant donné sa clé SHA-1, avec `cat-file -t` :

	$ git cat-file -t 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a
	blob

## Objets arbre

Le prochain type que vous allez étudier est l'objet arbre (*tree*) qui résout le problème de stockage d'un groupe de fichiers.
Git stocke du contenu de la même manière, mais plus simplement, qu'un système de fichier UNIX.
Tout le contenu est stocké comme des objets de type arbre ou blob : un arbre correspondant à un répertoire UNIX et un blob correspond à peu près à un i-nœud ou au contenu d'un fichier.
Un unique arbre contient une ou plusieurs entrées de type arbre, chacune incluant un pointeur SHA-1 vers un blob, un sous-arbre (*sub-tree*), ainsi que les droits d'accès (*mode*), le type et le nom de fichier.
L'arbre le plus récent du projet simplegit pourrait ressembler, par exemple à ceci :

	$ git cat-file -p master^{tree}
	100644 blob a906cb2a4a904a152e80877d4088654daad0c859      README
	100644 blob 8f94139338f9404f26296befa88755fc2598c289      Rakefile
	040000 tree 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0      lib

La syntaxe `master^{tree}` signifie l'objet arbre qui est pointé par le dernier *commit* de la branche `master`.
Remarquez que le sous-répertoire `lib` n'est pas un blob, mais un pointeur vers un autre arbre :

	$ git cat-file -p 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0
	100644 blob 47c6340d6459e05787f644c2447d2595f5d3a54b      simplegit.rb

Conceptuellement, les données que Git stocke ressemblent à la figure 9-1.

![](http://git-scm.com/figures/18333fig0901-tn.png)

Figure 9-1. Une version simple du modèle de données Git.

Vous pouvez créer votre propre arbre.
Git crée habituellement un arbre à partir de l'état de la zone d'attente ou de l'index.
Pour créer un objet arbre, vous devez donc d'abord mettre en place un index en mettant quelques fichiers en attente.
Pour créer un index contenant une entrée, la première version de votre fichier `test.txt` par exemple, utilisons la commande de plomberie `update-index`.
Vous pouvez utiliser cette commande pour ajouter artificiellement une version plus ancienne à une nouvelle zone d'attente.
Vous devez utiliser les options `--add` car le fichier n'existe pas encore dans votre zone d'attente (vous n'avez même pas encore mis en place une zone d'attente) et `--cacheinfo` car le fichier que vous ajoutez n'est pas dans votre répertoire, mais dans la base de données.
Vous pouvez ensuite préciser le mode, SHA-1 et le nom de fichier :

	$ git update-index --add --cacheinfo 100644 \
	  83baae61804e65cc73a7201a7252750c76066a30 test.txt

Dans ce cas, vous précisez le mode `100644`, qui signifie que c'est un fichier normal.
Les alternatives sont `100755`, qui signifie que c'est un exécutable et `120000`, qui précise que c'est un lien symbolique.
Le concept de « mode » a été repris des mode UNIX, mais est beaucoup moins flexible : ces trois modes sont les seuls valides pour Git, pour les fichiers (blobs) (bien que d'autres modes soient utilisés pour les répertoires et sous-modules).

Vous pouvez maintenant utiliser la commande `write-tree` pour écrire la zone d'attente dans un objet arbre.
L'option' `-w` est inutile (appeler `write-tree` crée automatiquement un objet arbre à partir de l'état de l'index si cet arbre n'existe pas) :

	$ git write-tree
	d8329fc1cc938780ffdd9f94e0d364e0ea74f579
	$ git cat-file -p d8329fc1cc938780ffdd9f94e0d364e0ea74f579
	100644 blob 83baae61804e65cc73a7201a7252750c76066a30      test.txt

Vous pouvez également vérifier que c'est un objet arbre :

	$ git cat-file -t d8329fc1cc938780ffdd9f94e0d364e0ea74f579
	tree

Vous allez créer maintenant un nouvel arbre avec la seconde version de `test.txt` et un nouveau fichier :

	$ echo 'new file' > new.txt
	$ git update-index test.txt
	$ git update-index --add new.txt

Votre zone d'attente contient maintenant la nouvelle version de `test.txt` ainsi qu'un nouveau fichier `new.txt`.
Enregistrez cet arbre (c'est-à-dire enregistrez l'état de la zone d'attente ou de l'index dans un objet arbre) :

	$ git write-tree
	0155eb4229851634a0f03eb265b69f5a2d56f341
	$ git cat-file -p 0155eb4229851634a0f03eb265b69f5a2d56f341
	100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
	100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

Remarquez que cet arbre contient des entrées pour les deux fichiers et que l'empreinte SHA de `test.txt` est l'empreinte de la « version 2 » de tout à l'heure (`1f7a7a`).
Pour le plaisir, ajoutez le premier arbre à celui-ci, en tant que sous-répertoire.
Vous pouvez maintenant récupérer un arbre de votre zone d'attente en exécutant `read-tree`.
Dans ce cas, vous pouvez récupérer un arbre existant dans votre zone d'attente comme étant un sous-arbre en utilisant l'option `--prefix` de `read-tree` :

	$ git read-tree --prefix=bak d8329fc1cc938780ffdd9f94e0d364e0ea74f579
	$ git write-tree
	3c4e9cd789d88d8d89c1073707c3585e41b0e614
	$ git cat-file -p 3c4e9cd789d88d8d89c1073707c3585e41b0e614
	040000 tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579      bak
	100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
	100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

Si vous créez un répertoire de travail à partir du nouvel arbre que vous venez d'enregistrer, vous aurez deux fichiers à la racine du répertoire de travail, ainsi qu'un sous-répertoire appelé `bak` qui contient la première version du fichier `test.txt`.
Vous pouvez vous représenter les données que Git utilise pour ces structures comme sur la figure 9-2.

![](http://git-scm.com/figures/18333fig0902-tn.png)

Figure 9-2. Structure du contenu de vos données Git actuelles.

## Objets *Commit*

Vous avez trois arbres qui définissent différents instantanés du projet que vous suivez, mais certains problèmes persistent : vous devez vous souvenir des valeurs des trois empreintes SHA-1 pour accéder aux instantanés.
Vous n'avez pas non plus d'information sur qui a enregistré les instantanés, quand et pourquoi.
Ce sont les informations élémentaires qu'un objet *commit* stocke pour vous.

Pour créer un objet *commit*, il suffit d'exécuter `commit-tree`, de préciser l'empreinte SHA-1 et quel objet *commit*, s'il y en a, le précède directement.
Commencez avec le premier arbre que vous avez créé :

	$ echo 'first commit' | git commit-tree d8329f
	fdf4fc3344e67ab068f836878b6c4951e3b15f3d

Vous pouvez voir votre nouvel objet *commit* avec `cat-file` :

	$ git cat-file -p fdf4fc3
	tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579
	author Scott Chacon <schacon@gmail.com> 1243040974 -0700
	committer Scott Chacon <schacon@gmail.com> 1243040974 -0700

	first commit

Le format d'un *commit* est simple : il contient l'arbre racine de l'instantané du projet à ce moment, les informations sur l'auteur et le validateur qui sont extraites des variables de configuration `user.name` et `user.email` accompagnées d'un horodatage, une ligne vide et le message de validation.

Ensuite, vous enregistrez les deux autres objets *commit*, chacun référençant le *commit* dont il est issu :

	$ echo 'second commit' | git commit-tree 0155eb -p fdf4fc3
	cac0cab538b970a37ea1e769cbbde608743bc96d
	$ echo 'third commit'  | git commit-tree 3c4e9c -p cac0cab
	1a410efbd13591db07496601ebc7a059dd55cfe9

Chacun des trois objets *commit* pointe sur un arbre de l'instantané que vous avez créé.
Curieusement, vous disposez maintenant d'un historique Git complet que vous pouvez visualiser avec la commande `git log`, si vous la lancez sur le SHA-1 du dernier *commit* :

	$ git log --stat 1a410e
	commit 1a410efbd13591db07496601ebc7a059dd55cfe9
	Author: Scott Chacon <schacon@gmail.com>
	Date:   Fri May 22 18:15:24 2009 -0700

	    third commit

	 bak/test.txt |    1 +
	 1 files changed, 1 insertions(+), 0 deletions(-)

	commit cac0cab538b970a37ea1e769cbbde608743bc96d
	Author: Scott Chacon <schacon@gmail.com>
	Date:   Fri May 22 18:14:29 2009 -0700

	    second commit

	 new.txt  |    1 +
	 test.txt |    2 +-
	 2 files changed, 2 insertions(+), 1 deletions(-)

	commit fdf4fc3344e67ab068f836878b6c4951e3b15f3d
	Author: Scott Chacon <schacon@gmail.com>
	Date:   Fri May 22 18:09:34 2009 -0700

	    first commit

	 test.txt |    1 +
	 1 files changed, 1 insertions(+), 0 deletions(-)

Fantastique.
Vous venez d'effectuer les opérations bas niveau pour construire un historique Git sans avoir utilisé aucune des commandes haut niveau.
C'est l'essence de ce que fait Git quand vous exécutez les commandes `git add` et `git commit`.
Il stocke les blobs correspondant aux fichiers modifiés, met à jour l'index, écrit les arbres et ajoute les objets *commit* qui référencent les arbres racines venant juste avant eux.
Ces trois objets principaux (le blob, l'arbre et le *commit*) sont initialement stockés dans des fichiers séparés du répertoire `.git/objects`.
Voici tous les objets contenus dans le répertoire exemple, commentés d'après leur contenu :

	$ find .git/objects -type f
	.git/objects/01/55eb4229851634a0f03eb265b69f5a2d56f341 # tree 2
	.git/objects/1a/410efbd13591db07496601ebc7a059dd55cfe9 # commit 3
	.git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a # test.txt v2
	.git/objects/3c/4e9cd789d88d8d89c1073707c3585e41b0e614 # tree 3
	.git/objects/83/baae61804e65cc73a7201a7252750c76066a30 # test.txt v1
	.git/objects/ca/c0cab538b970a37ea1e769cbbde608743bc96d # commit 2
	.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4 # 'test content'
	.git/objects/d8/329fc1cc938780ffdd9f94e0d364e0ea74f579 # tree 1
	.git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 # new.txt
	.git/objects/fd/f4fc3344e67ab068f836878b6c4951e3b15f3d # commit 1

Si vous suivez les pointeurs internes de ces objets, vous obtenez un graphe comme celui de la figure 9-3.

![](http://git-scm.com/figures/18333fig0903-tn.png)

Figure 9-3. Tous les objets de votre répertoire Git.

## Stockage des objets

On a parlé plus tôt de l'en-tête présent avec le contenu.
Prenons un moment pour étudier la façon dont Git stocke les objets.
On verra comment stocker interactivement un objet Blob (ici, la chaîne « what is up, doc? ») avec le langage Ruby.
Vous pouvez démarrer Ruby en mode interactif avec la commande `irb` :

	$ irb
	>> content = "what is up, doc?"
	=> "what is up, doc?"

Git construit un en-tête qui commence avec le type de l'objet, ici un blob.
Ensuite, il ajoute un espace suivi de taille du contenu et enfin un octet nul :

	>> header = "blob #{content.length}\0"
	=> "blob 16\000"

Git concatène l'en-tête avec le contenu original et calcule l'empreinte SHA-1 du nouveau contenu.
En Ruby, vous pouvez calculer l'empreinte SHA-1 d'une chaîne, en incluant la bibliothèque « digest/SHA-1 » via la commande `require`, puis en appelant `Digest::SHA1.hexdigest()` sur la chaîne :

	>> store = header + content
	=> "blob 16\000what is up, doc?"
	>> require 'digest/sha1'
	=> true
	>> sha1 = Digest::SHA1.hexdigest(store)
	=> "bd9dbf5aae1a3862dd1526723246b20206e5fc37"

Git compresse le nouveau contenu avec zlib, ce que vous pouvez faire avec la bibliothèque zlib de Ruby.
Vous devez inclure la bibliothèque et exécuter `Zlib::Deflate.deflate()` sur le contenu :

	>> require 'zlib'
	=> true
	>> zlib_content = Zlib::Deflate.deflate(store)
	=> "x\234K\312\311OR04c(\317H,Q\310,V(-\320QH\311O\266\a\000_\034\a\235"

Finalement, vous enregistrerez le contenu compressé dans un objet sur le disque.
Vous déterminerez le chemin de l'objet que vous voulez enregistrer (les deux premiers caractères de l'empreinte SHA-1 formeront le nom du sous-répertoire et les 38 derniers formeront le nom du fichier dans ce répertoire).
En Ruby, on peut utiliser la fonction `FileUtils.mkdir_p()` pour créer un sous-répertoire s'il n'existe pas.
Ensuite, ouvrez le fichier avec `File.open()` et enregistrez le contenu compressé en appelant la fonction `write()` sur la référence du fichier :

	>> path = '.git/objects/' + sha1[0,2] + '/' + sha1[2,38]
	=> ".git/objects/bd/9dbf5aae1a3862dd1526723246b20206e5fc37"
	>> require 'fileutils'
	=> true
	>> FileUtils.mkdir_p(File.dirname(path))
	=> ".git/objects/bd"
	>> File.open(path, 'w') { |f| f.write zlib_content }
	=> 32

C'est tout !
Vous venez juste de créer un objet Blob valide.
Tout les objets Git sont stockés de la même façon, mais avec des types différents : l'en-tête commencera par « commit » ou « tree » au lieu de la chaîne « blob ».
Bien que le contenu d'un blob puisse être presque n'importe quoi, le contenu  d'un *commit* ou d'un arbre est formaté d'une façon particulière.

{'repo_name': 'GitbookIO/git', 'stars': '264', 'repo_language': 'None', 'file_name': 'cd58eb48998d23f6657522cb0a713f0e.md', 'mime_type': 'text/plain', 'hash': -4795147567063175801, 'source_dataset': 'data'}


#ifndef _hls_media_h_
#define _hls_media_h_

#include <stdint.h>
#include <stddef.h>

#define HLS_FLAGS_KEYFRAME 0x8000

#ifdef __cplusplus
extern "C" {
#endif

typedef struct hls_media_t hls_media_t;

/// @param[in] param user-defined parameter(hls_media_create)
/// @param[in] data ts file content
/// @param[in] bytes ts file length in byte
/// @param[in] pts ts file first pts/dts(ms)
/// @param[in] dts ts file first pts/dts(ms)
/// @param[in] duration file duration(ms)
/// @return 0-ok, other-error
typedef int (*hls_media_handler)(void* param, const void* data, size_t bytes, int64_t pts, int64_t dts, int64_t duration);

/// param[in] duration ts segment duration(millisecond), 0-create segment per video key frame
hls_media_t* hls_media_create(int64_t duration, hls_media_handler handler, void* param);

void hls_media_destroy(hls_media_t* hls);

/// @param[in] avtype audio/video type (mpeg-ps.h STREAM_VIDEO_XXX/STREAM_AUDIO_XXX)
/// @param[in] data h264/h265 nalu with startcode(0x00000001), aac with adts
/// @param[in] bytes data length in byte, NULL-force new segment
/// @param[in] pts present timestamp in millisecond
/// @param[in] dts decode timestamp in millisecond
/// @param[in] flags HLS_FLAGS_XXX, such as HLS_FLAGS_KEYFRAME
/// @return 0-ok, other-error
int hls_media_input(hls_media_t* hls, int avtype, const void* data, size_t bytes, int64_t pts, int64_t dts, int flags);

#ifdef __cplusplus
}
#endif

#endif /* !_hls_media_h_*/

{'repo_name': 'ireader/media-server', 'stars': '960', 'repo_language': 'C', 'file_name': 'project.pbxproj', 'mime_type': 'text/plain', 'hash': -4143157987994075549, 'source_dataset': 'data'}


var convert = require('./convert'),
    func = convert('intersection', require('../intersection'));

func.placeholder = require('./placeholder');
module.exports = func;

{'repo_name': 'Voyzz/Fruit-store-mp', 'stars': '123', 'repo_language': 'JavaScript', 'file_name': 'index.js', 'mime_type': 'text/plain', 'hash': 8820524892474746726, 'source_dataset': 'data'}


libavfilter/vf_pullup.o: libavfilter/vf_pullup.c libavutil/avassert.h \
 libavutil/avutil.h libavutil/common.h libavutil/attributes.h \
 libavutil/macros.h libavutil/version.h libavutil/avconfig.h config.h \
 libavutil/intmath.h libavutil/mem.h libavutil/error.h \
 libavutil/internal.h libavutil/timer.h libavutil/log.h libavutil/cpu.h \
 libavutil/dict.h libavutil/pixfmt.h libavutil/libm.h \
 libavutil/intfloat.h libavutil/mathematics.h libavutil/rational.h \
 libavutil/imgutils.h libavutil/pixdesc.h libavutil/opt.h \
 libavutil/samplefmt.h libavutil/pixdesc.h libavfilter/avfilter.h \
 libavutil/attributes.h libavutil/avutil.h libavutil/buffer.h \
 libavutil/dict.h libavutil/frame.h libavutil/buffer.h libavutil/log.h \
 libavutil/samplefmt.h libavutil/pixfmt.h libavutil/rational.h \
 libavfilter/version.h libavutil/version.h libavfilter/formats.h \
 libavfilter/internal.h libavutil/internal.h libavfilter/avfiltergraph.h \
 libavfilter/framepool.h libavfilter/thread.h libavfilter/version.h \
 libavfilter/video.h libavcodec/avcodec.h libavutil/cpu.h \
 libavutil/channel_layout.h libavcodec/version.h libavfilter/vf_pullup.h

{'repo_name': 'zerochl/FFMPEG-AAC-264-Android-32-64', 'stars': '233', 'repo_language': 'C', 'file_name': 'h264qpel.c', 'mime_type': 'text/x-c', 'hash': 4654004357223417761, 'source_dataset': 'data'}


"""
    Copyright (C) 2017, ContraxSuite, LLC

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    You can also be released from the requirements of the license by purchasing
    a commercial license from ContraxSuite, LLC. Buying such a license is
    mandatory as soon as you develop commercial activities involving ContraxSuite
    software without disclosing the source code of your own applications.  These
    activities include: offering paid services to customers as an ASP or "cloud"
    provider, processing documents on the fly in a web application,
    or shipping ContraxSuite within a closed source product.
"""
# -*- coding: utf-8 -*-

from django.contrib import admin
from django.db.models import F

__author__ = "ContraxSuite, LLC; LexPredict, LLC"
__copyright__ = "Copyright 2015-2020, ContraxSuite, LLC"
__license__ = "https://github.com/LexPredict/lexpredict-contraxsuite/blob/1.7.0/LICENSE"
__version__ = "1.7.0"
__maintainer__ = "LexPredict, LLC"
__email__ = "support@contraxsuite.com"

from apps.analyze.models import (
    DocumentCluster, DocumentSimilarity, PartySimilarity,
    DocumentClassification, DocumentClassifier, DocumentClassifierSuggestion,
    TextUnitClassification, TextUnitClassifier, TextUnitClassifierSuggestion,
    TextUnitSimilarity, TextUnitCluster,
    DocumentTransformer, TextUnitTransformer, DocumentVector, TextUnitVector)

class DocumentClusterAdmin(admin.ModelAdmin):
    list_display = ('cluster_id', 'name', 'self_name', 'cluster_by', 'using')
    search_fields = ('name', 'self_name')

class TextUnitClusterAdmin(DocumentClusterAdmin):
    raw_id_fields = ('text_units',)

class DocumentSimilarityAdmin(admin.ModelAdmin):
    list_display = ('document_a', 'document_b', 'similarity')
    search_fields = ('document_a__name', 'document_b__name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.select_related('document_a', 'document_b') \
            .only('document_a__name', 'document_b__name', 'similarity')
        return qs

class PartySimilarityAdmin(admin.ModelAdmin):
    list_display = ('party_a', 'party_b', 'similarity')
    search_fields = ('party_a__name', 'party_b__name')

class TextUnitSimilarityAdmin(admin.ModelAdmin):
    list_display = ('similarity',
                    'document_a_name', 'text_unit_a_id',
                    'document_b_name', 'text_unit_b_id')
    search_fields = ('document_a_name', 'document_b_name',
                     'text_unit_a_id__exact', 'text_unit_b_id__exact')
    raw_id_fields = ('text_unit_a', 'text_unit_b')

    @staticmethod
    def document_a_name(obj):
        return obj.document_a_name

    @staticmethod
    def document_b_name(obj):
        return obj.document_b_name

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.annotate(document_a_name=F('text_unit_a__document__name'),
                         document_b_name=F('text_unit_b__document__name'))
        return qs

    def get_search_fields(self, request):
        q = request.GET.get('q')
        if q and q.isdigit():
            return 'text_unit_a_id__exact', 'text_unit_b_id__exact'
        return 'document_a_name', 'document_b_name'

class DocumentClassificationAdmin(admin.ModelAdmin):
    list_display = ('document_id', 'document', 'class_name', 'class_value')
    search_fields = ('document__name', 'class_name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.select_related('document') \
            .only('document_id', 'document__name', 'class_name', 'class_value')
        return qs

class DocumentClassifierAdmin(admin.ModelAdmin):
    list_display = ('name', 'version', 'class_name')
    search_fields = ('name', 'version', 'class_name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.only('name', 'version', 'class_name')
        return qs

class DocumentClassifierSuggestionAdmin(admin.ModelAdmin):
    list_display = ('classifier_id', 'document_id', 'classifier_run', 'classifier_confidence', 'class_name')
    search_fields = ('classifier__name', 'classifier__version', 'classifier_run', 'classifier_id',
                     'classifier_confidence', 'class_name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.select_related('classifier', 'document') \
            .only('classifier_id', 'classifier__name', 'document_id',
                  'classifier_run', 'classifier_confidence', 'class_name')
        return qs

class TextUnitClassificationAdmin(admin.ModelAdmin):
    list_display = ('text_unit_id', 'class_name', 'class_value')
    search_fields = ('text_unit__unit_type', 'class_name')
    raw_id_fields = ('text_unit',)

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.select_related('text_unit') \
            .only('text_unit_id', 'class_name', 'class_value')
        return qs

class TextUnitClassifierAdmin(admin.ModelAdmin):
    list_display = ('name', 'version', 'class_name')
    search_fields = ('name', 'version', 'class_name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.only('name', 'version', 'class_name')
        return qs

class TextUnitClassifierSuggestionAdmin(admin.ModelAdmin):
    list_display = ('classifier_id', 'text_unit_id', 'classifier_run', 'classifier_confidence', 'class_name')
    search_fields = ('classifier__name', 'classifier__version', 'classifier_run', 'classifier_id',
                     'classifier_confidence', 'class_name')
    raw_id_fields = ('text_unit',)

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        qs = qs.select_related('classifier', 'text_unit') \
            .only('classifier_id', 'classifier__name', 'text_unit_id',
                  'classifier_run', 'classifier_confidence', 'class_name')
        return qs

class DocumentTransformerAdmin(admin.ModelAdmin):
    list_display = ('name', 'version', 'is_active')
    search_fields = ('name', 'version', 'vector_name')

class TextUnitTransformerAdmin(admin.ModelAdmin):
    list_display = ('name', 'version', 'text_unit_type', 'is_active')
    search_fields = ('name', 'version', 'vector_name', 'text_unit_type')

class DocumentVectorAdmin(admin.ModelAdmin):
    list_display = ('vector_name', 'transformer_name', 'document', 'project', 'timestamp')
    search_fields = ('vector_name', 'transformer__name', 'document__name')

    @staticmethod
    def transformer_name(obj):
        return obj.transformer.name

    @staticmethod
    def project(obj):
        return obj.document.project.name

class TextUnitVectorAdmin(admin.ModelAdmin):
    list_display = ('vector_name', 'transformer_name', 'text_unit', 'document', 'project', 'timestamp')
    search_fields = ('vector_name', 'text_unit__document__name', 'text_unit__document__project__name')
    raw_id_fields = ('text_unit',)

    @staticmethod
    def transformer_name(obj):
        return obj.transformer.name

    @staticmethod
    def document(obj):
        return obj.text_unit.document.name

    @staticmethod
    def project(obj):
        return obj.text_unit.document.project.name

admin.site.register(DocumentCluster, DocumentClusterAdmin)
admin.site.register(TextUnitCluster, TextUnitClusterAdmin)
admin.site.register(DocumentSimilarity, DocumentSimilarityAdmin)
admin.site.register(TextUnitSimilarity, TextUnitSimilarityAdmin)
admin.site.register(PartySimilarity, PartySimilarityAdmin)
admin.site.register(DocumentClassification, DocumentClassificationAdmin)
admin.site.register(DocumentClassifier, DocumentClassifierAdmin)
admin.site.register(DocumentClassifierSuggestion, DocumentClassifierSuggestionAdmin)
admin.site.register(TextUnitClassification, TextUnitClassificationAdmin)
admin.site.register(TextUnitClassifier, TextUnitClassifierAdmin)
admin.site.register(TextUnitClassifierSuggestion, TextUnitClassifierSuggestionAdmin)
admin.site.register(DocumentTransformer, DocumentTransformerAdmin)
admin.site.register(TextUnitTransformer, TextUnitTransformerAdmin)
admin.site.register(DocumentVector, DocumentVectorAdmin)
admin.site.register(TextUnitVector, TextUnitVectorAdmin)

{'repo_name': 'LexPredict/lexpredict-contraxsuite', 'stars': '124', 'repo_language': 'Python', 'file_name': 'README.md', 'mime_type': 'text/plain', 'hash': 2472740428238379659, 'source_dataset': 'data'}


import scala.reflect.macros.blackbox.Context
import language.experimental.macros

trait T { def t(): Unit }
abstract class A extends T { override def t(): Unit = () }

object Macro { def t(c: Context)(): c.Expr[Unit] = c.universe.reify(()) }
class C extends A { override def t(): Unit = macro Macro.t }

{'repo_name': 'lampepfl/dotty', 'stars': '4027', 'repo_language': 'Scala', 'file_name': 'macro_1.scala', 'mime_type': 'text/plain', 'hash': 3003806530743557440, 'source_dataset': 'data'}