text:
<?php

use Symfony\Component\Translation\MessageCatalogue;

$catalogue = new MessageCatalogue('tr', array (
  'validators' =>
  array (
    'This value should be false.' => 'Bu değer olumsuz olmalıdır.',
    'This value should be true.' => 'Bu değer olumlu olmalıdır.',
    'This value should be of type {{ type }}.' => 'Bu değerin tipi {{ type }} olmalıdır.',
    'This value should be blank.' => 'Bu değer boş olmalıdır.',
    'The value you selected is not a valid choice.' => 'Seçtiğiniz değer geçerli bir seçenek değil.',
    'You must select at least {{ limit }} choice.|You must select at least {{ limit }} choices.' => 'En az {{ limit }} seçenek belirtmelisiniz.',
    'You must select at most {{ limit }} choice.|You must select at most {{ limit }} choices.' => 'En çok {{ limit }} seçenek belirtmelisiniz.',
    'One or more of the given values is invalid.' => 'Verilen değerlerden bir veya daha fazlası geçersiz.',
    'This field was not expected.' => 'Bu alan beklenen olmadı.',
    'This field is missing.' => 'Bu alan, eksik',
    'This value is not a valid date.' => 'Bu değer doğru bir tarih biçimi değildir.',
    'This value is not a valid datetime.' => 'Bu değer doğru bir tarihsaat biçimi değildir.',
    'This value is not a valid email address.' => 'Bu değer doğru bir e-mail adresi değildir.',
    'The file could not be found.' => 'Dosya bulunamadı.',
    'The file is not readable.' => 'Dosya okunabilir değil.',
    'The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Dosya çok büyük ({{ size }} {{ suffix }}). İzin verilen en büyük dosya boyutu {{ limit }} {{ suffix }}.',
    'The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.' => 'Dosyanın mime tipi geçersiz ({{ type }}). İzin verilen mime tipleri {{ types }}.',
    'This value should be {{ limit }} or less.' => 'Bu değer {{ limit }} ve altında olmalıdır.',
    'This value is too long. It should have {{ limit }} character or less.|This value is too long. It should have {{ limit }} characters or less.' => 'Bu değer çok uzun. {{ limit }} karakter veya daha az olmalıdır.',
    'This value should be {{ limit }} or more.' => 'Bu değer {{ limit }} veya daha fazla olmalıdır.',
    'This value is too short. It should have {{ limit }} character or more.|This value is too short. It should have {{ limit }} characters or more.' => 'Bu değer çok kısa. {{ limit }} karakter veya daha fazla olmaldır.',
    'This value should not be blank.' => 'Bu değer boş bırakılmamalıdır.',
    'This value should not be null.' => 'Bu değer boş bırakılmamalıdır.',
    'This value should be null.' => 'Bu değer boş bırakılmalıdır.',
    'This value is not valid.' => 'Bu değer geçerli değil.',
    'This value is not a valid time.' => 'Bu değer doğru bir saat değil.',
    'This value is not a valid URL.' => 'Bu değer doğru bir URL değil.',
    'The two values should be equal.' => 'İki değer eşit olmalıdır.',
    'The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Dosya çok büyük. İzin verilen en büyük dosya boyutu {{ limit }} {{ suffix }}.',
    'The file is too large.' => 'Dosya çok büyük.',
    'The file could not be uploaded.' => 'Dosya yüklenemiyor.',
    'This value should be a valid number.' => 'Bu değer geçerli bir rakam olmalıdır.',
    'This file is not a valid image.' => 'Bu dosya geçerli bir resim değildir.',
    'This is not a valid IP address.' => 'Bu geçerli bir IP adresi değildir.',
    'This value is not a valid language.' => 'Bu değer geçerli bir lisan değil.',
    'This value is not a valid locale.' => 'Bu değer geçerli bir yer değildir.',
    'This value is not a valid country.' => 'Bu değer geçerli bir ülke değildir.',
    'This value is already used.' => 'Bu değer şu anda kullanımda.',
    'The size of the image could not be detected.' => 'Resmin boyutu saptanamıyor.',
    'The image width is too big ({{ width }}px). Allowed maximum width is {{ max_width }}px.' => 'Resmin genişliği çok büyük ({{ width }}px). İzin verilen en büyük genişlik {{ max_width }}px.',
    'The image width is too small ({{ width }}px). Minimum width expected is {{ min_width }}px.' => 'Resmin genişliği çok küçük ({{ width }}px). En az {{ min_width }}px olmalıdır.',
    'The image height is too big ({{ height }}px). Allowed maximum height is {{ max_height }}px.' => 'Resmin yüksekliği çok büyük ({{ height }}px). İzin verilen en büyük yükseklik {{ max_height }}px.',
    'The image height is too small ({{ height }}px). Minimum height expected is {{ min_height }}px.' => 'Resmin yüksekliği çok küçük ({{ height }}px). En az {{ min_height }}px olmalıdır.',
    'This value should be the user\'s current password.' => 'Bu değer kullanıcının şu anki şifresi olmalıdır.',
    'This value should have exactly {{ limit }} character.|This value should have exactly {{ limit }} characters.' => 'Bu değer tam olarak {{ limit }} karakter olmaldır.',
    'The file was only partially uploaded.' => 'Dosya sadece kısmen yüklendi.',
    'No file was uploaded.' => 'Hiçbir dosya yüklenmedi.',
    'No temporary folder was configured in php.ini.' => 'php.ini içerisinde geçici dizin tanımlanmadı.',
    'Cannot write temporary file to disk.' => 'Geçici dosya diske yazılamıyor.',
    'A PHP extension caused the upload to fail.' => 'Bir PHP eklentisi dosyanın yüklemesini başarısız kıldı.',
    'This collection should contain {{ limit }} element or more.|This collection should contain {{ limit }} elements or more.' => 'Bu derlem {{ limit }} veya daha çok eleman içermelidir.',
    'This collection should contain {{ limit }} element or less.|This collection should contain {{ limit }} elements or less.' => 'Bu derlem {{ limit }} veya daha az eleman içermelidir.',
    'This collection should contain exactly {{ limit }} element.|This collection should contain exactly {{ limit }} elements.' => 'Bu derlem {{ limit }} eleman içermelidir.',
    'Invalid card number.' => 'Geçersiz kart numarası.',
    'Unsupported card type or invalid card number.' => 'Desteklenmeyen kart tipi veya geçersiz kart numarası.',
    'fos_user.username.already_used' => 'Kullanıcı adı zaten kullanılıyor',
    'fos_user.username.blank' => 'Lütfen bir kullanıcı adı girin',
    'fos_user.username.short' => '[-Inf,Inf]Kullanıcı adı çok kısa',
    'fos_user.username.long' => '[-Inf,Inf]Kullanıcı adı çok uzun',
    'fos_user.email.already_used' => 'e-posta zaten kullanılıyor',
    'fos_user.email.blank' => 'Lütfen bir e-posta girin',
    'fos_user.email.short' => '[-Inf,Inf]e-posta çok kısa',
    'fos_user.email.long' => '[-Inf,Inf]e-posta çok uzun',
    'fos_user.email.invalid' => 'e-posta geçerli değil',
    'fos_user.password.blank' => 'Lütfen bir parola girin',
    'fos_user.password.short' => '[-Inf,Inf]Parola çok kısa',
    'fos_user.new_password.blank' => 'Lütfen yeni parolayı girin',
    'fos_user.new_password.short' => '[-Inf,Inf]Yeni parola çok kısa',
    'fos_user.current_password.invalid' => 'Girilen parola geçersiz',
    'fos_user.group.blank' => 'Lütfen bir isim girin',
    'fos_user.group.short' => '[-Inf,Inf]İsim çok kısa',
    'fos_user.group.long' => '[-Inf,Inf]İsim çok uzun',
  ),
  'security' =>
  array (
    'An authentication exception occurred.' => 'Bir yetkilendirme istisnası oluştu.',
    'Authentication credentials could not be found.' => 'Kimlik bilgileri bulunamadı.',
    'Authentication request could not be processed due to a system problem.' => 'Bir sistem hatası nedeniyle yetkilendirme isteği işleme alınamıyor.',
    'Invalid credentials.' => 'Geçersiz kimlik bilgileri.',
    'Cookie has already been used by someone else.' => 'Çerez bir başkası tarafından zaten kullanılmıştı.',
    'Not privileged to request the resource.' => 'Kaynak talebi için imtiyaz bulunamadı.',
    'Invalid CSRF token.' => 'Geçersiz CSRF fişi.',
    'Digest nonce has expired.' => 'Derleme zaman aşımına uğradı.',
    'No authentication provider found to support the authentication token.' => 'Yetkilendirme fişini destekleyecek yetkilendirme sağlayıcısı bulunamadı.',
    'No session available, it either timed out or cookies are not enabled.' => 'Oturum bulunamadı, zaman aşımına uğradı veya çerezler etkin değil.',
    'No token could be found.' => 'Fiş bulunamadı.',
    'Username could not be found.' => 'Kullanıcı adı bulunamadı.',
    'Account has expired.' => 'Hesap zaman aşımına uğradı.',
    'Credentials have expired.' => 'Kimlik bilgileri zaman aşımına uğradı.',
    'Account is disabled.' => 'Hesap engellenmiş.',
    'Account is locked.' => 'Hesap kilitlenmiş.',
  ),
  'FOSUserBundle' =>
  array (
    'group.edit.submit' => 'Grubu Güncelle',
    'group.show.name' => 'Grup Adı',
    'group.new.submit' => 'Grup Yarat',
    'group.flash.updated' => 'Grup Güncellendi',
    'group.flash.created' => 'Grup Yaratıldı',
    'group.flash.deleted' => 'Grup Silindi',
    'security.login.username' => 'Kullanıcı adı',
    'security.login.password' => 'Parola',
    'security.login.remember_me' => 'Beni hatırla',
    'security.login.submit' => 'Giriş',
    'profile.show.username' => 'Kullanıcı adı',
    'profile.show.email' => 'E-posta adresi',
    'profile.edit.submit' => 'Güncelle',
    'profile.flash.updated' => 'Profil Güncellendi',
    'change_password.submit' => 'Parolayı Değiştir',
    'change_password.flash.success' => 'Parola değiştirildi',
    'registration.check_email' => '%email% adresine hesabınızı aktive etmek için kullanacağınız aktivasyon linkini barındıran bir e-posta gönderildi.',
    'registration.confirmed' => 'Tebrikler %username%. Hesabınız şu anda aktifleştirildi.',
    'registration.back' => 'Asıl sayfaya geri dön.',
    'registration.submit' => 'Kayıt ol',
    'registration.flash.user_created' => 'Kullanıcı başarıyla yaratıldı',
    'registration.email.subject' => 'Hoşgeldin %username%!',
    'registration.email.message' => 'Hoşgeldiniz %username%!

Hesabınızın aktivasyonunu tamamlamak için lütfen  %confirmationUrl%
adresini ziyaret ediniz.

Teşekkürler,
Web Takımı.
',
    'resetting.password_already_requested' => 'Son 24 saat içerisinde bu kullanıcı parola için istekte bulunmuş.',
    'resetting.check_email' => '%email% adresine parolanızı sıfırlama adresi bulunan bir e-posta gönderildi.',
    'resetting.request.invalid_username' => '%username% şeklinde bir kullanıcı adı ya da e-posta adresi bulunamadı.',
    'resetting.request.username' => 'Kullanıcı adı ya da e-posta adresi',
    'resetting.request.submit' => 'Parolayı Sıfırla',
    'resetting.reset.submit' => 'Parolayı değiştir',
    'resetting.flash.success' => 'Parola başarıyla değiştirildi',
    'resetting.email.subject' => 'Parola Yenileme',
    'resetting.email.message' => 'Merhaba  %username%!

Parolanızı yenilemek için  %confirmationUrl%
adresini ziyaret ediniz.

Teşekkürler,
Web Takımı.
',
    'layout.logout' => 'Çıkış',
    'layout.login' => 'Giriş',
    'layout.register' => 'Kayıt ol',
    'layout.logged_in_as' => '%username% olarak giriş yapıldı',
    'form.group_name' => 'Gurup Adı',
    'form.username' => 'Kullanıcı adı',
    'form.email' => 'E-posta adresi',
    'form.current_password' => 'Geçerli Parola',
    'form.password' => 'Parola',
    'form.password_confirmation' => 'Onay',
    'form.new_password' => 'Yeni Parola',
    'form.new_password_confirmation' => 'Onay',
  ),
));

