text:
class AnalogDecoder
{
  public:
    AnalogDecoder() = default;

    void handleMagnitude(float value);
    void setCallback(std::function<void(char)> cb) {m_cb = cb;};

  private:
    std::function<void(char)> m_cb;

    int m_discardedSamples = 0;
    float m_ookMax = 0.0;
    float m_val = 0.0;
};

#endif

redpajama_set_name: RedPajamaGithub


text:
- Fix the asynchronous writeFile bug
## 0.3.1
- Fix wrong notifications
## 0.3.0
Add sm.ms uploader
## 0.1.0
First Release


text:
package core

import org.scalatest.FunSuite
import org.junit.runner.RunWith
import org.scalatest.junit.JUnitRunner
import models.Session
import models.Tick
import org.joda.time.DateTime
import org.joda.time.DateTimeConstants

@RunWith(classOf[JUnitRunner])
class TariffCalculatorTest extends FunSuite with Fixtures {

  test("Monday morning before 6AM has Tariff3") {

    val a = now.withDayOfWeek(DateTimeConstants.MONDAY).withHourOfDay(3)
    val b = a.plusMillis(100)

    val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
    val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
    val intervals = Calculator.getTariffIntervals(previous, current)

    assert(intervals.head.fromTariff == Tariff3)
    assert(intervals.last.fromTariff == Tariff3)
    assert(intervals.size == 1)
  }

  test("Monday between 6AM and 8PM has Tariff1") {

    val a = now.withDayOfWeek(DateTimeConstants.MONDAY).withHourOfDay(10)
    val b = a.plusMillis(100)

    val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
    val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
    val intervals = Calculator.getTariffIntervals(previous, current)

    assert(intervals.head.fromTariff == Tariff1)
    assert(intervals.last.fromTariff == Tariff1)
    assert(intervals.size == 1)
  }

  test("Weekday morning before 6AM has Tariff3") {

    jodaWeekdays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(3)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff3)
      assert(intervals.last.fromTariff == Tariff3)
      assert(intervals.size == 1)
    })
  }

  test("Weekday between 6AM and 8PM has Tariff1") {

    jodaWeekdays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(10)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff1)
      assert(intervals.last.fromTariff == Tariff1)
      assert(intervals.size == 1)
    })
  }

  test("Weekday between 8PM and 10PM has Tariff2") {

    jodaWeekdays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(21)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff2)
      assert(intervals.last.fromTariff == Tariff2)
      assert(intervals.size == 1)
    })
  }

  test("Weekday after 10PM has Tariff3") {

    jodaWeekdays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(23)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff3)
      assert(intervals.last.fromTariff == Tariff3)
      assert(intervals.size == 1)
    })
  }

  test("Weekend morning before 6AM has Tariff3") {

    jodaWeekendDays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(3)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff3)
      assert(intervals.last.fromTariff == Tariff3)
      assert(intervals.size == 1)
    })
  }

  test("Weekend between 6AM and 10PM has Tariff2") {

    jodaWeekendDays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(10)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff2)
      assert(intervals.last.fromTariff == Tariff2)
      assert(intervals.size == 1)
    })
  }

  test("Weekend after 10PM has Tariff3") {

    jodaWeekendDays.map(now.withDayOfWeek(_)).foreach(day => {
      val a = day.withHourOfDay(23)
      val b = a.plusMillis(100)

      val previous = Session("test1", Tick(at = Some(a.getMillis()), odo = 0))
      val current = Session("test1", Tick(at = Some(b.getMillis()), odo = 0))
      val intervals = Calculator.getTariffIntervals(previous, current)

      assert(intervals.head.fromTariff == Tariff3)
      assert(intervals.last.fromTariff == Tariff3)
      assert(intervals.size == 1)
    })
  }
}


text:
package org.fusesource.camel.component.sap.model.rfc.impl;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.fusesource.camel.component.sap.model.rfc.RfcPackage;
import org.fusesource.camel.component.sap.model.rfc.Structure;
import org.fusesource.camel.component.sap.model.rfc.Table;

/**
 *  An implementation of the model object '
 * Table'.
 *

 * The following features are implemented:
 *

 *
{@link org.fusesource.camel.component.sap.model.rfc.impl.TableImpl#getName Name}

 *
{@link org.fusesource.camel.component.sap.model.rfc.impl.TableImpl#getLineType Line Type}

 *

 *

 *
 * @generated
 */
