text:
<title>Mixed Declarations - Using the GNU Compiler Collection (GCC)</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using the GNU Compiler Collection (GCC)">
<meta name="generator" content="makeinfo 4.7">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="C-Extensions.html#C-Extensions" title="C Extensions">
<link rel="prev" href="Case-Ranges.html#Case-Ranges" title="Case Ranges">
<link rel="next" href="Function-Attributes.html#Function-Attributes" title="Function Attributes">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">

<meta http-equiv="Content-Style-Type" content="text/css">

Next: Function Attributes,
Previous: Case Ranges,
Up: C Extensions

5.26 Mixed Declarations and Code

ISO C99 and ISO C++ allow declarations and code to be freely mixed
within compound statements.  As an extension, GCC also allows this in
C89 mode.  For example, you could do:

     int i;
     /* ... */
     i++;
     int j = i + 2;

Each identifier is visible from where it is declared until the end of
the enclosing block.


text:
<!DOCTYPE html>

    <title>Turn It UP ! • Méthodologie Agile</title>
    <meta charset="UTF-8">
    <link rel="stylesheet" type="text/css" href="public/css/main.css"/>
    <link rel="stylesheet" type="text/css" href="public/css/jquery-ui-1.10.3.custom.css"/>

Turn It UP !

                    Introduction

                        Analyse

                        Design

                        Réalisation

                        Livraison

Annexe

        Allez au bout de vos projets...

Turn It Up ! est une méthode agile simple qui vous accompagne tout au
            long de vos projets.

Commencez ici !

            <map name="map-introduction">
                <area shape="rect" coords="87,16,212,140" onclick="showModal('introduction-analyse-modal')" alt="L'analyse des besoins" title="L'analyse des besoins"/>
                <area shape="rect" coords="307,16,432,140" onclick="showModal('introduction-design-modal')" alt="Le design de la fonction" title="Le design de la fonction"/>
                <area shape="rect" coords="527,16,652,140" onclick="showModal('introduction-build-modal')" alt="La réalisation de la fonction" title="La réalisation de la fonction"/>
                <area shape="rect" coords="747,16,872,140" onclick="showModal('introduction-delivery-modal')" alt="La livraison de la fonction" title="La livraison de la fonction"/>
            </map>

Quoi ?

Définir la vision, la fonction et son périmètre

Comment ?

En réunissant les parties prenantes

En échangeant autour de la vision et du moyen de la réaliser

Qui ?

Celui qui mène la fonction

Celui qui demande la vision

Celui qui utilise la fonction

Celui qui réalise les mockups

Quoi ?

Préparer l'implémentation de la fonction

Comment ?

En suivant un cheminement permettant de n'omettre aucun détail, en réalisant des spécifications, en réalisant les maquettes

Qui ?

Celui qui mène la fonction

Celui qui réalise la conception

Celui qui réalise les maquettes

Quoi ?

Implémenter la fonction

Comment ?

En réalisant des tests, en développant, en intégrant, en faisant valider le code par des pairs

Qui ?

Celui qui mène la fonction

Celui qui développe

Celui qui intègre

Celui qui valide le code

Quoi ?

Mettre à la fonction disposition de celui qui l'utilise

Comment ?

En validant la fonction en pré production, en la déployant en production, en analysant les retours de ceux qui l'utilisent, en réflechissant à l'améliorer

Qui ?

Celui qui mène la fonction

Celui qui a la vision

Celui qui met en production la fonction

Celui qui utilise la fonction

L'analyse des besoins

            <map name="analyse-map">
                <area shape="rect" coords="23,181,77,236" onclick="showModal('analysis-vision-modal')" alt="La vision" title="La vision"/>
                <area shape="rect" coords="213,160,314,257" onclick="showModal('analysis-requirements-capture-modal')" alt="Le recueil des besoins" title="Le recueil des besoins"/>
                <area shape="rect" coords="428,158,529,261" onclick="showModal('requirements-analysis-modal')" alt="" title=""/>
                <area shape="rect" coords="643,157,744,260" onclick="showModal('ux-realization-modal')" alt="Réaliser l'expérience utilisateur" title="Réaliser l'expérience utilisateur"/>
                <area shape="rect" coords="865,189,909,233" onclick="showModal('analyse-check-modal')" alt="" title=""/>
                <area shape="rect" coords="454,330,504,394" onclick="showModal('requirements-and-use-case-document-modal')" alt="" title=""/>
                <area shape="rect" coords="453,28,503,92" href="#use-case-diagram" alt="" title=""/>
                <area shape="rect" coords="668,331,718,395" href="mockup-document" alt="" title=""/>

            </map>

Quoi ?

La vision d'une fonction qui pourrait apporter au business ou à l'utilisateur

Qui ?

Celui qui a la vision

Quoi ?

Etablir la fonction et les fonctionnalités pour atteindre cette vision

Comment ?

En réunissant les parties prenantes

En échangeant autour de la vision et du moyen de la réaliser

Qui ?

Celui qui mène la fonction

Celui qui a la vision

Celui qui utilise la fonction

Celui qui réalise l'expérience utilisateur

Quoi ?

Établir les besoins et les exigences autour de la fonction

Comment ?

En décrivant la vision

En décrivant les moyens de la réaliser (les fonctions)

En déterminant les acteurs et les cas d'utilisation

En déterminant les priorités des cas d'utilisation

En déterminant les exigences autour des fonctions et des fonctionnalités

Qui ?

Celui qui mène la fonction

Quoi ?

Établir l'expérience utilisateur

Comment ?

En réalisant des mockups

Qui ?

Celui qui réalise l'expérience utilisateur

Quoi ?

Déterminer les premières itérations

Comment ?

En évaluant le temps nécessaire à la réalisation des fonctionnalités

En triant les fonctionnalités selon le rapport Business value / temps
                nécessaire à la réalisation

Qui ?

Celui qui mène la fonction

Celui qui a la vision

Celui qui utilise la fonction

Celui qui réalise l'expérience utilisateur

        Exemple

Le design de la fonction

                Maquettes

                Mockups

                        Réaliser les maquettes

                Besoins et cas d'utilisation

                        Modeliser le métier

                        Modeliser les données

                        Modeliser l'application

                Modèle de domaine

                Modèle de données

                Spécifications

La réalisation de la fonction

                Modèle de domaine

                Spécifications

                        Implémenter les tests de comportement

                        Implémenter les tests unitaires

                        Développer

                        Soumettre le code

                        Intégrer

                        Soumettre le code

                Modèle de données

La livraison de la fonction

                Preproduction

                        Valider la fonction

                        Mettre en production

Suivre les retours utilisateurs

Annexe

                    Personnages

                    Outils

                    Planning

                    Références

        Fonction :
        Fonctionnalités :

                    Romain Kuzniak

Contact

redpajama_set_name: RedPajamaGithub


text:
> Modals are streamlined, but flexible, dialog prompts with the minimum required functionality and smart defaults.

<ins class="adsbygoogle"
     style="display:block; text-align:center;"
     data-ad-layout="in-article"
     data-ad-format="fluid"
     data-ad-client="ca-pub-4714899946256166"
     data-ad-slot="4603582855"></ins>

## Example

Toggle a modal by clicking the button below. It will slide down and fade in from the top of the page.

A simple modal example with callback:

```html
<template>
  <section>
    <btn type="primary" @click="open=true">Launch Demo Modal</btn>
    <modal v-model="open" title="Modal 1" @hide="callback" ref="modal" id="modal-demo">
      <h4>Text in a modal</h4>
      <p>Duis mollis, est non commodo luctus, nisi erat porttitor ligula.</p>
      <h4>Popover in a modal</h4>
      <p>
        This
        <btn v-popover:modal-demo="{title:'Title',content:'Some popover content...'}">button</btn>
        should trigger a popover on click.
      </p>
      <h4>Tooltips in a modal</h4>
      <p>
        <a role="button" v-tooltip:modal-demo="'Tooltip'">This link</a>
        <span>and</span>
        <a role="button" v-tooltip:modal-demo="'Tooltip'">that link</a>
        <span>should have tooltips on hover.</span>
      </p>
      <hr>
      <h4>Overflowing text to show scroll behavior</h4>
      <p>Cras mattis consectetur purus sit amet fermentum. Cras justo odio, dapibus ac facilisis in, egestas eget quam. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.</p>
      <p>Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.</p>
      <p>Aenean lacinia bibendum nulla sed consectetur. Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Donec ullamcorper nulla non metus auctor fringilla.</p>
      <p>Cras mattis consectetur purus sit amet fermentum. Cras justo odio, dapibus ac facilisis in, egestas eget quam. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.</p>
      <p>Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.</p>
      <p>Aenean lacinia bibendum nulla sed consectetur. Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Donec ullamcorper nulla non metus auctor fringilla.</p>
      <p>Cras mattis consectetur purus sit amet fermentum. Cras justo odio, dapibus ac facilisis in, egestas eget quam. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.</p>
      <p>Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.</p>
      <p>Aenean lacinia bibendum nulla sed consectetur. Praesent commodo cursus magna, vel scelerisque nisl consectetur et. Donec sed odio dui. Donec ullamcorper nulla non metus auctor fringilla.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open: false
      }
    },
    methods: {
      callback (msg) {
        this.$notify(`Modal dismissed with msg '${msg}'.`)
      }
    }
  }
</script>
<!-- modal-example.vue -->
```

## Optional sizes

Modals have two optional sizes: `lg` and `sm`.

```html
<template>
  <section>
    <btn type="primary" @click="open1=true">Large Modal</btn>
    <btn type="primary" @click="open2=true">Small Modal</btn>
    <modal v-model="open1" title="Modal Title" size="lg">
      <p>This is a large modal.</p>
    </modal>
    <modal v-model="open2" title="Modal Title" size="sm">
      <p>This is a small modal.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open1: false,
        open2: false
      }
    }
  }
</script>
<!-- modal-optional-sizes.vue -->
```

## Custom header

* Use `title` slot to customize the modal title.
* Set `header` prop to `false` to hide the modal header.
* You can also use `header` slot to take full control of the modal header. Notice that this slot will override `title` slot since it is a completely replacement

```html
<template>
  <section>
    <btn type="primary" @click="open1=true">HTML Title</btn>
    <btn type="primary" @click="open2=true">No Header</btn>
    <modal v-model="open1">
      <span slot="title"><i class="glyphicon glyphicon-heart"></i> Modal Title</span>
      <p>This is a modal with HTML title.</p>
    </modal>
    <modal v-model="open2" :header="false">
      <p>This is a modal with no header.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open1: false,
        open2: false
      }
    }
  }
</script>
<!-- modal-custom-header.vue -->
```