$catalogueFr = new MessageCatalogue('fr', array (
  'validators' =>
  array (
    'This value should be false.' => 'Cette valeur doit être fausse.',
    'This value should be true.' => 'Cette valeur doit être vraie.',
    'This value should be of type {{ type }}.' => 'Cette valeur doit être de type {{ type }}.',
    'This value should be blank.' => 'Cette valeur doit être vide.',
    'The value you selected is not a valid choice.' => 'Cette valeur doit être l\'un des choix proposés.',
    'You must select at least {{ limit }} choice.|You must select at least {{ limit }} choices.' => 'Vous devez sélectionner au moins {{ limit }} choix.|Vous devez sélectionner au moins {{ limit }} choix.',
    'You must select at most {{ limit }} choice.|You must select at most {{ limit }} choices.' => 'Vous devez sélectionner au maximum {{ limit }} choix.|Vous devez sélectionner au maximum {{ limit }} choix.',
    'One or more of the given values is invalid.' => 'Une ou plusieurs des valeurs soumises sont invalides.',
    'This field was not expected.' => 'Ce champ n\'a pas été prévu.',
    'This field is missing.' => 'Ce champ est manquant.',
    'This value is not a valid date.' => 'Cette valeur n\'est pas une date valide.',
    'This value is not a valid datetime.' => 'Cette valeur n\'est pas une date valide.',
    'This value is not a valid email address.' => 'Cette valeur n\'est pas une adresse email valide.',
    'The file could not be found.' => 'Le fichier n\'a pas été trouvé.',
    'The file is not readable.' => 'Le fichier n\'est pas lisible.',
    'The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Le fichier est trop volumineux ({{ size }} {{ suffix }}). Sa taille ne doit pas dépasser {{ limit }} {{ suffix }}.',
    'The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.' => 'Le type du fichier est invalide ({{ type }}). Les types autorisés sont {{ types }}.',
    'This value should be {{ limit }} or less.' => 'Cette valeur doit être inférieure ou égale à {{ limit }}.',
    'This value is too long. It should have {{ limit }} character or less.|This value is too long. It should have {{ limit }} characters or less.' => 'Cette chaine est trop longue. Elle doit avoir au maximum {{ limit }} caractère.|Cette chaine est trop longue. Elle doit avoir au maximum {{ limit }} caractères.',
    'This value should be {{ limit }} or more.' => 'Cette valeur doit être supérieure ou égale à {{ limit }}.',
    'This value is too short. It should have {{ limit }} character or more.|This value is too short. It should have {{ limit }} characters or more.' => 'Cette chaine est trop courte. Elle doit avoir au minimum {{ limit }} caractère.|Cette chaine est trop courte. Elle doit avoir au minimum {{ limit }} caractères.',
    'This value should not be blank.' => 'Cette valeur ne doit pas être vide.',
    'This value should not be null.' => 'Cette valeur ne doit pas être nulle.',
    'This value should be null.' => 'Cette valeur doit être nulle.',
    'This value is not valid.' => 'Cette valeur n\'est pas valide.',
    'This value is not a valid time.' => 'Cette valeur n\'est pas une heure valide.',
    'This value is not a valid URL.' => 'Cette valeur n\'est pas une URL valide.',
    'The two values should be equal.' => 'Les deux valeurs doivent être identiques.',
    'The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Le fichier est trop volumineux. Sa taille ne doit pas dépasser {{ limit }} {{ suffix }}.',
    'The file is too large.' => 'Le fichier est trop volumineux.',
    'The file could not be uploaded.' => 'Le téléchargement de ce fichier est impossible.',
    'This value should be a valid number.' => 'Cette valeur doit être un nombre.',
    'This file is not a valid image.' => 'Ce fichier n\'est pas une image valide.',
    'This is not a valid IP address.' => 'Cette adresse IP n\'est pas valide.',
    'This value is not a valid language.' => 'Cette langue n\'est pas valide.',
    'This value is not a valid locale.' => 'Ce paramètre régional n\'est pas valide.',
    'This value is not a valid country.' => 'Ce pays n\'est pas valide.',
    'This value is already used.' => 'Cette valeur est déjà utilisée.',
    'The size of the image could not be detected.' => 'La taille de l\'image n\'a pas pu être détectée.',
    'The image width is too big ({{ width }}px). Allowed maximum width is {{ max_width }}px.' => 'La largeur de l\'image est trop grande ({{ width }}px). La largeur maximale autorisée est de {{ max_width }}px.',
    'The image width is too small ({{ width }}px). Minimum width expected is {{ min_width }}px.' => 'La largeur de l\'image est trop petite ({{ width }}px). La largeur minimale attendue est de {{ min_width }}px.',
    'The image height is too big ({{ height }}px). Allowed maximum height is {{ max_height }}px.' => 'La hauteur de l\'image est trop grande ({{ height }}px). La hauteur maximale autorisée est de {{ max_height }}px.',
    'The image height is too small ({{ height }}px). Minimum height expected is {{ min_height }}px.' => 'La hauteur de l\'image est trop petite ({{ height }}px). La hauteur minimale attendue est de {{ min_height }}px.',
    'This value should be the user\'s current password.' => 'Cette valeur doit être le mot de passe actuel de l\'utilisateur.',
    'This value should have exactly {{ limit }} character.|This value should have exactly {{ limit }} characters.' => 'Cette chaine doit avoir exactement {{ limit }} caractère.|Cette chaine doit avoir exactement {{ limit }} caractères.',
    'The file was only partially uploaded.' => 'Le fichier a été partiellement transféré.',
    'No file was uploaded.' => 'Aucun fichier n\'a été transféré.',
    'No temporary folder was configured in php.ini.' => 'Aucun répertoire temporaire n\'a été configuré dans le php.ini.',
    'Cannot write temporary file to disk.' => 'Impossible d\'écrire le fichier temporaire sur le disque.',
    'A PHP extension caused the upload to fail.' => 'Une extension PHP a empêché le transfert du fichier.',
    'This collection should contain {{ limit }} element or more.|This collection should contain {{ limit }} elements or more.' => 'Cette collection doit contenir {{ limit }} élément ou plus.|Cette collection doit contenir {{ limit }} éléments ou plus.',
    'This collection should contain {{ limit }} element or less.|This collection should contain {{ limit }} elements or less.' => 'Cette collection doit contenir {{ limit }} élément ou moins.|Cette collection doit contenir {{ limit }} éléments ou moins.',
    'This collection should contain exactly {{ limit }} element.|This collection should contain exactly {{ limit }} elements.' => 'Cette collection doit contenir exactement {{ limit }} élément.|Cette collection doit contenir exactement {{ limit }} éléments.',
    'Invalid card number.' => 'Numéro de carte invalide.',
    'Unsupported card type or invalid card number.' => 'Type de carte non supporté ou numéro invalide.',
    'This is not a valid International Bank Account Number (IBAN).' => 'Le numéro IBAN (International Bank Account Number) saisi n\'est pas valide.',
    'This value is not a valid ISBN-10.' => 'Cette valeur n\'est pas un code ISBN-10 valide.',
    'This value is not a valid ISBN-13.' => 'Cette valeur n\'est pas un code ISBN-13 valide.',
    'This value is neither a valid ISBN-10 nor a valid ISBN-13.' => 'Cette valeur n\'est ni un code ISBN-10, ni un code ISBN-13 valide.',
    'This value is not a valid ISSN.' => 'Cette valeur n\'est pas un code ISSN valide.',
    'This value is not a valid currency.' => 'Cette valeur n\'est pas une devise valide.',
    'This value should be equal to {{ compared_value }}.' => 'Cette valeur doit être égale à {{ compared_value }}.',
    'This value should be greater than {{ compared_value }}.' => 'Cette valeur doit être supérieure à {{ compared_value }}.',
    'This value should be greater than or equal to {{ compared_value }}.' => 'Cette valeur doit être supérieure ou égale à {{ compared_value }}.',
    'This value should be identical to {{ compared_value_type }} {{ compared_value }}.' => 'Cette valeur doit être identique à {{ compared_value_type }} {{ compared_value }}.',
    'This value should be less than {{ compared_value }}.' => 'Cette valeur doit être inférieure à {{ compared_value }}.',
    'This value should be less than or equal to {{ compared_value }}.' => 'Cette valeur doit être inférieure ou égale à {{ compared_value }}.',
    'This value should not be equal to {{ compared_value }}.' => 'Cette valeur ne doit pas être égale à {{ compared_value }}.',
    'This value should not be identical to {{ compared_value_type }} {{ compared_value }}.' => 'Cette valeur ne doit pas être identique à {{ compared_value_type }} {{ compared_value }}.',
    'The image ratio is too big ({{ ratio }}). Allowed maximum ratio is {{ max_ratio }}.' => 'Le rapport largeur/hauteur de l\'image est trop grand ({{ ratio }}). Le rapport maximal autorisé est {{ max_ratio }}.',
    'The image ratio is too small ({{ ratio }}). Minimum ratio expected is {{ min_ratio }}.' => 'Le rapport largeur/hauteur de l\'image est trop petit ({{ ratio }}). Le rapport minimal attendu est {{ min_ratio }}.',
    'The image is square ({{ width }}x{{ height }}px). Square images are not allowed.' => 'L\'image est carrée ({{ width }}x{{ height }}px). Les images carrées ne sont pas autorisées.',
    'The image is landscape oriented ({{ width }}x{{ height }}px). Landscape oriented images are not allowed.' => 'L\'image est au format paysage ({{ width }}x{{ height }}px). Les images au format paysage ne sont pas autorisées.',
    'The image is portrait oriented ({{ width }}x{{ height }}px). Portrait oriented images are not allowed.' => 'L\'image est au format portrait ({{ width }}x{{ height }}px). Les images au format portrait ne sont pas autorisées.',
    'An empty file is not allowed.' => 'Un fichier vide n\'est pas autorisé.',
    'The host could not be resolved.' => 'Le nom de domaine n\'a pas pu être résolu.',
    'This value does not match the expected {{ charset }} charset.' => 'Cette valeur ne correspond pas au jeu de caractères {{ charset }} attendu.',
    'This form should not contain extra fields.' => 'Ce formulaire ne doit pas contenir des champs supplémentaires.',
    'The uploaded file was too large. Please try to upload a smaller file.' => 'Le fichier téléchargé est trop volumineux. Merci d\'essayer d\'envoyer un fichier plus petit.',
    'The CSRF token is invalid. Please try to resubmit the form.' => 'Le jeton CSRF est invalide. Veuillez renvoyer le formulaire.',
    'fos_user.username.already_used' => 'Le nom d\'utilisateur est déjà utilisé',
    'fos_user.username.blank' => 'Entrez un nom d\'utilisateur s\'il vous plait',
    'fos_user.username.short' => '[-Inf,Inf]Le nom d\'utilisateur est trop court',
    'fos_user.username.long' => '[-Inf,Inf]Le nom d\'utilisateur est trop long',
    'fos_user.email.already_used' => 'L\'adresse e-mail est déjà utilisée',
    'fos_user.email.blank' => 'Entrez une adresse e-mail s\'il vous plait',
    'fos_user.email.short' => '[-Inf,Inf]L\'adresse e-mail est trop courte',
    'fos_user.email.long' => '[-Inf,Inf]L\'adresse e-mail est trop longue',
    'fos_user.email.invalid' => 'L\'adresse e-mail est invalide',
    'fos_user.password.blank' => 'Entrez un mot de passe s\'il vous plait',
    'fos_user.password.short' => '[-Inf,Inf]Le mot de passe est trop court',
    'fos_user.password.mismatch' => 'Les deux mots de passe ne sont pas identiques',
    'fos_user.new_password.blank' => 'Entrez un nouveau mot de passe s\'il vous plait',
    'fos_user.new_password.short' => '[-Inf,Inf]Le nouveau mot de passe est trop court',
    'fos_user.current_password.invalid' => 'Le mot de passe est invalide',
    'fos_user.group.blank' => 'Entrez un nom s\'il vous plait',
    'fos_user.group.short' => '[-Inf,Inf]Le nom est trop court',
    'fos_user.group.long' => '[-Inf,Inf]Le nom est trop long',
  ),
  'security' =>
  array (
    'An authentication exception occurred.' => 'Une exception d\'authentification s\'est produite.',
    'Authentication credentials could not be found.' => 'Les identifiants d\'authentification n\'ont pas pu être trouvés.',
    'Authentication request could not be processed due to a system problem.' => 'La requête d\'authentification n\'a pas pu être executée à cause d\'un problème système.',
    'Invalid credentials.' => 'Identifiants invalides.',
    'Cookie has already been used by someone else.' => 'Le cookie a déjà été utilisé par quelqu\'un d\'autre.',
    'Not privileged to request the resource.' => 'Privilèges insuffisants pour accéder à la ressource.',
    'Invalid CSRF token.' => 'Jeton CSRF invalide.',
    'Digest nonce has expired.' => 'Le digest nonce a expiré.',
    'No authentication provider found to support the authentication token.' => 'Aucun fournisseur d\'authentification n\'a été trouvé pour supporter le jeton d\'authentification.',
    'No session available, it either timed out or cookies are not enabled.' => 'Aucune session disponible, celle-ci a expiré ou les cookies ne sont pas activés.',
    'No token could be found.' => 'Aucun jeton n\'a pu être trouvé.',
    'Username could not be found.' => 'Le nom d\'utilisateur n\'a pas pu être trouvé.',
    'Account has expired.' => 'Le compte a expiré.',
    'Credentials have expired.' => 'Les identifiants ont expiré.',
    'Account is disabled.' => 'Le compte est désactivé.',
    'Account is locked.' => 'Le compte est bloqué.',
  ),
  'FOSUserBundle' =>
  array (
    'group.edit.submit' => 'Mettre à jour le groupe',
    'group.show.name' => 'Nom du groupe',
    'group.new.submit' => 'Créer le groupe',
    'group.flash.updated' => 'Le groupe a été mis à jour',
    'group.flash.created' => 'Le groupe a été créé',
    'group.flash.deleted' => 'Le groupe a été supprimé',
    'security.login.username' => 'Nom d\'utilisateur',
    'security.login.password' => 'Mot de passe',
    'security.login.remember_me' => 'Se souvenir de moi',
    'security.login.submit' => 'Connexion',
    'profile.show.username' => 'Nom d\'utilisateur',
    'profile.show.email' => 'Adresse e-mail',
    'profile.edit.submit' => 'Mettre à jour',
    'profile.flash.updated' => 'Le profil a été mis à jour',
    'change_password.submit' => 'Modifier le mot de passe',
    'change_password.flash.success' => 'Le mot de passe a été modifié',
    'registration.check_email' => 'Un e-mail a été envoyé à l\'adresse %email%. Il contient un lien d\'activation sur lequel il vous faudra cliquer afin d\'activer votre compte.',
    'registration.confirmed' => 'Félicitations %username%, votre compte est maintenant activé.',
    'registration.back' => 'Retour à la page d\'origine.',
    'registration.submit' => 'Enregistrer',
    'registration.flash.user_created' => 'L\'utilisateur a été créé avec succès',
    'registration.email.subject' => 'Bienvenue %username% !',
    'registration.email.message' => 'Bonjour %username% !

Pour valider votre compte utilisateur, merci de vous rendre sur %confirmationUrl%

Cordialement,
L\'équipe.
',
    'resetting.password_already_requested' => 'Un nouveau mot de passe a déjà été demandé pour cet utilisateur dans les dernières 24 heures.',
    'resetting.check_email' => 'Un e-mail a été envoyé à l\'adresse %email%. Il contient un lien sur lequel il vous faudra cliquer afin de réinitialiser votre mot de passe.',
    'resetting.request.invalid_username' => 'Le nom d\'utilisateur ou l\'adresse e-mail "%username%" n\'existe pas.',
    'resetting.request.username' => 'Nom d\'utilisateur ou adresse e-mail',
    'resetting.request.submit' => 'Réinitialiser le mot de passe',
    'resetting.reset.submit' => 'Modifier le mot de passe',
    'resetting.flash.success' => 'Le mot de passe a été réinitialisé avec succès',
    'resetting.email.subject' => 'Réinitialisation de votre mot de passe',
    'resetting.email.message' => 'Bonjour %username% !

Pour réinitialiser votre mot de passe, merci de vous rendre sur %confirmationUrl%

Cordialement,
L\'équipe.
',
    'layout.logout' => 'Déconnexion',
    'layout.login' => 'Connexion',
    'layout.register' => 'Inscription',
    'layout.logged_in_as' => 'Connecté en tant que %username%',
    'form.group_name' => 'Nom du groupe',
    'form.username' => 'Nom d\'utilisateur',
    'form.email' => 'Adresse e-mail',
    'form.current_password' => 'Mot de passe actuel',
    'form.password' => 'Mot de passe',
    'form.password_confirmation' => 'Vérification',
    'form.new_password' => 'Nouveau mot de passe',
    'form.new_password_confirmation' => 'Vérification',
  ),
  'messages' =>
  array (
    'Symfony2 is great' => 'J\'aime Symfony2',
  ),
));
$catalogue->addFallbackCatalogue($catalogueFr);