public class TableImpl<S extends Structure> extends EObjectImpl implements
		Table<S> {
	/**
	 * The default value of the '{@link #getName() Name}' attribute.
	 *
	 *
	 * @see #getName()
	 * @generated
	 * @ordered
	 */
	protected static final String NAME_EDEFAULT = null;
	/**
	 * The default value of the '{@link #getLineType() Line Type}' attribute.
	 *
	 *
	 * @see #getLineType()
	 * @generated
	 * @ordered
	 */
	protected static final String LINE_TYPE_EDEFAULT = null;

	/**
	 *
	 * @generated
	 */
	protected TableImpl() {
		super();
	}

	/**
	 *
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return RfcPackage.Literals.TABLE;
	}

	/**
	 *
	 *
	 * @generated NOT
	 */
	public String getName() {
		String name = null;
		EAnnotation idocAnnotation = eClass().getEAnnotation(RfcPackage.eNS_URI);
		if (idocAnnotation != null) {
			name = idocAnnotation.getDetails().get("name");
		}
		return name;
	}

	/**
	 *
	 *
	 * @generated NOT
	 */
	public void setName(String newName) {
		// NOOP
	}

	/**
	 *
	 *
	 * @generated NOT
	 */
	public String getLineType() {
		String lineType = null;
		EAnnotation idocAnnotation = eClass().getEAnnotation(RfcPackage.eNS_URI);
		if (idocAnnotation != null) {
			lineType = idocAnnotation.getDetails().get("lineType");
		}
		return lineType;
	}

	/**
	 *
	 *
	 * @generated NOT
	 */
	public void setLineType(String newLineType) {
		// NOOP
	}

	/**
	 * @generated NOT
	 */
	@SuppressWarnings("unchecked")
	public EList<S> getRows() {
		EStructuralFeature feature = eClass().getEStructuralFeature("row");
		Object value = eGet(feature);
		if (value == null) {
			EClass eClass = ((EReference) feature).getEReferenceType();
			value = eClass.getEPackage().getEFactoryInstance().create(eClass);
			eSet(feature, value);
		}
		return (EList<S>) value;
	}

	/**
	 *
	 *
	 * @generated NOT
	 */
	public S getRow(int index) {
		return (S) get(index);
	}

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

	@Override
	public boolean isEmpty() {
		return getRows().isEmpty();
	}

	@Override
	public boolean contains(Object o) {
		return getRows().contains(0);
	}

	@Override
	public Iterator<S> iterator() {
		return getRows().iterator();
	}

	@Override
	public Object[] toArray() {
		return getRows().toArray();
	}

	@Override
	public <T> T[] toArray(T[] a) {
		return getRows().toArray(a);
	}

	public S add() {
		S newRow = createNewRow();
		getRows().add(newRow);
		return newRow;
	}

	public S add(int index) {
		S newRow = createNewRow();
		getRows().add(index, newRow);
		return newRow;
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case RfcPackage.TABLE__NAME:
				return getName();
			case RfcPackage.TABLE__LINE_TYPE:
				return getLineType();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case RfcPackage.TABLE__NAME:
				setName((String)newValue);
				return;
			case RfcPackage.TABLE__LINE_TYPE:
				setLineType((String)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case RfcPackage.TABLE__NAME:
				setName(NAME_EDEFAULT);
				return;
			case RfcPackage.TABLE__LINE_TYPE:
				setLineType(LINE_TYPE_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case RfcPackage.TABLE__NAME:
				return NAME_EDEFAULT == null ? getName() != null : !NAME_EDEFAULT.equals(getName());
			case RfcPackage.TABLE__LINE_TYPE:
				return LINE_TYPE_EDEFAULT == null ? getLineType() != null : !LINE_TYPE_EDEFAULT.equals(getLineType());
		}
		return super.eIsSet(featureID);
	}

	@Override
	public boolean add(S e) {
		return getRows().add(e);
	}

	@Override
	public boolean remove(Object o) {
		return getRows().remove(o);
	}

	@Override
	public boolean containsAll(Collection<?> c) {
		return getRows().containsAll(c);
	}

	@Override
	public boolean addAll(Collection<? extends S> c) {
		return getRows().addAll(c);
	}

	@Override
	public boolean addAll(int index, Collection<? extends S> c) {
		return getRows().addAll(index, c);
	}

	@Override
	public boolean removeAll(Collection<?> c) {
		return getRows().removeAll(c);
	}

	@Override
	public boolean retainAll(Collection<?> c) {
		return getRows().retainAll(c);
	}

	@Override
	public void clear() {
		getRows().clear();
	}

	@Override
	public S get(int index) {
		return getRows().get(index);
	}

	@Override
	public S set(int index, S element) {
		return getRows().set(index, element);
	}

	@Override
	public void add(int index, S element) {
		getRows().add(index, element);
	}

	@Override
	public S remove(int index) {
		return getRows().remove(index);
	}

	@Override
	public int indexOf(Object o) {
		return getRows().indexOf(o);
	}

	@Override
	public int lastIndexOf(Object o) {
		return getRows().lastIndexOf(o);
	}

	@Override
	public ListIterator<S> listIterator() {
		return getRows().listIterator();
	}

	@Override
	public ListIterator<S> listIterator(int index) {
		return getRows().listIterator(index);
	}

	@Override
	public List<S> subList(int fromIndex, int toIndex) {
		return getRows().subList(fromIndex, toIndex);
	}

	@SuppressWarnings("unchecked")
	protected S createNewRow() {
		EStructuralFeature feature = eClass().getEStructuralFeature("row");
		if (feature == null || !(feature instanceof EReference)) {
			return null;
		}

		EClass rowType = ((EReference) feature).getEReferenceType();

		return (S) rowType.getEPackage().getEFactoryInstance().create(rowType);
	}

} // TableImpl


text:
puushit
=======

A small script designed for puush.me integration in minimalist window managers.


text:
<?php

error_reporting(E_ALL);
ini_set('display_errors', 'on');
require_once '../src/Pretty4.inc.php';

use \net\shawn_huang\pretty as p;
use \net\shawn_huang\pretty\Config;
/**
 * @runInSeparateProcess
 */
class FilterTest extends \PHPUnit_Framework_TestCase {

    private $baseConfig;
    public function setup() {
        $this->baseConfig = [
            'class.path' => __DIR__ . '/test_classes',
        ];
    }

    public function testByPathInfo() {
        $_SERVER['PATH_INFO'] = '/sub/index';
        $this->expectOutputString(json_encode(['foo' => 'foo', 'holy' => 'crap']));
        p\Framework::instance($this->baseConfig)->start();

    }

}


text:
<?php

namespace Drest\Mapping;

use Doctrine\Common\Cache\Cache;
use Drest\DrestException;
use Drest\Mapping\Driver\DriverInterface;

class MetadataFactory
{

    /**
     * Driver attached to this meta data factory
     * @var \Drest\Mapping\Driver\DriverInterface $driver
     */
    private $driver;

    /**
     * Cache used to prevent metadata reloading
     * @var \Doctrine\Common\Cache\Cache $cache
     */
    private $cache;

    /**
     * A prefix string to use when interacting with a Doctrine cache object
     * @var string $cache_prefix
     */
    private $cache_prefix = '_drest_';

    /**
     * Metadata that has already been loaded by the driver
     * @var array $loadedMetadata
     */
    private $loadedMetadata = [];

    /**
     * @param DriverInterface $driver
     */
    public function __construct(DriverInterface $driver)
    {
        $this->driver = $driver;
    }

    /**
     * Set the doctrine cache drive to be user
     * @param Cache $cache
     */
    public function setCache(Cache $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Get all class names
     * @return array class names registered to this driver
     */
    public function getAllClassNames()
    {
        return $this->driver->getAllClassNames();
    }

    /**
     * Get metadata for a certain class - loads once and caches
     * @param  string                $className
     * @throws \Drest\DrestException
     * @return ClassMetaData         $metaData
     */
    public function getMetadataForClass($className)
    {
        if (isset($this->loadedMetadata[$className])) {
            return $this->loadedMetadata[$className];
        }

        // check the cache
        if ($this->cache !== null) {
            $classMetadata = $this->cache->fetch($this->cache_prefix . $className);
            if ($classMetadata instanceof ClassMetaData) {
                if ($classMetadata->expired()) {
                    $this->cache->delete($this->cache_prefix . $className);
                } else {
                    $this->loadedMetadata[$className] = $classMetadata;

                    return $classMetadata;
                }
            }
        }

        $classMetadata = $this->driver->loadMetadataForClass($className);
        if ($classMetadata !== null) {
            $this->loadedMetadata[$className] = $classMetadata;
            if ($this->cache !== null) {
                $this->cache->save($this->cache_prefix . $className, $classMetadata);
            }

            return $classMetadata;
        }

        if (!isset($this->loadedMetadata[$className])) {
            throw DrestException::unableToLoadMetaDataFromDriver();
        }

        return $this->loadedMetadata[$className];
    }
}


text:
package oauth2

import (
	"net/http"
)

// ClientConfig is used to configure a client.
type ClientConfig struct {
	BaseURI               string
	TokenEndpoint         string
	IntrospectionEndpoint string
	RevocationEndpoint    string
	ResponseLimit         int64
}

// Default will return a default configuration.
func Default(baseURI string) ClientConfig {
	return ClientConfig{
		BaseURI:               baseURI,
		TokenEndpoint:         "/oauth2/token",
		IntrospectionEndpoint: "/oauth2/introspect",
		RevocationEndpoint:    "/oauth2/revoke",
	}
}

// Client is a low-level OAuth2 client.
type Client struct {
	config ClientConfig
	client *http.Client
}

// NewClient will create and return a new client.
func NewClient(config ClientConfig) *Client {
	return NewClientWithClient(config, new(http.Client))
}

// NewClientWithClient will create and return an new client using the provided
// client.
func NewClientWithClient(config ClientConfig, client *http.Client) *Client {
	// set default response limit
	if config.ResponseLimit == 0 {
		config.ResponseLimit = 2048
	}

	return &Client{
		config: config,
		client: client,
	}
}

// Authenticate will send the provided token request and return the servers
// token response or an error if failed.
func (c *Client) Authenticate(trq TokenRequest) (*TokenResponse, error) {
	// prepare endpoint
	endpoint := c.config.BaseURI + c.config.TokenEndpoint

	// build request
	req, err := BuildTokenRequest(endpoint, trq)
	if err != nil {
		return nil, err
	}

	// perform request
	res, err := c.client.Do(req)
	if err != nil {
		return nil, err
	}

	// ensure body is closed
	defer res.Body.Close()

	// check status
	if res.StatusCode != http.StatusOK {
		return nil, ParseRequestError(res, c.config.ResponseLimit)
	}

	// parse response
	trs, err := ParseTokenResponse(res, c.config.ResponseLimit)
	if err != nil {
		return nil, err
	}

	return trs, nil
}

// Introspect will send the provided introspection request and return the servers
// response of an error if failed.
func (c *Client) Introspect(irq IntrospectionRequest) (*IntrospectionResponse, error) {
	// prepare endpoint
	endpoint := c.config.BaseURI + c.config.IntrospectionEndpoint

	// build request
	req, err := BuildIntrospectionRequest(endpoint, irq)
	if err != nil {
		return nil, err
	}

	// perform request
	res, err := c.client.Do(req)
	if err != nil {
		return nil, err
	}

	// ensure body is closed
	defer res.Body.Close()

	// check status
	if res.StatusCode != http.StatusOK {
		return nil, ParseRequestError(res, c.config.ResponseLimit)
	}

	// parse response
	irs, err := ParseIntrospectionResponse(res, c.config.ResponseLimit)
	if err != nil {
		return nil, err
	}

	return irs, nil
}

// Revoke will send the provided revocation request and return and error if it
// failed.
func (c *Client) Revoke(rrq RevocationRequest) error {
	// prepare endpoint
	endpoint := c.config.BaseURI + c.config.RevocationEndpoint

	// build request
	req, err := BuildRevocationRequest(endpoint, rrq)
	if err != nil {
		return err
	}

	// perform request
	res, err := c.client.Do(req)
	if err != nil {
		return err
	}

	// ensure body is closed
	defer res.Body.Close()

	// check status
	if res.StatusCode != http.StatusOK {
		return ParseRequestError(res, c.config.ResponseLimit)
	}

	return nil
}


text:
<?php

namespace Magento\Framework\ObjectManager;

/**
 * Marker interface, used to identify proxies for which we don't need to generate interceptors
 */
interface NoninterceptableInterface
{
}


text:
<?php

namespace CodePrimer\Tests\Functional;

use CodePrimer\Model\BusinessBundle;
use CodePrimer\Template\Artifact;

/**
 * Class ConfigurationTemplatesTest.
 *
 * @group functional
 */
class ConfigurationTemplatesTest extends TemplateTestCase
{
    const PHP_EXPECTED_DIR = self::EXPECTED_DIR.'configuration/php/';

    /**
     * @dataProvider configurationTemplateProvider
     *
     * @throws \Exception
     */
    public function testPhpConfigurationTemplate(Artifact $artifact, string $expectedFile)
    {
        $this->businessBundle = new BusinessBundle('CodePrimer Tests', 'FunctionalTest');
        $this->businessBundle->setDescription('This is a sample BusinessBundle used to test CodePrimer functionality');

        // Extract the template to use for this artifact
        $template = $this->templateRegistry->getTemplateForArtifact($artifact);
        self::assertNotNull($template);

        // Extract the builder to use for this artifact
        $builder = $this->factory->createBuilder($artifact);
        self::assertNotNull($builder);

        // Build the artifacts
        $builder->build($this->businessBundle, $template, $this->renderer);

        // Make sure the right files have been generated
        $this->assertGeneratedFile($expectedFile, self::PHP_EXPECTED_DIR.$artifact->getType().'/');
    }

    public function configurationTemplateProvider()
    {
        return [
            'composer.json' => [
                new Artifact(Artifact::CONFIGURATION, 'dependency manager', 'PHP', 'composer'),
                'composer.json',
            ],
            '.php_cs' => [
                new Artifact(Artifact::CONFIGURATION, 'coding standards', 'PHP', 'PHP CS Fixer'),
                '.php_cs.dist',
            ],
            'phpunit.xml.dist' => [
                new Artifact(Artifact::CONFIGURATION, 'tests', 'PHP', 'PHPUnit'),
                'phpunit.xml.dist',
            ],
            '.gitignore' => [
                new Artifact(Artifact::CONFIGURATION, 'git', 'php', 'gitignore'),
                '.gitignore',
            ],
            'validate-master.yml' => [
                new Artifact(Artifact::CONFIGURATION, 'github', 'php', 'validate-master'),
                '.github/workflows/validate-master.yml',
            ],
            'validate-pr.yml' => [
                new Artifact(Artifact::CONFIGURATION, 'github', 'php', 'validate-pr'),
                '.github/workflows/validate-pr.yml',
            ],
            'codeprimer/bundle.php' => [
                new Artifact(Artifact::CONFIGURATION, 'codeprimer', 'php', 'bundle'),
                'codeprimer/bundle.php',
            ],
            'codeprimer/BusinessModelFactory.php' => [
                new Artifact(Artifact::CONFIGURATION, 'codeprimer', 'php', 'BusinessModelFactory'),
                'codeprimer/BusinessModelFactory.php',
            ],
            'codeprimer/BusinessProcessFactory.php' => [
                new Artifact(Artifact::CONFIGURATION, 'codeprimer', 'php', 'BusinessProcessFactory'),
                'codeprimer/BusinessProcessFactory.php',
            ],
            'codeprimer/DatasetFactory.php' => [
                new Artifact(Artifact::CONFIGURATION, 'codeprimer', 'php', 'DatasetFactory'),
                'codeprimer/DatasetFactory.php',
            ],
        ];
    }
}


text:
<?php
get_header();
?>

			<big><?php _e('Oops..  404 Error', 'swift' ) ?> </big>

			<?php _e( 'It seems the page you were trying to find on my site isn\'t around anymore (or at least around here).', 'swift' ); ?>

			<?php _e( 'Report it missing using my contact form and I\'ll see what I can do about it.', 'swift' ); ?>

			<?php _e( 'Whilst you are here why not use the resources below? You never know, you may just find what you were looking for.', 'swift' ); ?>

		<?php get_template_part( 'lib/includes/listing-4-404');?>

<?php //get_sidebar(); ?>
<?php get_footer(); ?>


text:
// Provides control sap.m.GroupHeaderListItem.
sap.ui.define(["sap/ui/core/library", "./library", "./ListItemBase", "./GroupHeaderListItemRenderer"],
	function(coreLibrary, library, ListItemBase, GroupHeaderListItemRenderer) {
	"use strict";

	// shortcut for sap.m.ListMode
	var ListMode = library.ListMode;

	// shortcut for sap.ui.core.TextDirection
	var TextDirection = coreLibrary.TextDirection;

	/**
	 * Constructor for a new GroupHeaderListItem.
	 *
	 * @param {string} [sId] Id for the new control, generated automatically if no id is given
	 * @param {object} [mSettings] Initial settings for the new control
	 *
	 * @class
	 * sap.m.GroupHeaderListItem is used to display the title of a group and act as separator between groups in sap.m.List and sap.m.Table.
	 * Note: The inherited properties unread, selected, counter and press event from sap.m.ListItemBase are not supported.
	 *
	 * @extends sap.m.ListItemBase
	 *
	 * @author SAP SE
	 * @version ${version}
	 *
	 * @constructor
	 * @public
	 * @since 1.12
	 * @alias sap.m.GroupHeaderListItem
	 */
	var GroupHeaderListItem = ListItemBase.extend("sap.m.GroupHeaderListItem", /** @lends sap.m.GroupHeaderListItem.prototype */ {
		metadata : {

			library : "sap.m",
			properties : {

				/**
				 * Defines the title of the group header.
				 */
				title : {type : "string", group : "Data", defaultValue : null},

				/**
				 * Defines the count of items in the group, but it could also be an amount which represents the sum of all amounts in the group.
				 * Note: Will not be displayed if not set.
				 */
				count : {type : "string", group : "Data", defaultValue : null},

				/**
				 * Allows to uppercase the group title.
				 * @since 1.13.2
				 * @deprecated Since version 1.40.10
				 */
				upperCase : {type : "boolean", group : "Appearance", defaultValue : false, deprecated: true},

				/**
				 * Defines the title text directionality with enumerated options. By default, the control inherits text direction from the DOM.
				 * @since 1.28.0
				 */
				titleTextDirection : {type : "sap.ui.core.TextDirection", group : "Appearance", defaultValue : TextDirection.Inherit}
			}
		},

		renderer: GroupHeaderListItemRenderer
	});

	// GroupHeaderListItem does not respect the list mode
	GroupHeaderListItem.prototype.getMode = function() {
		return ListMode.None;
	};

	GroupHeaderListItem.prototype.shouldClearLastValue = function() {
		return true;
	};

	// returns responsible table control for the item
	GroupHeaderListItem.prototype.getTable = function() {
		var oParent = this.getParent();
		if (oParent && oParent.isA("sap.m.Table")) {
			return oParent;
		}
	};

	GroupHeaderListItem.prototype.onBeforeRendering = function() {
		var oTable = this.getTable();
		if (oTable) {
			// clear column last value to reset cell merging
			oTable.getColumns().forEach(function(oColumn) {
				oColumn.clearLastValue();
			});

			// defines the tag name
			this.TagName = "tr";
		}
	};

	GroupHeaderListItem.prototype.getAccessibilityType = function(oBundle) {
		var sType = this.getTable() ? "ROW" : "LISTITEM";
		return oBundle.getText("LIST_ITEM_GROUP_HEADER") + " " + oBundle.getText("ACC_CTR_TYPE_" + sType);
	};

	GroupHeaderListItem.prototype.getContentAnnouncement = function() {
		return this.getTitle();
	};

	// group header has no group announcement
	GroupHeaderListItem.prototype.getGroupAnnouncement = function() {};

	return GroupHeaderListItem;

});


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const pip_services3_components_node_1 = require("pip-services3-components-node");
const pip_services3_commons_node_1 = require("pip-services3-commons-node");
const QuotesMongoDbPersistence_1 = require("../persistence/QuotesMongoDbPersistence");
const QuotesFilePersistence_1 = require("../persistence/QuotesFilePersistence");
const QuotesMemoryPersistence_1 = require("../persistence/QuotesMemoryPersistence");
const QuotesController_1 = require("../logic/QuotesController");
const QuotesHttpServiceV1_1 = require("../services/version1/QuotesHttpServiceV1");
class QuotesServiceFactory extends pip_services3_components_node_1.Factory {
    constructor() {
        super();
        this.registerAsType(QuotesServiceFactory.MemoryPersistenceDescriptor, QuotesMemoryPersistence_1.QuotesMemoryPersistence);
        this.registerAsType(QuotesServiceFactory.FilePersistenceDescriptor, QuotesFilePersistence_1.QuotesFilePersistence);
        this.registerAsType(QuotesServiceFactory.MongoDbPersistenceDescriptor, QuotesMongoDbPersistence_1.QuotesMongoDbPersistence);
        this.registerAsType(QuotesServiceFactory.ControllerDescriptor, QuotesController_1.QuotesController);
        this.registerAsType(QuotesServiceFactory.HttpServiceDescriptor, QuotesHttpServiceV1_1.QuotesHttpServiceV1);
    }
}
exports.QuotesServiceFactory = QuotesServiceFactory;
QuotesServiceFactory.Descriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "factory", "default", "default", "1.0");
QuotesServiceFactory.MemoryPersistenceDescriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "persistence", "memory", "*", "1.0");
QuotesServiceFactory.FilePersistenceDescriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "persistence", "file", "*", "1.0");
QuotesServiceFactory.MongoDbPersistenceDescriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "persistence", "mongodb", "*", "1.0");
QuotesServiceFactory.ControllerDescriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "controller", "default", "*", "1.0");
QuotesServiceFactory.HttpServiceDescriptor = new pip_services3_commons_node_1.Descriptor("pip-services-quotes", "service", "http", "*", "1.0");
//# sourceMappingURL=QuotesServiceFactory.js.map


