text:
copyright:

  2014, 2016

---

{:shortdesc: .shortdesc}
{:new_window: target="_blank"}

# Présentation de {{site.data.keyword.Bluemix_notm}}
{: #overview}

*Dernière mise à jour : 9 mai 2016*
{: .last-updated}

{{site.data.keyword.Bluemix}} est la plateforme de cloud ouverte d'{{site.data.keyword.IBM}} qui offre aux développeurs
d'applications mobiles et Web un accès aux logiciels {{site.data.keyword.IBM_notm}} proposant des fonctions d'intégration, de sécurité, de
transaction, etc., ainsi qu'à l'environnement logiciel de partenaires commerciaux.
{:shortdesc}

{{site.data.keyword.Bluemix_notm}} s'appuie sur la technologie open source
[Cloud
Foundry](https://www.cloudfoundry.org/){: new_window} et facilite le développement des applications via la plateforme
sous forme de services (PaaS). {{site.data.keyword.Bluemix_notm}} propose également des capacités préconfigurées de système de back end
mobile sous forme de services (MBaas). Son objectif est de simplifier la livraison d'une application en fournissant des services prêts à l'emploi et en
hébergeant
des capacités permettant un développement à l'échelle d'Internet.

{{site.data.keyword.Bluemix_notm}} propose également des déploiements de cloud qui répondent à vos besoins. Que vous fassiez partie d'une
petite entreprise en pleine évolution ou d'une grande entreprise qui a besoin d'un isolement supplémentaire, vous pouvez vous développer dans un cloud sans
limite, dans lequel vous pouvez connecter vos services dédiés aux services {{site.data.keyword.Bluemix_notm}} publics mis à disposition par
{{site.data.keyword.IBM_notm}} et
des fournisseurs tiers. Toutes les instances de service sont gérées par {{site.data.keyword.IBM_notm}}. Vous recevez une seule facture,
uniquement pour les éléments que vous choisissez d'utiliser.

Avec le large ensemble de services et de contextes d'exécution de {{site.data.keyword.Bluemix_notm}}, le
développeur dispose d'un contrôle et d'une flexibilité accrus, ainsi que d'un accès à diverses options de données, de l'analyse prédictive aux mégadonnées.

{{site.data.keyword.Bluemix_notm}} fournit les fonctionnalités suivantes :

- Une gamme de services pour générer et étendre rapidement des applications Web et mobiles.
- Une puissance de traitement pour distribuer en continu des modifications d'application.
- Des services et des modèles de programmation adaptés au besoin.
- Des services et des applications d'une grande maniabilité.
- Des charges de travail optimisées et élastiques.
- Une disponibilité continue.

{{site.data.keyword.Bluemix_notm}} fait abstraction de la plupart des aspects complexes associés à l'hébergement et à la gestion des
applications basées sur le
cloud et les masque. En tant que développeur d'applications, vous pouvez vous consacrer au développement de votre application sans avoir à gérer l'infrastructure
requise pour son
hébergement. Pour les applications mobiles et Web, vous pouvez utiliser les services préconfigurés fournis par
{{site.data.keyword.Bluemix_notm}}. Pour les applications Web, vous pouvez télécharger votre application web dans {{site.data.keyword.Bluemix_notm}} et
indiquer le
nombre d'instances que vous souhaitez exécuter. Lorsque vos applications sont déployées, vous pouvez facilement les redimensionner en fonction des
changements
d'utilisation ou de charge.

{{site.data.keyword.Bluemix_notm}} permet de développer rapidement des applications dans la plupart des langages
de programmation les plus courants. Vous pouvez développer des applications mobiles dans iOS, Android et HTML avec JavaScript. Pour les applications Web,
vous pouvez utiliser des langages tels que Ruby, PHP, Java™, Go et Python. Vous pouvez aussi migrer des applications existantes vers {{site.data.keyword.Bluemix_notm}} et utiliser les
contextes d'exécution fournis par {{site.data.keyword.Bluemix_notm}} pour exécuter vos applications.

{{site.data.keyword.Bluemix_notm}} fournit également des services middleware pour vos applications. {{site.data.keyword.Bluemix_notm}} agit au nom de l'application lorsqu'il provisionne des instances de service, puis lie ces services à
l'application. Votre
application peut effectuer son véritable travail tout en laissant la gestion des services à l'infrastructure.

En général, il est inutile de se préoccuper des couches du système d'exploitation et de l'infrastructure lorsque vous exécutez des applications dans
{{site.data.keyword.Bluemix_notm}}. Les
couches, telles que les systèmes de fichiers racine et les composants de
middleware, sont masquées pour que vous puissiez vous concentrer sur le code de
votre application. Cependant, vous pouvez obtenir plus de détails sur ces couches si vous avez besoin d'informations spécifiques sur
l'emplacement d'exécution de votre application. Pour plus d'informations, voir [Affichage des couches de l'infrastructure {{site.data.keyword.Bluemix_notm}}](../cli/vcapsvc.html#viewinfra).

## Architecture {{site.data.keyword.Bluemix_notm}}
{: #ov_arch}

Avec {{site.data.keyword.Bluemix_notm}},
vous pouvez accéder à la plateforme {{site.data.keyword.Bluemix_notm}} publique, configurer une plateforme
{{site.data.keyword.Bluemix_notm}} dédiée, ou les deux.

### {{site.data.keyword.Bluemix_notm}} public
{: #public}

{{site.data.keyword.Bluemix_notm}}
est essentiellement un environnement dans lequel vous pouvez développer des applications et
utiliser des services qui fournissent des fonctions prêtes à l'emploi. {{site.data.keyword.Bluemix_notm}} fournit également un environnement pour héberger des artefacts s'exécutant sur un serveur d'applications tel que Liberty. En utilisant SoftLayer, {{site.data.keyword.Bluemix_notm}} déploie des conteneurs virtuels qui hébergent chaque
application déployée. Dans cet environnement, l'application peut utiliser des services préconfigurés (incluant des services de tiers) pour faciliter
l'assemblage d'applications.

En tant que développeur, vous pouvez interagir avec l'infrastructure {{site.data.keyword.Bluemix_notm}} via une interface utilisateur basée sur un navigateur. Vous pouvez également utiliser une interface de ligne de commande Cloud Foundry, appelée cf, pour déployer des applications Web.

Les clients, qui peuvent être des applications mobiles, des applications exécutées en externe, des applications construites dans
{{site.data.keyword.Bluemix_notm}} ou des développeurs qui utilisent des navigateurs, interagissent avec les applications hébergées par
{{site.data.keyword.Bluemix_notm}}. Ils utilisent des API REST OU HTTP pour
router les demandes via {{site.data.keyword.Bluemix_notm}} vers l'une des
instances d'application ou des services composites.

La figure suivante présente l'architecture de haut niveau {{site.data.keyword.Bluemix_notm}}.

![Architecture {{site.data.keyword.Bluemix_notm}}](images/arch.png)

*Figure 1. Architecture {{site.data.keyword.Bluemix_notm}}*

Vous pouvez déployer vos
applications dans différentes régions {{site.data.keyword.Bluemix_notm}}, pour des raisons de sécurité ou pour
réduire le temps d'attente. Vous pouvez procéder au déploiement dans une région ou dans plusieurs régions. Pour plus d'informations, voir
[Régions](#ov_intro__reg).

![Développement d'applications dans plusieurs régions](images/multi-region.png)

*Figure 2. Développement d'applications dans plusieurs régions*

### {{site.data.keyword.Bluemix_notm}} dédié
{: #dedicated}

{{site.data.keyword.Bluemix_notm}}
dédié constitue votre environnement SoftLayer exclusif qui est connecté de façon sécurisée à la plateforme
{{site.data.keyword.Bluemix_notm}} publique et à votre propre réseau. {{site.data.keyword.Bluemix_notm}} dédié réside sur votre réseau via une connexion de réseau privé virtuel ou
une connexion réseau directe. Votre matériel à service exclusif peut être configuré dans n'importe quel centre de données SoftLayer, n'importe où dans le
monde. {{site.data.keyword.IBM_notm}} gère la plateforme dédiée et les services dédiés pour que vous puissiez vous consacrer à la construction d'applications personnalisées. De plus, {{site.data.keyword.IBM_notm}} se charge de l'intégralité de la maintenance des instances dédiées au cours d'une fenêtre de maintenance
que vous choisissez.

{{site.data.keyword.IBM_notm}} met à disposition plusieurs services dans votre environnement dédié, mais vous pouvez vous connecter à tous les services publics. Tous les environnements d'exécution sont
disponibles dans l'environnement dédié.
Tous les déploiements dédiés de {{site.data.keyword.Bluemix_notm}}
incluent les fonctions et les avantages suivants gratuitement : réseau virtuel privé, réseau local virtuel privé, connectivité avec votre protocole LDAP,
possibilité d'optimiser des applications et des bases de données sur site existantes, sécurité sur site 24 heures sur 24 et 7 jours sur 7, matériel dédié
et
support standard.

![{{site.data.keyword.Bluemix_notm}} dédié](images/dedicated.png)

*Figure 3. {{site.data.keyword.Bluemix_notm}} dédié*

### {{site.data.keyword.Bluemix_notm}} local
{: #local}

L'environnement {{site.data.keyword.Bluemix_notm}} local est votre propre instance {{site.data.keyword.Bluemix_notm}} qui est
déployée dans votre centre de données, derrière le pare-feu de la société. Avec l'environnement {{site.data.keyword.Bluemix_notm}} local, vous
pouvez rester connecté de façon sécurisée à
l'environnement {{site.data.keyword.Bluemix_notm}} public et synchronisé.

L'environnement {{site.data.keyword.Bluemix_notm}} local inclut un catalogue privé mixte qui affiche les services locaux disponibles
exclusivement pour vous. Il inclut également des services qui sont à votre disposition depuis l'environnement
{{site.data.keyword.Bluemix_notm}} public. Tous les environnements d'exécution sont disponibles dans l'environnement local. Les déploiements
locaux de {{site.data.keyword.Bluemix_notm}} présentent les fonctions et les avantages suivants gratuitement : technologie de gestion de relais,
connectivité LDAP, possibilité d'optimiser des applications et des bases de données sur site existantes et support standard.

IBM utilise la technologie de relais pour surveiller et gérer votre environnement de façon sécurisée de sorte que vous puissiez vous consacrer à
votre activité. Le relais est une fonction de distribution incluse dans l'environnement {{site.data.keyword.Bluemix_notm}} local qui permet à IBM
de distribuer les mises à jour automatiquement et de façon cohérente, pour que vous disposiez toujours d'un système à jour, stable et sécurisé. Le relais
assure la connectivité via un tunnel de réseau privé virtuel ouvert, avec configuration SSL sortante, provenant de la machine virtuelle de création. Par le biais de ce tunnel, IBM sert et gère la plateforme, les ressources de traitement et les services pour votre instance. Voir
[{{site.data.keyword.Bluemix_notm}} local](../local/index.html#local).

![{{site.data.keyword.Bluemix_notm}} local.](images/localarch.png "Bluemix local")

*Figure 4. {{site.data.keyword.Bluemix_notm}} local*

La machine virtuelle de création s'exécute sur un réseau protégé par le pare-feu de votre client sur un réseau avec une connectivité sortante vers le centre des opérations IBM via un relais. Les composants de la plateforme {{site.data.keyword.Bluemix_notm}} et les services de base s'exécutent dans un réseau local virtuel (VLAN) isolé et privé. L'environnement {{site.data.keyword.Bluemix_notm}} local utilise un réseau VLAN pour le sous-réseau privé. L'utilisation d'un sous-réseau privé à la place d'un réseau VLAN public est plus sécurisée et peut vous aider à éviter les problèmes de routage.

Les dispositifs DataPower fournissent l'accès aux domaines d'application {{site.data.keyword.Bluemix_notm}}. Ces dispositifs se connectent au réseau accessible à partir de votre intranet. Les utilisateurs qui déploient des applications et des services obtiennent l'accès à partir du réseau accessible à partir de votre intranet. Vous devez fournir sept adresses IP ayant un accès Internet sortant. Les dispositifs DataPower effectuent le routage à partir de ces adresses IP client vers le déploiement {{site.data.keyword.Bluemix_notm}} isolé. Pour plus d'informations sur les spécifications de réseau et les exigences en matière d'infrastructure, voir [Exigences de l'infrastructure d'un environnement {{site.data.keyword.Bluemix_notm}} local](../local/index.html#localinfra).

### Fonctionnement de {{site.data.keyword.Bluemix_notm}}
{: #howwork}

Lorsque vous
déployez une application dans {{site.data.keyword.Bluemix_notm}}, vous devez configurer
{{site.data.keyword.Bluemix_notm}} avec les informations nécessaires à la prise en charge de celle-ci.

* Dans le cas d'une application mobile, {{site.data.keyword.Bluemix_notm}} contient un artefact qui représente
le système de back end de l'application mobile, comme les services utilisés par l'application mobile pour communiquer avec un serveur.
* Dans le cas d'une application Web, vous devez vous assurer que les informations appropriées sur l'environnement d'exécution et l'infrastructure sont
communiquées à
{{site.data.keyword.Bluemix_notm}}, de sorte que l'application puisse être exécutée.

Chaque
environnement d'exécution, y compris mobile et web, est distinct de celui des autres applications. Les environnements d'exécution sont isolés, même si les applications sont sur la même machine physique. La figure suivante présente le flux de base suivi par {{site.data.keyword.Bluemix_notm}} pour gérer le
déploiement des applications :

![Déploiement d'une application](images/deploy.png)

*Figure 5. Déploiement d'une application*

Lorsque vous créez une application et que vous la déployez sur
{{site.data.keyword.Bluemix_notm}}, l'environnement
{{site.data.keyword.Bluemix_notm}} choisit la machine virtuelle appropriée vers laquelle l'application ou les
artefacts représentés par l'application sont envoyés. Pour une application mobile, une projection de back end mobile est créée dans {{site.data.keyword.Bluemix_notm}}. Tout code de l'application mobile exécuté sur le cloud l'est finalement dans l'environnement {{site.data.keyword.Bluemix_notm}}. Pour une application Web, le code exécuté sur le cloud correspond à
l'application elle-même, que le développeur déploie dans {{site.data.keyword.Bluemix_notm}}. Le choix de la machine virtuelle dépend de plusieurs facteurs, dont :

* La charge actuelle de la machine
* Les environnements d'exécution et les infrastructures pris en charge par la machine virtuelle

Lorsque le choix de la machine virtuelle est
fait, un gestionnaire d'application installe l'infrastructure et l'environnement d'exécution requis pour l'application. Celle-ci peut alors être déployée
dans cette infrastructure. Ensuite, les artefacts d'application sont démarrés.

La figure suivante présente la structure d'une machine virtuelle,
aussi appelée agent DEA (Droplet Execution Agent), sur laquelle plusieurs applications sont déployées :

![Conception d'une machine virtuelle](images/container.png)

*Figure 6. Conception d'une machine virtuelle*

Dans chaque machine virtuelle, un gestionnaire d'application communique avec le reste de l'infrastructure {{site.data.keyword.Bluemix_notm}}
et gère les applications déployées. Chaque machine virtuelle
dispose de conteneurs pour séparer et protéger les applications. Dans chaque conteneur,
{{site.data.keyword.Bluemix_notm}} installe l'infrastructure et l'environnement d'exécution requis pour chaque
application.

Si l'application déployée dispose d'une interface Web (par exemple, une application Web Java) ou de services REST (par exemple, des services mobiles
exposés publiquement à l'application mobile), les utilisateurs de cette application peuvent communiquer avec elle via des demandes HTTP normales.

![Appel d'une application {{site.data.keyword.Bluemix_notm}}](images/execute.png)

*Figure 7. Appel d'une application {{site.data.keyword.Bluemix_notm}}*

Chaque application
peut être associée à une ou plusieurs adresses URL, mais elles doivent toutes désigner le noeud final
{{site.data.keyword.Bluemix_notm}}. Lorsqu'une demande arrive,
{{site.data.keyword.Bluemix_notm}} l'examine, détermine l'application à laquelle elle est adressée, puis
sélectionne l'instance de l'application qui recevra la demande.

### Résilience dans {{site.data.keyword.Bluemix_notm}}
{: #resiliency}

{{site.data.keyword.Bluemix_notm}} a été conçu pour héberger des applications et des artefacts d'application
évolutifs
et résilients pouvant s'adapter à vos besoins, rester hautement disponibles et
assurer une reprise rapide en cas de problème. {{site.data.keyword.Bluemix_notm}} sépare les composants qui assurent le suivi de l'état des interactions (avec état) de ceux qui n'effectuent
pas de suivi (sans état). Cette
distinction permet à {{site.data.keyword.Bluemix_notm}} de déplacer des applications de façon souple en fonction des besoins
pour
assurer l'évolutivité et la résilience.

Vous pouvez disposer d'une ou de plusieurs instances de votre application. Dans les deux cas, l'application
est chargée une seule fois. Toutefois, {{site.data.keyword.Bluemix_notm}} déploie le nombre d'instances de
l'application demandé et distribue ces instances sur autant de machines virtuelles que possible.

Vous devez sauvegarder toutes les données
persistantes dans un magasin de données avec état qui se trouve hors de votre application, par exemple dans un magasin de données des services de magasin de
données fournis par {{site.data.keyword.Bluemix_notm}}. Etant donné que les éléments mis en cache dans la mémoire ou sur le disque peuvent ne pas être disponibles même après un redémarrage, vous pouvez
utiliser l'espace
mémoire ou le système de fichiers d'une instance {{site.data.keyword.Bluemix_notm}} unique comme cache de
transaction unique temporaire. Dans le cas de la configuration d'une instance unique, la demande envoyée à votre application peut être interrompue en raison
de la nature sans état de {{site.data.keyword.Bluemix_notm}}. Il est recommandé d'utiliser au moins trois instances pour chaque application afin d'assurer la disponibilité de votre application.

L'ensemble de l'infrastructure {{site.data.keyword.Bluemix_notm}}, les composants Cloud Foundry et les composants de gestion propres à {{site.data.keyword.IBM_notm}} sont hautement disponibles. Plusieurs instances de l'infrastructure sont utilisées pour équilibrer la charge.

## Concepts {{site.data.keyword.Bluemix_notm}}
{: #ov_intro}

{{site.data.keyword.Bluemix_notm}} est composé d'applications, de services, de packs de construction, et d'autres composants. Vous pouvez
déployer des applications dans différentes régions {{site.data.keyword.Bluemix_notm}} avec un seul ID {{site.data.keyword.IBM_notm}}.

### Régions
{: #ov_intro__reg}

Une région {{site.data.keyword.Bluemix_notm}} est un territoire géographique défini sur lequel vous pouvez déployer vos applications. Vous
pouvez créer des instances d'application et de service dans différentes régions avec la même infrastructure {{site.data.keyword.Bluemix_notm}} pour
la gestion des applications et la même vue de détails de l'utilisation pour la facturation. Vous pouvez sélectionner la région la plus proche de vos clients et y déployer vos applications pour avoir un temps d'attente faible. Vous pouvez également sélectionner la région où vous voulez garder les données d'application permettant d'adresser les problèmes de sécurité. Lorsque vous construisez des applications dans plusieurs régions et que l'une des régions s'arrête, les applications des autres régions continuent de
fonctionner. La franchise de ressources est la même dans toutes les régions que vous utilisez.

Si
vous employez l'interface utilisateur
{{site.data.keyword.Bluemix_notm}}, vous pouvez basculer vers une région différente et travailler avec les
espaces de cette région.

Si vous utilisez l'interface de ligne de commande cf, vous devez vous connecter à la région {{site.data.keyword.Bluemix_notm}} avec laquelle vous voulez travailler en entrant la
commande cf api et en spécifiant le noeud final d'API de la région. Par exemple, entrez la commande suivante pour vous connecter à la région {{site.data.keyword.Bluemix_notm}}
Europe et Royaume-Uni :

```
cf api https://api.eu-gb.{{site.data.keyword.Bluemix_notm}}.net
```

Si vous utilisez les outils Eclipse, vous devez vous connecter à la région
{{site.data.keyword.Bluemix_notm}} avec laquelle vous voulez travailler en créant un serveur
{{site.data.keyword.Bluemix_notm}} et en spécifiant le noeud final d'API de la région. Pour plus d'informations sur l'utilisation des outils
Eclipse, voir [Déploiement d'applications avec {{site.data.keyword.IBM_notm}} Eclipse
Tools for {{site.data.keyword.Bluemix_notm}}](../manageapps/eclipsetools/eclipsetools.html#toolsinstall).

Un préfixe unique est affecté à chaque région. {{site.data.keyword.Bluemix_notm}} fournit les régions et les préfixes suivants :

<!-- PRODUCTION ONLY: Ensure that URLs are production URLs, not stage1-->

| **Nom de région** | **Zone géographique** | **Préfixe de région** | **cf API endpoint** | **Console d'interface utilisateur** |
|-----------------|-------------------------|-------------------|---------------------|----------------|
| Région Sud des Etats-Unis | Dallas, US | ng | api.ng.bluemix.net | console.ng.bluemix.net |
| Région Royaume-Uni | Londres, Angleterre | eu-gb | api.eu-gb.bluemix.net | console.eu-gb.bluemix.net |
| Région Sydney | Sydney, Australie | au-syd | api.au-syd.bluemix.net | console.au-syd.bluemix.net |

*Tableau 1. Liste des régions {{site.data.keyword.Bluemix_notm}}*

### Infrastructure
{: #infrastructure}

{{site.data.keyword.Bluemix_notm}} propose trois façons d'exécuter votre code : avec Cloud Foundry, avec
{{site.data.keyword.IBM_notm}} Containers et avec Virtual Machines. {{site.data.keyword.IBM_notm}} Containers et Virtual Machines sont
disponibles dans les régions Sud des Etats-Unis et Europe et Royaume-Uni seulement. Vous pouvez choisir l'infrastructure appropriée pour le déploiement
de vos applications.

<dl>
<dt>Cloud Foundry</dt>
    <dd>Les applications qui s'exécutent dans l'infrastructure Cloud Foundry fonctionnent avec des applications Cloud Foundry existantes et peuvent être
liées à n'importe quel service disponible dans le catalogue {{site.data.keyword.Bluemix_notm}}. Avec cette infrastructure, vous
développez et gérez le code de votre application, et {{site.data.keyword.Bluemix_notm}} se charge de la gestion
et de la maintenance de l'infrastructure qui optimise ces applications.</dd>
<dt>{{site.data.keyword.IBM_notm}}Containers</dt>
    <dd>Avec l'infrastructure {{site.data.keyword.IBM_notm}} Containers, vous pouvez exécuter votre application Web n'importe où, à condition que le
déploiement de conteneur soit pris en charge. Un *conteneur* est un objet qui contient tous les éléments nécessaires à l'exécution d'une application. Cette
infrastructure inclut un registre privé pour vos images sécurisées, afin que vous puissiez les télécharger, les
stocker et les extraire. Ensuite, vous pouvez mettre ces images à disposition dans
{{site.data.keyword.Bluemix_notm}} et gérer vos conteneurs sur la plateforme. L'infrastructure d'{{site.data.keyword.IBM_notm}} Containers
peut être
mise à l'échelle horizontalement et verticalement. Vous pouvez
utiliser toutes les images qui sont disponibles dans le concentrateur Docker public et utiliser l'API Docker et l'interface de ligne de commande pour gérer
vos
conteneurs dans {{site.data.keyword.Bluemix_notm}}. {{site.data.keyword.IBM_notm}} met également à disposition des images publiques dans le
registre Containers que vous pouvez utiliser et étendre.

    {{site.data.keyword.IBM_notm}} Containers est utilisé pour exécuter des
conteneurs Docker
dans un environnement de cloud hébergé. Docker ajoute un moteur qui déploie une application dans l'environnement virtuel que vous utilisez pour exécuter vos
conteneurs. Il fournit également un environnement que vous pouvez utiliser pour exécuter
votre code. Lorsque vous êtes prêt, il vous permet de transférer le code de votre environnement de développement à votre environnement de test, puis à
votre environnement de production.

    Pour en savoir plus sur {{site.data.keyword.IBM_notm}} Containers, voir
[{{site.data.keyword.IBM_notm}} Containers](../containers/container_index.html).</dd>
<dt>{{site.data.keyword.IBM_notm}} {{site.data.keyword.virtualmachinesshort}} (bêta)</dt>
    <dd><p>{{site.data.keyword.IBM_notm}} {{site.data.keyword.virtualmachinesshort}} est un environnement de cloud hébergé qui fait partie
d'{{site.data.keyword.IBM_notm}} {{site.data.keyword.Bluemix_notm}} et que vous pouvez utiliser pour générer, exécuter et surveiller vos
applications, tout en gardant un contrôle optimal sur vos applications et le middleware sur lequel elles s'exécutent. Utilisez
{{site.data.keyword.virtualmachinesshort}} pour isoler vos solutions d'entreprise, en particulier lorsque vous déployez vos applications dans
un cloud public. </p>
<p>
Vous pouvez exécuter et gérer des serveurs virtuels dans des clouds publics et privés (sur site) qui utilisent le logiciel OpenStack. Vous pouvez créer,
lancer et gérer vos serveurs virtuels via l'interface utilisateur {{site.data.keyword.Bluemix_notm}} ou le client OpenStackClient (OSC). Vous
pouvez utiliser des images de serveur virtuel mises à disposition par {{site.data.keyword.IBM_notm}} ou créer des serveurs virtuels à partir de vos
propres images personnalisées. Vous pouvez utiliser les fonctions d'{{site.data.keyword.IBM_notm}} {{site.data.keyword.Bluemix_notm}} pour
masquer la plupart des aspects complexes associés à l'hébergement et à la gestion des applications reposant sur le cloud, comme la journalisation, la mise
à l'échelle automatique et la surveillance. Vous pouvez combiner les services OpenStack et les services {{site.data.keyword.Bluemix_notm}} pour générer et exécuter des applications
hybrides. Vous pouvez mettre à disposition des ressources d'infrastructure en fonction des besoins, selon des stratégies d'exploitation et la demande en
charge de travail. </p>
<p>
Pour en savoir plus sur {{site.data.keyword.IBM_notm}} {{site.data.keyword.virtualmachinesshort}}, voir [{{site.data.keyword.IBM_notm}} {{site.data.keyword.virtualmachinesshort}}](../virtualmachines/vm_index.html).</p> </dd>
</dl>

### Applications
{: #applications}

Dans {{site.data.keyword.Bluemix_notm}}, une application, ou *appli*, représente l'artefact que le développeur génère. Le cycle de vie de l'application dans {{site.data.keyword.Bluemix_notm}} et dans Cloud Foundry est identique,
quelle que soit la manière dont l'application est déployée dans {{site.data.keyword.Bluemix_notm}}. Pour plus d'informations, voir [How Applications Are Staged](https://docs.cloudfoundry.org/concepts/how-applications-are-staged.html).

<dl>
<dt>Applications mobiles</dt>
    <dd>Les applications mobiles sont exécutées en dehors de l'environnement {{site.data.keyword.Bluemix_notm}}  et utilisent les services auxquels elles sont exposées. Ces services agissent ensemble et représentent la projection de back end de cette application. {{site.data.keyword.Bluemix_notm}} peut également héberger le code d'application, que le développeur préférera
exécuter sur un serveur de back end dans un environnement de conteneur.</dd>
<dt>Applications Web</dt>
    <dd>Les applications Web se composent de l'ensemble du code requis pour une exécution ou un référencement pendant la phase d'exécution. Les applications Web sont
téléchargées dans {{site.data.keyword.Bluemix_notm}} pour héberger l'application.</dd>
</dl>

Pour les langages tels que Java, où le code source est compilé dans des fichiers binaires d'exécution, seuls ces fichiers binaires doivent être
téléchargés.

### Services
{: #services}

Un *service* est une extension de cloud hébergée par {{site.data.keyword.Bluemix_notm}}. Le service fournit des fonctionnalités prêtes à l'emploi par le code en cours d'exécution de l'application. Les services prédéfinis qui sont fournis par {{site.data.keyword.Bluemix_notm}} incluent une base de données, un
système
de messagerie, des notifications push et une mise en cache élastique pour applications Web.

Vous pouvez créer vos propres services dans {{site.data.keyword.Bluemix_notm}}. Ces services peuvent varier en termes de complexité. Ils peuvent constituer de simples utilitaires, telles que les fonctions que l'on peut trouver dans une bibliothèque d'exécution. Mais ils peuvent aussi constituer une logique métier complexe comme on en trouve dans un service de modélisation de processus métier ou dans une base de données.

{{site.data.keyword.Bluemix_notm}} simplifie l'utilisation des services en mettant à disposition de nouvelles
instances de service et en liant celles-ci à votre application. La gestion du service est effectué automatiquement par {{site.data.keyword.Bluemix_notm}}. Pour prendre connaissance des services disponibles dans {{site.data.keyword.Bluemix_notm}}, consultez le catalogue dans l'interface utilisateur {{site.data.keyword.Bluemix_notm}}.

### Modules de démarrage
{: #starters}

Un *module de démarrage* est un modèle qui inclut des services prédéfinis et du code
d'application configuré avec un pack de construction particulier. Il
existe deux types de module de démarrage : les conteneurs boilerplate et les environnements d'exécution.  Un module de démarrage peut se composer d'un code
d'application écrit dans un langage de programmation spécifique, ou d'une combinaison de code d'application et d'un ensemble de services.

### Conteneurs boilerplate
{: #boilerplates}

Dans {{site.data.keyword.Bluemix_notm}}, un conteneur
*boilerplate* contient une application ainsi que son environnement d'exécution associé et ses services prédéfinis, pour un domaine
particulier. Un conteneur boilerplate permet une mise ne exécution rapide. Par exemple, vous pouvez sélectionner le conteneur boilerplate Mobile Cloud pour
héberger des applications mobiles et Web et accélérer les temps de développement de scripts côté serveur en utilisant le modèle d'application mobile et
le logiciel SDK.

### Environnements d'exécution
{: #runtimes}

Un *environnement d'exécution* est un ensemble de ressources utilisé pour exécuter
une
application. {{site.data.keyword.Bluemix_notm}} fournit des environnements d'exécution sous forme de conteneurs pour
différents types d'application. Les environnements d'exécution sont intégrés en tant que packs de construction dans
{{site.data.keyword.Bluemix_notm}},
et sont automatiquement configurés en vue de leur utilisation.

### Packs de construction
{: #buildpacks}

Un pack de construction est une collection de scripts qui prépare l'exécution de votre code sur la plateforme sous forme de services (PaaS) cible. Il regroupe les dépendances d'exécution et d'infrastructure d'une application. Puis, il les intègre
à l'application dans une gouttelette qui peut être déployée dans le cloud.

Si vous ne spécifiez pas de pack de construction lorsque vous déployez votre
application dans {{site.data.keyword.Bluemix_notm}}, les packs de construction intégrés sont utilisés par défaut.

<dl class="dl"><dt class="dt dlterm">Packs de construction {{site.data.keyword.IBM_notm}} intégrés</dt>
<dd class="dd"><div class="p">
<!-- begin PRODUCTION ONLY -->
La liste suivante est la liste des packs de construction intégrés créés par {{site.data.keyword.IBM_notm}} :
<ul>
<li>Liberty for Java</li>
<li>Node.js</li>
</ul>
<!-- end PRODUCTION ONLY -->
</div>
</div>
</dd>
<dt class="dt dlterm">Packs de construction de communauté intégrés</dt>
<dd class="dd"><p class="p">Dans {{site.data.keyword.Bluemix_notm}}, vous pouvez également utiliser des packs de construction intégrés fournis par la communauté Cloud Foundry. Pour afficher la liste des packs de construction de communauté intégrés, exécutez la commande <span class="keyword cmdname">cf buildpacks</span>.</p>
</dd>
<dt class="dt dlterm">Packs de construction externes</dt>
<dd class="dd"><div class="p">Si vous ne trouvez pas l'environnement d'exécution ou l'infrastructure nécessaire dans les packs de construction intégrés fournis par
{{site.data.keyword.Bluemix_notm}}, vous pouvez utiliser un pack de construction externe pour votre application.
Ces packs, fournis par la communauté Cloud Foundry, peuvent être utilisés comme vos propres packs. Le pack de construction doit être spécifié lorsque vous
déployez votre application avec la commande <span class="keyword cmdname">cf push</span>. <div class="note note"><span class="notetitle">Remarque :</span> les packs de construction externes ne sont
pas pris en charge par {{site.data.keyword.IBM_notm}} ; en cas de besoin, prenez contact avec la communauté Cloud Foundry.</div>
</div>
</dd>
</dl>

## Intégration avec les systèmes d'enregistrement
{: #sor}

{{site.data.keyword.Bluemix_notm}} peut aider les développeurs en connectant deux grandes catégories de systèmes dans un environnement de cloud : les systèmes d'enregistrement et les systèmes d'engagement.

Les *systèmes d'enregistrement* incluent les applications et les bases de données qui stockent des enregistrements métier et automatisent
des
processus standardisés. Des *systèmes d'engagement* permettent de développer l'utilité des systèmes d'enregistrement en les rendant
plus attractifs pour les utilisateurs.
En intégrant un système d'enregistrement à l'application que vous créez dans {{site.data.keyword.Bluemix_notm}}, vous pouvez :

 * Activer une communication sécurisée entre l'application et la base de données dorsale, via le téléchargement et l'installation d'un connecteur
sécurisé sur site.
 * Appeler une base de données de manière sécurisée.
 * Créer des interfaces de programme d'application à partir des flux d'intégration avec les bases de données et les systèmes expéditeurs, par exemple, un système de gestion de la relation client.
 * Exposer uniquement les schémas et les tables de votre choix à l'application.
 * En tant que responsable d'organisation {{site.data.keyword.Bluemix_notm}}, publier une interface de programme d'application sous forme de service privé, visible uniquement des membres de votre organisation.

Utiliser le service Cloud Integration pour intégrer un système d'enregistrement à l'application que vous créez dans {{site.data.keyword.Bluemix_notm}}. Le service Cloud Integration permet de créer et de publier une API Cloud Integration en tant que service privé pour
votre
organisation.

<dl>
<dt>API Cloud Integration</dt>
    <dd>Une API Cloud Integration fournit un accès sécurisé aux systèmes d'enregistrement résidant derrière un pare-feu
via des API Web. Lorsque vous créez l'API Cloud Integration, vous choisissez la ressource à laquelle vous voulez accéder via l'API Web, spécifiez les
opérations qui sont autorisées et incluez les logiciels SDK et les exemples pour accéder à l'API. Pour plus d'informations sur la création d'une API Cloud
Integration, voir [Création d'une API Cloud Integration](../services/CloudIntegration/index.html#cloudint_add_service).</dd>
<dt>Service privé</dt>
    <dd>Un service privé est composé d'une API Cloud Integration, de logiciels SDK et de règles de droits. De plus, le service privé peut contenir de la documentation ou d'autres éléments appartenant au fournisseur de services. Seul le responsable de l'organisation peut publier une API Cloud Integration en tant que service privé. Pour connaître les services privés à votre
disposition, cochez la case Privé dans le catalogue {{site.data.keyword.Bluemix_notm}}. Vous pouvez sélectionner et lier un service privé à une application sans vous connecter au service Cloud Integration. Pour lier un service privé à votre
application, procédez de la même façon que pour les services {{site.data.keyword.Bluemix_notm}}. Pour des informations sur la publication d'une API en tant que service privé, voir Publication d'une API en tant que service privé.</dd>
</dl>

### Scénario : Création d'une application mobile riche pour la connexion avec votre système d'enregistrement
{: #scenario}

{{site.data.keyword.Bluemix_notm}} fournit une plateforme dans laquelle vous pouvez intégrer votre application mobile, des services de cloud et
des
systèmes d'entreprise d'enregistrement pour générer une application qui interagit avec vos données sur site.

Par exemple, vous pouvez concevoir une application mobile pour interagir avec votre système de gestion de la relation client résidant sur site, derrière un pare-feu. Vous pouvez appeler le système d'enregistrement de manière sécurisée et optimiser les services mobiles dans {{site.data.keyword.Bluemix_notm}} afin
de générer une application mobile riche.

Tout d'abord, votre développeur d'intégration crée l'application de back end mobile dans {{site.data.keyword.Bluemix_notm}}. Il fait appel au conteneur boilerplate Mobile Cloud utilisant le contexte d'exécution Node.js qu'il connaît le mieux.

Puis, en utilisant le service Cloud Integration dans l'interface utilisateur {{site.data.keyword.Bluemix_notm}}, il expose une API via un connecteur
sécurisé. Le développeur d'application télécharge le connecteur sécurisé et l'installe sur site, afin d'activer la communication sécurisée entre son interface de programme d'application et la base de données. Après avoir créé le noeud final de base de données, il peut consulter tous les schémas et extraire les tables qu'il veut exposer à l'application en tant
qu'API.

Il ajoute ensuite le service Push pour distribuer des notifications mobiles aux clients intéressés. Il ajoute également un service de partenaire commercial pour écrire un tweet lorsqu'un nouvel enregistrement client est créé avec une interface de programme d'application Twitter.

En tant que développeur d'application, vous pouvez ensuite vous connecter à {{site.data.keyword.Bluemix_notm}}, télécharger le kit d'outils de développement Android et développer le code appelant les interfaces de programme d'application créées par le développeur d'intégration. Vous pouvez développer une application mobile qui permet aux utilisateurs d'entrer des informations sur leur périphérique mobile. Cette application crée alors un enregistrement client dans le système de gestion client. Lorsque l'enregistrement est créé, l'application crée une notification push pour périphérique mobile et un tweet pour signaler le nouvel enregistrement.

## Support de langue nationale pour {{site.data.keyword.Bluemix_notm}}
{: #lang}

{{site.data.keyword.Bluemix_notm}} prend en charge des langues autres que
l'anglais. Cependant, le contenu fourni avec {{site.data.keyword.Bluemix_notm}} n'est pas
entièrement traduit.
Le tableau ci-dessous répertorie les langues nationales prises en charge ainsi que les codes de langue pour {{site.data.keyword.Bluemix_notm}}.

| **Langue nationale** | **Code de langue** |
|-------------------|---------------|
| Portugais (Brésil) | pt_BR |
| Anglais | en |
| Français | fr |
| Allemand | de |
| Japonais | ja |
| Coréen | ko |
| Italien | it |
| Espagnol | es |
| Chinois simplifié | zh_CN |
| Chinois traditionnel | zh_TW |

*Tableau 2. Langues nationales prises en charge et codes de langue*

# Liens connexes
{: #rellinks}

## Liens connexes
{: #general}

* [Configuration requise pour {{site.data.keyword.Bluemix_notm}}](https://developer.ibm.com/bluemix/support/#prereqs)
* [Nouveautés de {{site.data.keyword.Bluemix_notm}}](../whatsnew/index.html)
* [Problèmes {{site.data.keyword.Bluemix_notm}} connus](https://developer.ibm.com/bluemix/support/#issues)
* [Glossaire {{site.data.keyword.Bluemix_notm}}](glossary/index.html)
* [Fiche des prix {{site.data.keyword.Bluemix_notm}}](https://console.{DomainName}/pricing/)
* [{{site.data.keyword.Bluemix_notm}} DevOps Services](https://hub.jazz.net)
* [Cloud Foundry](http://cloudfoundry.org/)
* [SoftLayer, une société {{site.data.keyword.IBM_notm}}](http://www.softlayer.com/)


text:
@class MISSING_TYPE;

@interface _TtC12SourceEditor14PerformanceLog : _TtCs12_SwiftObject
{
    MISSING_TYPE *loggingQueue;
    MISSING_TYPE *activeSessions;
    MISSING_TYPE *completedSessions;
}

- (void)flushPerformanceLogsNotification:(id)arg1;

@end

redpajama_set_name: RedPajamaGithub


text:
package ecologylab.bigsemantics.tools;

import java.awt.Desktop;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.net.URI;

import javax.swing.AbstractButton;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;

import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author quyin
 */
public class AssistApp extends WindowAdapter
{

  static Logger logger        = LoggerFactory.getLogger(AssistApp.class);

  static int    LOW_MEM_IN_MB = 128;

  private File  bsWrappersDir;

  private File  bsServiceDir;

  private File  bsJsDir;

  JButton       btnUpdate;

  JTextArea     textArea;

  JFrame        frame;

  AntRunner     antRunner;

  BSService     service;

  public AssistApp(Configuration configs)
  {
    createAndDisplayGUI();
    info("Initializing...");

    while (bsWrappersDir == null)
    {
      bsWrappersDir = PathUtil.checkAndChooseDir(frame,
                                                 configs.getString("bigsemantics_wrappers_dir"),
                                                 "BigSemanticsWrappers directory");
    }

    while (bsServiceDir == null)
    {
      bsServiceDir = PathUtil.checkAndChooseDir(frame,
                                                configs.getString("bigsemantics_service_dir"),
                                                "BigSemanticsService project directory");
    }

    while (bsJsDir == null)
    {
      bsJsDir = PathUtil.checkAndChooseDir(frame,
                                           configs.getString("bigsemantics_javascript_dir"),
                                           "BigSemanticsJavaScript project directory");
    }

    antRunner = new AntRunner();
    service = new BSService(configs);

    btnUpdate.setEnabled(false);
    info("Beginning service startup.");
    Thread thread = new Thread(new Runnable()
    {
      @Override
      public void run()
      {
        updateBackend();
        SwingUtilities.invokeLater(new Runnable()
        {
          @Override
          public void run()
          {
            btnUpdate.setEnabled(true);
          }
        });

        while (true)
        {
          if (MemoryUsageMonitor.get().getEffectiveFreeMem() <= AssistApp.LOW_MEM_IN_MB)
          {
            Object[] options = { "Close now", "Keep running" };
            Integer n = JOptionPane.showOptionDialog(frame,
                                                     "Low memory, close AssistApp before recompiling wrappers",
                                                     "Memory Warning",
                                                     JOptionPane.YES_NO_CANCEL_OPTION,
                                                     JOptionPane.QUESTION_MESSAGE,
                                                     null,
                                                     options,
                                                     options[1]);
            if (n == 0)
            {
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              try
              {
                stopService();
              }
              catch (Exception e)
              {
                error("Error stopping BS service.", null, e);
              }
              System.exit(0);
            }
            else
            {
              break;
            }
          }
        }

      }
    });
    thread.run();

    btnUpdate.setEnabled(true);
  }

  public void createAndDisplayGUI()
  {
    JPanel contentPanel = new JPanel(new GridBagLayout());
    contentPanel.setOpaque(true);

    btnUpdate = new JButton("Update Backend with New Wrappers");
    btnUpdate.setEnabled(false);
    btnUpdate.setVerticalTextPosition(AbstractButton.CENTER);
    btnUpdate.setHorizontalTextPosition(AbstractButton.CENTER);
    btnUpdate.addActionListener(new ActionListener()
    {
      @Override
      public void actionPerformed(ActionEvent event)
      {
        btnUpdate.setEnabled(false);

        MemoryUsageMonitor.get().log("after running for a bit");
        if (MemoryUsageMonitor.get().getEffectiveFreeMem() <= AssistApp.LOW_MEM_IN_MB)
        {
          JOptionPane.showMessageDialog(frame,
                                        "Not enough memory. Closing down.",
                                        "Memory Warning",
                                        JOptionPane.ERROR_MESSAGE);
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          try
          {
            stopService();
          }
          catch (Exception e)
          {
            error("Error stopping BS service.", null, e);
          }
          System.exit(0);

        }

        Thread thread = new Thread(new Runnable()
        {
          @Override
          public void run()
          {
            updateBackend();
            SwingUtilities.invokeLater(new Runnable()
            {
              @Override
              public void run()
              {
                btnUpdate.setEnabled(true);
              }
            });
          }
        });
        thread.run();
      }
    });

    GridBagConstraints c =
        new GridBagConstraints(0, // gridx
                               0, // gridy
                               1, // gridwidth
                               1, // gridheight
                               0, // weightx
                               0, // weighty
                               GridBagConstraints.CENTER, // anchor
                               GridBagConstraints.NONE, // fill
                               new Insets(8, 8, 8, 8), // insets
                               8, // ipadx
                               8); // ipady
    contentPanel.add(btnUpdate, c);

    textArea = new JTextArea(40, 100);
    textArea.setEditable(false);
    textArea.setBorder(BorderFactory.createLoweredBevelBorder());
    textArea.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 10));
    JScrollPane scroll = new JScrollPane(textArea);
    scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
    scroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
    c.gridx = 0;
    c.gridy = 1;
    c.weightx = 1;
    c.weighty = 1;
    c.fill = GridBagConstraints.BOTH;
    contentPanel.add(scroll, c);

    frame = new JFrame("BS Wrapper Dev Assist");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.addWindowListener(new WindowAdapter()
    {
      @Override
      public void windowClosing(WindowEvent event)
      {
        info("Window is closing, cleaning up ...");
        try
        {
          stopService();
        }
        catch (Exception e)
        {
          error("Error stopping BS service.", null, e);
        }
      }

    });
    frame.setContentPane(contentPanel);

    javax.swing.SwingUtilities.invokeLater(new Runnable()
    {
      public void run()
      {
        frame.pack();
        frame.setVisible(true);
      }
    });
  }

  private void updateBackend()
  {
    try
    {
      MemoryUsageMonitor.get().log("before updating backend");

      stopService();

      info("Recompiling wrappers and rebuilding service jar...");
      File wrappersBuildFile = PathUtil.subPath(bsWrappersDir, "build.xml");
      antRunner.runAntTarget(wrappersBuildFile, "clean");
      File serviceBuildFile = PathUtil.subPath(bsServiceDir, "BigSemanticsService", "build.xml");
      antRunner.runAntTarget(serviceBuildFile, "clean");
      antRunner.runAntTarget(serviceBuildFile, "main");

      MemoryUsageMonitor.get().log("after compiling wrappers and building bs-service");

      startService();
      MemoryUsageMonitor.get().log("after bs-service started");
    }
    catch (Exception e)
    {
      error("Error relaunching BS service.", null, e);
      return;
    }

    // Opens string URL in the browser
    String url = "http://localhost:8080/static/houseMICE/index.html";
    info("Service running. Opening MICE in your default browser.");
    if (Desktop.isDesktopSupported())
    {
      Desktop desktop = Desktop.getDesktop();
      try
      {
        desktop.browse(new URI(url));
      }
      catch (Exception e)
      {
        logger.error("Exception opening MICE in browser.", e);
      }
    }
    else
    {
      Runtime runtime = Runtime.getRuntime();
      try
      {
        runtime.exec("xdg-open " + url);
      }
      catch (Exception e)
      {
        logger.error("Exception opening MICE in browser through xdg-open.", e);
      }
    }
  }

  private void stopService() throws Exception
  {
    info("Stopping service...");
    service.stop();
  }

  private void startService() throws Exception
  {
    info("Starting service...");
    service.start();
  }

  private void infoHelper(String msg)
  {
    logger.info(msg);
    textArea.append(msg + "\n");
    textArea.setCaretPosition(textArea.getDocument().getLength());
  }

  private void info(String msg)
  {
    infoHelper(msg);
    SwingUtilities.invokeLater(new Runnable()
    {
      @Override
      public void run()
      {
        frame.invalidate();
      }
    });
  }

  private void error(String msg, String info, Throwable t)
  {
    if (t != null)
    {
      logger.error(msg, t);
    }
    if (info != null)
    {
      String[] lines = info.split("\n");
      for (String line : lines)
      {
        infoHelper("    >> " + line);
      }
    }
    info("ERROR: " + msg);
    info("Check for the log file for more details.");
  }

  public static void main(String[] args) throws ConfigurationException
  {
    Configuration configs = new PropertiesConfiguration("wrapper-dev-assist.conf");
    new AssistApp(configs);
  }

}


text:
package ch.hsr.evaluator;

public class Tuple {

	public Tuple(long id, double sim){
		this.itemid = id;
		this.similarity = sim;
	}
	public long itemid;
	public double similarity;
}


text:
'use strict';

angular
  .module('softvApp')
  .controller('DistribuidorDetalleCtrl', function (distribuidorFactory, $stateParams, ngNotify, $state) {

    function initData() {

      distribuidorFactory.Getplaza($stateParams.id, '')
        .then(function (result) {
          console.log(result.GetPlaza_DistribuidoresNewResult);
          var Distribuidor = result.GetPlaza_DistribuidoresNewResult[0];
          vm.Titulo = 'Detalle  Distribuidor - ' + Distribuidor.Nombre;
          vm.Nombre = Distribuidor.Nombre;
          vm.RFC = Distribuidor.RFC;
          vm.NumExt = Distribuidor.NumEx;
          vm.NumInt = Distribuidor.NumIn;
          vm.CP = Distribuidor.CP;
          vm.Calles = Distribuidor.EntreCalles;
          vm.Calle = Distribuidor.Calle;
          vm.Colonia = Distribuidor.Colonia;
          vm.Localidad = Distribuidor.Localidad;
          vm.Municipio = Distribuidor.Municipio;
          vm.Estado = Distribuidor.Estado;
          vm.Pais = Distribuidor.Pais;
          vm.Telefono = Distribuidor.Telefono;
          vm.Email = Distribuidor.Email;
          vm.Telefono2 = Distribuidor.Telefono2;
          vm.Pagare = Distribuidor.ImportePagare;

          distribuidorFactory.Getdatoscomerciales($stateParams.id)
            .then(function (data) {
              console.log(data);
              var Distribuidor = data.GetdatoscomercialesResult[0];
              vm.NombreDC = Distribuidor.Nombre;
              vm.EstadoDC = Distribuidor.Estado;
              vm.MunicipoDC = Distribuidor.Municipio;
              vm.LocalidadDC = Distribuidor.Localidad;
              vm.ColoniaDC = Distribuidor.Colonia;
              vm.CalleDC = Distribuidor.Calle;
              vm.NumeroInDC = Distribuidor.NumIn;
              vm.NumeroEXDC = Distribuidor.NumEx;
              vm.CPDC = Distribuidor.CP;
              vm.nombrecont = Distribuidor.NombreContacto;
              vm.telefonocont = Distribuidor.TelefonoContacto;
              vm.celularcont = Distribuidor.celularContacto;
              vm.emailcont = Distribuidor.emailContacto;
              vm.respcomcont = Distribuidor.responsablecomercial;
              vm.respopcont = Distribuidor.responsableOperaciones;
              vm.resatencont = Distribuidor.responsableAtencion;
            });

        });

      /*CatalogosFactory.GetDeepDistribuidor(IdDistribuidor).then(function(data){

      });*/
    }

    var vm = this;
    vm.IdDistribuidor = $stateParams.id;
    initData();
    vm.block=true;

  });


text:
var fs = require("fs");

if (fs.existsSync(process.cwd()+"/config/env_vars.js")) {
  var env = require(process.cwd()+"/config/env_vars.js").env;
  for (i in env) { process.env[i] = env[i]; }
}

if (process.env.NODE_ENV === "production"){
  throw Error("unit tests cannot be run in production!")
}

if (fs.existsSync(process.cwd()+"/config/config.json")) {
  console.log("config.json exists");
} else {
  console.log("config.json does not exist");
}


text:
package org.apache.polygene.entitystore.leveldb.assembly;

import org.apache.polygene.bootstrap.Assemblers;
import org.apache.polygene.bootstrap.ModuleAssembly;
import org.apache.polygene.bootstrap.ServiceDeclaration;
import org.apache.polygene.entitystore.leveldb.LevelDBEntityStoreConfiguration;
import org.apache.polygene.entitystore.leveldb.LevelDBEntityStoreService;

/**
 * LevelDB EntityStore assembly.
 */
public class LevelDBEntityStoreAssembler
    extends Assemblers.VisibilityIdentityConfig<LevelDBEntityStoreAssembler>
{
    @Override
    public void assemble( ModuleAssembly module )
    {
        super.assemble( module );
        ServiceDeclaration service = module.services( LevelDBEntityStoreService.class ).visibleIn( visibility() );
        if( hasIdentity() )
        {
            service.identifiedBy( identity() );
        }
        if( hasConfig() )
        {
            configModule().entities( LevelDBEntityStoreConfiguration.class ).visibleIn( configVisibility() );
        }
    }
}


text:
import * as yargs from 'yargs';
import { logger } from '../utils';
import WeTTy from '../wetty';
import { CLI } from './options';
import { unWrapArgs } from './parseArgs';

export default function init(opts: CLI): void {
  if (!opts.help) {
    const { ssh, server, command, forcessh, ssl } = unWrapArgs(opts);
    WeTTy(ssh, server, command, forcessh, ssl).catch(err => {
      logger.error(err);
      process.exitCode = 1;
    });
  } else {
    yargs.showHelp();
    process.exitCode = 0;
  }
}


text:
//snippet-sourcedescription:[StartPipelineExecution.java demonstrates how to execute a pipeline.]
//snippet-keyword:[SDK for Java 2.0]
//snippet-service:[AWS CodePipeline]

package com.example.pipeline;

// snippet-start:[pipeline.java2.start_pipeline.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.codepipeline.CodePipelineClient;
import software.amazon.awssdk.services.codepipeline.model.CodePipelineException;
import software.amazon.awssdk.services.codepipeline.model.StartPipelineExecutionRequest;
import software.amazon.awssdk.services.codepipeline.model.StartPipelineExecutionResponse;
// snippet-end:[pipeline.java2.start_pipeline.import]

/**
 * Before running this Java V2 code example, set up your development environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class StartPipelineExecution {

    public static void main(String[] args) {
        final String usage = "\n" +
            "Usage: " +
            "   <name>\n\n" +
            "Where:\n" +
            "   name - The name of the pipeline to execute \n\n" ;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String name = args[0];
        Region region = Region.US_EAST_1;
        CodePipelineClient pipelineClient = CodePipelineClient.builder()
            .region(region)
            .credentialsProvider(ProfileCredentialsProvider.create())
            .build();

        executePipeline(pipelineClient, name);
        pipelineClient.close();
    }

    // snippet-start:[pipeline.java2.start_pipeline.main]
    public static void executePipeline(CodePipelineClient pipelineClient, String name) {

        try {
            StartPipelineExecutionRequest pipelineExecutionRequest = StartPipelineExecutionRequest.builder()
                .name(name)
                .build();

            StartPipelineExecutionResponse response = pipelineClient.startPipelineExecution(pipelineExecutionRequest);
            System.out.println("Piepline "+response.pipelineExecutionId() +" was successfully executed");

        } catch (CodePipelineException e) {
        System.err.println(e.getMessage());
        System.exit(1);
    }
  }
    // snippet-end:[pipeline.java2.start_pipeline.main]
}


text:
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace BGE
{
    public class FPSController : MonoBehaviour
    {

        float speed = 10.0f;

        // Use this for initialization
        void Start()
        {
            Screen.showCursor = false;
            Screen.lockCursor = true;
        }

        void Yaw(float angle)
        {
            Quaternion rot = Quaternion.AngleAxis(angle, Vector3.up);
            transform.rotation = rot * transform.rotation;
        }

        void Roll(float angle)
        {
            Quaternion rot = Quaternion.AngleAxis(angle, Vector3.forward);
            transform.rotation = rot * transform.rotation;
        }

        void Pitch(float angle)
        {
            float invcosTheta1 = Vector3.Dot(transform.forward, Vector3.up);
            float threshold = 0.95f;
            if ((angle > 0 && invcosTheta1 < (-threshold)) || (angle < 0 && invcosTheta1 > (threshold)))
            {
                return;
            }

            // A pitch is a rotation around the right vector
            Quaternion rot = Quaternion.AngleAxis(angle, transform.right);

            transform.rotation = rot * transform.rotation;
        }

        void Walk(float units)
        {
            if (Params.riftEnabled)
            {
                transform.position += GameObject.FindGameObjectWithTag("rightcamera").transform.forward * units;
            }
            else
            {
                transform.position += transform.forward * units;
            }
        }

        void Strafe(float units)
        {
            if (Params.riftEnabled)
            {
                transform.position += GameObject.FindGameObjectWithTag("rightcamera").transform.right * units;
            }
            else
            {
                transform.position += transform.right * units;
            }
        }

        // Update is called once per frame
        void Update()
        {
            float mouseX, mouseY;
            float speed = this.speed;

            float runAxis = Input.GetAxis("Run Axis");

            if (Input.GetKey(KeyCode.LeftShift) || runAxis != 0)
            {
                speed *= 10.0f;
            }

            if (Input.GetKey(KeyCode.W))
            {
                Walk(Time.deltaTime * speed);
            }

            if (Input.GetKey(KeyCode.S))
            {
                Walk(- Time.deltaTime * speed);
            }

            if (Input.GetKey(KeyCode.A))
            {
                Strafe(- Time.deltaTime * speed);
            }

            if (Input.GetKey(KeyCode.D))
            {
                Strafe(Time.deltaTime * speed);
            }
            if (Input.GetKey(KeyCode.Q))
            {
                Roll(- Time.deltaTime * speed);
            }
            if (Input.GetKey(KeyCode.E))
            {
                Roll(Time.deltaTime * speed);
            }

            mouseX = Input.GetAxis("Mouse X");
            mouseY = Input.GetAxis("Mouse Y");

            GameObject ovrplayer = GameObject.FindGameObjectWithTag("ovrcamera");
            if (ovrplayer != null)
            {
                ovrplayer.transform.position = transform.position;
            }

            Yaw(mouseX);
            float contYaw = Input.GetAxis("Yaw Axis");
            float contPitch = Input.GetAxis("Pitch Axis");
            Yaw(contYaw);

            // If in Rift mode, dont pitch
            if (!Params.riftEnabled)
            {
                Pitch(-mouseY);
                Pitch(contPitch);
            }

            float contWalk = Input.GetAxis("Walk Axis");
            float contStrafe = Input.GetAxis("Strafe Axis");
            Walk(-contWalk * speed * Time.deltaTime);
            Strafe(contStrafe * speed * Time.deltaTime);

            //SteeringManager.PrintVector("Cam pos: ", transform.position);
            //SteeringManager.PrintVector("Cam forward: ", transform.forward);
        }
    }
}


text:
package io.cdap.re;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

import java.util.ArrayList;
import java.util.List;

/**
 * Class description here.
 */
public final class Rulebook {
  private String name;
  private long version;
  private RulebookMeta meta;
  private List<Rule> rules;

  private Rulebook(String name, RulebookMeta meta, long version, List<Rule> rules) {
    this.name = name;
    this.meta = meta;
    this.version = version;
    this.rules = rules;
  }

  public String getName() {
    return name;
  }

  public RulebookMeta getMeta() {
    return meta;
  }

  public long getVersion() {
    return version;
  }

  public List<Rule> getRules() {
    return rules;
  }

  public JsonElement toJson() {
    JsonObject object = new JsonObject();
    object.addProperty("name", name);
    object.addProperty("version", version);
    object.add("meta", meta.toJson());
    JsonArray array = new JsonArray();
    for (Rule rule : rules) {
      array.add(rule.toJson());
    }
    object.add("rules", array);
    return object;
  }

  public Builder builder(String name) {
    return new Builder(name);
  }

  public static final class Builder {
    private String name;
    private long version;
    private String rbDescription;
    private long created;
    private long updated;
    private String source;
    private String user;
    private List<Rule> rules;

    public Builder(String name) {
      this.name = name;
      this.rules = new ArrayList<>();
    }

    public Builder version(long version) {
      this.version = version;
      return this;
    }

    public Builder description(String description) {
      this.rbDescription = description;
      return this;
    }

    public Builder created(long created) {
      this.created = created;
      return this;
    }

    public Builder updated(long updated) {
      this.updated = updated;
      return this;
    }

    public Builder source(String source) {
      this.source = source;
      return this;
    }

    public Builder user(String user) {
      this.user = user;
      return this;
    }

    public Builder addRule(Rule rule) {
      this.rules.add(rule);
      return this;
    }

    public Rulebook build() {
      if (created == 0) {
        created = System.currentTimeMillis() / 1000;
      }

      if (updated == 0) {
        updated = created;
      }

      if (source == null || source.isEmpty()) {
        source = "not defined";
      }

      if (user == null || user.isEmpty()) {
        user = "";
      }
      RulebookMeta meta = new RulebookMeta(rbDescription, created, updated, source, user);
      return new Rulebook(name, meta, version, rules);
    }
  }
}


text:
import warning from 'warning'
import invariant from 'invariant'
import React, { Component } from 'react'
import Redirect from './Redirect'
import { falsy } from './PropTypes'

const { string, object } = React.PropTypes

/**
 * An <IndexRedirect> is used to redirect from an indexRoute.
 */
class IndexRedirect extends Component {

  static createRouteFromReactElement(element, parentRoute) {
    if (parentRoute) {
      parentRoute.indexRoute = Redirect.createRouteFromReactElement(element)
    } else {
      warning(
        false,
        'An <IndexRedirect> does not make sense at the root of your route config'
      )
    }
  }

  static propTypes = {
    to: string.isRequired,
    query: object,
    state: object,
    onEnter: falsy,
    children: falsy
  }

  render() {
    invariant(
      false,
      '<IndexRedirect> elements are for router configuration only and should not be rendered'
    )
  }

}

export default IndexRedirect


text:
The latest version of documents in this section are also available as a
[docset](https://elv.sh/ref/docset/Elvish.tgz). You can also
[subscribe](dash-feed://https%3A%2F%2Felv.sh%2Fref%2Fdocset%2FElvish.xml) to the
feed.


text:
require_dependency "rearview/application_controller"

module Rearview
  class DashboardsController < Rearview::ApplicationController
    respond_to :json

    def index
      @dashboards = Rearview::Dashboard.roots
    end

    def show
      @dashboard = Rearview::Dashboard.find(params[:id])
    end

    def create
      upsert
      render :show
    end

    def update
      upsert
      render :show
    end

    def destroy
      @dashboard = Rearview::Dashboard.find params[:id]
      @dashboard.destroy
      render :show
    end

    def errors
      @job_errors = Rearview::JobError.calculate_durations(Rearview::JobError.application_errors(params[:id]).order_created.load)
    end

    private

    def upsert
      @dashboard = Rearview::Dashboard.find_or_initialize_by(id: params[:id])
      @dashboard.name = params[:name]
      @dashboard.user = current_user
      @dashboard.description = params[:description]
      @dashboard.save!
    end

  end
end


text:
package com.intellij.lang.ant.dom;

import com.intellij.openapi.util.Pair;
import org.jetbrains.annotations.NotNull;

import java.util.*;
import java.util.regex.Pattern;

/**
* @author Eugene Zhuravlev
*         Date: Apr 23, 2010
*/
public class PropertyExpander {
  private static final Pattern $$_PATTERN = Pattern.compile("\\$\\$");
  final List<PropertiesProvider> myProviders = new ArrayList<PropertiesProvider>();
  final Resolver myResolver;
  final Set<String> myNamesToSkip = new HashSet<String>();
  private PropertyExpansionListener myPropertyExpansionListener;

  public interface PropertyExpansionListener {
    void onPropertyExpanded(String propName, String propValue);
  }

  public PropertyExpander(final @NotNull String str) {
    this(str, Collections.<String>emptySet());
  }

  private PropertyExpander(final @NotNull String str, Set<String> namesToSkip) {
    myResolver = new Resolver(str, namesToSkip);
    myNamesToSkip.addAll(namesToSkip);
  }

  /**
   * @param listener new listener implementation
   * @return previous listener
   */
  public PropertyExpansionListener setPropertyExpansionListener(PropertyExpansionListener listener) {
    final PropertyExpansionListener prevListener = myPropertyExpansionListener;
    myPropertyExpansionListener = listener;
    return prevListener;
  }

  public boolean hasPropertiesToExpand() {
    return myResolver.hasNext();
  }

  // true if should continue, false to stop
  public void acceptProvider(PropertiesProvider provider) {
    while (myResolver.hasNext()) {
      final String propName = myResolver.next();
      final String value = provider.getPropertyValue(propName);
      if (value != null) {
        myNamesToSkip.add(propName); // prevent infinite recursion
        final String propValue;
        if (provider instanceof PropertiesProvider.SkipPropertyExpansionInValues) {
          propValue = value;
        }
        else {
          final PropertyExpander propertyValueExpander = new PropertyExpander(value, myNamesToSkip);
          propertyValueExpander.setPropertyExpansionListener(myPropertyExpansionListener);
          if (propertyValueExpander.hasPropertiesToExpand()) {
            for (PropertiesProvider p : myProviders) {
              propertyValueExpander.acceptProvider(p);
              if (!propertyValueExpander.hasPropertiesToExpand()) {
                break;
              }
            }
            if (propertyValueExpander.hasPropertiesToExpand()) {
              propertyValueExpander.acceptProvider(provider);
            }
          }
          propValue = propertyValueExpander.getResult();
        }
        myResolver.replace(propValue);
        notifyPropertyExpanded(propName, propValue);
      }
    }
    myProviders.add(provider);
    myResolver.restart();
  }

  public void notifyPropertyExpanded(String propName, String propValue) {
    final PropertyExpansionListener listener = myPropertyExpansionListener;
    if (listener != null) {
      listener.onPropertyExpanded(propName, propValue);
    }
  }

  @NotNull
  public String getResult() {
    return myResolver.getResult();
  }

  private static class Resolver implements Iterator<String> {
    private int myCurrentIndex = -1;
    private List<Pair<String /*property name without ${} characters*/, Integer /*offset of property occurrence including '$' char*/>> myPropertyNames;
    private StringBuilder myBuilder;

    private Resolver(final String str, Set<String> namesToSkip) {
      myBuilder = new StringBuilder(str);
      int startProp = 0;
      while ((startProp = str.indexOf("${", startProp)) >= 0) {
        if (startProp > 0 && str.charAt(startProp - 1) == '$') {
          // the '$' is escaped
          startProp += 2;
          continue;
        }
        final int endProp = str.indexOf('}', startProp + 2);
        if (endProp <= startProp + 2) {
          startProp += 2;
          continue;
        }
        final String prop = str.substring(startProp + 2, endProp);
        if (!namesToSkip.contains(prop)) {
          if (myPropertyNames == null) {
            myPropertyNames = new ArrayList<Pair<String, Integer>>();
          }
          myPropertyNames.add(new Pair<String, Integer>(prop, startProp));
        }
        startProp += 2;
      }
      if (myPropertyNames == null) {
        myPropertyNames = Collections.emptyList();
      }
    }

    void restart() {
      myCurrentIndex = -1;
    }

    void replace(String newValue) {
      final String name = getPropertyName(myCurrentIndex);
      final int shift = newValue.length() - name.length() - 3/*property beginning and ending symbols '${}'*/;
      // correct property offsets
      for (int idx = myCurrentIndex + 1; idx < myPropertyNames.size(); idx++) {
        final int currentOffset = getPropertyOffset(idx);
        setPropertyOffset(idx, currentOffset + shift);
      }
      final int offset = getPropertyOffset(myCurrentIndex);
      myBuilder.replace(offset, offset + name.length() + 3/*ending brace*/, newValue);
      myPropertyNames.remove(myCurrentIndex);
      myCurrentIndex--;
    }

    private String getPropertyName(int index) {
      return myPropertyNames.get(index).getFirst();
    }

    private int getPropertyOffset(int index) {
      return myPropertyNames.get(index).getSecond();
    }

    private void setPropertyOffset(int index, int value) {
      final Pair<String, Integer> pair = myPropertyNames.get(index);
      myPropertyNames.set(index, new Pair<String, Integer>(pair.getFirst(), value));
    }

    String getResult() {
      final String value = myBuilder.toString();
      if (value.indexOf("$$") >= 0) {
        return $$_PATTERN.matcher(value).replaceAll("\\$");
      }
      return value;
    }

    public boolean hasNext() {
      return (myCurrentIndex + 1) < myPropertyNames.size();
    }

    public String next() {
      return getPropertyName(++myCurrentIndex);
    }

    public void remove() {
      replace("");
    }
  }

}


text:
class RemovePasswordHashFromUsers < ActiveRecord::Migration
  def change
    remove_column :users, :password_hash, :string
  end
end


text:
namespace ExampleApp
{
    namespace NavRouting
    {
        namespace SdkModel
        {
            NavRoutingHighlightsController::NavRoutingHighlightsController(INavRoutingModel& routingModel,
                                                                           Eegeo::Resources::Interiors::Highlights::IInteriorsHighlightService& interiorsHighlightService)
            : m_routingModel(routingModel)
            , m_interiorsHighlightService(interiorsHighlightService)
            {
            }

            void NavRoutingHighlightsController::AddHighlights()
            {
                NavRoutingLocationModel startLocation;
                if (m_routingModel.TryGetStartLocation(startLocation))
                {
                    HighlightEntities(startLocation);
                }

                NavRoutingLocationModel endLocation;
                if (m_routingModel.TryGetEndLocation(endLocation))
                {
                    HighlightEntities(endLocation);
                }
            }

            void NavRoutingHighlightsController::RefreshHighlights()
            {
                ClearHighlights();
                AddHighlights();
            }

            void NavRoutingHighlightsController::ClearHighlights()
            {
                m_interiorsHighlightService.ClearAllHighlights();
            }

            void NavRoutingHighlightsController::HighlightEntities(const NavRoutingLocationModel locationModel)
            {
                if (locationModel.GetIsIndoors())
                {
                    m_interiorsHighlightService.SetHighlights(locationModel.GetIndoorMapId().Value(), locationModel.GetEntityIds(), locationModel.GetHighlightColor());
                }
            }
        }
    }
}


text:
package com.studio.jc.modules.demand.controller;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.studio.jc.common.persistence.Page;
import com.studio.jc.common.web.BaseController;
import com.studio.jc.modules.demand.service.DemandService;
import com.studio.jc.modules.demand.vo.DemandVo;
import com.studio.jc.modules.project.service.UserProjectService;
import com.studio.jc.modules.project.vo.UserProjectVo;
import com.studio.jc.modules.sys.utils.UserUtils;

import groovy.mock.interceptor.Demand;

@Controller
@RequestMapping(value="${adminPath}/demand")
public class DemandController extends BaseController{
	@Autowired
	private DemandService demandService;

	@Autowired
	private UserProjectService userProjectService;

	@RequestMapping(value = "list")
	public String list(HttpServletRequest request,
			HttpServletResponse response, Model model, DemandVo demand){
		Page<DemandVo> page = new Page<DemandVo>(request, response);
		//判断参数
		if(StringUtils.isBlank(demand.getProjectId())){
			page.setList(new ArrayList<DemandVo>());
			model.addAttribute("page", page);
			model.addAttribute("message", "参数错误");
			return "modules/demand/demandList";
		}

		List<DemandVo> list = demandService.findList(page, demand);
		page.setList(list);

		//检查是否是项目经理
		UserProjectVo up = userProjectService.findByPidAndUid(UserUtils.getUser().getId(), demand.getProjectId());
		model.addAttribute("isManager", "1".equals(up.getPost()) ? "1" : "0");

		//获取项目组员

		model.addAttribute("page", page);
		model.addAttribute("projectId", demand.getProjectId());

		return "modules/demand/demandList";
	}

	@RequestMapping(value = "addForm")
	public String addForm(HttpServletRequest request,
			HttpServletResponse response, DemandVo demand, Model model){
		model.addAttribute("demand", demand);
		return "modules/demand/demandForm";
	}

	@RequestMapping(value = "add")
	public String add(HttpServletRequest request,
			HttpServletResponse response, DemandVo demand, Model model){

		//验证

		return null;
	}

}


text:
/**
 * @overview UI button used become the current DNS node in manual DNS mode.
 */
'use strict';

var markup = require('./NetSimDnsManualControl.html.ejs');

/**
 * Generator and controller for DNS mode selector
 * @param {jQuery} rootDiv
 * @param {function} becomeDnsCallback
 * @constructor
 */
var NetSimDnsManualControl = module.exports = function (rootDiv,
    becomeDnsCallback) {
  /**
   * Component root, which we fill whenever we call render()
   * @type {jQuery}
   * @private
   */
  this.rootDiv_ = rootDiv;

  /**
   * @type {function}
   * @private
   */
  this.becomeDnsCallback_ = becomeDnsCallback;

  this.render();
};

/**
 * Fill the root div with new elements reflecting the current state
 */
NetSimDnsManualControl.prototype.render = function () {
  var renderedMarkup = $(markup({}));
  this.rootDiv_.html(renderedMarkup);
  this.rootDiv_.find('input[type="button"]').click(
      this.onBecomeDnsButtonClick_.bind(this));
};

/**
 * Handler for button click.
 * @private
 */
NetSimDnsManualControl.prototype.onBecomeDnsButtonClick_ = function () {
  this.becomeDnsCallback_();
};

/**
 * @param {boolean} isDnsNode
 */
NetSimDnsManualControl.prototype.setIsDnsNode = function (isDnsNode) {
  this.rootDiv_.find('input[type="button"]').attr('disabled', isDnsNode);
};


text:
@interface ESObjectKeyValueTransformer : NSObject <ESObjectValueTransformerProtocol>

- (void)setObject:(id)object forKey:(id<NSCopying>)key;

@end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
C-Index
</TITLE>

<META NAME="date" CONTENT="2013-08-28">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../stylesheet.css" TITLE="Style">

      Overview
      Package
      Class
      Use
      Tree
      Deprecated
    Index
      Help

 PREV LETTER
 NEXT LETTER

  FRAMES
 NO FRAMES

  All Classes

A B C E F G H I J K M O P R S T U

C

CALLBACK_FLAG_PERFORM_ACTIVE_SCAN -
Static variable in class android.support.v7.media.MediaRouter

Flag for MediaRouter.addCallback(android.support.v7.media.MediaRouteSelector, android.support.v7.media.MediaRouter.Callback): Actively scan for routes while this callback
 is registered.

CALLBACK_FLAG_REQUEST_DISCOVERY -
Static variable in class android.support.v7.media.MediaRouter

Flag for MediaRouter.addCallback(android.support.v7.media.MediaRouteSelector, android.support.v7.media.MediaRouter.Callback): Request that route discovery be performed while this
 callback is registered.

CALLBACK_FLAG_UNFILTERED_EVENTS -
Static variable in class android.support.v7.media.MediaRouter

Flag for MediaRouter.addCallback(android.support.v7.media.MediaRouteSelector, android.support.v7.media.MediaRouter.Callback): Do not filter route events.

CATEGORY_LIVE_AUDIO -
Static variable in class android.support.v7.media.MediaControlIntent

Media control category: Live audio.

CATEGORY_LIVE_VIDEO -
Static variable in class android.support.v7.media.MediaControlIntent

Media control category: Live video.

CATEGORY_REMOTE_PLAYBACK -
Static variable in class android.support.v7.media.MediaControlIntent

Media control category: Remote playback.

contains(MediaRouteSelector) -
Method in class android.support.v7.media.MediaRouteSelector

Returns true if this selector contains all of the capabilities described
 by the specified selector.

      Overview
      Package
      Class
      Use
      Tree
      Deprecated
    Index
      Help

 PREV LETTER
 NEXT LETTER

  FRAMES
 NO FRAMES

  All Classes

A B C E F G H I J K M O P R S T U


text:
#include <aws/emr-containers/model/EksInfo.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::Utils::Json;
using namespace Aws::Utils;

namespace Aws
{
namespace EMRContainers
{
namespace Model
{

EksInfo::EksInfo() :
    m_namespaceHasBeenSet(false)
{
}

EksInfo::EksInfo(JsonView jsonValue) :
    m_namespaceHasBeenSet(false)
{
  *this = jsonValue;
}

EksInfo& EksInfo::operator =(JsonView jsonValue)
{
  if(jsonValue.ValueExists("namespace"))
  {
    m_namespace = jsonValue.GetString("namespace");

    m_namespaceHasBeenSet = true;
  }

  return *this;
}

JsonValue EksInfo::Jsonize() const
{
  JsonValue payload;

  if(m_namespaceHasBeenSet)
  {
   payload.WithString("namespace", m_namespace);

  }

  return payload;
}

} // namespace Model
} // namespace EMRContainers
} // namespace Aws


text:
import {
  AnthroponymInflector,
  FirstNameInflector,
  InflectorRule,
  LastNameInflector,
  MiddleNameInflector,
} from './anthroponym-inflection';
import { Gender } from './core';
import {
  NeuralNetwork,
  NeuralNetworkTrainingData,
  PartOfSpeechRecognizer,
  PartOfSpeechRecognitionRule,
} from './part-of-speech-recognition';
// tslint:disable-next-line import-name
import inflectorRules from './resources/inflector/rules.json';
// tslint:disable-next-line import-name
import kosmiiCache from './resources/neural-networks/kosmii/cache.json';
// tslint:disable-next-line import-name
import kosmiiStructure from './resources/neural-networks/kosmii/structure.json';
// tslint:disable-next-line import-name
import pelykhCache from './resources/neural-networks/pelykh/cache.json';
// tslint:disable-next-line import-name
import pelykhStructure from './resources/neural-networks/pelykh/structure.json';
// tslint:disable-next-line import-name
import pohorielovaCache from './resources/neural-networks/pohorielova/cache.json';
// tslint:disable-next-line import-name
import pohorielovaStructure from './resources/neural-networks/pohorielova/structure.json';

const partOfSpeechRecognizer = new PartOfSpeechRecognizer([
  new PartOfSpeechRecognitionRule(
    (word: string, gender: Gender) => gender === Gender.Female && /[ая]$/i.test(word),
    NeuralNetwork.fromJSON(pohorielovaStructure),
    pohorielovaCache as NeuralNetworkTrainingData,
  ),
  new PartOfSpeechRecognitionRule(
    (word: string, gender: Gender) => gender === Gender.Male && /(ой|ий|ій)$/i.test(word),
    NeuralNetwork.fromJSON(kosmiiStructure),
    kosmiiCache as NeuralNetworkTrainingData,
  ),
  new PartOfSpeechRecognitionRule(
    (word: string, gender: Gender) => gender === Gender.Male && /(их)$/i.test(word),
    NeuralNetwork.fromJSON(pelykhStructure),
    pelykhCache as NeuralNetworkTrainingData,
  ),
]);

const firstNameInflector = new FirstNameInflector(inflectorRules as InflectorRule[]);
const middleNameInflector = new MiddleNameInflector(inflectorRules as InflectorRule[]);
const lastNameInflector = new LastNameInflector(inflectorRules as InflectorRule[], partOfSpeechRecognizer);
const anthroponymInflector = new AnthroponymInflector(firstNameInflector, middleNameInflector, lastNameInflector);

export { anthroponymInflector };


text:
package com.betahikaru.app.controller.aws;

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

import com.betahikaru.app.usecase.aws.Ec2Monitor;
import com.betahikaru.app.usecase.aws.IamMonitor;
import com.betahikaru.app.usecase.aws.S3Monitor;

@Controller
@RequestMapping("/aws")
public class DefaultAwsController extends AbstractAwsController {
	@Autowired
	public void setEc2Monitor(Ec2Monitor ec2Monitor) {
		this.monitors.add(ec2Monitor);
	}

	@Autowired
	public void setIamMonitor(IamMonitor iamMonitor) {
		this.monitors.add(iamMonitor);
	}

	@Autowired
	public void setS3Monitor(S3Monitor s3Monitor) {
		this.monitors.add(s3Monitor);
	}
}