return $catalogue;


text:
layout: post
status: publish
published: true
title: But de gardien
author: mick
author_login: mick
author_email: mickael@flochlay.com
wordpress_id: 95
wordpress_url: http://morningcoffee.mickaelflochlay.com/?p=95
date: 2011-04-13 07:54:38.000000000 +02:00
categories:
- Fun
- Sport
tags:
- foot
comments: []
---

> Un but de plus de 80 mètres qui a permis au siens de ramener le match nul (1-1).

<iframe title="YouTube video player" width="425" height="349" src="http://www.youtube.com/embed/etDVngjr77U" frameborder="0"> </iframe>

via [UN BUT DE 80 MÈTRES][1]

[1]: http://www.lequipemag.fr/EquipeMag/Insolite/un-but-de-80-metres-20110412_112451.html

redpajama_set_name: RedPajamaGithub


text:
package org.apache.hadoop.mapred;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.net.URL;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.mapred.JSPUtil.JobWithViewAccessCheck;
import org.apache.hadoop.util.*;

public final class jobconf_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

	private static final long serialVersionUID = 1L;

  private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();

  private static java.util.Vector _jspx_dependants;

  private org.apache.jasper.runtime.ResourceInjector _jspx_resourceInjector;

  public Object getDependants() {
    return _jspx_dependants;
  }

  public void _jspService(HttpServletRequest request, HttpServletResponse response)
        throws java.io.IOException, ServletException {

    PageContext pageContext = null;
    HttpSession session = null;
    ServletContext application = null;
    ServletConfig config = null;
    JspWriter out = null;
    Object page = this;
    JspWriter _jspx_out = null;
    PageContext _jspx_page_context = null;

    try {
      response.setContentType("text/html; charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
      			null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;
      _jspx_resourceInjector = (org.apache.jasper.runtime.ResourceInjector) application.getAttribute("com.sun.appserv.jsp.resource.injector");

      out.write('\n');
      out.write("\n\n\n");

  final JobTracker tracker = (JobTracker) application.getAttribute("job.tracker");
  final String jobId = request.getParameter("jobid");
  if (jobId == null) {
    out.println("
Missing 'jobid' for fetching job configuration!
");
    return;
  }

      out.write("\n  \n<!DOCTYPE html>\n\n\n<title>Job Configuration: JobId - ");
      out.print( jobId );
      out.write("</title>\n\n\n
Job Configuration: JobId - ");
      out.print( jobId );
      out.write("

\n\n");

  JobWithViewAccessCheck myJob = JSPUtil.checkAccessAndGetJob(tracker,
      JobID.forName(jobId), request, response);
  if (!myJob.isViewJobAllowed()) {
    return; // user is not authorized to view this job
  }

  JobInProgress job = myJob.getJob();
  if (job == null) {
    out.print("Job " + jobId + " not found.
\n");
    return;
  }

  String jobFilePath = JobTracker.getLocalJobFilePath(JobID.forName(jobId));
  FileInputStream jobFile = null;
  try {
    jobFile = new FileInputStream(jobFilePath);
    JobConf jobConf = new JobConf(jobFilePath);
    XMLUtils.transform(
        jobConf.getConfResourceAsInputStream("webapps/static/jobconf.xsl"),
        jobFile, out);
  } catch (Exception e) {
    out.println("Failed to retreive job configuration for job '" + jobId + "!");
    out.println(e);
  } finally {
    if (jobFile != null) {
      try {
        jobFile.close();
      } catch (IOException e) {}
    }
  }

      out.write("\n\n
\n");

out.println(ServletUtil.htmlFooter());

      out.write('\n');
    } catch (Throwable t) {
      if (!(t instanceof SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          out.clearBuffer();
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}


text:
package models

import (
	"time"

	"github.com/jinzhu/gorm"
)

type App struct {
	ID       uint      `gorm:"primary_key"`
	Name     string    `gorm:"size:30;not null"`
	Type     string    `gorm:"type:char;not null"`
	Key      string    `gorm:"type:char(32);not null"`
	AppUsers []AppUser `gorm:"many2many:app_user_app;"`

	CreatedAt time.Time  `gorm:"not null;type:datetime;default:CURRENT_TIMESTAMP"`
	UpdatedAt *time.Time `gorm:"default:NULL"`
	UpdatedBy *uint      `gorm:"default:NULL"`
	DeletedAt *time.Time `gorm:"default:NULL"`
}

// GetApp gets an app by key
func GetApp(key string, db *gorm.DB) *gorm.DB {
	var result App

	return db.Where(&App{Key: key}).First(&result)
}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.tools.hql-builder</groupId>
		<artifactId>bom</artifactId>
		<version>6.0.3-SNAPSHOT</version>
		<relativePath>../pom.xml</relativePath>
	</parent>
	<packaging>pom</packaging>
	<artifactId>hql-builder-full</artifactId>
	<name>hql-builder-full</name>
	<description>hql-builder-full</description>
	<dependencies>
		<dependency>
			<groupId>org.tools.hql-builder.spring</groupId>
			<artifactId>hibernate4-spring-orm</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>org.tools.hql-builder.hibernate</groupId>
			<artifactId>hibernate-5.2</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>hql-builder-common</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>hql-builder-service</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>hql-builder-client</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>${project.groupId}.web</groupId>
			<artifactId>hql-builder-webservice</artifactId>
			<version>${project.version}</version>
		</dependency>
		<dependency>
			<groupId>${project.groupId}.web</groupId>
			<artifactId>hql-builder-webclient</artifactId>
			<version>${project.version}</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!-- assembly:single -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<descriptors>
						<descriptor>src/assemblies/bin-with-dependencies.xml</descriptor>
					</descriptors>
					<tarLongFileMode>gnu</tarLongFileMode>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-deploy-plugin</artifactId>
				<version>2.8.2</version>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>


text:
package org.jenkinsci.plugins.ghprb.extensions;

import hudson.model.AbstractBuild;
import hudson.model.TaskListener;

public interface GhprbCommentAppender {

    public String postBuildComment(AbstractBuild<?, ?> build, TaskListener listener);

}


text:
The cluster host provides a simple way to configure and spin up [EventStore](http://www.geteventstore.com) OSS clusters as detailed in the [documentation](https://github.com/eventstore/eventstore/wiki/Setting-Up-OSS-Cluster).

The host itself is a single Windows service that can contains any number of "internal" instances (running on that server), which will be restarted if they fail, and the configuration allows connection to "external" hosts for cross-machine clusters.

The host currently only supports "gossip seed" based clusters, rather than DNS based clusters.

### Installation

To install just build, copy the output to a directory on the server, update the configuration file as appropriate, copy the EventStore binaries to the correct location and run "Slicedbread.EventStore.ClusterHost install".

The host uses [TopShelf](http://topshelf-project.com/) for the Windows service configuration, for more information on commandline parameters please see their [documentation](http://docs.topshelf-project.com/en/latest/overview/commandline.html)

### Configuration
Configuration is split into four parts, logging, the global config, the internal node config and the external node config. You can dump the configuration to the screen by running Slicedbread.EventStore.ClusterHost with the --test parameter".

#### Logging

Logging uses [NLog](http://nlog-project.org/) and by default logs INFO messages and above to Slicedbread.EventStore.ClusterHost.log. The logging level (Debug, Info, Error etc.), and the targets (files, event log etc.) can be configured in Slicedbread.EventStore.ClusterHost.exe.config. For more information on logging configuration see the NLog [documentation](https://github.com/nlog/NLog/wiki).

#### Global Configuration
The global configuration options are:

**eventStorePath** *(optional)* - provides the path to the EventStore.ClusterNode.exe. If this is not specified then the host will look for it in an "eventstore" subdirectory. If it is specified it can be either an absolute or relative path, and shoudl include the executable name.

**restartDelayMs** *(optional)* - how long to wait (in milliseconds) before restarting a failed host process. Defaults to 3 seconds.

**restartWindowMs** *(optional)* - how long the "no restart" window is. If a host is started and fails within this window then it won't be restarted. This is to prevent a configuration change or other issue making the host constantly spin up new processes that will fail immediately. Defaults to 30 seconds.

**additionalFlags** *(optional)* - any additional flags to pass to **all** of the internal nodes.

#### Internal Node Configuration
Internal nodes are nodes that will be started up and managed by the host and are defined by a collection of "node" elements inside a "internalNodes" element. The configuration values for each node are:

**name** *(required)* - names the node, this will be the name that's used in all output messages.

**dbPath** *(required)* - specifies the database path for the node, can be relative or absolute.

**logPath** *(required)* - specified the log path for the node, can be relative or absolute.

**intHttpPort** *(required)* - specifies the internal http port.

**extHttpPort** *(required)* - specifies the external http port.

**intTcpPort** *(required)* - specifies the internal tcp port.

**extTcpPort** *(required)* - specifies the external tcp port.

**httpPrefix** *(optional)* - the http prefix to bind to - this is necessary if you need to listen on a particular hostname which some hosting providers (such as Azure) mandate.

**internalIpAddress** *(optional)* - the internal ip address of the node. Defaults to automatically detecting the IP - automatic detection will set the internal and external IPs to the same value.

**externalIpAddress** *(optional)* - the external ip address of the node. Defaults to automatically detecting the IP - automatic detection will set the internal and external IPs to the same value.

**additionalFlags** *(optional)* - any additional flags to pass to just this internal node.

For more information on internal/external ports and ips take a look at the EventStore [documentation](https://github.com/eventstore/eventstore/wiki/Setting-Up-OSS-Cluster)

#### External Node Configuration
External nodes are nodes that are not hosted inside this host instance, but form part of your cluster. They are defined by a collection of "node" elements inside an "externalNodes" element. The configuration values for each node are:

**name** *(required)* - names the node, this will be the name that's used in all output messages.

**ipAddress** *(required)* - the IP address the external node is available on.

**gossipPort** *(required)* - the gossip port for the node (normally the internal HTTP port).


text:
/*
Title: @bartleby_scrvnr
Description: A short-story character turned into a bot.
Author: Stefan Bohacek
Date: July 9, 2015
Tags: twitter,twitterbot,active,node,rivescript,fourtonfish

Nav: hidden
Robots: index,follow
*/

[![](/content/bots/twitterbots/images/bartleby_scrvnr.png)](https://twitter.com/bartleby_scrvnr)

[@bartleby_scrvnr](https://twitter.com/bartleby_scrvnr) is a short-story character turned into a Twitter bot. It was created by [@fourtonfish](https://twitter.com/fourtonfish).


text:
This release adds a few smallish fixes and removes previous inconveniences.

 - [#12](https://github.com/sbt/sbt-boilerplate/issues/12) Literal sharp signs can now be escaped with `\#`. Thanks [@marklister](https://github.com/marklister).
 - [#15](https://github.com/sbt/sbt-boilerplate/issues/15) Include source positions when template parsing fails.
 - [#16](https://github.com/sbt/sbt-boilerplate/issues/16) Generated files include a signature and will be deleted if source file was deleted.
 - [#17](https://github.com/sbt/sbt-boilerplate/issues/17) Generate templates in the test configuration. Thanks [@nrinaudo](https://github.com/nrinaudo).
 - [#18](https://github.com/sbt/sbt-boilerplate/issues/18) Add ".scala" if template didn't include an extension
 - [#19](https://github.com/sbt/sbt-boilerplate/issues/19) sbt-boilerplate is now an AutoPlugin (but needs to be enabled manually).

## Migration notes

 - This plugin is now an AutoPlugin. Replace `settings(Boilerplate.settings :_*)` with `enablePlugins(spray.boilerplate.BoilerplatePlugin)`
   in your build.
 - The source folder is now specified using the `boilerplateSource` key instead of `sourceDirectory in boilerplateGenerate`.


text:
"""
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJtaWd1ZWxvdXZpbmhhQGdtYWlsLmNvbSIsImp0aSI6ImY2MGY2ZTdhLTcxMmMtNDY0ZS05YTlmLTYzNWUyYjgyNThlYSIsImV4cCI6MTQ5OTE2MjExNiwiaXNzIjoiQUVNRVQiLCJpYXQiOjE0OTEzODYxMTYsInVzZXJJZCI6ImY2MGY2ZTdhLTcxMmMtNDY0ZS05YTlmLTYzNWUyYjgyNThlYSIsInJvbGUiOiIifQ.w0OazTbsiZdI5YQXCMIRnny_f0TwWF7leFvik1WeA8s
"""

import requests
import json
import pandas as pd
from pandas import DataFrame, Series
import numpy as np
import matplotlib.pyplot as plt
import math

# Datos comunes (API_KEY)
querystring = {"api_key":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJtaWd1ZWxvdXZpbmhhQGdtYWlsLmNvbSIsImp0aSI6ImY2MGY2ZTdhLTcxMmMtNDY0ZS05YTlmLTYzNWUyYjgyNThlYSIsImV4cCI6MTQ5OTE2MjExNiwiaXNzIjoiQUVNRVQiLCJpYXQiOjE0OTEzODYxMTYsInVzZXJJZCI6ImY2MGY2ZTdhLTcxMmMtNDY0ZS05YTlmLTYzNWUyYjgyNThlYSIsInJvbGUiOiIifQ.w0OazTbsiZdI5YQXCMIRnny_f0TwWF7leFvik1WeA8s"}

# Pedimos los datos al ususario
# Con esto pedimos el idema directamente, pero seria deseable pedir lugar y buscar nosotros el idema
print("Inserte el lugar del que quiera obtener los datos: \n")
print(" Provincia ------------ Estacion ------------- Idema ")
print(" A Coruña       A Coruña (Estacion completa)   1387")
print(" A Coruña         A Coruña (Aeroporto)         1387E")
print(" A Coruña  Santiago de Compostela (Labacolla)  1428")
print(" A Coruña             Cabo Vilán               1393")
print(" Lugo              Rozas (Aeródromo)           1505")
print(" Ourense       Ourense (Granxa Deputación)     1690A")
print(" Pontevedra        Pontevedra (Mourente)       1484C")
print(" Pontevedra           Vigo (Peinador)          1495")
idema = str(input())

analisis = str(input("Desea un analisis mensual/anual (1) o diario (2): \n"))

# Anuales
if (analisis == "1"):
    anho = str(input("De que año desea hacer la comparacion de datos (1931 - 2016): \n"))
    url = "https://opendata.aemet.es/opendata/api/valores/climatologicos/mensualesanuales/datos/anioini/" + anho + "/aniofin/" + anho + "/estacion/" + idema
    response = requests.request("GET" , url ,params = querystring, verify = False)
    #print(response.text)
    cont = json.loads(response.text)
    #print(cont)
    cont = cont['datos']
    #print(cont)
    # Obtenemos los datos que nos interesan y los pasamos a formato json
    response = requests.request("GET", cont, verify = False)
    #print(response.text)
    datos = json.loads(response.text)
    #print(datos)
    """
    ANALISIS DE DATOS CON PANDAS
    """

    temperaturas = [ 'tm_mes', 'ta_max', 'ta_min', 'fecha', 'indicativo']

    estado_ceo = ['n_cub', 'n_des', 'n_nub']

    precipitacions = ['p_mes']

    vento = ['w_med', 'w_racha']

    humedad = ['hr']

    cota_nieve = ['n_nie', 'n_gra']

    cols = [ 'tm_mes', 'ta_max', 'ta_min', 'fecha', 'indicativo', 'n_cub', 'n_des', 'n_nub', 'p_mes',
    'w_med', 'w_racha', 'hr', 'n_nie', 'n_gra']

    indice = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio',
    'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre', 'Resumen']

    #frame = DataFrame(datos, index = indice)
    '''
    TEMPERATURAS
    '''
    # Creamos el DataFrame
    frame_tem = DataFrame(datos, columns = temperaturas, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    frame_tem = frame_tem.iloc[0:12]
    print(frame_tem)

    #Procedemos a limpiar las filas del DataFrame
    temperatura_max = frame_tem.ta_max.map(lambda x: x.replace('(', ',')).map(lambda x: x.split(',')).map(lambda x: x[0]).map(lambda x: float(x))
    temperatura_min = frame_tem.ta_min.map(lambda x: x.replace('(', ',')).map(lambda x: x.split(',')).map(lambda x: x[0]).map(lambda x: float(x))
    temperatura_media = frame_tem.tm_mes
    temperatura_fechas = frame_tem.fecha.map(lambda x: x.replace('-', ',')).map(lambda x: x.split(',')).map(lambda x: x[1])

    data = { 'Temperatura Maxima' : temperatura_max,
             'Temperatura Media' : temperatura_media,
             'Temperatura Minima' : temperatura_min }

    finalTemperatura = DataFrame(data)
    print(finalTemperatura)

    '''
    ESTADO CEO
    '''
    # Creamos el DataFrame
    frame_ceo = DataFrame(datos, columns = estado_ceo, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    # En este caso puede que nos sirva de utilidad esta fila
    frame_ceo = frame_ceo.iloc[0:12]
    print(frame_ceo)

    # En este apartado podemos mostrar graficas de sectores o barras multiples
    # no se cual se adpatara mejor

    '''
    PRECIPITACIONES
    '''
    frame_pre = DataFrame(datos, columns = precipitacions, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    frame_pre = frame_pre.iloc[0:12]
    frame_pre = frame_pre.p_mes.map(lambda x: float(x))
    print(frame_pre)

    '''
    VENTO
    '''
    frame_vento = DataFrame(datos, columns = vento, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    frame_vento = frame_vento.iloc[0:12]
    print(frame_vento)
    frame_vento = frame_vento.dropna()

    # Limpiamos datos y obtenemos los grados completos del resultada
    frame_vento_dir = frame_vento.w_racha.map(lambda x: x.replace('(', '/')).map(lambda x: x.split('/')).map(lambda x: x[0]).map(lambda x: float(x)) * 10
    # Limpiamos datos y pasamos a kilometros por hora
    frame_vento_vel = frame_vento.w_racha.map(lambda x: x.replace('(', '/')).map(lambda x: x.split('/')).map(lambda x: x[1]).map(lambda x: float(x)) / 1000 * 3600

    print("dir \n")
    print(frame_vento_dir)
    print("vel \n")
    print(frame_vento_vel)

    '''
    HUMEDAD
    '''
    frame_hm = DataFrame(datos, columns = humedad, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    frame_hm = frame_hm.iloc[0:12]
    print(frame_hm)

    '''
    COTA DE NEVE
    '''
    frame_cota = DataFrame(datos, columns = cota_nieve, index = indice)
    # Con esto eliminamos la fila resumen que no nos sirve en nustro caso
    frame_cota = frame_cota.iloc[0:12]
    print(frame_cota)

    '''
    GRAFICAS
    '''

    #### TEMPERATURAS
    finalTemperatura.plot()
    plt.title("Gráfica de Temperaturas año: " + anho)
    plt.xlabel("Mes")
    plt.ylabel("Grados Celsius")
    plt.savefig("grafica.png")

    #### RECIPITACIONES

    #### VIENTO
    ## Discretizamos el conjunto de valores en n intervalos,
    ## en este caso 8 intervalos
    datosbin = np.histogram(frame_vento_dir, bins = np.linspace(np.min(frame_vento_dir), np.max(frame_vento_dir), 9))[0]
    ## Los datos los queremos en tanto por ciento
    datosbin = datosbin * 100. / len(frame_vento_dir)
    ## Los datos los queremos en n direcciones/secciones/sectores,
    ## en este caso usamos 8 sectores de una circunferencia
    sect = np.array([90, 45, 0, 315, 270, 225, 180, 135]) * 2. * math.pi / 360.
    nombresect = ['E','NE','N','NW','W','SW','S','SE']
    ## Dibujamos la rosa de frecuencias
    plt.axes([0.1,0.1,0.8,0.8], polar = True)
    plt.bar(sect, datosbin, align='center', width=45 * 2 * math.pi / 360.,
            facecolor='b', edgecolor='k', linewidth=2, alpha=0.5)
    plt.thetagrids(np.arange(0, 360, 45),nombresect,frac = 1.1, fontsize = 10)
    plt.title(u'Procedencia del viento en el año ' + anho)
    plt.show()

# Diarios  (Formato de fecha: 2016-06-01T10:00:00UTC)
elif (analisis == "2"):
    print("Esto aun no esta implementado illooooooo!!")

# Analisis incorrecto
else:
    print("Tipo de analisis incorrecto, aprende a leer mamón")


text:
<?php
/**
 * 数据表code_industry
 * 行业表
 */
namespace app\modules\admin\models;

use yii\db\ActiveRecord;

class Code_industry extends ActiveRecord{

}


text:
@interface SBNotificationSeparatorView : UIView
{
    double _height;
}

+ (long long)blendMode;
+ (id)color;
+ (id)separatorForCurrentState;
+ (long long)separatorViewModeForCurrentState;
+ (id)separatorWithScreenScale:(double)arg1 mode:(long long)arg2;
- (void)setBounds:(struct CGRect)arg1;
- (void)setFrame:(struct CGRect)arg1;
- (void)updateForCurrentState;
- (id)initWithFrame:(struct CGRect)arg1 mode:(long long)arg2;

@end


text:
lib_dir = File.dirname(__FILE__) + '/../lib'
require File.dirname(__FILE__) + '/linked_rails'

require 'test/unit'
require 'fileutils'
$:.unshift lib_dir unless $:.include?(lib_dir)
require 'haml'
require 'sass'

require 'haml/template'
Haml::Template.options[:ugly] = false
Haml::Template.options[:format] = :xhtml

Sass::RAILS_LOADED = true unless defined?(Sass::RAILS_LOADED)

module Sass::Script::Functions
  module UserFunctions; end
  include UserFunctions

  def option(name)
    Sass::Script::String.new(@options[name.value.to_sym].to_s)
  end
end

class Test::Unit::TestCase
  def munge_filename(opts = {})
    return if opts.has_key?(:filename)
    opts[:filename] = filename_for_test(opts[:syntax] || :sass)
  end

  def filename_for_test(syntax = :sass)
    test_name = caller.
      map {|c| Haml::Util.caller_info(c)[2]}.
      compact.
      map {|c| c.sub(/^(block|rescue) in /, '')}.
      find {|c| c =~ /^test_/}
    "#{test_name}_inline.#{syntax}"
  end

  def clean_up_sassc
    path = File.dirname(__FILE__) + "/../.sass-cache"
    FileUtils.rm_r(path) if File.exist?(path)
  end

  def assert_warning(message)
    the_real_stderr, $stderr = $stderr, StringIO.new
    yield

    if message.is_a?(Regexp)
      assert_match message, $stderr.string.strip
    else
      assert_equal message.strip, $stderr.string.strip
    end
  ensure
    $stderr = the_real_stderr
  end

  def silence_warnings(&block)
    Haml::Util.silence_warnings(&block)
  end

  def rails_block_helper_char
    return '=' if Haml::Util.ap_geq_3?
    return '-'
  end

  def form_for_calling_convention(name)
    return "@#{name}, :as => :#{name}, :html => {:class => nil, :id => nil}" if Haml::Util.ap_geq_3?
    return ":#{name}, @#{name}"
  end

  def rails_form_attr
    return 'accept-charset="UTF-8" ' if Haml::Util.ap_geq?("3.0.0.rc")
    return ''
  end

  def rails_form_opener
    return '' unless Haml::Util.ap_geq?("3.0.0.rc")
    if Haml::Util.ap_geq?("3.0.0.rc2")
      encoding = 'utf8'
      char = '✓'
    else
      encoding = '_snowman'
      char = '☃'
    end
    return '
<input name="' + encoding +
      '" type="hidden" value="' + char + '" />
'
  end

  def assert_raise_message(klass, message)
    yield
  rescue Exception => e
    assert_instance_of(klass, e)
    assert_equal(message, e.message)
  else
    flunk "Expected exception #{klass}, none raised"
  end
end


text:
namespace content {

#if BUILDFLAG(IS_CHROMEOS_LACROS)
namespace {

class LacrosMediaSessionServiceImpl
    : public media_session::MediaSessionService {
 public:
  LacrosMediaSessionServiceImpl() = default;
  ~LacrosMediaSessionServiceImpl() override = default;
  LacrosMediaSessionServiceImpl(const LacrosMediaSessionServiceImpl&) = delete;
  LacrosMediaSessionServiceImpl& operator=(
      const LacrosMediaSessionServiceImpl&) = delete;

  void BindAudioFocusManager(
      mojo::PendingReceiver<media_session::mojom::AudioFocusManager> receiver)
      override {
    auto* lacros_service = chromeos::LacrosService::Get();
    if (lacros_service && lacros_service->IsMediaSessionAudioFocusAvailable()) {
      lacros_service->BindAudioFocusManager(std::move(receiver));
    }
  }

  void BindAudioFocusManagerDebug(
      mojo::PendingReceiver<media_session::mojom::AudioFocusManagerDebug>
          receiver) override {
    auto* lacros_service = chromeos::LacrosService::Get();
    if (lacros_service &&
        lacros_service->IsMediaSessionAudioFocusDebugAvailable()) {
      lacros_service->BindAudioFocusManagerDebug(std::move(receiver));
    }
  }

  void BindMediaControllerManager(
      mojo::PendingReceiver<media_session::mojom::MediaControllerManager>
          receiver) override {
    auto* lacros_service = chromeos::LacrosService::Get();
    if (lacros_service && lacros_service->IsMediaSessionControllerAvailable()) {
      lacros_service->BindMediaControllerManager(std::move(receiver));
    }
  }
};

}  // namespace
#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)

media_session::MediaSessionService& GetMediaSessionService() {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);

#if BUILDFLAG(IS_CHROMEOS_LACROS)
  auto* lacros_service = chromeos::LacrosService::Get();
  if (lacros_service && lacros_service->IsMediaSessionControllerAvailable() &&
      lacros_service->IsMediaSessionAudioFocusDebugAvailable() &&
      lacros_service->IsMediaSessionAudioFocusAvailable()) {
    static base::NoDestructor<LacrosMediaSessionServiceImpl> service;
    return *service;
  }
#endif  // BUILDFLAG(IS_CHROMEOS_LACROS)
  static base::NoDestructor<media_session::MediaSessionServiceImpl> service;
  return *service;
}

}  // namespace content


text:
package client

const (
	NetworkConfigType                        = "networkConfig"
	NetworkConfigFieldAciNetworkProvider     = "aciNetworkProvider"
	NetworkConfigFieldCalicoNetworkProvider  = "calicoNetworkProvider"
	NetworkConfigFieldCanalNetworkProvider   = "canalNetworkProvider"
	NetworkConfigFieldFlannelNetworkProvider = "flannelNetworkProvider"
	NetworkConfigFieldMTU                    = "mtu"
	NetworkConfigFieldNodeSelector           = "nodeSelector"
	NetworkConfigFieldOptions                = "options"
	NetworkConfigFieldPlugin                 = "plugin"
	NetworkConfigFieldTolerations            = "tolerations"
	NetworkConfigFieldUpdateStrategy         = "updateStrategy"
	NetworkConfigFieldWeaveNetworkProvider   = "weaveNetworkProvider"
)

type NetworkConfig struct {
	AciNetworkProvider     *AciNetworkProvider      `json:"aciNetworkProvider,omitempty" yaml:"aciNetworkProvider,omitempty"`
	CalicoNetworkProvider  *CalicoNetworkProvider   `json:"calicoNetworkProvider,omitempty" yaml:"calicoNetworkProvider,omitempty"`
	CanalNetworkProvider   *CanalNetworkProvider    `json:"canalNetworkProvider,omitempty" yaml:"canalNetworkProvider,omitempty"`
	FlannelNetworkProvider *FlannelNetworkProvider  `json:"flannelNetworkProvider,omitempty" yaml:"flannelNetworkProvider,omitempty"`
	MTU                    int64                    `json:"mtu,omitempty" yaml:"mtu,omitempty"`
	NodeSelector           map[string]string        `json:"nodeSelector,omitempty" yaml:"nodeSelector,omitempty"`
	Options                map[string]string        `json:"options,omitempty" yaml:"options,omitempty"`
	Plugin                 string                   `json:"plugin,omitempty" yaml:"plugin,omitempty"`
	Tolerations            []Toleration             `json:"tolerations,omitempty" yaml:"tolerations,omitempty"`
	UpdateStrategy         *DaemonSetUpdateStrategy `json:"updateStrategy,omitempty" yaml:"updateStrategy,omitempty"`
	WeaveNetworkProvider   *WeaveNetworkProvider    `json:"weaveNetworkProvider,omitempty" yaml:"weaveNetworkProvider,omitempty"`
}


text:
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context=".activities.WebViewActivity">

    <item
        android:id="@+id/open_browser"
        android:title="@string/open_browser"
        app:showAsAction="never" />
</menu>


text:
package ankit.account.manager.model;

import org.json.JSONObject;

import android.content.Context;
import ankit.account.manager.completionhandler.Callback;
import ankit.account.manager.completionhandler.RequestJSONCallback;
import ankit.account.manager.exception.SessionException;
import ankit.account.manager.service.Service;
import ankit.account.manager.util.AccountUtils;
import ankit.account.manager.util.Preferences;

/**
 * The Session class models a user's session. It is the intermediate level between Controllers and Service.
 */
public final class Session {

    private static final String LOG_TAG = Session.class.getSimpleName();

    private Service service;

    private Preferences preferences;

    private static Session currentSession = null;

    /**
     * The constructor of the session.
     * Because it is a singleton, there is not parameters for the constructors and it's private
     */
    private Session() {}

    /**
     * SingletonHolder is loaded on the first execution of Singleton.getInstance() or the first access to
     * SingletonHolder.INSTANCE, not before.
     */
    private static class SingletonHolder {
        private static final Session INSTANCE = new Session();
    }

    // It is synchronized to avoid problems with multithreading
    // Once get, it must initialize the service and the preferences based on the context
    private static synchronized Session getInstance() {
        return SingletonHolder.INSTANCE;
    }

    // To avoid clone problem
    @Override
    public Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    /**
     * This method starts the sign up process.
     * @param context Context in which execution must be
     * @param username the name of the user
     * @param password User's password
     * @param callback Callback to call when process finishes
     */
    public static void signUp(final Context context, final String username,
    		final String password, final Callback callback) {

        Service service = new Service(username);

        service.signUp(username, password, new Callback() {
            @Override
            public void done(final boolean error) {
                // If there is not error, the method login will call callback
                if (!error) {
                    Session.logIn(context, username, password, callback);
                } else {
                    callback.done(error);
                }
            }
        });
    }

    /**
     * Allow the user to log in.
     * It checks the user name and the password against the server.
     * @param context    The context utilized
     * @param username   The name of the user
     * @param password   The password
     * @param callback   The callback to call when the server returns an answer
     */
    public static void logIn(final Context context, final String username,
            final String password, final Callback callback) {

        final Service service = new Service(username);
        // The preferences is here to avoid to be used statically
        final Preferences preferences = new Preferences(context);

        service.logIn(username, password, new RequestJSONCallback() {
            @Override
            public void done(JSONObject jsonObject, boolean error) {
                if (!error) {
                    /*
                     * Creates an instance of the current session.
                     */
                    Session session = Session.getInstance();
                    session.setService(service);
                    session.setPreferences(preferences);

                    /*
                     * Save the current session
                     */
                    Session.setCurrentSession(session);
                    Session.currentSession.saveAsCurrentSession(context, username, password);
                }

                callback.done(error);
            }
        });
    }

    /**
     * Save the session in a persistent way.
     * @param context  The context utilized to get the data
     * @param username The name of the verified user
     * @param password The password of the verified user
     */
    private void saveAsCurrentSession(Context context, String username, String password) {
        // Save the user name
        preferences.setUserName(username);

        // Save the password
        AccountUtils.setPasswordByUserName(context, username, password);

    }

    /**
     * Check if there is any saved session
     * @param context The context used
     * @return true if there is any saved session
     *         false otherwise
     */
    public static boolean isSavedSessionExists(Context context) {
        Preferences preferences = new Preferences(context);

        // Check if the user name exists in the Shared preferences
        String username = preferences.getUsername();
        if (username == null || username.equals(Preferences.DEFAULT_USERNAME)) {
            return false;
        }

        // Check if the user account exists
        if (AccountUtils.getUserAccount(context, username) == null) {
        	return false;
        }

        return true;
    }

    /**
     * Get the current session.
     * @param context The context utilized to retrieve the data
     * @return The current session
     * @throws SessionException if some data is missing
     */
    public static synchronized Session getCurrentSession(Context context) throws SessionException {
        if (Session.currentSession == null) {
            Session.currentSession = Session.sessionFromCurrentSession(context);
        }

        return Session.currentSession;
    }

    /**
     * Creates a new session from the data saved in the persistent data storage.
     * It might return null. Use the method existSavedSession to check if
     * the session saved exists
     * Precondition: The user name exists in the Shared preferences and the user
     *  account exists.
     * @param context The context utilized.
     * @return A new session if all the data are set
     * @throws SessionException if some data is missing
     */
    private static Session sessionFromCurrentSession(Context context) throws SessionException {
        Preferences preferences = new Preferences(context);

        // Get the user name
        String username = preferences.getUsername();
        if (username == null || username.equals(Preferences.DEFAULT_USERNAME)) {
            throw new SessionException("Error getting the session from the current one. " +
            "The previous session doesn't exsit");
        }

        Service newService = new Service(username);
        Session newSession = Session.getInstance();
        newSession.setService(newService);
        newSession.setPreferences(preferences);

        return newSession;
    }

    // Getters & setters

    private static synchronized void setCurrentSession(Session session) {
        Session.currentSession = session;
    }

    /*
    private Service getService() {
        return service;
    }*/

    /**
     * Set the service as the service utilized for the sessions
     * This is private to prevent other to set the service
     * The service won't be set until the user has logged in.
     * @param service The service to set.
     */
    private void setService(Service service) {
        this.service = service;
    }

    public Preferences getPreferences() {
       return preferences;
    }

    /**
     * Set the preferences as the preferences utilized for the session.
     * This is private to prevent other ot set the preferences from outside
     * The preferences won't be set until the user has logged in.
     * @param preferences The preferences to set.
     */
    private void setPreferences(Preferences preferences) {
        this.preferences = preferences;
    }

}


text:
package com.nhom7.adapter;

import java.lang.reflect.Method;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.CallLog;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.widget.Toast;
public class Blockphone_BroadcastReceiver extends BroadcastReceiver {
	Context context;
	TelephonyManager telephonyManager;
	DataBlackContact_Adapter dbblack;

	@Override
	public void onReceive(Context context, Intent intent) {
		// TODO Auto-generated method stub
		this.context = context;
		telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
		dbblack = new DataBlackContact_Adapter(context);
		Cursor cur = dbblack.getAllDataBlack();
		//myNumber = tMgr.getLine1Number();
		if(cur.getCount()<=0)
		{

		}
		else{
			while (cur.moveToNext()) {
				Bundle extras = intent.getExtras();
				if (extras != null) {
					String state = extras.getString(TelephonyManager.EXTRA_STATE);
					if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
						String phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
						if (phoneNumber.equalsIgnoreCase(cur.getString(2))) {
						disconnectCall();
						DeleteCallLogByNumber(cur.getString(2));
					}
					}
				}
			}
			}
	}

	public void disconnectCall() {
		try {
			Class<?> classTelephony = Class.forName(telephonyManager.getClass().getName());
			Method method = classTelephony.getDeclaredMethod("getITelephony");
			method.setAccessible(true);
			Object telephonyInterface = method.invoke(telephonyManager);
			Class<?> telephonyInterfaceClass = Class.forName(telephonyInterface.getClass().getName());
			Method methodEndCall = telephonyInterfaceClass.getDeclaredMethod("endCall");
			methodEndCall.invoke(telephonyInterface);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	public void DeleteCallLogByNumber(String numberp) {
		try {
	        Thread.sleep(4000);
	        String strNumberOne[] = { numberp };
	        Cursor cursor = context.getContentResolver().query(
	                CallLog.Calls.CONTENT_URI, null,
	                CallLog.Calls.NUMBER + " = ? ", strNumberOne, "");
	        boolean bol = cursor.moveToFirst();
	        if (bol) {
	            do {
	                int idOfRowToDelete = cursor.getInt(cursor
	                        .getColumnIndex(CallLog.Calls._ID));
	                context.getContentResolver().delete(
	                        CallLog.Calls.CONTENT_URI,
	                        CallLog.Calls._ID + "= ? ",
	                        new String[] { String.valueOf(idOfRowToDelete) });
	            } while (cursor.moveToNext());
	        }
	    } catch (Exception ex) {
	        Log.v("deleteNumber",
	                "Exception, unable to remove # from call log: "
	                        + ex.toString());
	    }

	}
}


text:
using System.Collections.Generic;
using LibGit2Sharp.Tests.TestHelpers;
using Xunit;
using Xunit.Extensions;

namespace LibGit2Sharp.Tests
{
    public class RemoteFixture : BaseFixture
    {
        [Fact]
        public void CanGetRemoteOrigin()
        {
            using (var repo = new Repository(StandardTestRepoPath))
            {
                Remote origin = repo.Network.Remotes["origin"];
                Assert.NotNull(origin);
                Assert.Equal("origin", origin.Name);
                Assert.Equal("c:/GitHub/libgit2sharp/Resources/testrepo.git", origin.Url);
            }
        }

        [Fact]
        public void GettingRemoteThatDoesntExistReturnsNull()
        {
            using (var repo = new Repository(StandardTestRepoPath))
            {
                Assert.Null(repo.Network.Remotes["test"]);
            }
        }

        [Fact]
        public void CanEnumerateTheRemotes()
        {
            using (var repo = new Repository(StandardTestRepoPath))
            {
                int count = 0;

                foreach (Remote remote in repo.Network.Remotes)
                {
                    Assert.NotNull(remote);
                    count++;
                }

                Assert.Equal(1, count);
            }
        }

        [Fact]
        public void CanCheckEqualityOfRemote()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoPath);

            using (var repo = new Repository(path.RepositoryPath))
            {
                Remote oneOrigin = repo.Network.Remotes["origin"];
                Assert.NotNull(oneOrigin);

                Remote otherOrigin = repo.Network.Remotes["origin"];
                Assert.Equal(oneOrigin, otherOrigin);

                Remote createdRemote = repo.Network.Remotes.Add("origin2", oneOrigin.Url);

                Remote loadedRemote = repo.Network.Remotes["origin2"];
                Assert.NotNull(loadedRemote);
                Assert.Equal(createdRemote, loadedRemote);

                Assert.NotEqual(oneOrigin, loadedRemote);
            }
        }

        [Theory]
        [InlineData("http://github.com/libgit2/TestGitRepository")]
        [InlineData("https://github.com/libgit2/TestGitRepository")]
        [InlineData("git://github.com/libgit2/TestGitRepository.git")]
        public void CanFetchIntoAnEmptyRepository(string url)
        {
            string remoteName = "testRemote";

            var scd = BuildSelfCleaningDirectory();
            using (var repo = Repository.Init(scd.RootedDirectoryPath))
            {
                Remote remote = repo.Network.Remotes.Add(remoteName, url);

                // Set up structures for the expected results
                // and verifying the RemoteUpdateTips callback.
                TestRemoteInfo expectedResults = TestRemoteInfo.TestRemoteInstance;
                ExpectedFetchState expectedFetchState = new ExpectedFetchState(remoteName);

                // Add expected branch objects
                foreach (KeyValuePair<string, ObjectId> kvp in expectedResults.BranchTips)
                {
                    expectedFetchState.AddExpectedBranch(kvp.Key, ObjectId.Zero, kvp.Value);
                }

                // Add the expected tags
                string[] expectedTagNames = { "blob", "commit_tree", "annotated_tag" };
                foreach (string tagName in expectedTagNames)
                {
                    TestRemoteInfo.ExpectedTagInfo expectedTagInfo = expectedResults.Tags[tagName];
                    expectedFetchState.AddExpectedTag(tagName, ObjectId.Zero, expectedTagInfo);
                }

                // Perform the actual fetch
                remote.Fetch(onUpdateTips: expectedFetchState.RemoteUpdateTipsHandler);

                // Verify the expected
                expectedFetchState.CheckUpdatedReferences(repo);
            }
        }

        [SkippableFact]
        public void CanFetchIntoAnEmptyRepositoryWithCredentials()
        {
            InconclusiveIf(() => string.IsNullOrEmpty(Constants.PrivateRepoUrl),
                "Populate Constants.PrivateRepo* to run this test");

            string remoteName = "testRemote";

            var scd = BuildSelfCleaningDirectory();
            using (var repo = Repository.Init(scd.RootedDirectoryPath))
            {
                Remote remote = repo.Network.Remotes.Add(remoteName, Constants.PrivateRepoUrl);

                // Perform the actual fetch
                remote.Fetch(credentials: new Credentials
                                              {
                                                  Username = Constants.PrivateRepoUsername,
                                                  Password = Constants.PrivateRepoPassword
                                              });
            }
        }

        [Theory]
        [InlineData("http://github.com/libgit2/TestGitRepository")]
        [InlineData("https://github.com/libgit2/TestGitRepository")]
        [InlineData("git://github.com/libgit2/TestGitRepository.git")]
        public void CanFetchAllTagsIntoAnEmptyRepository(string url)
        {
            string remoteName = "testRemote";

            var scd = BuildSelfCleaningDirectory();
            using (var repo = Repository.Init(scd.RootedDirectoryPath))
            {
                Remote remote = repo.Network.Remotes.Add(remoteName, url);

                // Set up structures for the expected results
                // and verifying the RemoteUpdateTips callback.
                TestRemoteInfo remoteInfo = TestRemoteInfo.TestRemoteInstance;
                ExpectedFetchState expectedFetchState = new ExpectedFetchState(remoteName);

                // Add expected branch objects
                foreach (KeyValuePair<string, ObjectId> kvp in remoteInfo.BranchTips)
                {
                    expectedFetchState.AddExpectedBranch(kvp.Key, ObjectId.Zero, kvp.Value);
                }

                // Add expected tags
                foreach (KeyValuePair<string, TestRemoteInfo.ExpectedTagInfo> kvp in remoteInfo.Tags)
                {
                    expectedFetchState.AddExpectedTag(kvp.Key, ObjectId.Zero, kvp.Value);
                }

                // Perform the actual fetch
                remote.Fetch(TagFetchMode.All, onUpdateTips: expectedFetchState.RemoteUpdateTipsHandler);

                // Verify the expected
                expectedFetchState.CheckUpdatedReferences(repo);
            }
        }

        [Fact]
        public void CreatingANewRemoteAddsADefaultRefSpec()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoPath);

            using (var repo = new Repository(path.RepositoryPath))
            {
                const string name = "upstream";
                const string url = "https://github.com/libgit2/libgit2sharp.git";

                repo.Network.Remotes.Add(name, url);
                Remote remote = repo.Network.Remotes[name];
                Assert.NotNull(remote);

                Assert.Equal(name, remote.Name);
                Assert.Equal(url, remote.Url);

                var refSpec = repo.Config.Get<string>("remote", remote.Name, "fetch");
                Assert.NotNull(refSpec);

                Assert.Equal("+refs/heads/*:refs/remotes/upstream/*", refSpec.Value);
            }
        }

        [Fact]
        public void CanAddANewRemoteWithAFetchRefSpec()
        {
            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoPath);

            using (var repo = new Repository(path.RepositoryPath))
            {
                const string name = "pull-requests";
                const string url = "https://github.com/libgit2/libgit2sharp.git";
                const string fetchRefSpec = "+refs/pull/*:refs/remotes/pull-requests/*";

                repo.Network.Remotes.Add(name, url, fetchRefSpec);

                var refSpec = repo.Config.Get<string>("remote", name, "fetch");
                Assert.NotNull(refSpec);

                Assert.Equal(fetchRefSpec, refSpec.Value);
            }
        }

        [Theory]
        [InlineData("sher.lock")]
        [InlineData("/")]
        public void AddingARemoteWithAnInvalidNameThrows(string name)
        {
            using (var repo = new Repository(BareTestRepoPath))
            {
                const string url = "https://github.com/libgit2/libgit2sharp.git";

                Assert.Throws<InvalidSpecificationException>(() => repo.Network.Remotes.Add(name, url));
            }
        }

        [Theory]
        [InlineData("valid/remote", true)]
        [InlineData("sher.lock", false)]
        [InlineData("/", false)]
        public void CanTellIfARemoteNameIsValid(string refname, bool expectedResult)
        {
            using (var repo = new Repository(BareTestRepoPath))
            {
                Assert.Equal(expectedResult, repo.Network.Remotes.IsValidName(refname));
            }
        }
    }
}


text:
(function () {
  'use strict';

  /**
   * @ngdoc module
   * @ngname horizon.dashboard.project
   * @description
   * Dashboard module to host project panels.
   */
  angular
    .module('horizon.dashboard.project', [
      'horizon.dashboard.project.images',
      'horizon.dashboard.project.workflow'
    ])
    .config(config);

  config.$inject = [
    '$provide',
    '$windowProvider'
  ];

  /**
   * @name horizon.dashboard.project.basePath
   * @description Base path for the project dashboard
   */
  function config($provide, $windowProvider) {
    var path = $windowProvider.$get().STATIC_URL + 'dashboard/project/';
    $provide.constant('horizon.dashboard.project.basePath', path);
  }

})();


text:
package mk.ukim.finki.wp.web.rest.db;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import mk.ukim.finki.wp.model.db.EventArea;
import mk.ukim.finki.wp.service.db.EventAreaService;
import mk.ukim.finki.wp.web.CrudResource;

@RestController
@RequestMapping("/data/rest/EventArea")
public class EventAreaResource extends CrudResource<EventArea, EventAreaService> {

	@Autowired
	private EventAreaService service;

	@Override
	public EventAreaService getService() {
		return service;
	}

}


text:
package me.vilsol.nmswrapper.wraps.unparsed;

import me.vilsol.nmswrapper.NMSWrapper;
import me.vilsol.nmswrapper.reflections.ReflectiveClass;
import me.vilsol.nmswrapper.reflections.ReflectiveMethod;
import me.vilsol.nmswrapper.wraps.NMSItemStack;
import me.vilsol.nmswrapper.wraps.NMSWorld;

@ReflectiveClass(name = "BlockBeacon")
public class NMSBlockBeacon extends NMSBlockContainer {

    public NMSBlockBeacon(Object nmsObject){
        super(nmsObject);
    }

    /**
     * TODO Find correct name
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#a(net.minecraft.server.v1_9_R1.World, int)
     */
    @ReflectiveMethod(name = "a", types = {NMSWorld.class, int.class})
    public NMSTileEntity a(NMSWorld world, int i){
        return new NMSTileEntity(NMSWrapper.getInstance().exec(nmsObject, world, i));
    }

    /**
     * TODO Find correct name
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#b()
     */
    @ReflectiveMethod(name = "b", types = {})
    public int b(){
        return (int) NMSWrapper.getInstance().exec(nmsObject);
    }

    /**
     * TODO Find correct name
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#c()
     */
    @ReflectiveMethod(name = "c", types = {})
    public boolean c(){
        return (boolean) NMSWrapper.getInstance().exec(nmsObject);
    }

    /**
     * TODO Find correct name
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#d()
     */
    @ReflectiveMethod(name = "d", types = {})
    public boolean d(){
        return (boolean) NMSWrapper.getInstance().exec(nmsObject);
    }

    /**
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#doPhysics(net.minecraft.server.v1_9_R1.World, net.minecraft.server.v1_9_R1.BlockPosition, net.minecraft.server.v1_9_R1.IBlockData, net.minecraft.server.v1_9_R1.Block)
     */
    @ReflectiveMethod(name = "doPhysics", types = {NMSWorld.class, NMSBlockPosition.class, NMSIBlockData.class, NMSBlock.class})
    public void doPhysics(NMSWorld world, NMSBlockPosition blockPosition, NMSIBlockData iBlockData, NMSBlock block){
        NMSWrapper.getInstance().exec(nmsObject, world, blockPosition, iBlockData, block);
    }

    /**
     * TODO Find correct name
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#f(net.minecraft.server.v1_9_R1.World, net.minecraft.server.v1_9_R1.BlockPosition)
     */
    @ReflectiveMethod(name = "f", types = {NMSWorld.class, NMSBlockPosition.class})
    public void f(NMSWorld world, NMSBlockPosition blockPosition){
        NMSWrapper.getInstance().exec(nmsObject, world, blockPosition);
    }

    /**
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#interact(net.minecraft.server.v1_9_R1.World, net.minecraft.server.v1_9_R1.BlockPosition, net.minecraft.server.v1_9_R1.IBlockData, net.minecraft.server.v1_9_R1.EntityHuman, net.minecraft.server.v1_9_R1.EnumDirection, float, float, float)
     */
    @ReflectiveMethod(name = "interact", types = {NMSWorld.class, NMSBlockPosition.class, NMSIBlockData.class, NMSEntityHuman.class, NMSEnumDirection.class, float.class, float.class, float.class})
    public boolean interact(NMSWorld world, NMSBlockPosition blockPosition, NMSIBlockData iBlockData, NMSEntityHuman entityHuman, NMSEnumDirection enumDirection, float f, float f1, float f2){
        return (boolean) NMSWrapper.getInstance().exec(nmsObject, world, blockPosition, iBlockData, entityHuman, enumDirection, f, f1, f2);
    }

    /**
     * @see net.minecraft.server.v1_9_R1.BlockBeacon#postPlace(net.minecraft.server.v1_9_R1.World, net.minecraft.server.v1_9_R1.BlockPosition, net.minecraft.server.v1_9_R1.IBlockData, net.minecraft.server.v1_9_R1.EntityLiving, net.minecraft.server.v1_9_R1.ItemStack)
     */
    @ReflectiveMethod(name = "postPlace", types = {NMSWorld.class, NMSBlockPosition.class, NMSIBlockData.class, NMSEntityLiving.class, NMSItemStack.class})
    public void postPlace(NMSWorld world, NMSBlockPosition blockPosition, NMSIBlockData iBlockData, NMSEntityLiving entityLiving, NMSItemStack itemStack){
        NMSWrapper.getInstance().exec(nmsObject, world, blockPosition, iBlockData, entityLiving, itemStack);
    }

}


text:
package org.fedorahosted.freeotp;

import java.util.LinkedList;
import java.util.List;

import org.fedorahosted.freeotp.Token.TokenUriInvalidException;
import org.json.JSONArray;
import org.json.JSONException;

import android.content.Context;
import android.content.SharedPreferences;

public class TokenPersistence {
    private static final String     NAME  = "tokens";
    private static final String     ORDER = "tokenOrder";
    private final SharedPreferences prefs;

    private List<String> getTokenOrder() {
        try {
            JSONArray array = new JSONArray(prefs.getString(ORDER, null));
            List<String> out = new LinkedList<String>();
            for (int i = 0; i < array.length(); i++)
                out.add(array.getString(i));
            return out;
        } catch (JSONException e) {
        } catch (NullPointerException e) {
        }

        return new LinkedList<String>();
    }

    private SharedPreferences.Editor setTokenOrder(List<String> order) {
        JSONArray array = new JSONArray();
        for (String key : order)
            array.put(key);

        return prefs.edit().putString(ORDER, array.toString());
    }

    public TokenPersistence(Context ctx) {
        prefs = ctx.getApplicationContext().getSharedPreferences(NAME, Context.MODE_PRIVATE);
    }

    public int length() {
        return getTokenOrder().size();
    }

    public Token get(int position) {
        try {
            return new Token(prefs.getString(getTokenOrder().get(position), null), true);
        } catch (TokenUriInvalidException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            e.printStackTrace();
        }

        return null;
    }

    public void add(String uri) throws TokenUriInvalidException {
        Token token = new Token(uri, false);
        String key = token.getID();

        if (prefs.contains(key))
            return;

        List<String> order = getTokenOrder();
        order.add(0, key);
        setTokenOrder(order).putString(key, token.toString()).apply();
    }

    public void move(int fromPosition, int toPosition) {
        if (fromPosition == toPosition)
            return;

        List<String> order = getTokenOrder();
        if (fromPosition < 0 || fromPosition > order.size())
            return;
        if (toPosition < 0 || toPosition > order.size())
            return;

        order.add(toPosition, order.remove(fromPosition));
        setTokenOrder(order).apply();
    }

    public void delete(int position) {
        List<String> order = getTokenOrder();
        String key = order.remove(position);
        setTokenOrder(order).remove(key).apply();
    }

    public void save(Token token) {
        prefs.edit().putString(token.getID(), token.toString()).apply();
    }
}


text:
/*
 * $Id$
 */
package lia.util.net.common;

import java.nio.ByteBuffer;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Wrapper class over {@link ByteBuffer} which keeps track whether a buffer is
 * in use or not
 *
 * @author ramiro
 */
public class FDTBuffer {

    private ByteBuffer[] buffers;
    private AtomicBoolean inUse;

    FDTBuffer() {
        this.inUse = new AtomicBoolean(false);
    }

    void setBuffer(ByteBuffer[] buffers) {
        if (inUse.compareAndSet(false, true)) {
            this.buffers = buffers;
        } else {
            throw new RuntimeException("cannot set buffers because the buffer is still in use");
        }
    }

    boolean free() {
        return inUse.compareAndSet(true, false);
    }

    public ByteBuffer[] get() {
        return buffers;
    }

    public boolean hasRemaining() {
        return buffers[buffers.length - 1].hasRemaining();
    }
}


text:
'use strict';

var S         = require('string')
var ignore    = ['latest', 'cdn', 'mains', 'files']
var request   = require('request')

function getCdnReference(primaryCdn, list) {
  if (list[primaryCdn]) return primaryCdn
  for (var cdn in list) {
    if (ignore.indexOf(cdn) < 0) {
      return cdn
    }
  }
}

function packDetails(name, pack, selectVersion) {
  if (selectVersion) selectVersion = S(selectVersion).replaceAll('.x', '.').replaceAll('..', '.').replaceAll('..', '.').s
  var selectVersionLength = (selectVersion) ? selectVersion.length : 0
  var result = { name: name }
  for (var i in pack) {
    if (ignore.indexOf(i) < 0) {
      var version = S(i).replaceAll(':', '.').s
      if (!selectVersion || version.substr(0, selectVersionLength) == selectVersion) {
        result.version = version
        result.data    = pack[i]
      }
    }
  }
  if (!result.version) return null
  result.cdn   = getCdnReference(pack.cdn, result.data)
  var main     = 0
  var file     = 0
  var cdnRef   = result.data[result.cdn]
  if (typeof cdnRef === 'number') {
    file = cdnRef
  } else {
    main = cdnRef.mains
    file = cdnRef.files
  }
  result.files = pack.files[file].split(',')
  result.main = pack.mains[main]
  result.data = undefined
  return result
}

function cdnallPack(req, res, next) {
  function getFile(url, cb) {
    req.app.locals.logger.info('getFile ' + url)
    request(url, function (error, response, body) {
      if (error) {
        cb(error)
      } else {
        var data = {
          type: response.headers['content-type'],
          body: body
        }
        cb(null, data)
      }
    })
  }

  var pack = res.locals.pack
  if (pack) {
    pack            = pack[0]
    var packname    = pack.name
    var version     = pack.version
    var packages    = req.app.locals.db.packages
    var pkg         = packages[packname]
    var data
    var pretty_json
    if (pkg) pkg    = packDetails(packname, pkg, version)
    if (pkg) {
      pkg.cdnPath = req.app.locals.db.available[pkg.cdn]
      var templateData    = {
        package: pkg.name,
        version: pkg.version,
        file:    pkg.main
      }
      if (res.locals.file) {
        if (res.locals.file.substr(0,1) != '.') {
          templateData.file = res.locals.file
        }
      }
//      console.log(templateData, ':', pkg)
      pkg.path = S(pkg.cdnPath).template(templateData, '{', '}').s
      data     = { packname: packname, file: res.locals.file, pkg: pkg, pack: pack }

      if (res.locals.redirect) {
        res.locals.statusCode = 302
        res.redirect(302, pkg.path)
      } else if (res.locals.debug) {
        res.set('Content-Type', 'application/json') // JSONP: application/javascript
        pretty_json = JSON.stringify(data, null, 2)
        res.locals.statusCode = 200
        res.status(200).send(pretty_json)
      } else {
        getFile(pkg.path, function(error, data) {
          if (error) {
            res.locals.statusCode = 500
            next(error)
          } else {
            res.set('Content-Type', data.type) // content-encoding: gzip
            res.locals.statusCode = 200
            res.status(200).send(data.body)
          }
        })
      }
    } else {
      if (res.locals.debug) {
        res.set('Content-Type', 'application/json') // JSONP: application/javascript
        data = {
          'error': "Not Found",
          pack: pack
        }
        pretty_json = JSON.stringify(data, null, 2)
        res.locals.statusCode = 200
        res.status(200).send(pretty_json)
      } else {
        res.locals.statusCode = 404
          res.status(404).send('Not Found')
      }
    }
  } else {
    next()
  }
}

module.exports = cdnallPack


text:
function flatten<T>(matrix: T[][]): T[] {
  return matrix.reduce((flatten, array) => flatten.concat(array), []);
}

export default flatten;


text:
Sis.HomeRoute = Ember.Route.extend({
  needs: ['navigation'],
  model: function() {
    if (this.get('auth.currentUser') && this.get('auth.currentUser.isTeacher')) {
      return this.store.findAll('semester');
    }
  },
});


text:
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
// we can use #297, but here's a more compact string using #105
class Codec {
public:

    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }

private:

    void serialize(TreeNode* root, ostringstream& out) {
        if (root) {
            out << root->val << ' ';
            serialize(root->left, out);
            serialize(root->right, out);
        } else {
            // just give the inorder string
        }
    }

    TreeNode* deserialize(istringstream& in) {
        vector<int> preorder;
        string val;
        while (in >> val) {
            preorder.push_back(stoi(val));
        }
        vector<int> inorder = preorder;
        sort(inorder.begin(), inorder.end());

        TreeNode* root = buildTree(preorder, inorder);
        return root;
    }

    unordered_map<int, int> hashMap;

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
	    for(size_t i = 0; i < inorder.size(); i++)
		   hashMap[inorder[i]] = i;
	    int prePos = 0;
	    return constructTree(inorder, preorder, 0, inorder.size()-1, prePos);
    }

    TreeNode* constructTree(vector<int>& inorder, vector<int>& preorder, int left, int right, int& prePos){
	    if(left > right || prePos == inorder.size()) {
		    prePos--;
		    return NULL;
	    }
	    int inPos = hashMap[preorder[prePos]];
	    TreeNode* root = new TreeNode(inorder[inPos]);
	    root->left = constructTree(inorder, preorder, left, inPos-1, ++prePos);
	    root->right = constructTree(inorder, preorder, inPos+1, right, ++prePos);
	    return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));


text:
package org.sleuthkit.autopsy.casemodule;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.openide.WizardDescriptor;
import org.openide.WizardValidationException;
import org.openide.util.HelpCtx;
import org.openide.windows.WindowManager;
import java.awt.Cursor;

/**
 * The second panel of the New Case wizard.
 */
class NewCaseWizardPanel2 implements WizardDescriptor.ValidatingPanel<WizardDescriptor> {

    private NewCaseVisualPanel2 component;
    private final Set<ChangeListener> listeners = new HashSet<>(1);

    /**
     * Get the visual component for the panel.
     *
     * @return component The UI component of this wizard panel.
     */
    @Override
    public NewCaseVisualPanel2 getComponent() {
        if (component == null) {
            component = new NewCaseVisualPanel2();
        }
        return component;
    }

    /**
     * Gets the help object for this panel. When the panel is active, this is
     * used as the help for the wizard dialog.
     *
     * @return The help for this panel.
     */
    @Override
    public HelpCtx getHelp() {
        /*
         * Currently, no help is provided for this panel.
         */
        return HelpCtx.DEFAULT_HELP;
    }

    /**
     * Tests whether the panel is finished. If the panel is valid, the "Finish"
     * button will be enabled.
     *
     * @return boolean true if all the fields are correctly filled, false
     *         otherwise
     */
    @Override
    public boolean isValid() {
        return true;
    }

    /**
     * Adds a change listener to this panel.
     *
     * @param listener The change listener to add.
     */
    @Override
    public final void addChangeListener(ChangeListener listener) {
        synchronized (listeners) {
            listeners.add(listener);
        }
    }

    /**
     * Removes a change listener from this panel.
     *
     * @param listener The change listener to remove.
     */
    @Override
    public final void removeChangeListener(ChangeListener listener) {
        synchronized (listeners) {
            listeners.remove(listener);
        }
    }

    /**
     * Notifies any registerd change listeners of a change in the panel.
     */
    protected final void fireChangeEvent() {
        Iterator<ChangeListener> it;
        synchronized (listeners) {
            it = new HashSet<>(listeners).iterator();
        }
        ChangeEvent ev = new ChangeEvent(this);
        while (it.hasNext()) {
            it.next().stateChanged(ev);
        }
    }

    /**
     * Provides the wizard panel with the current data--either the default data
     * or already-modified settings, if the user used the previous and/or next
     * buttons. This method can be called multiple times on one instance of
     * WizardDescriptor.Panel.
     *
     * @param settings the setting to be read from
     */
    @Override
    public void readSettings(WizardDescriptor settings) {
    }

    /**
     * Provides the wizard panel with the opportunity to update the settings
     * with its current customized state. Rather than updating its settings with
     * every change in the GUI, it should collect them, and then only save them
     * when requested to by this method. This method can be called multiple
     * times on one instance of WizardDescriptor.Panel.
     *
     * @param settings the setting to be stored to
     */
    @Override
    public void storeSettings(WizardDescriptor settings) {
        NewCaseVisualPanel2 currentComponent = getComponent();
        settings.putProperty("caseNumber", currentComponent.getCaseNumber()); //NON-NLS
        settings.putProperty("caseExaminer", currentComponent.getExaminer()); //NON-NLS
    }

    @Override
    public void validate() throws WizardValidationException {
        WindowManager.getDefault().getMainWindow().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
    }
}


text:
<!doctype html>
<title>innerHTML getter for pre/textarea/listing with initial LF</title>

x

x

<textarea id="textarea1">
x</textarea>
<textarea id="textarea2">

x</textarea>
<listing id="listing1">
x</listing>
<listing id="listing2">

x</listing>


text:
#ifndef CPPCOMMON_STRING_FORMAT_H
#define CPPCOMMON_STRING_FORMAT_H

#if defined(__clang__)
#pragma clang system_header
#elif defined(__GNUC__)
#pragma GCC system_header
#elif defined(_MSC_VER)
#pragma system_header
#endif

#include <fmt/args.h>
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <fmt/xchar.h>

namespace CppCommon {

//! Format string
/*!
    Format string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param pattern - Format string pattern
    \param args - Format arguments
    \return Formatted string
*/
template <typename... T>
std::string format(fmt::format_string<T...> pattern, T&&... args);

//! Format wide string
/*!
    Format wide string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param pattern - Format wide string pattern
    \param args - Format arguments
    \return Formatted wide string
*/
template <typename... T>
std::wstring format(fmt::wformat_string<T...> pattern, T&&... args);

//! Format string and print it into the std::cout
/*!
    Format string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param pattern - Format string pattern
    \param args - Format arguments
*/
template <typename... T>
void print(fmt::format_string<T...> pattern, T&&... args);

//! Format wide string and print it into the std::cout
/*!
    Format wide string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param pattern - Format wide string pattern
    \param args - Format arguments
*/
template <typename... T>
void print(fmt::wformat_string<T...> pattern, T&&... args);

//! Format string and print it into the given std::ostream
/*!
    Format string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param stream - Output stream
    \param pattern - Format string pattern
    \param args - Format arguments
*/
template <typename TOutputStream, typename... T>
void print(TOutputStream& stream, fmt::format_string<T...> pattern, T&&... args);

//! Format wide string and print it into the given std::ostream
/*!
    Format wide string with the help of {fmt} library (http://fmtlib.net)

    Thread-safe.

    \param stream - Output stream
    \param pattern - Format wide string pattern
    \param args - Format arguments
*/
template <typename TOutputStream, typename... T>
void print(TOutputStream& stream, fmt::wformat_string<T...> pattern, T&&... args);

/*! \example string_format.cpp Format string example */

} // namespace CppCommon

#include "format.inl"

#endif // CPPCOMMON_STRING_FORMAT_H