text:
'use strict';

var compileSchema = require('./compile')
    , resolve = require('./compile/resolve')
    , Cache = require('./cache')
    , SchemaObject = require('./compile/schema_obj')
    , stableStringify = require('json-stable-stringify')
    , formats = require('./compile/formats');

module.exports = Ajv;

var META_SCHEMA_ID = 'http://json-schema.org/draft-04/schema';
var SCHEMA_URI_FORMAT = /^(?:(?:[a-z][a-z0-9+-.]*:)?\/\/)?[^\s]*$/i;
function SCHEMA_URI_FORMAT_FUNC(str) {
    return SCHEMA_URI_FORMAT.test(str);
}

/**
 * Creates validator instance.
 * Usage: `Ajv(opts)`
 * @param {Object} opts optional options
 * @return {Object} ajv instance
 */
function Ajv(opts) {
    if (!(this instanceof Ajv)) return new Ajv(opts);
    var self = this;

    this.opts = opts || {};
    this._schemas = {};
    this._refs = {};
    this._formats = formats(this.opts.format);
    this._cache = this.opts.cache || new Cache;
    this._loadingSchemas = {};

    // this is done on purpose, so that methods are bound to the instance
    // (without using bind) so that they can be used without the instance
    this.validate = validate;
    this.compile = compile;
    this.compileAsync = compileAsync;
    this.addSchema = addSchema;
    this.addMetaSchema = addMetaSchema;
    this.validateSchema = validateSchema;
    this.getSchema = getSchema;
    this.removeSchema = removeSchema;
    this.addFormat = addFormat;
    this.errorsText = errorsText;

    this._compile = _compile;

    addInitialSchemas();
    if (this.opts.formats) addInitialFormats();

    /**
     * Validate data using schema
     * Schema will be compiled and cached (using serialized JSON as key. [json-stable-stringify](https://github.com/substack/json-stable-stringify) is used to serialize.
     * @param  {String|Object} schemaKeyRef key, ref or schema object
     * @param  {Any} data to be validated
     * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).
     */
    function validate(schemaKeyRef, data) {
        var v;
        if (typeof schemaKeyRef == 'string') {
            v = getSchema(schemaKeyRef);
            if (!v) throw new Error('no schema with key or ref "' + schemaKeyRef + '"');
        } else {
            var schemaObj = _addSchema(schemaKeyRef);
            v = schemaObj.validate || _compile(schemaObj);
        }

        var valid = v(data);
        self.errors = v.errors;
        return valid;
    }

    /**
     * Create validating function for passed schema.
     * @param  {String|Object} schema
     * @return {Function} validating function
     */
    function compile(schema) {
        var schemaObj = _addSchema(schema);
        return schemaObj.validate || _compile(schemaObj);
    }

    /**
     * Create validating function for passed schema with asynchronous loading of missing schemas.
     * `loadSchema` option should be a function that accepts schema uri and node-style callback.
     * @param  {String|Object} schema
     * @param  {Function} callback node-style callback, it is always called with 2 parameters: error (or null) and validating function.
     */
    function compileAsync(schema, callback) {
        var schemaObj;
        try {
            schemaObj = _addSchema(schema);
        } catch(e) {
            setTimeout(function() { callback(e); });
            return;
        }
        if (schemaObj.validate)
            setTimeout(function() { callback(null, schemaObj.validate); });
        else {
            if (typeof self.opts.loadSchema != 'function')
                throw new Error('options.loadSchema should be a function');
            _compileAsync(schema, callback, true);
        }
    }

    function _compileAsync(schema, callback, firstCall) {
        var validate;
        try { validate = compile(schema); }
        catch(e) {
            if (e.missingSchema) loadMissingSchema(e);
            else if (firstCall) setTimeout(function() { callback(e); });
            else callback(e);

            return;
        }
        if (firstCall) setTimeout(function() { callback(null, validate); });
        else callback(null, validate);

        function loadMissingSchema(e) {
            var ref = e.missingSchema;
            if (self._refs[ref] || self._schemas[ref])
                return callback(new Error('Schema ' + ref + ' is loaded but' + e.missingRef + 'cannot be resolved'));
            var _callbacks = self._loadingSchemas[ref];
            if (_callbacks) {
                if (typeof _callbacks == 'function')
                    self._loadingSchemas[ref] = [_callbacks, schemaLoaded];
                else
                    _callbacks[_callbacks.length] = schemaLoaded;
            } else {
                self._loadingSchemas[ref] = schemaLoaded;
                self.opts.loadSchema(ref, function (err, sch) {
                    var _callbacks = self._loadingSchemas[ref];
                    delete self._loadingSchemas[ref];
                    if (typeof _callbacks == 'function')
                        _callbacks(err, sch);
                    else
                        for (var i=0; i<_callbacks.length; i++)
                            _callbacks[i](err, sch);
                });
            }

            function schemaLoaded(err, sch) {
                if (err) callback(err);
                else {
                    if (!(self._refs[ref] || self._schemas[ref])) {
                        try {
                            addSchema(sch, ref);
                        } catch(e) {
                            callback(e);
                            return;
                        }
                    }
                    _compileAsync(schema, callback);
                }
            }
        }
    }

    /**
     * Adds schema to the instance.
     * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` will be ignored.
     * @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.
     */
    function addSchema(schema, key, _skipValidation, _meta) {
        if (Array.isArray(schema)){
            schema.forEach(function(sch) { addSchema(sch); });
            return;
        }
        // can key/id have # inside?
        key = resolve.normalizeId(key || schema.id);
        checkUnique(key);
        var schemaObj = self._schemas[key] = _addSchema(schema, _skipValidation);
        schemaObj.meta = _meta;
    }

    /**
     * Add schema that will be used to validate other schemas
     * removeAdditional option is alway set to false
     * @param {Object} schema
     * @param {String} key optional schema key
     */
    function addMetaSchema(schema, key, _skipValidation) {
        addSchema(schema, key, _skipValidation, true);
    }

    /**
     * Validate schema
     * @param  {Object} schema schema to validate
     * @return {Boolean}
     */
    function validateSchema(schema) {
        var $schema = schema.$schema || META_SCHEMA_ID;
        var currentUriFormat = self._formats.uri;
        self._formats.uri = typeof currentUriFormat == 'function'
                            ? SCHEMA_URI_FORMAT_FUNC
                            : SCHEMA_URI_FORMAT;
        var valid = validate($schema, schema);
        self._formats.uri = currentUriFormat;
        return valid;
    }

    /**
     * Get compiled schema from the instance by `key` or `ref`.
     * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).
     * @return {Function} schema validating function (with property `schema`).
     */
    function getSchema(keyRef) {
        var schemaObj = _getSchemaObj(keyRef);
        switch (typeof schemaObj) {
            case 'object': return schemaObj.validate || _compile(schemaObj);
            case 'string': return getSchema(schemaObj);
        }
    }

    function _getSchemaObj(keyRef) {
        keyRef = resolve.normalizeId(keyRef);
        return self._schemas[keyRef] || self._refs[keyRef];
    }

    /**
     * Remove cached schema
     * Even if schema is referenced by other schemas it still can be removed as other schemas have local references
     * @param  {String|Object} schemaKeyRef key, ref or schema object
     */
    function removeSchema(schemaKeyRef) {
        switch (typeof schemaKeyRef) {
            case 'string':
                var schemaObj = _getSchemaObj(schemaKeyRef);
                self._cache.del(schemaObj.jsonStr);
                delete self._schemas[schemaKeyRef];
                delete self._refs[schemaKeyRef];
                break;
            case 'object':
                var jsonStr = stableStringify(schemaKeyRef);
                self._cache.del(jsonStr);
                var id = schemaKeyRef.id;
                if (id) {
                    id = resolve.normalizeId(id);
                    delete self._refs[id];
                }
        }
    }

    function _addSchema(schema, skipValidation) {
        if (typeof schema != 'object') throw new Error('schema should be object');
        var jsonStr = stableStringify(schema);
        var cached = self._cache.get(jsonStr);
        if (cached) return cached;

        var id = resolve.normalizeId(schema.id);
        if (id) checkUnique(id);

        var ok = skipValidation || self.opts.validateSchema === false
                 || validateSchema(schema);
        if (!ok) {
            var message = 'schema is invalid:' + errorsText();
            if (self.opts.validateSchema == 'log') console.error(message);
            else throw new Error(message);
        }

        var localRefs = resolve.ids.call(self, schema);

        var schemaObj = new SchemaObject({
            id: id,
            schema: schema,
            localRefs: localRefs,
            jsonStr: jsonStr,
        });

        if (id[0] != '#') self._refs[id] = schemaObj;
        self._cache.put(jsonStr, schemaObj);

        return schemaObj;
    }

    function _compile(schemaObj, root) {
        if (schemaObj.compiling) {
            schemaObj.validate = callValidate;
            callValidate.schema = schemaObj.schema;
            callValidate.errors = null;
            callValidate.root = root ? root : callValidate;
            return callValidate;
        }
        schemaObj.compiling = true;

        var currentRA = self.opts.removeAdditional;
        if (currentRA && schemaObj.meta) self.opts.removeAdditional = false;
        var v;
        try { v = compileSchema.call(self, schemaObj.schema, root, schemaObj.localRefs); }
        finally {
            schemaObj.compiling = false;
            if (currentRA) self.opts.removeAdditional = currentRA;
        }

        schemaObj.validate = v;
        schemaObj.refs = v.refs;
        schemaObj.refVal = v.refVal;
        schemaObj.root = v.root;
        return v;

        function callValidate() {
            var v = schemaObj.validate;
            var result = v.apply(null, arguments);
            callValidate.errors = v.errors;
            return result;
        }
    }

    function errorsText(errors, opts) {
        errors = errors || self.errors;
        if (!errors) return 'No errors';
        opts = opts || {};
        var separator = opts.separator || ', ';
        var dataVar = opts.dataVar || 'data';

        var text = errors.reduce(function(txt, e) {
            return e ? txt + dataVar + e.dataPath + ' ' + e.message + separator : txt;
        }, '');
        return text.slice(0, -separator.length);
    }

    function addFormat(name, format) {
        if (typeof format == 'string') format = new RegExp(format);
        self._formats[name] = format;
    }

    function addInitialSchemas() {
        if (self.opts.meta !== false) {
            var metaSchema = require('./refs/json-schema-draft-04.json');
            addMetaSchema(metaSchema, META_SCHEMA_ID, true);
            self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID;
        }

        var optsSchemas = self.opts.schemas;
        if (!optsSchemas) return;
        if (Array.isArray(optsSchemas)) addSchema(optsSchemas);
        else for (var key in optsSchemas) addSchema(optsSchemas[key], key);
    }

    function addInitialFormats() {
        for (var name in self.opts.formats) {
            var format = self.opts.formats[name];
            addFormat(name, format);
        }
    }

    function checkUnique(id) {
        if (self._schemas[id] || self._refs[id])
            throw new Error('schema with key or id "' + id + '" already exists');
    }
}