## Custom footer

* Use `footer` slot to customize the modal footer.
* Set `footer` prop to `false` to hide the modal footer.

```html
<template>
  <section>
    <btn type="primary" @click="open1=true">Custom Footer</btn>
    <btn type="primary" @click="open2=true">No Footer</btn>
    <modal v-model="open1" title="Modal Title">
      <p>This is a modal with custom footer.</p>
      <div slot="footer">
        <btn @click="open1=false">Cancel</btn>
        <btn type="warning">Warning Action</btn>
        <btn type="danger">Danger Action</btn>
      </div>
    </modal>
    <modal v-model="open2" title="Modal Title" :footer="false">
      <p>This is a modal with no footer.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open1: false,
        open2: false
      }
    }
  }
</script>
<!-- modal-custom-footer.vue -->
```

## Custom button texts and types

* Use `ok-text` and `cancel-text` to customize button texts
* Use `ok-type` and `cancel-type` to customize button types

```html
<template>
  <section>
    <btn type="primary" @click="open=true">Custom Button Text and Type</btn>
    <modal v-model="open" title="Are you sure?"
           ok-text="Yes, please" cancel-text="No way!"
           ok-type="danger" cancel-type="warning">
      <p>Do you really want to destroy this item?</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open: false,
      }
    }
  }
</script>
<!-- modal-custom-button-text-and-type.vue -->
```

## Auto focus

Auto focus on footer button with `data-action="auto-focus"` attribute after modal open. By default it is the OK button.

```html
<template>
  <section>
    <btn type="primary" @click="open=true">Auto Focus</btn>
    <modal v-model="open" title="Modal Title" auto-focus>
      <p>Check this out! The OK button is focused now.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open: false
      }
    }
  }
</script>
<!-- modal-auto-focus.vue -->
```

## Disable backdrop

Set `backdrop` prop to `false` to disable the modal dismiss action on backdrop click.

```html
<template>
  <section>
    <btn type="primary" @click="open=true">Disable Backdrop</btn>
    <modal v-model="open" title="Modal Title" :backdrop="false">
      <p>This is a modal that can not close by backdrop click.</p>
    </modal>
  </section>
</template>

<script>
  export default {
    data () {
      return {
        open: false
      }
    }
  }
</script>
<!-- modal-disable-backdrop.vue -->
```

## Disable animation

Set `transition-duration` to `0` to disable modal animations.

```html
<template>
  <section>
    <btn type="primary" @click="open=true">Disable Animation</btn>
    <modal v-model="open" title="Modal Title" :transition-duration="0">
      <p>This is a modal that has no transition effect.</p>
    </modal>
  </section>
</template>

<script>
  export default {
    data () {
      return {
        open: false
      }
    }
  }
</script>
<!-- modal-disable-animation.vue -->
```

## Nested modals

Note that if you want modals to be real nested to each other, you have to add `append-to-body` prop to them. For example:

```html
<template>
  <section>
    <btn type="primary" @click="open1=true">Open set of nested modals</btn>
    <!-- `append-to-body` not required here -->
    <modal v-model="open1" title="Modal 1" size="lg" ref="modal1">
      <p>This is a simple large modal.</p>
      <p>Click on the button below to open a nested modal.</p>
      <btn type="info" @click="open2=true">Open Modal 2</btn>
      <!-- `append-to-body` required, because this is a nested modal -->
      <modal v-model="open2" title="Modal 2" append-to-body ref="modal2">
        <p>This is a nested modal.</p>
        <btn type="info" @click="open3=true">Open Modal 3</btn>
        <!-- `append-to-body` required, because this is a nested modal -->
        <modal v-model="open3" title="Modal 3" size="sm" append-to-body ref="modal3">
          <p>This is another nested modal.</p>
        </modal>
      </modal>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open1: false,
        open2: false,
        open3: false
      }
    }
  }
</script>
<!-- modal-nested.vue -->
```

Otherwise, you can simply nest them logically, without any extra settings:

```html
<template>
  <section>
    <btn type="primary" @click="open1=true">Open set of nested modals (logically)</btn>
    <modal v-model="open1" title="Modal 1" size="lg">
      <p>This is a simple large modal.</p>
      <p>Click on the button below to open a nested modal.</p>
      <btn type="info" @click="open2=true">Open Modal 2</btn>
    </modal>
    <modal v-model="open2" title="Modal 2">
      <p>This is a nested modal.</p>
      <btn type="info" @click="open3=true">Open Modal 3</btn>
    </modal>
    <modal v-model="open3" title="Modal 3" size="sm">
      <p>This is another nested modal.</p>
    </modal>
  </section>
</template>
<script>
  export default {
    data () {
      return {
        open1: false,
        open2: false,
        open3: false
      }
    }
  }
</script>
<!-- modal-nested-logically.vue -->
```

# API Reference

## [Modal](https://github.com/wxsms/uiv/blob/master/src/components/modal/Modal.vue)

### Props

Name                  | Type       | Default  | Required | Description
----------------      | ---------- | -------- | -------- | -----------------------
`v-model`             | Boolean    | false    | ✔ | Show / hide the modal.
`title`               | String     |          |          | The modal title (will be override if title slot exist).
`size`                | String     |          |          | The alternative modal size. Support `lg` / `sm`.
`backdrop`            | Boolean    | true     |          | Dismiss the modal by backdrop click.
`footer`              | Boolean    | true     |          | Show modal footer.
`header`              | Boolean    | true     |          | Show modal header.
`dismiss-btn`         | Boolean    | true     |          | Display the dismiss button in header.
`cancel-text`         | String     |          |          | Override the text of cancel button.
`cancel-type`         | String     | default  |          | (0.26.0+) Button type of cancel button.
`ok-text`             | String     |          |          | Override the text of ok button.
`ok-type`             | String     | primary  |          | (0.26.0+) Button type of ok button.
`transition-duration` | Number     | 150      |          | Transition time of the modal, set to 0 to disable animation.
`auto-focus`          | Boolean    | false    |          | Focus on the action button that has `data-action="auto-focus"` attribute after modal open, by default it is the OK button.
`keyboard`            | Boolean    | true     |          | Close the modal after `esc` key pressed.
`append-to-body`      | Boolean    | false    |          | Append the modal element to `<body>`.
`before-close`        | Function   |          |          | Call with the `msg` param, return `false` to interrupt the modal hiding process. Promise supported since 0.34.1.

### Slots

Name      | Description
--------- | -----------------------
`title`   | Replace as the modal title.
`default` | Replace as the modal body.
`header`  | Replace as the modal header. Note: this slot will override `title` slot since it is a completely replacement of header.
`footer`  | Replace as the modal footer.

### Events

Name        | Params | Description
----------- | ------ | ---------------
`show`      |        | Fire after modal show.
`hide`      | msg    | Fire after modal dismiss with message (if exist).


text:
<?php
// autogenerated file 30.09.2013 15:20
// $Id: $
// $Log: $
//
//
require_once 'EbatNs_ComplexType.php';

/**
 * Indicates whether the seller making the request can list with certain features.A
 * seller's eligibility is determined by their feedback rating.
 *
 * @link http://developer.ebay.com/DevZone/XML/docs/Reference/eBay/types/FeatureEligibilityType.html
 *
 */
class FeatureEligibilityType extends EbatNs_ComplexType
{
	/**
	 * @var boolean
	 */
	protected $QualifiesForBuyItNow;
	/**
	 * @var boolean
	 */
	protected $QualifiesForBuyItNowMultiple;
	/**
	 * @var boolean
	 */
	protected $QualifiedForFixedPriceOneDayDuration;
	/**
	 * @var boolean
	 */
	protected $QualifiesForVariations;
	/**
	 * @var boolean
	 */
	protected $QualifiedForAuctionOneDayDuration;

	/**
	 * @return boolean
	 */
	function getQualifiesForBuyItNow()
	{
		return $this->QualifiesForBuyItNow;
	}
	/**
	 * @return void
	 * @param boolean $value
	 */
	function setQualifiesForBuyItNow($value)
	{
		$this->QualifiesForBuyItNow = $value;
	}
	/**
	 * @return boolean
	 */
	function getQualifiesForBuyItNowMultiple()
	{
		return $this->QualifiesForBuyItNowMultiple;
	}
	/**
	 * @return void
	 * @param boolean $value
	 */
	function setQualifiesForBuyItNowMultiple($value)
	{
		$this->QualifiesForBuyItNowMultiple = $value;
	}
	/**
	 * @return boolean
	 */
	function getQualifiedForFixedPriceOneDayDuration()
	{
		return $this->QualifiedForFixedPriceOneDayDuration;
	}
	/**
	 * @return void
	 * @param boolean $value
	 */
	function setQualifiedForFixedPriceOneDayDuration($value)
	{
		$this->QualifiedForFixedPriceOneDayDuration = $value;
	}
	/**
	 * @return boolean
	 */
	function getQualifiesForVariations()
	{
		return $this->QualifiesForVariations;
	}
	/**
	 * @return void
	 * @param boolean $value
	 */
	function setQualifiesForVariations($value)
	{
		$this->QualifiesForVariations = $value;
	}
	/**
	 * @return boolean
	 */
	function getQualifiedForAuctionOneDayDuration()
	{
		return $this->QualifiedForAuctionOneDayDuration;
	}
	/**
	 * @return void
	 * @param boolean $value
	 */
	function setQualifiedForAuctionOneDayDuration($value)
	{
		$this->QualifiedForAuctionOneDayDuration = $value;
	}
	/**
	 * @return
	 */
	function __construct()
	{
		parent::__construct('FeatureEligibilityType', 'urn:ebay:apis:eBLBaseComponents');
		if (!isset(self::$_elements[__CLASS__]))
				self::$_elements[__CLASS__] = array_merge(self::$_elements[get_parent_class()],
				array(
					'QualifiesForBuyItNow' =>
					array(
						'required' => false,
						'type' => 'boolean',
						'nsURI' => 'http://www.w3.org/2001/XMLSchema',
						'array' => false,
						'cardinality' => '0..1'
					),
					'QualifiesForBuyItNowMultiple' =>
					array(
						'required' => false,
						'type' => 'boolean',
						'nsURI' => 'http://www.w3.org/2001/XMLSchema',
						'array' => false,
						'cardinality' => '0..1'
					),
					'QualifiedForFixedPriceOneDayDuration' =>
					array(
						'required' => false,
						'type' => 'boolean',
						'nsURI' => 'http://www.w3.org/2001/XMLSchema',
						'array' => false,
						'cardinality' => '0..1'
					),
					'QualifiesForVariations' =>
					array(
						'required' => false,
						'type' => 'boolean',
						'nsURI' => 'http://www.w3.org/2001/XMLSchema',
						'array' => false,
						'cardinality' => '0..1'
					),
					'QualifiedForAuctionOneDayDuration' =>
					array(
						'required' => false,
						'type' => 'boolean',
						'nsURI' => 'http://www.w3.org/2001/XMLSchema',
						'array' => false,
						'cardinality' => '0..1'
					)
				));
	}
}
?>