text:
module ForemanApi
  module Resources
    class Parameter < ForemanApi::Base
      def self.doc
        @doc ||= ForemanApi.doc['resources']["parameters"]
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      # @option params [String] page  paginate results
      # @option params [String] per_page  number of entries per request
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def index(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] id  id of parameter
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def show(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      # @option params [Hash, nil] parameter
      #   allowed keys are:
      #   * name [String]
      #   * value [String]
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def create(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] id  id of parameter
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      # @option params [Hash, nil] parameter
      #   allowed keys are:
      #   * name [String]
      #   * value [String]
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def update(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] id  id of parameter
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def destroy(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

      # @param [Hash] params a hash of params to be passed to the service
      # @option params [String] domain_id  id of domain
      # @option params [String] host_id  id of host
      # @option params [String] hostgroup_id  id of hostgroup
      # @option params [String] location_id  id of location
      # @option params [String] operatingsystem_id  id of operating system
      # @option params [String] organization_id  id of organization
      #
      # @param [Hash] headers additional http headers
      # @return [Array] First item: parsed data; second item: raw body
      def reset(params = {}, headers = {})
        perform_call(__method__, params, headers)
      end

    end
  end
end


text:
For CZ2006 Software Engineering Course Project.

NTU Survey is a google-forms-like survey creation and management system powered by [Django](https://www.djangoproject.com/) and [Bootstrap](http://twitter.github.com/bootstrap/)

##Live Demo##
* Demo [here](http://survey.sfdye.com)

##Key Features##
* User sign up and login
![Sign up](http://raw.github.com/sfdye/ntusurvey/master/screenshots/sign_up.png)
![Login](http://raw.github.com/sfdye/ntusurvey/master/screenshots/login.png)
* Friendly and powerful dashboard
![Dashboard](http://raw.github.com/sfdye/ntusurvey/master/screenshots/dashboard.png)
* Create survey at ease
![Create Survey](http://raw.github.com/sfdye/ntusurvey/master/screenshots/create_survey.png)
* Easy share by email
![Collaboration](http://raw.github.com/sfdye/ntusurvey/master/screenshots/share.png)
* Graphical analysis powered google-charts (question specific stats, time stats, and demography)
![Question](http://raw.github.com/sfdye/ntusurvey/master/screenshots/question.png)
![Daily](http://raw.github.com/sfdye/ntusurvey/master/screenshots/daily.png)
![Demography](http://raw.github.com/sfdye/ntusurvey/master/screenshots/demography.png)

* Multi-user collaboratoin, themes, share by QR code and many more features. Sign up [here](http://survey.sfde.com)

##Dependencies##
* [python-mysql](http://sourceforge.net/projects/mysql-python/)
* [shortuuid](https://github.com/stochastic-technologies/shortuuid)
* [south](https://github.com/lambdafu/django-south)
* [django-qrcode](https://github.com/zocolab/django-qrcode)
* [pygeoip](https://github.com/appliedsec/pygeoip)
* [google-chart](https://developers.google.com/chart/)

##Contributors##
* Wan Liuyang
* Chu Xiaoqi
* Chia Ming En
* Zhao Fangyuan
* Huang Wei
* Qian Cheng
* Ning Haoyan

##License##
This project is released under MIT License.
##External Source##

* Themes by [douban](https://www.djangoproject.com/)
* Geoip data by [Maxmind](http://www.maxmind.com/en/geolocation_landing)


text:
<?php namespace SeBuDesign\BuckarooJson\Tests;

use SeBuDesign\BuckarooJson\Transaction;

class OriginalTransactionKeyTest extends TestCase
{
    /** @test */
    public function it_should_set_the_original_transaction_key()
    {
        $oTransaction = $this->getTransaction();

        $sTransactionKey = $this->faker->uuid;

        $this->assertInstanceOf(
            Transaction::class,
            $oTransaction->setOriginalTransactionKey($sTransactionKey)
        );
        $this->assertEquals(
            $sTransactionKey,
            $oTransaction->oData->OriginalTransactionKey
        );
        $this->assertEquals(
            $sTransactionKey,
            $oTransaction->getOriginalTransactionKey()
        );
    }

    /** @test */
    public function it_should_return_false_when_the_original_transaction_key_is_not_set()
    {
        $oTransaction = $this->getTransaction();

        $this->assertFalse(
            $oTransaction->getOriginalTransactionKey()
        );
    }
}


text:
<!doctype html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="chrome=1">
    <title>Analytics & Metrics </title>
    <link rel="stylesheet" href="stylesheets/styles.css">
    <link rel="stylesheet" href="stylesheets/pygment_trac.css">

    <meta name="viewport" content="width=device-width, initial-scale=55, user-scalable=no">

  Cohort Formation &amp Research Analysis Tools

  Personalized/Precision  Medicine

     Faysal.El.Khettabi@gmail.com

  Cohort Formation in Personalized/Precision  Medicine

 Important efforts are developing ways to design and build landmark longitudinal data-cohorts for personalized/precision  medicine research. These longitudinal data-cohorts will be formed by engaging and organizing a number of participants from a single survival population into data sub-cohorts with a scientific goal to shape efficient predictive models in order to develop a well-defined references "healthy" and "not-healthy" or to find two sub-groups, one with better and the other with worse survival prognosis, for instance.

The characterization of these sub-groups will be facilitated by using a number of tests based on features associated to clinical, molecular, imaging, sensor, self-reported, behavioral, psychological, environmental and genetic/genemics and so on.
A score from a regression of these potential factors(biomarkers) or some other model to characterize the sub-groups can also be used as one unified biomarker.

When well-integrated, the preprocessed data related to these tests is expected to provide an estimation of the difference in the survival of two prognostic subgroups in the single survival population at any given time.

Recently, we developed an Informatics Solution to assess numerically the impact of a number of issues** on the accuracy of these cohort studies, some illustrations are in these Essays:

Difference in the survival of two prognostic subgroups at a given time versus sensitivity/specificity/prevalence.

Difference in the survival of two prognostic subgroups with numerical simulation in the presence of censoring.

Competing Risks &amp Time-to-Event Analysis with Censoring.

 **We are interested to assess the analytics and the numerics of the cohort formation and its relation of the accuracy and reliability of the project using  cohort studies, i.e. impact of censoring on the used formulations to estimate the sensitivity and specificity values and by consequent on  the difference in the survival of two prognostic subgroups in the single survival population at any given time.

Our Informatics Solution uses R Software to generate/analyze this simulated database. R is a software environment for statistical computing and graphics supported by the  R Foundation for Statistical Computing . R performs
many statistical analyses needed in practical applications: linear and generalized linear models, nonlinear regression
models, time-series analysis, parametric and nonparametric tests, clustering, smoothing and survival analysis. R also
provides additional packages for specific purposes.

   Author scientific profile:

Statistics and Applied Mathematics for Data Analytics, Identify opportunities to apply Mathematical Statistics, Numerical Methods, Machine Learning and Pattern Recognition to investigate and implement solutions to the field of Data Content Analytics. Data prediction via computational methods to predict from massive amounts of data (Big Data Content). These methods included clustering, regression, survival analysis, neural network, classification , ranking, deep discrepancy learning .

     Author: Faysal.El.Khettabi@gmail.com , Living in Vancouver, BC, Canada.

   The MIT License (MIT) Copyright 1994-2017, Faysal El Khettabi, Numerics&Analytics, All Rights Reserved.


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Aster ramulosus Labill.

### Remarks
null


text:
<? session_start();
//incluímos la clase ajax
require ('../../xajax/xajax.inc.php');

//instanciamos el objeto de la clase xajax
$xajax = new xajax();

//require ('../includes/funciones_XAJAX.php');

//El objeto xajax tiene que procesar cualquier petición
$xajax->processRequests();

?>

 <? $xajax->printJavascript("../../xajax/");  ?>

  <title><? echo "$empresa $aplicacion $page $usuario"; ?></title>

    <link href="../estilos/impresion_pantalla.css" rel="stylesheet" type="text/css" >
<link href="../estilos/impresion.css" rel="stylesheet" type="text/css" media="print">
  <link rel="SHORTCUT ICON" href="../../icono.ico">

  		<?php if ( isset ( $_REQUEST['page'] ) )
					{$page=$_REQUEST['page']; include_once("$page/$page.php");}

					?>

<?php
$control_version = '0aa0b6b3207f0b3839381db1962574a2';

?>


text:
1. Deploy Onyx on Kubernetes
1. Show idiomatic Onyx usage and conventions
1. Input from a cool data source (Twitter)
1. Output to [some free cloud resource?]

1. Mount a volume for /dev/shm for Aeron or else you'll run out of space with
   the default 64mb


text:
package com.shing.aputimetable.model;

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.Log;

import com.shing.aputimetable.model.ApuClassContract.ApuClassEntry;

/**
 * Created by Shing on 31-Jul-17.
 */

public class ApuClassProvider extends ContentProvider {

    /**
     * Tag for the log messages
     */
    public static final String TAG = ApuClassProvider.class.getSimpleName();

    /**
     * URI matcher code for the content URI for the pets table
     */
    private static final int CLASS = 100;

    /**
     * URI matcher code for the content URI for a single pet in the pets table
     */
    private static final int CLASS_ID = 101;

    /**
     * UriMatcher object to match a content URI to a corresponding code.
     * The input passed into the constructor represents the code to return for the root URI.
     * It's common to use NO_MATCH as the input for this case.
     */
    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    // Static initializer. This is run the first time anything is called from this class.
    static {
        // The calls to addURI() go here, for all of the content URI patterns that the provider
        // should recognize. All paths added to the UriMatcher have a corresponding code to return
        // when a match is found.

        // The content URI of the form "content://com.example.android.pets/pets" will map to the
        // integer code {@link #PETS}. This URI is used to provide access to MULTIPLE rows
        // of the pets table.
        sUriMatcher.addURI(ApuClassContract.CONTENT_AUTHORITY, ApuClassContract.PATH_APU_CLASS, CLASS);

        // The content URI of the form "content://com.example.android.pets/pets/#" will map to the
        // integer code {@link #PET_ID}. This URI is used to provide access to ONE single row
        // of the pets table.
        //
        // In this case, the "#" wildcard is used where "#" can be substituted for an integer.
        // For example, "content://com.example.android.pets/pets/3" matches, but
        // "content://com.example.android.pets/pets" (without a number at the end) doesn't match.
        sUriMatcher.addURI(ApuClassContract.CONTENT_AUTHORITY, ApuClassContract.PATH_APU_CLASS + "/#", CLASS_ID);
    }

    /**
     * Database helper object
     */
    private ApuClassDbHelper mDbHelper;

    @Override
    public boolean onCreate() {
        mDbHelper = new ApuClassDbHelper(getContext());
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        // Get readable database
        SQLiteDatabase database = mDbHelper.getReadableDatabase();

        // This cursor will hold the result of the query
        Cursor cursor;

        // Figure out if the URI matcher can match the URI to a specific code
        int match = sUriMatcher.match(uri);
        switch (match) {
            case CLASS:
                // For the PETS code, query the pets table directly with the given
                // projection, selection, selection arguments, and sort order. The cursor
                // could contain multiple rows of the pets table.
                cursor = database.query(ApuClassEntry.TABLE_NAME, projection, selection, selectionArgs,
                        null, null, sortOrder);
                break;
            case CLASS_ID:
                // For the PET_ID code, extract out the ID from the URI.
                // For an example URI such as "content://com.example.android.pets/pets/3",
                // the selection will be "_id=?" and the selection argument will be a
                // String array containing the actual ID of 3 in this case.
                //
                // For every "?" in the selection, we need to have an element in the selection
                // arguments that will fill in the "?". Since we have 1 question mark in the
                // selection, we have 1 String in the selection arguments' String array.
                selection = ApuClassEntry._ID + "=?";
                selectionArgs = new String[]{String.valueOf(ContentUris.parseId(uri))};

                // This will perform a query on the pets table where the _id equals 3 to return a
                // Cursor containing that row of the table.
                cursor = database.query(ApuClassEntry.TABLE_NAME, projection, selection, selectionArgs,
                        null, null, sortOrder);
                break;
            default:
                throw new IllegalArgumentException("Cannot query unknown URI " + uri);
        }

        // Set notification URI on the Cursor,
        // so we know what content URI the Cursor was created for.
        // If the data at this URI changes, then we know we need to update the Cursor.
        cursor.setNotificationUri(getContext().getContentResolver(), uri);

        // Return the cursor
        return cursor;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        final int match = sUriMatcher.match(uri);
        switch (match) {
            case CLASS:
                return ApuClassEntry.CONTENT_LIST_TYPE;
            case CLASS_ID:
                return ApuClassEntry.CONTENT_ITEM_TYPE;
            default:
                throw new IllegalStateException("Unknown URI " + uri + " with match " + match);
        }
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) {
        final int match = sUriMatcher.match(uri);
        switch (match) {
            case CLASS:
                return insertClass(uri, contentValues);
            default:
                throw new IllegalArgumentException("Insertion is not supported for " + uri);
        }
    }

    /**
     * Insert a pet into the database with the given content values. Return the new content URI
     * for that specific row in the database.
     */
    private Uri insertClass(Uri uri, ContentValues contentValues) {

        // Get writeable database
        SQLiteDatabase database = mDbHelper.getWritableDatabase();

        // Insert the new pet with the given values
        long id = database.insert(ApuClassEntry.TABLE_NAME, null, contentValues);
        // If the ID is -1, then the insertion failed. Log an error and return null.
        if (id == -1) {
            Log.e(TAG, "Failed to insert row for " + uri);
            return null;
        }

        // Notify all listeners that the data has changed for the pet content URI
        getContext().getContentResolver().notifyChange(uri, null);

        // Return the new URI with the ID (of the newly inserted row) appended at the end
        return ContentUris.withAppendedId(uri, id);
    }

    @Override
    public int delete(@NonNull Uri uri, String selection, String[] selectionArgs) {
        // Get writeable database
        SQLiteDatabase database = mDbHelper.getWritableDatabase();

        // Track the number of rows that were deleted
        int rowsDeleted;

        final int match = sUriMatcher.match(uri);
        switch (match) {
            case CLASS:
                // Delete all rows that match the selection and selection args
                rowsDeleted = database.delete(ApuClassEntry.TABLE_NAME, selection, selectionArgs);
                break;
            case CLASS_ID:
                // Delete a single row given by the ID in the URI
                selection = ApuClassEntry._ID + "=?";
                selectionArgs = new String[]{String.valueOf(ContentUris.parseId(uri))};
                rowsDeleted = database.delete(ApuClassEntry.TABLE_NAME, selection, selectionArgs);
                break;
            default:
                throw new IllegalArgumentException("Deletion is not supported for " + uri);
        }

        // If 1 or more rows were deleted, then notify all listeners that the data at the
        // given URI has changed
        if (rowsDeleted != 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }

        // Return the number of rows deleted
        return rowsDeleted;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues contentValues, @Nullable String selection, @Nullable String[] selectionArgs) {
        final int match = sUriMatcher.match(uri);
        switch (match) {
            case CLASS:
                return updateClass(uri, contentValues, selection, selectionArgs);
            case CLASS_ID:
                // For the PET_ID code, extract out the ID from the URI,
                // so we know which row to update. Selection will be "_id=?" and selection
                // arguments will be a String array containing the actual ID.
                selection = ApuClassEntry._ID + "=?";
                selectionArgs = new String[]{String.valueOf(ContentUris.parseId(uri))};
                return updateClass(uri, contentValues, selection, selectionArgs);
            default:
                throw new IllegalArgumentException("Update is not supported for " + uri);
        }
    }

    private int updateClass(Uri uri, ContentValues values, String selection, String[] selectionArgs) {

        // If there are no values to update, then don't try to update the database
        if (values.size() == 0) {
            return 0;
        }

        // Otherwise, get writeable database to update the data
        SQLiteDatabase database = mDbHelper.getWritableDatabase();

        // Perform the update on the database and get the number of rows affected
        int rowsUpdated = database.update(ApuClassEntry.TABLE_NAME, values, selection, selectionArgs);

        // If 1 or more rows were updated, then notify all listeners that the data at the
        // given URI has changed
        if (rowsUpdated != 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }

        // Return the number of rows updated
        return rowsUpdated;
    }
}


text:
from .constants import WAITING, SUCCESS, FAILED, ALL
from .gator import Gator
from .tasks import Task
from .workers import Worker

__author__ = "Daniel Lindsley"
__version__ = (1, 0, 0)
__license__ = "BSD"

def version():
    """
    Returns a human-readable version string.

    For official releases, it will follow a semver style (e.g. ``1.2.7``).
    For dev versions, it will have the semver style first, followed by
    hyphenated qualifiers (e.g. ``1.2.7-dev``).

    Returns a string.
    """
    short = ".".join([str(bit) for bit in __version__[:3]])
    return "-".join([short] + [str(bit) for bit in __version__[3:]])


text:
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright © 1991-2020 Unicode, Inc.
For terms of use, see http://www.unicode.org/copyright.html
Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
-->
<ldml xmlns:sil="urn://www.sil.org/ldml/0.1">
	<identity>
		<version number="$Revision$"/>
		<language type="ru"/>
		<territory type="UA"/>
		<special>
			<sil:identity source="cldr" defaultRegion="UA" script="Cyrl"/>
		</special>
	</identity>
	<localeDisplayNames>
		<territories>
			<territory type="AC" draft="contributed">О-в Вознесения</territory>
			<territory type="AE" draft="contributed">Объединенные Арабские Эмираты</territory>
			<territory type="BV" draft="contributed">О-в Буве</territory>
			<territory type="CK" draft="contributed">О-ва Кука</territory>
			<territory type="CP" draft="contributed">О-в Клиппертон</territory>
			<territory type="CX" draft="contributed">О-в Рождества</territory>
			<territory type="HM" draft="contributed">О-ва Херд и Макдональд</territory>
			<territory type="NF" draft="contributed">О-в Норфолк</territory>
			<territory type="TL" draft="contributed">Тимор-Лесте</territory>
			<territory type="UM" draft="contributed">Малые Тихоокеанские Отдаленные Острова США</territory>
		</territories>
	</localeDisplayNames>
	<dates>
		<calendars>
			<calendar type="generic">
				<dateTimeFormats>
					<intervalFormats>
						<intervalFormatItem id="h">
							<greatestDifference id="h">h–h 'ч'. a</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="H">
							<greatestDifference id="H">HH–HH 'ч'.</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="hv">
							<greatestDifference id="h">h–h 'ч'. a, v</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="Hv">
							<greatestDifference id="H">HH–HH 'ч'., v</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="MMMEd">
							<greatestDifference id="d">E, d – E, d MMM</greatestDifference>
							<greatestDifference id="M">E, d MMM – E, d MMM</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMEd">
							<greatestDifference id="d">E, dd.MM.y – E, dd.MM.y</greatestDifference>
							<greatestDifference id="M">E, dd.MM.y – E, dd.MM.y</greatestDifference>
							<greatestDifference id="y">E, dd.MM.y – E, dd.MM.y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMM">
							<greatestDifference id="M">MMM–MMM y</greatestDifference>
							<greatestDifference id="y">MMM y – MMM y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMd">
							<greatestDifference id="d">d–d MMM y</greatestDifference>
							<greatestDifference id="M">d MMM – d MMM y</greatestDifference>
							<greatestDifference id="y">d MMM y – d MMM y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMEd">
							<greatestDifference id="d">E, d – E, d MMM y 'г'.</greatestDifference>
							<greatestDifference id="M">E, d MMM – E, d MMM y 'г'.</greatestDifference>
							<greatestDifference id="y">E, d MMM y – E, d MMM y 'г'.</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMM">
							<greatestDifference id="M">LLLL–LLLL y</greatestDifference>
							<greatestDifference id="y">LLLL y – LLLL y</greatestDifference>
						</intervalFormatItem>
					</intervalFormats>
				</dateTimeFormats>
			</calendar>
			<calendar type="gregorian">
				<dateTimeFormats>
					<availableFormats>
						<dateFormatItem id="GyMMM" draft="contributed">LLL y 'г'. G</dateFormatItem>
						<dateFormatItem id="yMEd" draft="contributed">ccc, d.MM.y</dateFormatItem>
					</availableFormats>
					<intervalFormats>
						<intervalFormatItem id="yMMM">
							<greatestDifference id="y" draft="contributed">LLL y – LLL y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMd">
							<greatestDifference id="y" draft="contributed">d MMM y – d MMM y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMEd">
							<greatestDifference id="y" draft="contributed">ccc, d MMM y – ccc, d MMM y</greatestDifference>
						</intervalFormatItem>
						<intervalFormatItem id="yMMMM">
							<greatestDifference id="y" draft="contributed">LLLL y – LLLL y</greatestDifference>
						</intervalFormatItem>
					</intervalFormats>
				</dateTimeFormats>
			</calendar>
		</calendars>
	</dates>
	<numbers>
		<minimumGroupingDigits draft="contributed">2</minimumGroupingDigits>
	</numbers>
	<special>
		<sil:external-resources>
			<sil:font name="Charis SIL" types="default">
				<sil:url>https://wirl.api.sil.org/CharisSILReg&type=ttf</sil:url>
			</sil:font>
			<sil:font name="Noto Sans"><!--types="ui"-->
				<sil:url>https://github.com/googlefonts/noto-fonts/raw/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf</sil:url>
			</sil:font>
			<sil:font name="Noto Serif">
				<sil:url>https://github.com/googlefonts/noto-fonts/raw/main/hinted/ttf/NotoSerif/NotoSerif-Regular.ttf</sil:url>
			</sil:font>
		</sil:external-resources>
	</special>
</ldml>


text:
package de.lancom.systems.stomp.spring;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import de.lancom.systems.stomp.core.client.StompClient;
import de.lancom.systems.stomp.core.client.StompUrl;
import de.lancom.systems.stomp.core.connection.StompFrameContextHandler;
import de.lancom.systems.stomp.core.connection.StompSubscription;
import de.lancom.systems.stomp.core.util.StringUtil;
import de.lancom.systems.stomp.core.wire.StompData;
import de.lancom.systems.stomp.core.wire.StompFrame;
import de.lancom.systems.stomp.core.wire.StompHeader;
import de.lancom.systems.stomp.core.wire.frame.SendFrame;
import de.lancom.systems.stomp.core.wire.frame.SubscribeFrame;
import de.lancom.systems.stomp.spring.annotation.Destination;
import de.lancom.systems.stomp.spring.annotation.Subscription;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NonNull;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

/**
 * Handles injection of {@link StompProducer} and creates subscriptions.
 */
@Slf4j
@SuppressWarnings("unchecked")
public class StompSupportProcessor implements
        MergedBeanDefinitionPostProcessor,
        InstantiationAwareBeanPostProcessor,
        DestructionAwareBeanPostProcessor,
        ApplicationContextAware,
        ApplicationListener<ContextRefreshedEvent> {

    private final Map<String, StompBeanInformation> informationCache = new HashMap<>();

    @Autowired
    private StompClient client;

    private ConfigurableBeanFactory beanFactory;

    @Override
    public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
        this.findBeanInformation(bean.getClass(), beanName);
        return bean;
    }

    @Override
    public void postProcessMergedBeanDefinition(
            final RootBeanDefinition beanDefinition,
            final Class<?> beanType,
            final String beanName
    ) {
        final StompBeanInformation information = this.findBeanInformation(beanType, beanName);
        if (information != null) {
            for (final StompBeanProducer producer : information.getProducers()) {
                if (!beanDefinition.isExternallyManagedConfigMember(producer.getField())) {
                    beanDefinition.registerExternallyManagedConfigMember(producer.getField());
                }
            }
            for (final StompBeanConsumer consumer : information.getConsumers()) {
                if (!beanDefinition.isExternallyManagedConfigMember(consumer.getMethod())) {
                    beanDefinition.registerExternallyManagedConfigMember(consumer.getMethod());
                }
            }
        }
    }

    /**
     * Lookup bean information.
     *
     * @param beanClass bean class
     * @param beanName bean name
     * @return information
     */
    private StompBeanInformation findBeanInformation(
            final Class beanClass,
            final String beanName
    ) {
        final String cacheKey = (StringUtils.hasLength(beanName) ? beanName : beanClass.getName());

        final StompBeanInformation information;
        if (informationCache.containsKey(cacheKey)) {
            information = informationCache.get(cacheKey);
        } else {
            information = new StompBeanInformation();
            informationCache.put(cacheKey, information);

            ReflectionUtils.doWithFields(beanClass, field -> {
                final Class contentType = field.getType();

                boolean use = true;
                use = use && field.getAnnotation(Destination.class) != null;
                use = use && contentType == StompProducer.class;

                if (use) {
                    information.getProducers().add(new StompBeanProducer(field));
                }
            });

            ReflectionUtils.doWithMethods(beanClass, method -> {

                final Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);

                boolean use = true;
                use = use && BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod);
                use = use && bridgedMethod.isAnnotationPresent(Subscription.class);
                use = use && method.equals(ClassUtils.getMostSpecificMethod(method, beanClass));

                if (use) {
                    information.getConsumers().add(new StompBeanConsumer(bridgedMethod));
                }
            });
        }

        return information;
    }

    @Override
    public boolean requiresDestruction(final Object bean) {
        return true;
    }

    @Override
    public Object postProcessBeforeInstantiation(
            final Class<?> beanClass,
            final String beanName
    ) throws BeansException {
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(final Object bean, final String beanName) throws BeansException {
        final StompBeanInformation information = this.findBeanInformation(bean.getClass(), beanName);
        if (information != null) {
            for (final StompBeanProducer producer : information.getProducers()) {
                producer.add(client, bean);
            }
            for (final StompBeanConsumer consumer : information.getConsumers()) {
                consumer.add(client, bean);
            }
        }
        return true;
    }

    @Override
    public void postProcessBeforeDestruction(final Object bean, final String beanName) throws BeansException {
        final StompBeanInformation information = this.findBeanInformation(bean.getClass(), beanName);
        if (information != null) {
            for (final StompBeanProducer producer : information.getProducers()) {
                producer.remove(client, bean);
            }
            for (final StompBeanConsumer consumer : information.getConsumers()) {
                consumer.remove(client, bean);
            }
        }
    }

    @Override
    public PropertyValues postProcessPropertyValues(
            final PropertyValues pvs, final PropertyDescriptor[] pds, final Object bean, final String beanName
    ) throws BeansException {
        return pvs;
    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
        final ConfigurableApplicationContext context = (ConfigurableApplicationContext) applicationContext;
        this.beanFactory = context.getBeanFactory();
    }

    @Override
    public void onApplicationEvent(final ContextRefreshedEvent event) {
    }

    /**
     * Bean infomration holder.
     */
    @Data
    private static class StompBeanInformation {
        private final List<StompBeanProducer> producers = new ArrayList<>();
        private final List<StompBeanConsumer> consumers = new ArrayList<>();
    }

    /**
     * Bean producer information.
     */
    @Data
    @ToString(of = "field")
    private class StompBeanProducer {
        private final Field field;

        /**
         * Add producer for bean.
         *
         * @param stompClient stomp client
         * @param bean bean
         */
        public void add(final StompClient stompClient, final Object bean) {
            final Destination annotation = field.getAnnotation(Destination.class);
            final StompUrl url = StompUrl.parse(beanFactory.resolveEmbeddedValue(annotation.value()));
            ReflectionUtils.makeAccessible(field);
            ReflectionUtils.setField(field, bean, Proxy.newProxyInstance(
                    bean.getClass().getClassLoader(),
                    new Class[] {
                            StompProducer.class
                    },
                    new ProducerHandler(stompClient, url)
            ));
        }

        /**
         * Remove producer for bean.
         *
         * @param stompClient stomp client
         * @param bean bean
         */
        public void remove(final StompClient stompClient, final Object bean) {
            ReflectionUtils.makeAccessible(field);
            ReflectionUtils.setField(field, bean, null);
        }
    }

    /**
     * Generic pair holder.
     *
     * @param <Key> key type
     * @param <Value> value type
     */
    @Data
    private static class Pair<Key, Value> {
        private final Key key;
        private final Value value;
    }

    /**
     * Bean consumer information.
     */
    @Data
    @ToString(of = "method")
    private class StompBeanConsumer {
        private final Map<Object, StompSubscription> subscriptionMap = new HashMap<>();
        private final Method method;

        /**
         * Add consumer for bean.
         *
         * @param stompClient stomp client
         * @param bean bean
         */
        public void add(final StompClient stompClient, final Object bean) {
            final Class[] parameterTypes = method.getParameterTypes();
            final Object[] parameters = new Object[parameterTypes.length];
            final StompFrameContextHandler handler = (c) -> {
                final StompFrame frame = c.getFrame();
                try {
                    for (int index = 0; index < parameterTypes.length; index++) {
                        final Class type = parameterTypes[index];
                        if (type.isAssignableFrom(frame.getClass())) {
                            parameters[index] = frame;
                        } else if (StompData.class.isAssignableFrom(type)) {
                            parameters[index] = frame.copy(type);
                        } else if (type == String.class) {
                            parameters[index] = frame.getBodyAsString();
                        } else if (type == byte[].class) {
                            parameters[index] = frame.getBody();
                        } else {
                            parameters[index] = c.getParameter(type);
                        }
                    }
                } catch (final Exception e) {
                    log.warn("Exception while handling frame: '{}'", e.getMessage());
                    throw (e);
                }

                try {
                    final Object result = method.invoke(bean, parameters);
                    if (result instanceof Boolean) {
                        return (Boolean) result;
                    } else {
                        return true;
                    }
                } catch (final Exception ex) {
                    log.warn("Exception while handling frame", ex);
                    return false;
                }
            };

            final Subscription annotation = method.getAnnotation(Subscription.class);

            final StompUrl url = StompUrl.parse(beanFactory.resolveEmbeddedValue(annotation.value()));
            final String id = beanFactory.resolveEmbeddedValue(annotation.id());

            final StompSubscription subscription = stompClient.createSubscription(url, id, handler);

            final SubscribeFrame subscribeFrame = subscription.getSubscribeFrame();
            subscribeFrame.setId(StringUtil.isBlank(id) ? UUID.randomUUID().toString() : id);
            subscribeFrame.setDestination(url.getDestination());
            subscribeFrame.setAckMode(annotation.ackMode());

            if (!StringUtil.isBlank(annotation.selector())) {
                subscribeFrame.setSelector(annotation.selector());
            }

            subscription.subscribe();
            this.subscriptionMap.put(bean, subscription);
        }

        /**
         * Remove consumer for bean.
         *
         * @param stompClient stomp client
         * @param bean bean
         */
        public void remove(final StompClient stompClient, final Object bean) {
            final StompSubscription subscription = this.subscriptionMap.get(bean);
            if (subscription != null) {
                subscription.remove();
            }
        }
    }

    /**
     * Handler for {@link StompProducer} instances.
     */
    @AllArgsConstructor
    private static class ProducerHandler implements InvocationHandler {

        @NonNull
        private final StompClient client;

        @NonNull
        private final StompUrl url;

        @Override
        public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
            switch (method.getName()) {
                case "send": {
                    final Object value = args[0];

                    if (value != null) {
                        final SendFrame sendFrame;
                        if (value instanceof SendFrame) {
                            sendFrame = (SendFrame) value;
                        } else {
                            sendFrame = new SendFrame();
                            if (value instanceof StompData) {
                                StompData.class.cast(value).copy(sendFrame);
                            } else if (value instanceof String) {
                                sendFrame.setBodyAsString((String) value);
                            } else if (value instanceof byte[]) {
                                sendFrame.setBody((byte[]) value);
                            } else {
                                throw new RuntimeException(String.format(
                                        "Send body of type %s is not supported",
                                        value.getClass()
                                ));
                            }
                        }

                        if (sendFrame.getHeader(StompHeader.DESTINATION) == null) {
                            sendFrame.setDestination(url.getDestination());
                        }
                        return client.transmitFrame(url, sendFrame);
                    }
                }
                case "toString": {
                    return String.format("Stomp Producer for '%s'", url);
                }
                default: {
                    throw new UnsupportedOperationException(String.format("Method %s is not implemented ", method));
                }
            }
        }
    }

}


text:
package com.department13.skryfi;

import org.json.JSONException;
import org.json.JSONObject;

import android.database.Cursor;
import android.net.wifi.ScanResult;

public class Survey {
	public long timestamp;
	public String bssid;
	public String ssid;
	public double latitude;
	public double longitude;
	public double altitude;
	public int level;
	public int channel;
	public double frequency;

	public static enum EncryptionType{ OPEN, WEP, WPA, WPA2 };
	public EncryptionType encryption = EncryptionType.OPEN;

	public static enum CipherType { NONE, UNKNOWN, WEP40, WEP104, CCMP, WRAP, TKIP };
	public CipherType cipher = CipherType.NONE;

	public static enum AuthType { NONE, UNKNOWN, PSK, SKA, MGT, OPEN };
	public AuthType authentication = AuthType.UNKNOWN;
	// human readable version of the security features
	public String security = "";

	public Survey(Cursor cursor)
	{
		// TODO Auto-generated constructor stub
	}

	public Survey(String bssid, String ssid, double freq, int level, String sec)
	{
		this.timestamp = System.currentTimeMillis();
		this.bssid = bssid;
		this.ssid = ssid;
		this.frequency = freq;
		this.level = level;
		this.channel = FrequencyToChannel(this.frequency);

		this.security = sec;
		if (security.contains("WEP"))
			encryption = EncryptionType.WEP;
		else if (security.contains("WPA2"))
			encryption = EncryptionType.WPA2;
		else if (security.contains("WPA"))
			encryption = EncryptionType.WPA;
		else if ((security.contains("OPEN")) || (security.contains("OPN")))
			encryption = EncryptionType.OPEN;
	}

	public Survey(ScanResult result)
	{
		this.timestamp = System.currentTimeMillis();
		this.bssid = result.BSSID;
		this.ssid = result.SSID;
		this.level = result.level;
		this.frequency = result.frequency;
		this.channel = FrequencyToChannel(this.frequency);
		this.security = result.capabilities.toUpperCase();

		if (security.contains("WEP"))
			encryption = EncryptionType.WEP;
		else if (security.contains("WPA2"))
			encryption = EncryptionType.WPA2;
		else if (security.contains("WPA"))
			encryption = EncryptionType.WPA;
		else if ((security.contains("OPEN")) || (security.contains("OPN")))
			encryption = EncryptionType.OPEN;
	}

	public Survey(JSONObject obj) throws JSONException
	{
		this.timestamp = System.currentTimeMillis();
		this.bssid = obj.getString("mac");
		this.ssid = obj.getString("essid");
		this.level = obj.getInt("power");
		this.channel = obj.getInt("channel");
		this.frequency = ChannelToFrequency(this.channel);
		String priv = obj.getString("privacy");
		String cip = obj.getString("cipher");
		String auth = obj.getString("auth");
		this.security = priv + ", " + cip + ", " + auth;

		if (priv.equalsIgnoreCase("WEP"))
			encryption = EncryptionType.WEP;
		else if (priv.equalsIgnoreCase("WPA"))
			encryption = EncryptionType.WPA;
		else if (priv.equalsIgnoreCase("WPA2"))
			encryption = EncryptionType.WPA2;
		else if ((priv.equalsIgnoreCase("OPEN"))||(priv.equalsIgnoreCase("OPN")))
			encryption = EncryptionType.OPEN;

		if ((cip.equalsIgnoreCase("WEP"))||(cip.equalsIgnoreCase("WEP104")))
			cipher = CipherType.WEP104;
		else if (cip.equalsIgnoreCase("WEP40"))
			cipher = CipherType.WEP40;
		else if (cip.equalsIgnoreCase("CCMP"))
			cipher = CipherType.CCMP;
		else if (cip.equalsIgnoreCase("TKIP"))
			cipher = CipherType.TKIP;
		else if (cip.equalsIgnoreCase("WRAP"))
			cipher = CipherType.WRAP;

		if ((cip.equalsIgnoreCase("OPN"))||(cip.equalsIgnoreCase("OPEN")))
			authentication = AuthType.OPEN;
		else if (cip.equalsIgnoreCase("MGT"))
			authentication = AuthType.MGT;
		else if (cip.equalsIgnoreCase("SKA"))
			authentication = AuthType.SKA;
		else if (cip.equalsIgnoreCase("PSK"))
			authentication = AuthType.PSK;
	}

	public void updatePosition(double lat, double lng, double alt)
	{
		latitude = lat;
		longitude = lng;
		altitude = alt;
	}

	static public int FrequencyToChannel(double freq)
	{
		double delta = freq - 2.407;
		return (int)(delta/0.005);
	}

	static public double ChannelToFrequency(int channel)
	{
		return ((double)channel * 0.005) + 2.407;
	}
}


text:
#ifndef BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
#define BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP

#if defined(_MSC_VER)&&(_MSC_VER>=1200)
#pragma once
#endif

#include <lslboost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <cstddef>
#include <iterator>

namespace lslboost{

namespace multi_index{

namespace detail{

/* duplicates_operator is given a range of ordered elements and
 * passes only over those which are duplicated.
 */

template<typename Node,typename Predicate>
class duplicates_iterator
{
public:
  typedef typename Node::value_type        value_type;
  typedef std::ptrdiff_t                   difference_type;
  typedef const typename Node::value_type* pointer;
  typedef const typename Node::value_type& reference;
  typedef std::forward_iterator_tag        iterator_category;

  duplicates_iterator(Node* node_,Node* end_,Predicate pred_):
    node(node_),begin_chunk(0),end(end_),pred(pred_)
  {
    advance();
  }

  duplicates_iterator(Node* end_,Predicate pred_):
    node(end_),begin_chunk(end_),end(end_),pred(pred_)
  {
  }

  reference operator*()const
  {
    return node->value();
  }

  pointer operator->()const
  {
    return &node->value();
  }

  duplicates_iterator& operator++()
  {
    Node::increment(node);
    sync();
    return *this;
  }

  duplicates_iterator operator++(int)
  {
    duplicates_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  Node* get_node()const{return node;}

private:
  void sync()
  {
    if(node!=end&&pred(begin_chunk->value(),node->value()))advance();
  }

  void advance()
  {
    for(Node* node2=node;node!=end;node=node2){
      Node::increment(node2);
      if(node2!=end&&!pred(node->value(),node2->value()))break;
    }
    begin_chunk=node;
  }

  Node*     node;
  Node*     begin_chunk;
  Node*     end;
  Predicate pred;
};

template<typename Node,typename Predicate>
bool operator==(
  const duplicates_iterator<Node,Predicate>& x,
  const duplicates_iterator<Node,Predicate>& y)
{
  return x.get_node()==y.get_node();
}

template<typename Node,typename Predicate>
bool operator!=(
  const duplicates_iterator<Node,Predicate>& x,
  const duplicates_iterator<Node,Predicate>& y)
{
  return !(x==y);
}

} /* namespace multi_index::detail */

} /* namespace multi_index */

} /* namespace lslboost */

#endif


text:
/* The file is part of Snowman decompiler. */
/* See doc/licenses.asciidoc for the licensing information. */

#pragma once

#include <nc/config.h>

#include <vector>

#include <boost/unordered_map.hpp>

#include <nc/common/Range.h>

namespace nc {

class CancellationToken;

namespace core {
namespace ir {

class BasicBlock;
class CFG;

/**
 * Dominator sets.
 */
class Dominators {
    /** Mapping from a basic block to the set of its dominators. */
    boost::unordered_map<const BasicBlock *, std::vector<const BasicBlock *>> dominators_;

public:
    /**
     * Constructs dominator sets from the control flow graph.
     * Uses classic iterative algorithm for that.
     *
     * \param cfg Control flow graph.
     * \param canceled Cancellation token.
     */
    Dominators(const CFG &cfg, const CancellationToken &canceled);

    /**
     * \param basicBlock Valid pointer to a basic block.
     *
     * \return The set of dominators of this basic block.
     */
    const std::vector<const BasicBlock *> &getDominators(const BasicBlock *basicBlock) const {
        assert(basicBlock != nullptr);
        assert(nc::contains(dominators_, basicBlock));
        return nc::find(dominators_, basicBlock);
    }

    /**
     * \param dominating Valid pointer to a basic block.
     * \param dominated Valid pointer to a basic block.
     *
     * \return True of dominating dominates dominated.
     */
    bool isDominating(const BasicBlock *dominating, const BasicBlock *dominated) const {
        assert(dominating != nullptr);
        assert(nc::contains(dominators_, dominating));
        assert(dominated != nullptr);
        assert(nc::contains(dominators_, dominated));

        const auto &dominators = getDominators(dominated);
        return std::binary_search(dominators.begin(), dominators.end(), dominating);
    }
};

} // namespace ir
} // namespace core
} // namespace nc

/* vim:set et sts=4 sw=4: */


text:
<?php

namespace PhpEws\DataType;

use PhpEws\DataType;

/**
 * Definition of the ArrayOfFreeBusyResponse type
 */
class ArrayOfFreeBusyResponse extends DataType
{
    /**
     * FreeBusyResponse property
     *
     * @var FreeBusyResponseType
     */
    public $FreeBusyResponse;
}