text:
<resources>

    <dimen name="indicator_right_padding">10dp</dimen>
    <dimen name="indicator_corner_radius">12dp</dimen>
    <dimen name="indicator_internal_padding">4dp</dimen>
</resources>


text:
package org.apache.xml.security.stax.securityEvent;

import org.apache.xml.security.stax.securityToken.SecurityToken;

/**
 * @author $Author: giger $
 * @version $Revision: 1228829 $ $Date: 2012-01-08 11:44:13 +0000 (Sun, 08 Jan 2012) $
 */
public class X509TokenSecurityEvent extends TokenSecurityEvent<SecurityToken> {

    public X509TokenSecurityEvent() {
        super(SecurityEventConstants.X509Token);
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<Tokens version="1.0">
	<File path="Constants/GlucoseSampleLocationOption.html">

		<Token>
			<TokenIdentifier>//apple_ref/c/tdef/GlucoseSampleLocationOption</TokenIdentifier>
			<Abstract type="html">All possible glucose sample locations with their assigned value</Abstract>
			<DeclaredIn>UHNBLETypes.h</DeclaredIn>

			<NodeRef refid="14"/>
		</Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationFinger</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the glucose measurement was taken from the finger</Abstract>
            <Declaration>GlucoseSampleLocationFinger</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationAlternativeSiteTest</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the glucose measurement was taken from an alternative site</Abstract>
            <Declaration>GlucoseSampleLocationAlternativeSiteTest</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationEarlobe</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the glucose measurement was taken from the earlobe</Abstract>
            <Declaration>GlucoseSampleLocationEarlobe</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationControlSolution</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the glucose measurement was taken with control solution</Abstract>
            <Declaration>GlucoseSampleLocationControlSolution</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationSubcutaneousTissue</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the glucose measurement was taken from subcutaneous tissue</Abstract>
            <Declaration>GlucoseSampleLocationSubcutaneousTissue</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

        <Token>
            <TokenIdentifier>//apple_ref/c/econst/GlucoseSampleLocationNotAvailable</TokenIdentifier>
            <Abstract type="html">Sample location indicating that the location is not available</Abstract>
            <Declaration>GlucoseSampleLocationNotAvailable</Declaration>

            <DeclaredIn>UHNBLETypes.h</DeclaredIn>

            <NodeRef refid="14"/>
        </Token>

	</File>
</Tokens>


text:
package org.apache.asterix.om.base;

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

import org.apache.asterix.om.types.AUnorderedListType;
import org.apache.asterix.om.types.IAType;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class AUnorderedList implements IACollection {

    protected List<IAObject> values;
    protected AUnorderedListType type;

    public AUnorderedList(AUnorderedListType type) {
        values = new ArrayList<>();
        this.type = type;
    }

    public AUnorderedList(AUnorderedListType type, List<IAObject> sequence) {
        values = sequence;
        this.type = type;
    }

    @Override
    public IACursor getCursor() {
        ACollectionCursor cursor = new ACollectionCursor();
        cursor.reset(this);
        return cursor;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof AUnorderedList)) {
            return false;
        } else {
            AUnorderedList y = (AUnorderedList) o;
            return InMemUtils.cursorEquals(this.getCursor(), y.getCursor());
        }
    }

    @Override
    public int hashCode() {
        return InMemUtils.hashCursor(getCursor());
    }

    @Override
    public IAType getType() {
        return type;
    }

    @Override
    public int size() {
        return values.size();
    }

    @Override
    public boolean deepEqual(IAObject obj) {
        return equals(obj);
    }

    @Override
    public int hash() {
        return hashCode();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("multiset: {{ ");
        boolean first = true;
        for (IAObject v : values) {
            if (first) {
                first = false;
            } else {
                sb.append(", ");
            }
            sb.append(v.toString());
        }
        sb.append(" }}");
        return sb.toString();
    }

    @Override
    public ObjectNode toJSON() {
        ObjectMapper om = new ObjectMapper();
        ObjectNode json = om.createObjectNode();

        ArrayNode list = om.createArrayNode();
        for (IAObject v : values) {
            list.add(v.toJSON());
        }
        json.set("AUnorderedList", list);

        return json;
    }
}


text:
- Ruby
- RubyGems
- Rake
- Bundler

## Usage

Assuming you have RubyGems, install [Rake](http://rake.rubyforge.org) and
[Bundler](http://bundler.io).

	$ gem install rake bundler

Now clone the repository.

	$ git clone https://github.com/hsmty/web.git hsmty.web
	$ cd hsmty.web
	$ bundle install

Run the `rake` command to serve and watch any changes you make automatically.

	$ rake

Have fun.


text:
require "rack/polymer/version"
require "rack/jquery/helpers"

module Rack
  class Polymer
    include Rack::JQuery::Helpers # for caching

    # Namespaced CDNs for convenience.
    module CDN

      # Script tags for the Media Temple CDN
      CLOUDFLARE = "//cdnjs.cloudflare.com/ajax/libs/polymer/#{POLYMER_VERSION}/polymer.min.js"

    end

    # The file name to use for the fallback route.
    POLYMER_FILE_NAME = "polymer-#{POLYMER_VERSION}.min.js"

    # The file name of the source map.
    POLYMER_SOURCE_MAP = "polymer.min.js.map"

    # This javascript checks if the Polymer object has loaded. If not, that most likely means the CDN is unreachable, so it uses the local minified Polymer.
    FALLBACK = <<STR
<script type="text/javascript">
  if (typeof Polymer == 'undefined') {
    document.write(unescape("%3Cscript src='/js/#{POLYMER_FILE_NAME}' type='text/javascript'%3E%3C/script%3E"))
  };
</script>
STR

    # @param [Hash] env The rack env.
    # @param [Hash] opts Extra options.
    # @options opts [Symbol] :organisation Choose which CDN to use. The default is :cloudflare. If an organisation was set via the Rack env this will override it.
    # @options opts [FalseClass] :cdn Mark as false if you *don't* want to use the CDN and only want to use the fallback script. This option is primarily here so I can use the latest script without relying on the CDN, but use it however you wish.
    # @return [String] The HTML script tags to get the CDN.
    # @example
    #   Rack::Polymer.cdn( env )
    #
    #   # Choose an organisation
    #   Rack::Polymer.cdn( env, organisation: :cloudflare )
    #
    #   # Don't use a CDN, just use the fallback
    #   Rack::Polymer.cdn( env, cdn: false )
    def self.cdn( env, opts={} )
      organisation =  opts[:organisation] ||
                        (env["rack.polymer"] && env["rack.polymer"]["organisation"]) ||
                        Rack::Polymer::DEFAULT_ORGANISATION

      script = case organisation
        when :cloudflare then CDN::CLOUDFLARE
        else CDN::CLOUDFLARE
      end

      opts[:cdn] == false ?
        FALLBACK :
        "<script src='#{script}'></script>\n#{FALLBACK}"
    end

    # The default CDN to use.
    DEFAULT_ORGANISATION = :cloudflare

    # Default options hash for the middleware.
    DEFAULT_OPTIONS = {
      :http_path => "/js",
      :organisation => DEFAULT_ORGANISATION
    }

    # @param [#call] app
    # @param [Hash] options
    # @option options [String] :http_path If you wish the Polymer fallback route to be "/js/polymer-0.0.20130711.min.js" (or whichever version this is at) then do nothing, that's the default. If you want the path to be "/assets/javascripts/polymer-0.0.20130711.min.js" then pass in `:http_path => "/assets/javascripts".
    # @option options [Symbol] :organisation Choose which CDN to use. The default is :cloudflare.
    # @example
    #   # The default:
    #   use Rack::Polymer
    #
    #   # With a different route to the fallback:
    #   use Rack::Polymer, :http_path => "/assets/js"
    #
    #   # With the CDN specified via the use statement
    #   use Rack::Polymer, :organisation => :cloudflare
    def initialize( app, options={} )
      @app, @options  = app, DEFAULT_OPTIONS.merge(options)
      @http_path_to_polymer, @http_path_to_polymer_source_map =
        [POLYMER_FILE_NAME,POLYMER_SOURCE_MAP].map{|file_name|
          ::File.join @options[:http_path], file_name
        }
      @organisation = @options[:organisation]
    end

    # @param [Hash] env Rack request environment hash.
    def call( env )
      dup._call env
    end

    # For thread safety
    # @param (see #call)
    def _call( env )
      env.merge! "rack.polymer" => {"organisation" => @organisation}

      request = Rack::Request.new(env.dup)
      if request.path_info == @http_path_to_polymer
        @response = Rack::Response.new
        # for caching
        @response.headers.merge! caching_headers( POLYMER_FILE_NAME, POLYMER_VERSION_DATE)

        # There's no need to test if the IF_MODIFIED_SINCE against the release date because the header will only be passed if the file was previously accessed by the requester, and the file is never updated. If it is updated then it is accessed by a different path.
        if request.env['HTTP_IF_MODIFIED_SINCE']
          @response.status = 304
        else
          serve_static_file "polymer.min.js"
        end
        @response.finish
      elsif request.path_info == @http_path_to_polymer_source_map
        # The source map isn't cached
        serve_static_file( "polymer.min.js.map" ).finish
      else
        @app.call(env)
      end
    end # call

    # Helper method for serving static files.
    # @param [String] file The short file name.
    # @return [Rack::Response]
    def serve_static_file( file )
      @response ||= Rack::Response.new
      @response.status = 200
      @response.write ::File.read( ::File.expand_path "../../../vendor/assets/javascript/libs/polymer/#{POLYMER_VERSION}/#{file}", __FILE__)
      @response
    end

  end
end


text:
<?php
/**
* Properties
*
* Properties
*
* @package MajorDoMo
* @author Serge Dzheigalo <jey@tut.by> http://smartliving.ru/
* @version 0.2 (wizard, 12:05:47 [May 22, 2009])
*/
//
//
class properties extends module {
/**
* properties
*
* Module class constructor
*
* @access private
*/
function properties() {
  $this->name="properties";
  $this->title="<#LANG_MODULE_PROPERTIES#>";
  $this->module_category="<#LANG_SECTION_OBJECTS#>";
  $this->checkInstalled();
}
/**
* saveParams
*
* Saving module parameters
*
* @access public
*/
function saveParams() {
 $p=array();
 if (IsSet($this->id)) {
  $p["id"]=$this->id;
 }
 if (IsSet($this->view_mode)) {
  $p["view_mode"]=$this->view_mode;
 }
 if (IsSet($this->edit_mode)) {
  $p["edit_mode"]=$this->edit_mode;
 }
 if (IsSet($this->tab)) {
  $p["tab"]=$this->tab;
 }
 return parent::saveParams($p);
}
/**
* getParams
*
* Getting module parameters from query string
*
* @access public
*/
function getParams() {
  global $id;
  global $mode;
  global $view_mode;
  global $edit_mode;
  global $tab;
  if (isset($id)) {
   $this->id=$id;
  }
  if (isset($mode)) {
   $this->mode=$mode;
  }
  if (isset($view_mode)) {
   $this->view_mode=$view_mode;
  }
  if (isset($edit_mode)) {
   $this->edit_mode=$edit_mode;
  }
  if (isset($tab)) {
   $this->tab=$tab;
  }
}
/**
* Run
*
* Description
*
* @access public
*/
function run() {
 global $session;
  $out=array();
  if ($this->action=='admin') {
   $this->admin($out);
  } else {
   $this->usual($out);
  }
  if (IsSet($this->owner->action)) {
   $out['PARENT_ACTION']=$this->owner->action;
  }
  if (IsSet($this->owner->name)) {
   $out['PARENT_NAME']=$this->owner->name;
  }
  $out['VIEW_MODE']=$this->view_mode;
  $out['EDIT_MODE']=$this->edit_mode;
  $out['MODE']=$this->mode;
  $out['ACTION']=$this->action;
  $out['TAB']=$this->tab;
  if (IsSet($this->class_id)) {
   $out['IS_SET_CLASS_ID']=1;
  }
  if ($this->single_rec) {
   $out['SINGLE_REC']=1;
  }
  $this->data=$out;
  $p=new parser(DIR_TEMPLATES.$this->name."/".$this->name.".html", $this->data, $this);
  $this->result=$p->result;
}
/**
* BackEnd
*
* Module backend
*
* @access public
*/
function admin(&$out) {
 if (isset($this->data_source) && !$_GET['data_source'] && !$_POST['data_source']) {
  $out['SET_DATASOURCE']=1;
 }
 if ($this->data_source=='properties' || $this->data_source=='') {
  if ($this->view_mode=='' || $this->view_mode=='search_properties') {
   $this->search_properties($out);
  }
  if ($this->view_mode=='edit_properties') {
   $this->edit_properties($out, $this->id);
  }
  if ($this->view_mode=='delete_properties') {
   $this->delete_properties($this->id);
   $this->redirect("?");
  }
 }
}
/**
* FrontEnd
*
* Module frontend
*
* @access public
*/
function usual(&$out) {
 $this->admin($out);
}
/**
* properties search
*
* @access public
*/
 function search_properties(&$out) {
  require(DIR_MODULES.$this->name.'/properties_search.inc.php');
 }
/**
* properties edit/add
*
* @access public
*/
 function edit_properties(&$out, $id) {
  require(DIR_MODULES.$this->name.'/properties_edit.inc.php');
 }
/**
* properties delete record
*
* @access public
*/
 function delete_properties($id) {
  $rec=SQLSelectOne("SELECT * FROM properties WHERE ID='$id'");
  // some action for related tables
  $values=SQLSelect("SELECT * FROM pvalues WHERE PROPERTY_ID='".$rec['ID']."'");
  $total=count($values);
  for($i=0;$i<$total;$i++) {
   SQLExec("DELETE FROM phistory WHERE VALUE_ID='".$values[$i]['ID']."'");
   SQLExec("DELETE FROM pvalues WHERE ID='".$values[$i]['ID']."'");
  }

  SQLExec("DELETE FROM properties WHERE ID='".$rec['ID']."'");
 }
/**
* Install
*
* Module installation routine
*
* @access private
*/
 function install($parent_name="") {
  parent::install($parent_name);
 }
/**
* Uninstall
*
* Module uninstall routine
*
* @access public
*/
 function uninstall() {
  SQLExec('DROP TABLE IF EXISTS properties');
  parent::uninstall();
 }
/**
* dbInstall
*
* Database installation routine
*
* @access private
*/
 function dbInstall($data) {
/*
properties - Properties
*/
  $data = <<<EOD
 properties: ID int(10) unsigned NOT NULL auto_increment
 properties: CLASS_ID int(10) NOT NULL DEFAULT '0'
 properties: OBJECT_ID int(10) NOT NULL DEFAULT '0'
 properties: TITLE varchar(255) NOT NULL DEFAULT ''
 properties: KEEP_HISTORY int(10) NOT NULL DEFAULT '0'
 properties: DESCRIPTION text
 properties: ONCHANGE varchar(255) NOT NULL DEFAULT ''
 properties: INDEX (CLASS_ID)
 properties: INDEX (OBJECT_ID)

 phistory: ID int(10) unsigned NOT NULL auto_increment
 phistory: VALUE_ID int(10) unsigned NOT NULL DEFAULT '0'
 phistory: ADDED datetime
 phistory: INDEX (VALUE_ID)

EOD;
  parent::dbInstall($data);
 }
// --------------------------------------------------------------------
}
/*
*
* TW9kdWxlIGNyZWF0ZWQgTWF5IDIyLCAyMDA5IHVzaW5nIFNlcmdlIEouIHdpemFyZCAoQWN0aXZlVW5pdCBJbmMgd3d3LmFjdGl2ZXVuaXQuY29tKQ==
*
*/
?>


text:
div.canvas {
    margin-top: 20px;
    margin-left: 10%;
    padding-top: 20px;
    width: 80%;
    height: 500px;
    background-color: white;
}

.canvas .rectangle {
    margin: 50px auto;
    width: 100px;
    height: 100px;
    background-color: green;
    border: 0;
    padding: 0;
}

.canvas .rectangle-with-border {
    margin: 50px auto;
    width: 150px;
    height: 100px;
    background-color: transparent;
    border: 20px solid green;
}

.canvas .rectangle-with-different-border {
    margin: 50px auto;
    width: 150px;
    height: 100px;
    background-color: transparent;
    border-top: 10px solid green;
    border-right: 20px solid yellow;
    border-bottom: 30px solid red;
    border-left: 40px solid blue;
}

.canvas .rectangle-with-different-border-and-zero-size {
    margin: 50px auto;
    width: 0;
    height: 0;
    background-color: transparent;
    border-top: 60px solid green;
    border-right: 70px solid yellow;
    border-bottom: 80px solid red;
    border-left: 90px solid blue;
}

.canvas .triangle {
    margin: 50px auto;
    width: 0;
    height: 0;
    background-color: transparent;
    border-top: 60px solid green;
    border-right: 70px solid transparent;
    border-bottom: 80px solid transparent;
    border-left: 90px solid transparent;
}

.canvas .triangle-topleft {
    margin: 50px auto;
    width: 0;
    height: 0;
    background-color: transparent;
    border-top: 60px solid green;
    border-right: 70px solid transparent;
    border-bottom: 60px solid transparent;
    border-left: 70px solid green;
}

.canvas .trapezoid {
    margin: 50px auto;
    width: 100px;
    height: 0;
    background-color: transparent;
    border-top: 100px solid green;
    border-right: 70px solid transparent;
    border-bottom: 0;
    border-left: 90px solid transparent;
}

div.canvas-top {
    margin-top: 20px;
    margin-left: 10%;
    padding-top: 20px;
    width: 80%;
    height: 200px;
    background-color: white;
}

.canvas-top .diamond .top {
    margin: 50px auto 0;
    border-top: 0 solid transparent;
    border-bottom: 25px solid green;
    border-left: 25px solid transparent;
    border-right: 25px solid transparent;
    height: 0;
    width: 50px;
}

.canvas-top .diamond .bottom {
    margin: 0 auto 50px;
    border-top: 70px solid green;
    border-bottom: 0 solid transparent;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
    width: 0;
    height: 0;
}

.canvas-top .cut-diamond {
    border-top: 0 solid transparent;
    border-bottom: 25px solid pink;
    border-left: 25px solid transparent;
    border-right: 25px solid transparent;
    height: 0;
    width: 50px;
    position: relative;
    margin: 20px auto 90px;
}

.canvas-top .cut-diamond:after {
    content: "";
    position: absolute;
    top: 25px;
    left: -25px;
    width: 0;
    height: 0;
    border-top: 70px solid pink;
    border-bottom: 0 solid transparent;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
}

.canvas .rounded-rectangle {
    margin: 50px auto;
    width: 80px;
    height: 80px;
    background-color: transparent;
    border: 20px solid green;
    border-radius: 20px;
}

.canvas .ellipse {
    margin: 50px auto;
    width: 0;
    height: 0;
    border-top: 20px solid green;
    border-left: 40px solid green;
    border-bottom: 20px solid green;
    border-right: 40px solid green;
    border-top-left-radius: 40px 20px;
    border-top-right-radius: 40px 20px;
    border-bottom-left-radius: 40px 20px;
    border-bottom-right-radius: 40px 20px;
}

.canvas .top-half-circle {
    margin: 50px auto;
    width: 0;
    height: 0;
    border-top: 50px solid green;
    border-left: 50px solid green;
    border-bottom: 0 solid transparent;
    border-right: 50px solid green;
    border-top-left-radius: 50px;
    border-top-right-radius: 50px;
    border-bottom-left-radius: 0;
    border-bottom-right-radius: 0;
}

.canvas-top .up-capsule {
    margin: 10px auto;
    width: 0;
    height: 0;
    border-top: 150px solid green;
    border-left: 50px solid green;
    border-bottom: 0 solid transparent;
    border-right: 50px solid green;
    border-top-left-radius: 50px;
    border-top-right-radius: 50px;
    border-bottom-left-radius: 0;
    border-bottom-right-radius: 0;
}

.canvas-top .heart {
    margin: 10px auto;
    width: 0;
    height: 0;
    border-top: 150px solid red;
    border-left: 50px solid red;
    border-bottom: 0 solid transparent;
    border-right: 50px solid red;
    border-top-left-radius: 50px;
    border-top-right-radius: 50px;
    border-bottom-left-radius: 0;
    border-bottom-right-radius: 0;
    position: relative;
    -webkit-transform: rotate(-45deg);
}
.canvas-top .heart:after {
    content: "";
    margin: 10px auto;
    width: 0;
    height: 0;
    border-top: 150px solid red;
    border-left: 50px solid red;
    border-bottom: 0 solid transparent;
    border-right: 50px solid red;
    border-top-left-radius: 50px;
    border-top-right-radius: 50px;
    border-bottom-left-radius: 0;
    border-bottom-right-radius: 0;
    -webkit-transform: rotate(90deg);
    position: absolute;
    top:-135px;
    left:-25px;
}

.canvas-top .taiji {
    margin: 10px auto;
    height: 98px;
    width: 48px;
    background-color: #eee;
    border-top: 2px solid blue;
    border-bottom: 2px solid blue;
    border-left: 50px solid blue;
    border-right: 2px solid blue;
    border-radius: 50px;
    position: relative;
}
.canvas-top .taiji:before {
    content: "";
    position: absolute;
    top: 0;
    left: -26px;
    background: #eee;
    border: 18px solid blue;
    border-radius: 24px;
    width: 13px;
    height: 13px;
}
.canvas-top .taiji:after {
    content: "";
    position: absolute;
    top: 49px;
    left: -24px;
    background: blue;
    border: 18px solid #eee;
    border-radius: 24px;
    width: 13px;
    height: 13px;
}


text:
package org.basex.query.func.file;

import static org.basex.query.QueryError.*;
import static org.basex.util.Token.*;

import java.io.*;
import java.nio.charset.*;
import java.nio.file.*;

import org.basex.io.out.*;
import org.basex.query.*;
import org.basex.query.value.item.*;
import org.basex.util.*;

/**
 * Function implementation.
 *
 * @author BaseX Team 2005-15, BSD License
 * @author Christian Gruen
 */
public class FileWriteText extends FileFn {
  @Override
  public Item item(final QueryContext qc) throws IOException, QueryException {
    return write(false, qc);
  }

  /**
   * Writes items to a file.
   * @param append append flag
   * @param qc query context
   * @return true if file was successfully written
   * @throws QueryException query exception
   * @throws IOException I/O exception
   */
  final synchronized Item write(final boolean append, final QueryContext qc)
      throws QueryException, IOException {

    final Path path = checkParentDir(toPath(0, qc));
    final byte[] s = toToken(exprs[1], qc);
    final String enc = toEncoding(2, FILE_UNKNOWN_ENCODING_X, qc);
    final Charset cs = enc == null || enc == Strings.UTF8 ? null : Charset.forName(enc);

    try(final PrintOutput out = PrintOutput.get(new FileOutputStream(path.toFile(), append))) {
      out.write(cs == null ? s : string(s).getBytes(cs));
    }
    return null;
  }
}


text:
package org.apache.hadoop.hbase.regionserver.wal;

import static junit.framework.Assert.assertEquals;

import java.io.IOException;
import java.util.List;
import java.util.Random;
import java.util.SortedMap;
import java.util.TreeMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.HBaseTestingUtility;
import org.apache.hadoop.hbase.MediumTests;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.master.HMaster;
import org.apache.hadoop.hbase.protobuf.RequestConverter;
import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.FlushRegionRequest;
import org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.GetLastFlushedSequenceIdRequest;
import org.apache.hadoop.hbase.regionserver.HRegion;
import org.apache.hadoop.hbase.regionserver.HRegionServer;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;

import com.google.common.collect.Lists;
import com.google.protobuf.ServiceException;

@Category(MediumTests.class)
public class TestHLogFiltering {
  private static final Log LOG = LogFactory.getLog(TestHLogFiltering.class);

  private static final int NUM_MASTERS = 1;
  private static final int NUM_RS = 4;

  private static final TableName TABLE_NAME =
      TableName.valueOf("TestHLogFiltering");
  private static final byte[] CF1 = Bytes.toBytes("MyCF1");
  private static final byte[] CF2 = Bytes.toBytes("MyCF2");
  private static final byte[][] FAMILIES = { CF1, CF2 };

  private HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();

  @Before
  public void setUp() throws Exception {
    TEST_UTIL.startMiniCluster(NUM_MASTERS, NUM_RS);
    fillTable();
  }

  @After
  public void tearDown() throws Exception {
    TEST_UTIL.shutdownMiniCluster();
  }

  private void fillTable() throws IOException, InterruptedException {
    HTable table = TEST_UTIL.createTable(TABLE_NAME, FAMILIES, 3,
        Bytes.toBytes("row0"), Bytes.toBytes("row99"), NUM_RS);
    Random rand = new Random(19387129L);
    for (int iStoreFile = 0; iStoreFile < 4; ++iStoreFile) {
      for (int iRow = 0; iRow < 100; ++iRow) {
        final byte[] row = Bytes.toBytes("row" + iRow);
        Put put = new Put(row);
        Delete del = new Delete(row);
        for (int iCol = 0; iCol < 10; ++iCol) {
          final byte[] cf = rand.nextBoolean() ? CF1 : CF2;
          final long ts = Math.abs(rand.nextInt());
          final byte[] qual = Bytes.toBytes("col" + iCol);
          if (rand.nextBoolean()) {
            final byte[] value = Bytes.toBytes("value_for_row_" + iRow +
                "_cf_" + Bytes.toStringBinary(cf) + "_col_" + iCol + "_ts_" +
                ts + "_random_" + rand.nextLong());
            put.add(cf, qual, ts, value);
          } else if (rand.nextDouble() < 0.8) {
            del.deleteColumn(cf, qual, ts);
          } else {
            del.deleteColumns(cf, qual, ts);
          }
        }
        table.put(put);
        table.delete(del);
        table.flushCommits();
      }
    }
    TEST_UTIL.waitUntilAllRegionsAssigned(TABLE_NAME);
  }

  @Test
  public void testFlushedSequenceIdsSentToHMaster()
  throws IOException, InterruptedException, ServiceException {
    SortedMap<byte[], Long> allFlushedSequenceIds =
        new TreeMap<byte[], Long>(Bytes.BYTES_COMPARATOR);
    for (int i = 0; i < NUM_RS; ++i) {
      flushAllRegions(i);
    }
    Thread.sleep(10000);
    HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster();
    for (int i = 0; i < NUM_RS; ++i) {
      for (byte[] regionName : getRegionsByServer(i)) {
        if (allFlushedSequenceIds.containsKey(regionName)) {
          GetLastFlushedSequenceIdRequest req =
            RequestConverter.buildGetLastFlushedSequenceIdRequest(regionName);

          assertEquals((long)allFlushedSequenceIds.get(regionName),
              master.getLastFlushedSequenceId(null, req).getLastFlushedSequenceId());
        }
      }
    }
  }

  private List<byte[]> getRegionsByServer(int rsId) throws IOException {
    List<byte[]> regionNames = Lists.newArrayList();
    HRegionServer hrs = getRegionServer(rsId);
    for (HRegion r : hrs.getOnlineRegions(TABLE_NAME)) {
      regionNames.add(r.getRegionName());
    }
    return regionNames;
  }

  private HRegionServer getRegionServer(int rsId) {
    return TEST_UTIL.getMiniHBaseCluster().getRegionServer(rsId);
  }

  private void flushAllRegions(int rsId)
  throws ServiceException, IOException {
    HRegionServer hrs = getRegionServer(rsId);
    for (byte[] regionName : getRegionsByServer(rsId)) {
      FlushRegionRequest request =
        RequestConverter.buildFlushRegionRequest(regionName);
      hrs.flushRegion(null, request);
    }
  }

}


text:
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**data** | [**UserConnectionsAllOfData**](UserConnectionsAllOfData.md) |  | [optional]


text:
/*
 *
 */
package net.community.chest.util.logging;

import java.io.IOException;
import java.io.PrintStream;
import java.nio.channels.Channel;
import java.util.Map;
import java.util.TreeMap;

import net.community.chest.io.EOLStyle;
import net.community.chest.io.output.NullOutputStream;
import net.community.chest.reflect.MethodUtil;

/**
 *
Copyright 2008 as per GPLv2

 *
 *
Used to "intercept" printed data and log it

 * @author Lyor G.
 * @since Sep 1, 2008 1:29:18 PM
 */
public abstract class AbstractLoggingPrintStream extends PrintStream implements Channel {
    private final Map<String,StackTraceElement>    _hierarchyMap;
    protected AbstractLoggingPrintStream ()
    {
        super(new NullOutputStream());

        // build a map of the hierarchy so we can ignore it when resolving the call sequence
        final StackTraceElement[]    sa=new Exception().getStackTrace();
        if ((null == sa) || (sa.length <= 1))
            throw new IllegalStateException("No stack trace hierarchy");

        final int    cIndex=MethodUtil.getFirstConstructorElement(sa);
        if (cIndex < 0)
            throw new IllegalStateException("Cannot determine class hierarchy");

        _hierarchyMap = new TreeMap<String,StackTraceElement>();

        for (int    sIndex=cIndex; sIndex >= 0; sIndex--)
        {
            final StackTraceElement    elem=sa[sIndex];
            final String            clsName=(null == elem) ? null : elem.getClassName();
            if ((null == clsName) || (clsName.length() <= 0))
                continue;

            _hierarchyMap.put(clsName, elem);
        }
    }
    /*
     * @see java.io.PrintStream#append(char)
     */
    @Override
    public PrintStream append (char c)
    {
        print(c);
        return this;
    }
    /*
     * @see java.io.PrintStream#append(java.lang.CharSequence)
     */
    @Override
    public PrintStream append (CharSequence csq)
    {
        print(csq.toString());
        return this;
    }
    /*
     * @see java.io.PrintStream#append(java.lang.CharSequence, int, int)
     */
    @Override
    public PrintStream append (CharSequence csq, int start, int end)
    {
        return append(csq.subSequence(start, end));
    }

    private boolean    _open    /* =false */;
    /*
     * @see java.nio.channels.Channel#isOpen()
     */
    @Override
    public boolean isOpen ()
    {
        return _open;
    }

    public void setOpen (boolean o)
    {
        _open = o;
    }
    /*
     * @see java.io.PrintStream#close()
     */
    @Override
    public void close ()
    {
        if (isOpen())
            setOpen(false);
        super.close();
    }
    /**
     * TRUE=Attach the {@link StackTraceElement} of the caller
     */
    private boolean    _resolveCaller=true;
    public boolean isResolveCaller ()
    {
        return _resolveCaller;
    }

    public void setResolveCaller (boolean resolveCaller)
    {
        _resolveCaller = resolveCaller;
    }

    protected StackTraceElement    resolveCallerElement ()
    {
        final StackTraceElement[]    sa=new Exception().getStackTrace();
        if ((null == sa) || (sa.length <= 1))
            return null;    // debug breakpoint

        for (final StackTraceElement elem : sa)
        {
            final String    eClass=(null == elem) ? null : elem.getClassName();
            if ((null == eClass) || (eClass.length() <= 0))
                continue;

            // stop at first method that is NOT part of the hierarchy
            if (_hierarchyMap.get(eClass) != null)
                continue;

            return elem;
        }

        return null;
    }
    /**
     * The default {@link LogLevelWrapper} used for logging the data
     */
    private LogLevelWrapper    _defLevel=LogLevelWrapper.DEBUG;
    public LogLevelWrapper getDefaultLogLevel ()
    {
        return _defLevel;
    }

    public void setDefaultLogLevel (LogLevelWrapper l)
    {
        _defLevel = l;
    }
    /**
     * Called by default implementation of {@link #print(String)} to execute
     * the actual logging
     * @param l The {@link LogLevelWrapper} value
     * @param ce The location (if {@link #isResolveCaller()}=TRUE) and
     * successfully resolved the caller
     * @param s The written data {@link String} "line"
     * @throws IOException if failed to write the data
     */
    public abstract void log (LogLevelWrapper l, StackTraceElement ce, String s) throws IOException;

    private StringBuilder    _workBuf    /* =null */;
    protected StringBuilder getWorkBuffer (final int len)
    {
        if (null == _workBuf)
            _workBuf = new StringBuilder(Math.max(len, Byte.MAX_VALUE));

        return _workBuf;
    }

    private static StringBuilder appendCleanData (final StringBuilder sb, final String s)
    {
        final int    sLen=(null == s) ? 0 : s.length();
        for (int    curPos=0; curPos < sLen; )
        {
            final int    crPos=s.indexOf('\r', curPos);
            if (crPos < curPos)
            {
                final String    remString=(curPos > 0) ? s.substring(curPos) : s;
                if ((remString != null) && (remString.length() > 0))
                    sb.append(remString);
                break;
            }

            final String    clrText=(curPos == crPos) ? null : s.substring(curPos, crPos);
            if ((clrText != null) && (clrText.length() > 0))
                sb.append(clrText);

            curPos = crPos + 1;
        }

        return sb;
    }

    private static String getCleanData (final StringBuilder sb, final String s)
    {
        if ((null == s) || (s.length() <= 0) || (s.indexOf('\r') < 0))
            return s;

        final int            prevLen=sb.length();
        final StringBuilder    res=appendCleanData(sb, s);
        final String        ret=res.toString();
        res.setLength(prevLen);
        return ret;
    }
    /*
     * @see java.io.PrintStream#print(java.lang.String)
     */
    @Override
    public void print (final String s)
    {
        if (!isOpen())
        {
            setError();
            return;
        }

        StackTraceElement    ce=null;
        final int            sLen=(null == s) ? 0 : s.length();
        final StringBuilder    sb=getWorkBuffer(sLen);
        // break it up into LF separated lines
        for (int    curPos=0; curPos < sLen; )
        {
            final int        lfPos=s.indexOf('\n', curPos);
            // if no more LF(s) then accumulate whatever is left for next time
            if (lfPos < curPos)
            {
                final String    remString=(curPos > 0) ? s.substring(curPos) : s;
                if ((remString != null) && (remString.length() > 0))
                    appendCleanData(sb, remString);
                break;
            }

            final String    clrText=(curPos == lfPos) ? null : s.substring(curPos, lfPos), msgText;
            // check if have data from previous call
            if (sb.length() > 0)
            {
                if ((clrText != null) && (clrText.length() > 0))
                    appendCleanData(sb, clrText);

                msgText = sb.toString();
                sb.setLength(0);    // re-start accumulation
            }
            else
                msgText = getCleanData(sb, clrText);

            if ((msgText != null) && (msgText.length() > 0))
            {
                if ((null == ce) && isResolveCaller())
                     ce = resolveCallerElement();

                try
                {
                    log(getDefaultLogLevel(), ce, msgText);
                }
                catch(IOException e)
                {
                    setError();
                }
            }

            curPos = lfPos + 1;
        }
    }
    /*
     * @see java.io.PrintStream#print(boolean)
     */
    @Override
    public void print (boolean b)
    {
        print(String.valueOf(b));
    }
    /*
     * @see java.io.PrintStream#print(char)
     */
    @Override
    public void print (char c)
    {
        print(String.valueOf(c));
    }
    /*
     * @see java.io.PrintStream#print(char[])
     */
    @Override
    public void print (char[] s)
    {
        print(new String(s));
    }
    /*
     * @see java.io.PrintStream#print(double)
     */
    @Override
    public void print (double d)
    {
        print(String.valueOf(d));
    }
    /*
     * @see java.io.PrintStream#print(float)
     */
    @Override
    public void print (float f)
    {
        print(String.valueOf(f));
    }
    /*
     * @see java.io.PrintStream#print(int)
     */
    @Override
    public void print (int i)
    {
        print(String.valueOf(i));
    }
    /*
     * @see java.io.PrintStream#print(long)
     */
    @Override
    public void print (long l)
    {
        print(String.valueOf(l));
    }
    /*
     * @see java.io.PrintStream#print(java.lang.Object)
     */
    @Override
    public void print (Object obj)
    {
        print(String.valueOf(obj));
    }
    /*
     * @see java.io.PrintStream#println()
     */
    @Override
    public void println ()
    {
        print(EOLStyle.LOCAL.getStyleString());
    }
    /*
     * @see java.io.PrintStream#println(boolean)
     */
    @Override
    public void println (boolean x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(char)
     */
    @Override
    public void println (char x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(char[])
     */
    @Override
    public void println (char[] x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(double)
     */
    @Override
    public void println (double x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(float)
     */
    @Override
    public void println (float x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(int)
     */
    @Override
    public void println (int x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(long)
     */
    @Override
    public void println (long x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(java.lang.Object)
     */
    @Override
    public void println (Object x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#println(java.lang.String)
     */
    @Override
    public void println (String x)
    {
        print(x);
        println();
    }
    /*
     * @see java.io.PrintStream#write(byte[], int, int)
     */
    @Override
    public void write (byte[] buf, int off, int len)
    {
        if (len > 0)
        {
            final char[]    ca=new char[len];
            for (int    cIndex=0, cOffset=off; cIndex < len; cOffset++, cIndex++)
                ca[cIndex] = (char) (buf[cOffset] & 0x00FF);
            print(ca);
        }
    }
    /*
     * @see java.io.PrintStream#write(int)
     */
    @Override
    public void write (int b)
    {
        print((char) (b & 0x00FF));
    }
}


text:
package com.medievallords.carbyne.squads.commands;

import com.medievallords.carbyne.utils.MessageManager;
import com.medievallords.carbyne.utils.StaticClasses;
import com.medievallords.carbyne.utils.command.BaseCommand;
import com.medievallords.carbyne.utils.command.Command;
import com.medievallords.carbyne.utils.command.CommandArgs;
import org.bukkit.entity.Player;

/**
 * Created by Williams on 2017-03-12.
 *
 */
public class SquadCreateCommand extends BaseCommand {

    @Command(name = "squad.create", inGameOnly = true, aliases = {"party.create"})
    public void execute(CommandArgs commandArgs) {
        String[] args = commandArgs.getArgs();
        Player player = commandArgs.getPlayer();

        if (args.length != 0) {
            MessageManager.sendMessage(player, "&cUsage: /squad");
            return;
        }

        StaticClasses.squadManager.createSquad(player.getUniqueId());
    }
}


text:
using namespace System;
using namespace System::Threading;

namespace CefSharp
{

    ///<summary>Return-To-Zero latch, signals whenever count is zero</summary>
    [System::Diagnostics::DebuggerDisplayAttribute("Current Count={CurrentCount}")]
    public ref class RtzCountdownEvent sealed
    {
        initonly ManualResetEvent^ _event;
        int _currentCount;
        bool _disposed;

    public:

        RtzCountdownEvent() :
            _event(gcnew ManualResetEvent(true)),
            _currentCount(0),
            _disposed(false) {}

        !RtzCountdownEvent()
        {
            if(_disposed)
            {
                _disposed = true;
                //_event->Dispose();
            }
        }

        ~RtzCountdownEvent()
        {
            this->!RtzCountdownEvent();
        }

        property int CurrentCount
        {
            int get() { return _currentCount; }
        }

        void AddCount(int count);
        void AddCount();
        bool Signal(int count);
        bool Signal();
        void Reset();
        void Wait();
        void Wait(int timeout);
    };

}


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

  angular
    .module('ion-gallery')
    .directive('ionImageScale',ionImageScale);

  ionImageScale.$inject = [];

  function ionImageScale(){

    return {
      restrict: 'A',
      link : link
    };

    function link(scope, element, attrs) {
      element.bind("load" , function(e){

        if(this.naturalHeight > this.naturalWidth){
            element.attr('width','100%');
        }
        else{
          element.attr('height',element.parent()[0].offsetHeight+'px');
        }
      });
    }
  }
})();


text:
namespace MateCat.Net.Enums
{
    /// <summary>
    /// The status the project is from analysis perspective enum.
    /// </summary>
    public enum AnalysisProjectPerspectiveStatus
    {
        /// <summary>
        /// Just created, not analyzed yet.
        /// </summary>
        New,

        /// <summary>
        /// Preliminary ("fast") analysis completed, now running translations ("TM") analysis.
        /// </summary>
        FastOk,

        /// <summary>
        /// Analysis complete.
        /// </summary>
        Done
    }
}


text:
package com.geeksaga.web.servlet.async;

//import akka.actor.ActorSystem;
import com.geeksaga.light.logger.CommonLogger;
import com.geeksaga.light.logger.LightLogger;

import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

/**
 * @author geeksaga
 */
@WebServlet(name = "AkkaServlet", urlPatterns = { "/consoleAKKA" }, asyncSupported = true)
public class AkkaServlet extends HttpServlet
{
    private LightLogger logger;

    public AkkaServlet()
    {
        logger = CommonLogger.getLogger(getClass().getName());
    }

    @Override
    public void init() throws ServletException {}

    @Override
    protected void doGet(HttpServletRequest servletRequest, HttpServletResponse servletResponse) throws ServletException, IOException
    {
//        final AsyncContext asyncContext = servletRequest.startAsync();
//        final ActorSystem actorSystem = (ActorSystem) servletRequest.getServletContext().getAttribute("ActorSystem");
//
//        Enumeration<String> enums = servletRequest.getServletContext().getAttributeNames();
//
//        while (enums.hasMoreElements())
//        {
//            System.out.println(enums.nextElement());
//        }

        //        actorSystem.actorOf(Props.create(AskActor.class, asyncContext));
    }

    //    private static class TestActor extends UntypedActor
    //    {
    //        @Override
    //        public void onReceive(Object msg) throws Exception
    //        {
    //            if (msg == "Test!!!")
    //            {
    //                getSender().tell("Ok", getSelf());
    //            }
    //            else
    //            {
    //                unhandled(msg);
    //            }
    //        }
    //    }

    //    private static class AskActor extends UntypedActor
    //    {
    //        private final AsyncContext asyncContext;
    //
    //        public AskActor(AsyncContext asyncContext)
    //        {
    //            this.asyncContext = asyncContext;
    //            //            ActorRef testActor = getContext().actorOf(Props.create(TestActor.class), "TestActor");
    //            ActorRef actorRef = getContext().actorOf(Props.create(TestActor.class));
    //            getContext().watch(actorRef);
    //            getContext().setReceiveTimeout(Duration.create("5 seconds"));
    //            actorRef.tell("Test!!!", getSelf());
    //        }
    //
    //        @Override
    //        public void onReceive(Object msg) throws IOException
    //        {
    //            HttpServletResponse resp = (HttpServletResponse) asyncContext.getResponse();
    //            if (msg instanceof ReceiveTimeout)
    //            {
    //                getContext().stop(getSelf());
    //                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Timeout");
    //                asyncContext.complete();
    //            }
    //            else if (msg instanceof Terminated)
    //            {
    //                getContext().stop(getSelf());
    //                resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Unexpectedly Stopped");
    //                asyncContext.complete();
    //            }
    //            else if (msg instanceof String)
    //            {
    //                getContext().stop(getSelf());
    //                resp.setContentType("text/plain");
    //                try (PrintWriter writer = resp.getWriter())
    //                {
    //                    writer.print("Ok");
    //                }
    //                asyncContext.complete();
    //            }
    //            else
    //            {
    //                unhandled(msg);
    //            }
    //        }
    //    }
}


text:
<?php

declare(strict_types=1);

namespace Baethon\Phln;

const group_by = 'Baethon\\Phln\\group_by';

/**
 * @param array<array<string, mixed>>            $collection
 * @param callable(array<string, mixed>): string $fn
 *
 * @return array<string, array<string, mixed>>
 */
function group_by(array $collection, callable $fn): array
{
    return reduce(
        $collection,
        function ($carry, $item) use ($fn) {
            $key = $fn($item);
            $innerList = array_key_exists($key, $carry)
                ? $carry[$key]
                : [];

            $carry[$key] = array_merge($innerList, [$item]);

            return $carry;
        },
        []
    );
};


text:
MSVC71
------

True when using Microsoft Visual C 7.1

Set to true when the compiler is version 7.1 of Microsoft Visual C.


text:
function [data]=Rigaku_Read(filename,ext)

openresults=fopen(filename,'r');

if strcmp(ext,'.asc')
    pp=0;
while pp<1
                a=fgetl(openresults);
                as=strsplit(a);
    if strcmp(as{1},'*COUNT') % this line is before * Count
                pp=1;
    elseif strcmp(as{1},'*SCAN_MODE')
        scanType=as{3};
    elseif strcmp(as{1},'*WAVE_LENGTH1')
        kalpha1=str2double(as{3});
    elseif strcmp(as{1},'*WAVE_LENGTH2')
        kalpha2=str2double(as{3});
    elseif strcmp(as{1},'*START')
        start=str2double(as{3});
    elseif strcmp(as{1},'*STOP')
        stop=str2double(as{3});
    elseif strcmp(as{1},'*STEP')
        step=str2double(as{3});
    elseif a==-1
        disp('Nothing was detected')
        break
    end
end
results1=transpose(textscan(openresults,'%f','Delimiter',','));%opens the file listed above and obtains data in all 5 columns
twotheta=start:step:stop;
intensity=results1{1}';
mult=1;
else
% for i=1:4
% a=fgetl(openresults);
% end
pp=0;
a='Test';
while pp<1
    if strcmp(a,'*RAS_INT_START')
        pp=1;
        continue
    elseif contains(a,'ALPHA1')
        alpha1=strsplit(a);
        kalpha1=str2double(strrep(alpha1{2},'"',''));

    elseif contains(a,'ALPHA2')
        alpha2=strsplit(a);
        kalpha2=str2double(strrep(alpha2{2},'"',''));
    elseif contains(a,'MEAS_SCAN_AXIS_X')
                scanType=strsplit(a);
                scanType=strrep(scanType{2},'"','');
    end
        a=fgetl(openresults);
end
n=3;

results1=fscanf(openresults,'%f',[n inf]);%opens the file listed above and obtains data in all 5 columns
                   %change the 3 in [3, inf]%for all other%xy files that%dont pertain %to%integrations%done on 2-ID-D%data

twotheta=results1(1,:);
intensity=results1(2,:);
mult=results1(3,:);
intensity=intensity.*mult;
end

data = struct('KAlpha1',kalpha1,'KAlpha2',kalpha2,'two_theta',twotheta,...
    'data_fit',intensity,'mult',mult,'ext',ext,'scanType',java.lang.String(scanType));


text:
'use strict';

const common = require('../common');
const { Readable } = require('stream');
const assert = require('assert');

// basic
{
  // Find it on Readable.prototype
  assert(Readable.prototype.hasOwnProperty('readableEnded'));
}

// event
{
  const readable = new Readable();

  readable._read = () => {
    // The state ended should start in false.
    assert.strictEqual(readable.readableEnded, false);
    readable.push('asd');
    assert.strictEqual(readable.readableEnded, false);
    readable.push(null);
    assert.strictEqual(readable.readableEnded, false);
  };

  readable.on('end', common.mustCall(() => {
    assert.strictEqual(readable.readableEnded, true);
  }));

  readable.on('data', common.mustCall(() => {
    assert.strictEqual(readable.readableEnded, false);
  }));
}

// Verifies no `error` triggered on multiple .push(null) invocations
{
  const readable = new Readable();

  readable.on('readable', () => { readable.read(); });
  readable.on('error', common.mustNotCall());
  readable.on('end', common.mustCall());

  readable.push('a');
  readable.push(null);
  readable.push(null);
}


text:
import {Facebook} from 'ionic-native';

export class FacebookLogin{
  static login(successCallback, errorCallback){
    Facebook.login(['user_friends']).then(response => {
      successCallback(response.authResponse);
    }, error =>  {
      errorCallback(error);
  })
  }
}


text:
#region Using Directives

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Reflection;

#endregion

namespace Windows.Mvvm.Reactive
{
    /// <summary>
    /// Represents a reactive collection, which derives from another reactive collection. Everytime the reactive collection, the derived collection is based on, changes, the content of the derived collection is updated.
    /// </summary>
    public class DerivedReactiveCollection<TInput, TOutput> : ReadOnlyReactiveCollection<TOutput>
    {
        #region Constructors

        /// <summary>
        /// Initializes a new <see cref="DerivedReactiveCollection{TInput, TOutput}"/> instance.
        /// </summary>
        /// <param name="reactiveCollection">The reactive collection on which the derived reactive collection is based.</param>
        /// <param name="wherePredicate">The delegate, which is used to filter the source reactive collection.</param>
        /// <param name="selectPredicate">The delegate, which is used to map the elements of the source reactive collection to the target type of the derived reactive collection.</param>
        public DerivedReactiveCollection(IReactiveCollection<TInput> reactiveCollection, Func<TInput, bool> wherePredicate, Func<TInput, TOutput> selectPredicate)
        {
            // Stores the where predicate, if no where predicate was specified, then it defaults to a predicate, which does not filter out any elements
            this.wherePredicate = wherePredicate ?? (input => true);

            // Stores the select predicate, if no select predicate was specified, then it defaults to four predicates with falling precedence:
            // 1. If the output type is the same as the input type, then the select predicate, just returns the input item
            // 2. If the output type has a constructor that takes one parameter which is assignable from the input type, then the predicate creates a new output type by calling the constructor
            // 3. If the output type has a default constructor, then the predicate creates a new output type by calling the default constructor
            // 4. If none of the above apply, then the select predicate defaults to a delegate, which is just maps every input to null
            Type outputType = typeof(TOutput);
            ConstructorInfo outputTypeConstructorInfo = outputType.GetConstructors().Where(constructorInfo => !constructorInfo.ContainsGenericParameters && constructorInfo.GetParameters().Count() == 1 && constructorInfo.GetParameters().First().ParameterType.GetTypeInfo().IsAssignableFrom(typeof(TInput).GetTypeInfo())).FirstOrDefault();
            ConstructorInfo outputTypeDefaultConstructorInfo = outputType.GetConstructors().Where(constructorInfo => constructorInfo.GetParameters().Count() == 0).FirstOrDefault();
            if (selectPredicate != null)
                this.selectPredicate = selectPredicate;
            else if (typeof(TInput) == typeof(TOutput))
                this.selectPredicate = input => (TOutput)Convert.ChangeType(input, outputType);
            else if (outputTypeConstructorInfo != null)
                this.selectPredicate = input => (TOutput)outputTypeConstructorInfo.Invoke(new object[] { input });
            else if (outputTypeDefaultConstructorInfo != null)
                this.selectPredicate = input => (TOutput)outputTypeDefaultConstructorInfo.Invoke(new object[0]);
            else
                this.selectPredicate = input => default(TOutput);

            // Initializes the derived collection by adding the initial content of the collection retrieved as a constructor parameter
            List<TOutput> initialContent = new List<TOutput>();
            foreach (TInput item in reactiveCollection)
            {
                Guid initialInputItemGuid = Guid.NewGuid();
                this.inputItemMap.Add(initialInputItemGuid);
                if (this.wherePredicate(item))
                {
                    this.outputItemMap.Add(initialInputItemGuid);
                    initialContent.Add(this.selectPredicate(item));
                }
            }
            this.Collection = initialContent;

            // Everytime the input reactive collection changes, the derived collection changes
            (reactiveCollection as INotifyCollectionChanged).CollectionChanged += (sender, e) =>
            {
                // Creates some local variables that are needed in the algorithm
                TInput inputItem = default(TInput);
                Guid inputItemGuid = Guid.Empty;
                bool isInDerivedCollection = false;
                TOutput outputItem = default(TOutput);

                // Checks kind of change took place in the input reactive collection and performs the same operation on the derived reactive collection
                switch (e.Action)
                {
                    case NotifyCollectionChangedAction.Add:

                        // Converts the new item that was added to the type TOutput
                        inputItem = (TInput)e.NewItems[0];
                        inputItemGuid = Guid.NewGuid();
                        isInDerivedCollection = this.wherePredicate(inputItem);
                        outputItem = isInDerivedCollection ? this.selectPredicate(inputItem) : default(TOutput);

                        // There are two cases when a new element was added, either the item was added to the end of the original reactive collection or it was inserted at a specific index
                        if (e.NewStartingIndex == -1)
                        {
                            if (isInDerivedCollection)
                            {
                                this.Add(outputItem);
                                this.outputItemMap.Add(inputItemGuid);
                            }
                            this.inputItemMap.Add(inputItemGuid);
                        }
                        else
                        {
                            // Checks if the new item is in the derived reactive collection, if so then it is inserted
                            if (isInDerivedCollection)
                            {
                                // At first the index has to be determined, this is done by finding the index of the first predecessor of the new item that is in the derived reactive collection
                                int newIndex = -1;
                                for (int i = e.NewStartingIndex; i >= 0; i--)
                                {
                                    newIndex = this.outputItemMap.IndexOf(this.inputItemMap[i]);
                                    if (newIndex != -1)
                                        break;
                                }
                                newIndex = newIndex == -1 ? 0 : newIndex + 1;

                                // Inserts the item at the index that was determined
                                this.Insert(newIndex, outputItem);
                                this.outputItemMap.Insert(newIndex, inputItemGuid);
                            }

                            // Adds the GUID that uniquely identifies the new input item in the input item map
                            this.inputItemMap.Insert(e.NewStartingIndex, inputItemGuid);
                        }
                        break;

                    case NotifyCollectionChangedAction.Remove:

                        // Gets the GUID, which uniquely identifies the input item that was removed
                        inputItemGuid = this.inputItemMap[e.OldStartingIndex];

                        // Removes the input item GUID from the input item map, because it is no longer in the input reactive collection
                        this.inputItemMap.Remove(inputItemGuid);

                        // Checks an output item was generated for the input item, if so then it is removed from the output item map and the derived collection
                        int outputItemIndex = this.outputItemMap.IndexOf(inputItemGuid);
                        if (outputItemIndex != -1)
                        {
                            this.outputItemMap.RemoveAt(outputItemIndex);
                            this.RemoveAt(outputItemIndex);
                        }
                        break;

                    case NotifyCollectionChangedAction.Replace:

                        // Converts the new item that was added to the type TOutput
                        inputItem = (TInput)e.NewItems[0];
                        inputItemGuid = Guid.NewGuid();
                        isInDerivedCollection = this.wherePredicate(inputItem);
                        outputItem = isInDerivedCollection ? this.selectPredicate(inputItem) : default(TOutput);

                        // Gets the index of the old item in the derived reactive collection
                        outputItemIndex = this.outputItemMap.IndexOf(this.inputItemMap[e.NewStartingIndex]);

                        // Checks if the old item is currently in the derived reactive collection, if not then it is added, otherwise it replaced
                        if (outputItemIndex == -1)
                        {
                            // Checks if the item, the old item is to be replaced with, should be added to the derived reactive collection, if so then it is inserted at the correct position
                            if (isInDerivedCollection)
                            {
                                // At first the index has to be determined, this is done by finding the index of the first predecessor of the new item that is in the derived reactive collection
                                int newIndex = -1;
                                for (int i = e.NewStartingIndex; i >= 0; i--)
                                {
                                    newIndex = this.outputItemMap.IndexOf(this.inputItemMap[i]);
                                    if (newIndex != -1)
                                        break;
                                }
                                newIndex = newIndex == -1 ? 0 : newIndex + 1;

                                // Inserts the item at the index that was determined
                                this.Insert(newIndex, outputItem);
                                this.outputItemMap.Insert(newIndex, inputItemGuid);
                            }
                        }
                        else
                        {
                            // Checks if the item, the old item is to be replaced with, should be added to the derived reactive collection, if so then it is replaced, otherwise the old item is removed
                            if (isInDerivedCollection)
                            {
                                base[outputItemIndex] = outputItem;
                                this.outputItemMap[outputItemIndex] = inputItemGuid;
                            }
                            else
                            {
                                this.RemoveAt(outputItemIndex);
                                this.outputItemMap.RemoveAt(outputItemIndex);
                            }
                        }

                        // Replaces the old item with the new one in the input item map
                        this.inputItemMap[e.NewStartingIndex] = inputItemGuid;
                        break;

                    case NotifyCollectionChangedAction.Reset:

                        // Clears the maps, which were used to map from input items to output items
                        this.inputItemMap.Clear();
                        this.outputItemMap.Clear();

                        // Clears the derived collection
                        this.Clear();

                        // Rebuilds the whole reactive collection
                        List<TOutput> newContent = new List<TOutput>();
                        foreach (TInput item in reactiveCollection)
                        {
                            Guid initialInputItemGuid = Guid.NewGuid();
                            this.inputItemMap.Add(initialInputItemGuid);
                            if (this.wherePredicate(item))
                            {
                                this.outputItemMap.Add(initialInputItemGuid);
                                newContent.Add(this.selectPredicate(item));
                            }
                        }
                        this.AddRange(newContent);
                        break;
                }
            };
        }

        /// <summary>
        /// Initializes a new <see cref="DerivedReactiveCollection{TInput, TOutput}"/> instance.
        /// </summary>
        /// <param name="reactiveCollection">The reactive collection on which the derived reactive collection is based.</param>
        /// <param name="wherePredicate">The delegate, which is used to filter the source reactive collection.</param>
        public DerivedReactiveCollection(IReactiveCollection<TInput> reactiveCollection, Func<TInput, bool> wherePredicate)
            : this(reactiveCollection, wherePredicate, null)
        { }

        /// <summary>
        /// Initializes a new <see cref="DerivedReactiveCollection{TInput, TOutput}"/> instance.
        /// </summary>
        /// <param name="reactiveCollection">The reactive collection on which the derived reactive collection is based.</param>
        /// <param name="selectPredicate">The delegate, which is used to map the elements of the source reactive collection to the target type of the derived reactive collection.</param>
        public DerivedReactiveCollection(IReactiveCollection<TInput> reactiveCollection, Func<TInput, TOutput> selectPredicate)
            : this(reactiveCollection, null, selectPredicate)
        { }

        /// <summary>
        /// Initializes a new <see cref="DerivedReactiveCollection{TInput, TOutput}"/> instance.
        /// </summary>
        /// <param name="reactiveCollection">The reactive collection on which the derived reactive collection is based.</param>
        public DerivedReactiveCollection(IReactiveCollection<TInput> reactiveCollection)
            : this(reactiveCollection, null, null)
        { }

        #endregion

        #region Private Fields

        /// <summary>
        /// Contains a map, which contains for each input element a GUID, which uniquely identifies the item (this is needed, because the input collection may contain the same element multiple times are different indices).
        /// </summary>
        private readonly List<Guid> inputItemMap = new List<Guid>();

        /// <summary>
        /// Contains a map, which contains for each output element the GUID that uniquely identifies the input item it derived from.
        /// </summary>
        private readonly List<Guid> outputItemMap = new List<Guid>();

        /// <summary>
        /// Contains the delegate, which is used to filter the source reactive collection.
        /// </summary>
        private readonly Func<TInput, bool> wherePredicate;

        /// <summary>
        /// Contains the delegate, which is used to map the elements of the source reactive collection to the target type of the derived reactive collection.
        /// </summary>
        private readonly Func<TInput, TOutput> selectPredicate;

        #endregion
    }
}


text:
require 'test_helper'

class DeliveryHelperTest < ActionView::TestCase
end


text: from EventDetector import EventDetector


text:
title: Develop customized solution
description: We gather the requirements and implement your idea from scratch. You can keep the focus on client satisfaction and core business.
img: 2.png
alt: Develop customized solution
---


text:
import socketio from 'socket.io'
import semafor from 'semafor'
import os from 'os'
import http from 'http'
import express from 'express'
import path from 'path'

export default function server(port) {
  let logger = semafor()
  let app = express();
  let server = http.Server(app);
  let io = socketio(server);

  let public_path =  path.join(__dirname, '..', 'public')
  app.use(express.static(public_path))

  let ifaces = os.networkInterfaces()
  let en1 = ifaces["en1"]
  let local_ip
  for(let i in en1){
    var addr = en1[i]
    if(addr.family != "IPv4") continue
    local_ip = ["http", addr.address].join("://")
    break;
  }
  let namespace = [local_ip, port].join(":")

  io.on("connection", (socket) => {
    let _card = {};
    socket.on("greetings", (card) => {
      _card = card
      io.emit("greetings", card)
    })
    socket.on("dump", (log) => {
      io.emit("dump", log)
    })
    socket.on("disconnect", () => {
      io.emit("goodbye", _card)
    })
  })

  server.listen(port, () => {
    logger.ok(`Server running on ${namespace}`)
  })
}


text:
Computing Frame Works
=======================
Hadoop & YARN
-------------

Spark
-------------
Spark + H2O = Sparkling Watr

Cloud Computing
---------------
Setting up H2O on EC2
Accessing S3 for data storage


text:
namespace Orchard.Alias.Records {
    public class AliasRecord {
        public virtual int Id { get; set; }
        public virtual string Path { get; set; }
        public virtual ActionRecord Action { get; set; }
        public virtual string RouteValues { get; set; }
        public virtual string Source { get; set; }
        public virtual bool IsManaged { get; set; }
    }
}