text:
"""Generated client library for testing version v1."""
# NOTE: This file is autogenerated and should not be edited by hand.

from googlecloudapis.apitools.base.py import base_api
from googlecloudapis.testing.v1 import testing_v1_messages as messages

class TestingV1(base_api.BaseApiClient):
  """Generated client library for service testing version v1."""

  MESSAGES_MODULE = messages

  _PACKAGE = u'testing'
  _SCOPES = [u'https://www.googleapis.com/auth/cloud-platform']
  _VERSION = u'v1'
  _CLIENT_ID = '1042881264118.apps.googleusercontent.com'
  _CLIENT_SECRET = 'x_Tw5K8nnjoRAqULM9PFAC2b'
  _USER_AGENT = ''
  _CLIENT_CLASS_NAME = u'TestingV1'
  _URL_VERSION = u'v1'

  def __init__(self, url='', credentials=None,
               get_credentials=True, http=None, model=None,
               log_request=False, log_response=False,
               credentials_args=None, default_global_params=None,
               additional_http_headers=None):
    """Create a new testing handle."""
    url = url or u'https://testing.googleapis.com/'
    super(TestingV1, self).__init__(
        url, credentials=credentials,
        get_credentials=get_credentials, http=http, model=model,
        log_request=log_request, log_response=log_response,
        credentials_args=credentials_args,
        default_global_params=default_global_params,
        additional_http_headers=additional_http_headers)
    self.projects_devices = self.ProjectsDevicesService(self)
    self.projects_testMatrices = self.ProjectsTestMatricesService(self)
    self.projects = self.ProjectsService(self)
    self.testEnvironmentCatalog = self.TestEnvironmentCatalogService(self)

  class ProjectsDevicesService(base_api.BaseApiService):
    """Service class for the projects_devices resource."""

    _NAME = u'projects_devices'

    def __init__(self, client):
      super(TestingV1.ProjectsDevicesService, self).__init__(client)
      self._method_configs = {
          'Create': base_api.ApiMethodInfo(
              http_method=u'POST',
              method_id=u'testing.projects.devices.create',
              ordered_params=[u'projectId'],
              path_params=[u'projectId'],
              query_params=[u'sshPublicKey'],
              relative_path=u'v1/projects/{projectId}/devices',
              request_field=u'device',
              request_type_name=u'TestingProjectsDevicesCreateRequest',
              response_type_name=u'Device',
              supports_download=False,
          ),
          'Delete': base_api.ApiMethodInfo(
              http_method=u'DELETE',
              method_id=u'testing.projects.devices.delete',
              ordered_params=[u'projectId', u'deviceId'],
              path_params=[u'deviceId', u'projectId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/devices/{deviceId}',
              request_field='',
              request_type_name=u'TestingProjectsDevicesDeleteRequest',
              response_type_name=u'Empty',
              supports_download=False,
          ),
          'Get': base_api.ApiMethodInfo(
              http_method=u'GET',
              method_id=u'testing.projects.devices.get',
              ordered_params=[u'projectId', u'deviceId'],
              path_params=[u'deviceId', u'projectId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/devices/{deviceId}',
              request_field='',
              request_type_name=u'TestingProjectsDevicesGetRequest',
              response_type_name=u'Device',
              supports_download=False,
          ),
          'Keepalive': base_api.ApiMethodInfo(
              http_method=u'POST',
              method_id=u'testing.projects.devices.keepalive',
              ordered_params=[u'projectId', u'deviceId'],
              path_params=[u'deviceId', u'projectId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/devices/{deviceId}/keepalive',
              request_field='',
              request_type_name=u'TestingProjectsDevicesKeepaliveRequest',
              response_type_name=u'Empty',
              supports_download=False,
          ),
          'List': base_api.ApiMethodInfo(
              http_method=u'GET',
              method_id=u'testing.projects.devices.list',
              ordered_params=[u'projectId'],
              path_params=[u'projectId'],
              query_params=[u'pageSize', u'pageToken'],
              relative_path=u'v1/projects/{projectId}/devices',
              request_field='',
              request_type_name=u'TestingProjectsDevicesListRequest',
              response_type_name=u'ListDevicesResponse',
              supports_download=False,
          ),
          }

      self._upload_configs = {
          }

    def Create(self, request, global_params=None):
      """Creates a new GCE Android device.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write to project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the device type or project does not exist

      Args:
        request: (TestingProjectsDevicesCreateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Device) The response message.
      """
      config = self.GetMethodConfig('Create')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Delete(self, request, global_params=None):
      """Deletes a GCE Android device instance.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the project does not exist

      Args:
        request: (TestingProjectsDevicesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Empty) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Get(self, request, global_params=None):
      """Returns the GCE Android device.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the device type or project does not exist

      Args:
        request: (TestingProjectsDevicesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Device) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Keepalive(self, request, global_params=None):
      """Issues a keep-alive to a GCE Android device instance.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the project does not exist

      Args:
        request: (TestingProjectsDevicesKeepaliveRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Empty) The response message.
      """
      config = self.GetMethodConfig('Keepalive')
      return self._RunMethod(
          config, request, global_params=global_params)

    def List(self, request, global_params=None):
      """Lists all the current devices.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the project does not exist

      Args:
        request: (TestingProjectsDevicesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ListDevicesResponse) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

  class ProjectsTestMatricesService(base_api.BaseApiService):
    """Service class for the projects_testMatrices resource."""

    _NAME = u'projects_testMatrices'

    def __init__(self, client):
      super(TestingV1.ProjectsTestMatricesService, self).__init__(client)
      self._method_configs = {
          'Cancel': base_api.ApiMethodInfo(
              http_method=u'POST',
              method_id=u'testing.projects.testMatrices.cancel',
              ordered_params=[u'projectId', u'testMatrixId'],
              path_params=[u'projectId', u'testMatrixId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/testMatrices/{testMatrixId}:cancel',
              request_field='',
              request_type_name=u'TestingProjectsTestMatricesCancelRequest',
              response_type_name=u'CancelTestMatrixResponse',
              supports_download=False,
          ),
          'Create': base_api.ApiMethodInfo(
              http_method=u'POST',
              method_id=u'testing.projects.testMatrices.create',
              ordered_params=[u'projectId'],
              path_params=[u'projectId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/testMatrices',
              request_field=u'testMatrix',
              request_type_name=u'TestingProjectsTestMatricesCreateRequest',
              response_type_name=u'TestMatrix',
              supports_download=False,
          ),
          'Delete': base_api.ApiMethodInfo(
              http_method=u'DELETE',
              method_id=u'testing.projects.testMatrices.delete',
              ordered_params=[u'projectId', u'testMatrixId'],
              path_params=[u'projectId', u'testMatrixId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/testMatrices/{testMatrixId}',
              request_field='',
              request_type_name=u'TestingProjectsTestMatricesDeleteRequest',
              response_type_name=u'Empty',
              supports_download=False,
          ),
          'Get': base_api.ApiMethodInfo(
              http_method=u'GET',
              method_id=u'testing.projects.testMatrices.get',
              ordered_params=[u'projectId', u'testMatrixId'],
              path_params=[u'projectId', u'testMatrixId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/testMatrices/{testMatrixId}',
              request_field='',
              request_type_name=u'TestingProjectsTestMatricesGetRequest',
              response_type_name=u'TestMatrix',
              supports_download=False,
          ),
          'List': base_api.ApiMethodInfo(
              http_method=u'GET',
              method_id=u'testing.projects.testMatrices.list',
              ordered_params=[u'projectId'],
              path_params=[u'projectId'],
              query_params=[],
              relative_path=u'v1/projects/{projectId}/testMatrices',
              request_field='',
              request_type_name=u'TestingProjectsTestMatricesListRequest',
              response_type_name=u'ListTestMatricesResponse',
              supports_download=False,
          ),
          }

      self._upload_configs = {
          }

    def Cancel(self, request, global_params=None):
      """Cancels unfinished test executions in a test matrix.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the Test Matrix does not exist

      Args:
        request: (TestingProjectsTestMatricesCancelRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (CancelTestMatrixResponse) The response message.
      """
      config = self.GetMethodConfig('Cancel')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Create(self, request, global_params=None):
      """Request to run a matrix of tests according to the given specifications.
Unsupported environments will be returned in the state UNSUPPORTED.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write to project
- INVALID_ARGUMENT - if the request is malformed

      Args:
        request: (TestingProjectsTestMatricesCreateRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestMatrix) The response message.
      """
      config = self.GetMethodConfig('Create')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Delete(self, request, global_params=None):
      """Delete all record of a test matrix plus any associated test executions.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the Test Matrix does not exist

      Args:
        request: (TestingProjectsTestMatricesDeleteRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (Empty) The response message.
      """
      config = self.GetMethodConfig('Delete')
      return self._RunMethod(
          config, request, global_params=global_params)

    def Get(self, request, global_params=None):
      """Check the status of a test matrix.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the Test Matrix does not exist

      Args:
        request: (TestingProjectsTestMatricesGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestMatrix) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)

    def List(self, request, global_params=None):
      """List test matrices.
The matrices are returned in the order of newest first by submit time.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project
- INVALID_ARGUMENT - if the request is malformed

      Args:
        request: (TestingProjectsTestMatricesListRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (ListTestMatricesResponse) The response message.
      """
      config = self.GetMethodConfig('List')
      return self._RunMethod(
          config, request, global_params=global_params)

  class ProjectsService(base_api.BaseApiService):
    """Service class for the projects resource."""

    _NAME = u'projects'

    def __init__(self, client):
      super(TestingV1.ProjectsService, self).__init__(client)
      self._method_configs = {
          }

      self._upload_configs = {
          }

  class TestEnvironmentCatalogService(base_api.BaseApiService):
    """Service class for the testEnvironmentCatalog resource."""

    _NAME = u'testEnvironmentCatalog'

    def __init__(self, client):
      super(TestingV1.TestEnvironmentCatalogService, self).__init__(client)
      self._method_configs = {
          'Get': base_api.ApiMethodInfo(
              http_method=u'GET',
              method_id=u'testing.testEnvironmentCatalog.get',
              ordered_params=[u'environmentType'],
              path_params=[u'environmentType'],
              query_params=[],
              relative_path=u'v1/testEnvironmentCatalog/{environmentType}',
              request_field='',
              request_type_name=u'TestingTestEnvironmentCatalogGetRequest',
              response_type_name=u'TestEnvironmentCatalog',
              supports_download=False,
          ),
          }

      self._upload_configs = {
          }

    def Get(self, request, global_params=None):
      """Get the catalog of supported test environments.

May return any of the following canonical error codes:

- INVALID_ARGUMENT - if the request is malformed
- NOT_FOUND - if the environment type does not exist
- INTERNAL - if an internal error occurred

      Args:
        request: (TestingTestEnvironmentCatalogGetRequest) input message
        global_params: (StandardQueryParameters, default: None) global arguments
      Returns:
        (TestEnvironmentCatalog) The response message.
      """
      config = self.GetMethodConfig('Get')
      return self._RunMethod(
          config, request, global_params=global_params)


text:
Get metrics from kubernetes_state service in real time to:

* Visualize and monitor kubernetes_state states
* Be notified about kubernetes_state failovers and events.

## Setup
### Installation

Install the `dd-check-kubernetes_state` package manually or with your favorite configuration manager

### Configuration

Edit the `kubernetes_state.yaml` file to point to your server and port, set the masters to monitor

### Validation

When you run `datadog-agent info` you should see something like the following:

    Checks
    ======

        kubernetes_state
        -----------
          - instance #0 [OK]
          - Collected 39 metrics, 0 events & 7 service checks

## Compatibility

The kubernetes_state check is compatible with all major platforms

## Data Collected
### Metrics
See [metadata.csv](https://github.com/DataDog/integrations-core/blob/master/kubernetes_state/metadata.csv) for a list of metrics provided by this integration.

### Events
The Kubernetes-state check does not include any event at this time.

### Service Checks
The Kubernetes-state check does not include any service check at this time.

redpajama_set_name: RedPajamaGithub


text:
from __future__ import print_function

import re
import sys

import setuptools

REQUIREMENTS = [
    "kazoo==2.0",
    "six==1.11.0",
]

# Regex matching pattern  followed by 3 numerical values separated by .
pattern = re.compile("[0-9]+\.[0-9]+\.?[0-9]*")

def get_version():
    with open("CHANGELOG.md", "r") as fn:
        while True:
            version = pattern.findall(fn.readline())
            if len(version) > 0:
                return "".join(version[0])

if __name__ == "__main__":
    if len(sys.argv) > 1 and sys.argv[1] == "requirements":
        for req in REQUIREMENTS:
            print(req)
        sys.exit(0)

    setuptools.setup(
        name="runners",
        version=get_version(),
        author="EDITD",
        author_email="engineering@editd.com",
        packages=setuptools.find_packages(),
        scripts=[],
        url="https://github.com/EDITD/runners",
        license="LICENSE.txt",
        description="Help with running stuff",
        long_description="View the github page " +
            "(https://github.com/EDITD/runners) for more details.",
        install_requires=REQUIREMENTS,
    )


text:
namespace Sdl.Community.GroupShareKit.Models.Response.TranslationMemory
{
    public class TmSettings
    {
	    public string Id { get; set; }
	    public bool Lookup { get; set; }
	    public bool Update { get; set; }
	    public bool Concordance { get; set; }
	    public int Penalty { get; set; }
    }
}


text:
package graph;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Classe para armazenar o grafos e respectivas configurações.
 * @author aline
 *
 */
public class Graph {

	private File file; //Arquivo CSV de entrada.

	private Map<String, Vertex> interfaces = new HashMap<String, Vertex>();
	private Map<String, Vertex> clients = new HashMap<String, Vertex>();

	public Graph(final File file) {
		this.file = file;
		this.createGraph();
	}

	/**
	 * Preenche matriz de vertices e respectivas arestas.
	 */
	private void createGraph(){
		try {
			BufferedReader inputReader = new BufferedReader(new FileReader(this.file));
			String  line = null;
			while((line = inputReader.readLine()) != null){ //Percorre as linhas do arquivo.
				String values[] = line.split(";");
				String interfaceInternal = values[1];
				String client = values[0];
				this.addClientToInterface(interfaceInternal, client);
				this.addClient(interfaceInternal, client);
			}
			System.out.println(this.interfaces.size() + " interfaces.");
			System.out.println(this.clients.size() + " clientes.");
		} catch (IOException e) {
			System.err.println("[ERROR] Falha ao ler o arquivo de entrada." + e);
		}
	}

	private void addClientToInterface(final String interfaceInternal, final String client){

		if(this.interfaces.containsKey(interfaceInternal)){
			if(!this.interfaces.get(interfaceInternal).getListAdj().contains(client)){
				this.interfaces.get(interfaceInternal).getListAdj().add(client);
			}
		}
		else{
			Vertex v = new Vertex();
			v.setType(Type.INTERNAL_INTERFACE);
			v.setLabel(interfaceInternal);
			v.getListAdj().add(client);
			this.interfaces.put(interfaceInternal, v);
		}
	}

	private void addClient(final String interfaceInternal, final String client){
		if(this.clients.containsKey(client)){
			if(!this.clients.get(client).getListAdj().contains(interfaceInternal)){
				this.clients.get(client).getListAdj().add(interfaceInternal);
			}
		}
		else{
			Vertex v = new Vertex();
			v.setType(Type.CLIENT);
			v.setLabel(client);
			v.getListAdj().add(interfaceInternal);
			this.clients.put(client, v);
		}
	}

	/**
	 * Calcula o baseline (solução exata), do cálculo do conjunto dominante.
	 * @param list
	 * @return
	 */
	public List<String> calcBaseline() {
		Baseline baseline = new Baseline();
		return baseline.calc(this.interfaces, this.clients);
	}

	/**
	 * Calcula o heurística gulosa para cálculo do baseline.
	 * @param list
	 * @return
	 */
	public List<String> calcHeuristic() {
		Heuristic heuristic = new Heuristic();
		return heuristic.calc(this.interfaces, this.clients);
	}

}


text:
<sect1 id="zend.config.introduction">
    <title>Úvod</title>
    <para>
        Zend_Config je navrhnutý pre zjednodušenie prístupu a použitia
        konfiguračných údajov v rámci aplikácie. Poskytuje vnorené vlastnosti pre
        prístup ku konfigurácii v rámci aplikácie. Konfiguračné údaje môžu byt
        z rozličných zdrojov a je podporované aj hierarchické uloženie. Momentálne
        Zend_Config poskytuje adaptéry pre prístup k konfiguračným
        dátam uloženým v textových súboroch pomocou
        <link linkend="zend.config.adapters.ini">Zend_Config_Ini</link> a
        <link linkend="zend.config.adapters.xml">Zend_Config_Xml</link>.
    </para>
    <example id="zend.config.introduction.example.using">
        <title>Použitie Zend_Config</title>
        <para>
            Očakáva sa, že sa použije jeden z adaptérov ako napríklad
            <link linkend="zend.config.adapters.ini">Zend_Config_Ini</link>, alebo
            <link linkend="zend.config.adapters.xml">Zend_Config_Xml</link>, ale
            ak sú konfiguračné dáta prístupné ako PHP pole, je možné predať toto
            pole Zend_Config konštruktoru a zužitkovať jednoduchý
            objektovo-orientovaný prístup:
        </para>
        <programlisting role="php"><![CDATA[<?php
// konfigurácia uložená v poli
$configArray = array(
    'webhost' => 'www.example.com',
    'database' => array(
        'type'     => 'pdo_mysql',
        'host'     => 'db.example.com',
        'username' => 'dbuser',
        'password' => 'secret',
        'name'     => 'dbname'
    )
);

// Vytvorenie Zend_Config
require_once 'Zend/Config.php';
$config = new Zend_Config($configArray);

// vypísanie položky z konfigurácie (výsledok: 'www.example.com')
echo $config->webhost;

// Použitie dát na pripojenie k databáze
$myApplicationObject->databaseConnect($config->database->type,
                                      $config->database->host,
                                      $config->database->username,
                                      $config->database->password,
                                      $config->database->name);]]></programlisting>
    </example>
    <para>
        V uvedenom príklade, Zend_Config poskytuje pomocou vnorených
        objektov prístup ku konfiguračným dátam, ktoré mu boli predané v konštruktore.
    </para>
    <para>
        Popri objektovo-orientovanom prístupe Zend_Config poskytuje
        metódu get() ktorá umožňuje vrátiť zadanú východziu hodnotu.
        Na príklad:
    </para>
    <programlisting role="php"><![CDATA[<?php
    $host = $config->database->get('host', 'localhost');
    ]]></programlisting>
</sect1>


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

  angular
  .module('hires.routes')
  .config(routeConfig);

  routeConfig.$inject = ['$stateProvider'];

  function routeConfig($stateProvider) {
    $stateProvider
    .state('hires', {
      abstract: true,
      url: '/hires',
      template: '<ui-view/>'
    })
    .state('hires.interview', {
      url: '/interview',
      templateUrl: 'modules/hires/client/views/interview-hires.client.view.html',
      controller: 'InterviewHiresController',
      controllerAs: 'vm',
      data: {
        pageTitle: 'SkillFinderQ Hiring Module - Interview'
      }
    })
    .state('hires.interview_1', {
      url: '/interview_1',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Interview 1',
        section: { module: 0, unit: 0, chapter: 0, section: 0 }
      }
    })
    .state('hires.interview_2', {
      url: '/interview_2',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Interview 2',
        section: { module: 0, unit: 0, chapter: 1, section: 0 }
      }
    })
    .state('hires.location_1', {
      url: '/location_1',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Previous Location',
        section: { module: 0, unit: 1, chapter: 0, section: 0 }
      }
    })
    .state('hires.location_2', {
      url: '/location_2',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Current Location',
        section: { module: 0, unit: 1, chapter: 1, section: 0 }
      }
    })
    .state('hires.checks', {
      url: '/checks',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Checks',
        section: { module: 0, unit: 2, chapter: 0, section: 0 }
      }
    })
    .state('hires.tests', {
      url: '/tests',
      templateUrl: 'modules/hires/client/views/list-hires.client.view.html',
      controller: 'HiresListController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Tests',
        section: { module: 0, unit: 3, chapter: 0, section: 0 }
      }
    })
    .state('hires.candidateReport', {
      url: '/reports/candidate',
      templateUrl: 'modules/hires/client/views/individual-report-hires.client.view.html',
      controller: 'HiresIndividualReportController',
      controllerAs: 'vm',
      params: {
        id: {}
      },
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Individual Report'
      }
    })
    .state('hires.comparisonReport', {
      url: '/reports/comparison',
      templateUrl: 'modules/hires/client/views/comparison-report-hires.client.view.html',
      controller: 'HiresReportsController',
      controllerAs: 'vm',
      data: {
        roles: ['user', 'admin'],
        pageTitle: 'SkillFinderQ Hiring Module - Comparison Report'
      }
    });
  }

}());


text:
/**
 * Application for bootstrapping Master/Minion Nodes in kubernetes.
 */
package org.onosproject.k8snode.web;


text:
import collections

from cassandra.query import ValueSequence

from cqlsl.utils import sorted_kwargs

try:
    basestring
except NameError:
    basestring = str

class BaseStatement(object):
    def __init__(self, table_name):
        self.table_name = table_name

    @property
    def query(self):
        raise NotImplementedError('Redefine this in derived classes')

    @property
    def context(self):
        raise NotImplementedError('Redefine this in derived classes')

class WhereClauseMixin(object):
    CONDITIONS = {
        'in': 'IN',
        'gt': '>',
        'lt': '<',
        'gte': '>=',
        'lte': '<=',
    }

    def __init__(self):
        self._where_conditions = {}

    def where(self, **conditions):
        self._where_conditions = sorted_kwargs(**conditions)
        return self

    def _get_where_clause(self):
        conditions = []

        for expression in self._where_conditions.keys():
            try:
                field, condition = expression.rsplit('__', 1)
            except ValueError:
                field, condition = expression, None

            if condition and condition not in self.CONDITIONS:
                raise AttributeError('Unknown condition "{}"'.format(condition))

            condition = self.CONDITIONS.get(condition, '=')
            conditions.append('{field} {condition} %s'.format(field=field, condition=condition))

        return ' AND '.join(conditions)

    def _get_where_context(self):
        context = []

        for value in self._where_conditions.values():
            if isinstance(value, collections.Iterable) and not isinstance(value, basestring):
                value = ValueSequence(value)

            context.append(value)

        return tuple(context)


text:
<?xml version="1.0" encoding="UTF-8" ?>

<!--  This file is part of the DITA Open Toolkit project. See the accompanying LICENSE file for applicable license.  -->

<project name="sample_all" default="all" basedir=".">

  <property name="args.logdir" value="log"/>

  <import file="sample_html5.xml"/>
  <import file="sample_xhtml_plus_css.xml"/>
  <import file="sample_tocjs.xml"/>
  <import file="sample_eclipsehelp.xml"/>
  <import file="sample_htmlhelp.xml"/>
  <import file="sample_pdf.xml"/>
  <import file="sample_troff.xml"/>

  <target name="all" depends="samples"/>

  <target name="samples" description="build the sample output"
          depends="samples.html5, samples.xhtml_plus_css, samples.tocjs, samples.eclipse, samples.htmlhelp, samples.pdf, samples.troff"/>

  <target name="clean.samples" description="remove the sample output"
          depends="clean.samples.html5, clean.samples.xhtml_plus_css, clean.samples.eclipse, clean.samples.tocjs, clean.samples.htmlhelp, clean.samples.pdf">
    <delete dir="${dita.dir}/out/samples"/>
  </target>

</project>


text:
namespace NQtScreen {

template<class T>
class TSerializer {
public:
    static void Save(std::ostream& out, const T& object) {
        object.Save(out);
    }
    static void Load(std::istream& in, T& object) {
        object.Load(in);
    }
};

template <class T>
static inline void Save(std::ostream& out, const T& t);

template <class T>
static inline void Load(std::istream& in, T& t);

template <class A, class B>
class TSerializer<std::pair<A, B> > {
public:
    static void Save(std::ostream& out, const std::pair<A, B>& object) {
        NQtScreen::Save(out, object.first);
        NQtScreen::Save(out, object.second);
    }
    static void Load(std::istream& in, std::pair<A, B>& object) {
        NQtScreen::Load(in, object.first);
        NQtScreen::Load(in, object.second);
    }
};

template<class TVec, class TObj>
class TVectorSerializer {
public:
    static inline void Save(std::ostream& out, const TVec& object) {
        unsigned short size = object.size();
        out.write((const char*)(&size), 2);
        for (const auto& obj: object) {
            NQtScreen::Save(out, obj);
        }
    }

    static inline void Load(std::istream& in, TVec& object) {
        unsigned short size;
        in.read((char*)(&size), 2);
        object.clear();
        for (size_t i = 0; i < size; ++i) {
            TObj obj;
            NQtScreen::Load(in, obj);
            object.push_back(std::move(obj));
        }
    }
};

template <class T> class TSerializer<std::vector<T> >: public TVectorSerializer<std::vector<T>, T > {};
template <class T> class TSerializer<std::list<T> >: public TVectorSerializer<std::list<T>, T > {};
template <> class TSerializer<std::string>: public TVectorSerializer<std::string, char> {};

template <class T>
class TPodSerializer {
public:
    static inline void Save(std::ostream& out, const T& object) {
        out.write((const char*)(&object), sizeof(T));
    }
    static inline void Load(std::istream& in, T& object) {
        in.read((char*)(&object), sizeof(T));
    }
};

template <> class TSerializer<bool>: public TPodSerializer<bool> {};
template <> class TSerializer<char>: public TPodSerializer<char> {};
template <> class TSerializer<signed char>: public TPodSerializer<signed char> {};
template <> class TSerializer<uint8_t>: public TPodSerializer<uint8_t> {};
template <> class TSerializer<int16_t>: public TPodSerializer<int16_t> {};
template <> class TSerializer<uint16_t>: public TPodSerializer<uint16_t> {};
template <> class TSerializer<int32_t>: public TPodSerializer<int32_t> {};
template <> class TSerializer<uint32_t>: public TPodSerializer<uint32_t> {};
template <> class TSerializer<long>: public TPodSerializer<long> {};
template <> class TSerializer<unsigned long>: public TPodSerializer<unsigned long> {};

template <> class TSerializer<int64_t>: public TPodSerializer<int64_t> {};
template <> class TSerializer<uint64_t>: public TPodSerializer<uint64_t> {};

template <> class TSerializer<float>: public TPodSerializer<float> {};
template <> class TSerializer<double>: public TPodSerializer<double> {};

template <class T>
static inline void Save(std::ostream& out, const T& t) {
    TSerializer<T>::Save(out, t);
}

template <class T>
static inline void Load(std::istream& in, T& t) {
    TSerializer<T>::Load(in, t);
}

template <class T1>
static inline void SaveMany(std::ostream& out, const T1& t1) {
    NQtScreen::Save(out, t1);
}
template <class T1>
static inline void LoadMany(std::istream& in, T1& t1) {
    NQtScreen::Load(in, t1);
}

template <class T1, class T2>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2) {
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
}
template <class T1, class T2>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2) {
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
}

template <class T1, class T2, class T3>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2, const T3& t3) {
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
}
template <class T1, class T2, class T3>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3) {
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
}

template <class T1, class T2, class T3, class T4>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
}
template <class T1, class T2, class T3, class T4>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3, T4& t4) {
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
}

template <class T1, class T2, class T3, class T4, class T5>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2,
                            const T3& t3, const T4& t4, const T5& t5)
{
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
    NQtScreen::Save(out, t5);
}
template <class T1, class T2, class T3, class T4, class T5>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3,
                            T4& t4, T5& t5)
{
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
    NQtScreen::Load(in, t5);
}

template <class T1, class T2, class T3, class T4, class T5, class T6>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2,
                            const T3& t3, const T4& t4, const T5& t5, const T6& t6)
{
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
    NQtScreen::Save(out, t5);
    NQtScreen::Save(out, t6);
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3,
                            T4& t4, T5& t5, T6& t6)
{
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
    NQtScreen::Load(in, t5);
    NQtScreen::Load(in, t6);
}

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2,
                            const T3& t3, const T4& t4, const T5& t5, const T6& t6,
                            const T7& t7)
{
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
    NQtScreen::Save(out, t5);
    NQtScreen::Save(out, t6);
    NQtScreen::Save(out, t7);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3,
                            T4& t4, T5& t5, T6& t6, T7& t7)
{
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
    NQtScreen::Load(in, t5);
    NQtScreen::Load(in, t6);
    NQtScreen::Load(in, t7);
}

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2,
                            const T3& t3, const T4& t4, const T5& t5, const T6& t6,
                            const T7& t7, const T8& t8)
{
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
    NQtScreen::Save(out, t5);
    NQtScreen::Save(out, t6);
    NQtScreen::Save(out, t7);
    NQtScreen::Save(out, t8);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3,
                            T4& t4, T5& t5, T6& t6, T7& t7, T8& t8)
{
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
    NQtScreen::Load(in, t5);
    NQtScreen::Load(in, t6);
    NQtScreen::Load(in, t7);
    NQtScreen::Load(in, t8);
}

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
static inline void SaveMany(std::ostream& out, const T1& t1, const T2& t2,
                            const T3& t3, const T4& t4, const T5& t5, const T6& t6,
                            const T7& t7, const T8& t8, const T9& t9)
{
    NQtScreen::Save(out, t1);
    NQtScreen::Save(out, t2);
    NQtScreen::Save(out, t3);
    NQtScreen::Save(out, t4);
    NQtScreen::Save(out, t5);
    NQtScreen::Save(out, t6);
    NQtScreen::Save(out, t7);
    NQtScreen::Save(out, t8);
    NQtScreen::Save(out, t9);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
static inline void LoadMany(std::istream& in, T1& t1, T2& t2, T3& t3,
                            T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9)
{
    NQtScreen::Load(in, t1);
    NQtScreen::Load(in, t2);
    NQtScreen::Load(in, t3);
    NQtScreen::Load(in, t4);
    NQtScreen::Load(in, t5);
    NQtScreen::Load(in, t6);
    NQtScreen::Load(in, t7);
    NQtScreen::Load(in, t8);
    NQtScreen::Load(in, t9);
}

#define SAVELOAD(...) \
    inline virtual void Save(std::ostream& out) const { \
        NQtScreen::SaveMany(out, __VA_ARGS__);             \
    } \
 \
    inline virtual void Load(std::istream& in) { \
        NQtScreen::LoadMany(in, __VA_ARGS__);             \
    }

struct membuf: std::streambuf {
    membuf(char const* base, size_t size) {
        char* p(const_cast<char*>(base));
        this->setg(p, p, p + size);
    }
};
struct imemstream: virtual membuf, std::istream {
    imemstream(char const* base, size_t size)
        : membuf(base, size)
        , std::istream(static_cast<std::streambuf*>(this)) {
    }
};

#define SAVELOAD_POD(TypeName) template <> class TSerializer<TypeName>: public TPodSerializer<TypeName> {};

} // NQtScreen


text:
pub use anyhow::{anyhow, Context, Result};
pub use log::{debug, info};


text:
@class CRendererView2;

@interface CMainWindowController : NSWindowController {

}

@property (readwrite, nonatomic, retain) IBOutlet CRendererView2 *rendererView;

@end


text:
package caperutxa.dimoni.parser.report.steps;

import caperutxa.dimoni.parser.report.ReportStep;

public class StepMinor extends ReportStep {

	public StepMinor(String content) {
		super(content);
		iconClass = "glyphicon glyphicon-eye-close";
		cssClass = "col-xs-11 col-xs-offset-1 text-primary";
	}

	@Override
	public void parseContent() {
		// Nothing to do
	}
}


text:
package com.gemstone.gemfire.cache.query.partitioned;

import java.io.Serializable;

import com.gemstone.gemfire.LogWriter;
import com.gemstone.gemfire.cache.query.data.PortfolioData;
import com.gemstone.gemfire.internal.cache.PartitionedRegionDUnitTestCase;

import dunit.Host;
import dunit.VM;

/**
 *This tests executes an array of queries to be executed over the PR ,
 * benchmarking them over the time taken by the same when executed over the
 * Local Region
 * The performance difference is reported for scenarios
 * encompassing various permutations of the PR attributes
 * like Redundancy / No. of D.S / No. of Accessors etc
 *
 * @author pbatra
 */

public class PRQueryPerfDUnitTest extends PartitionedRegionDUnitTestCase {
  public static final int SLEEP = 0;

  /**
   * Constructor
   *
   * @param name
   */

  public PRQueryPerfDUnitTest(String name) {
    super(name);
  }

  int totalNumBuckets = 100;

  PRQueryDUnitHelper PRQHelp = new PRQueryDUnitHelper("");

  final String name = "Portfolios";

  final String localName = "LocalPortfolios";

  final int cnt = 0, cntDest = 5000;

  /**
   * A nuthing test to make DUnit happy.
   * The rest of these tests shouldn't be run
   * as part of our CruiseControl or precheckin
   * since they don't assert any behavior.
   */
  public void testNuthin() {}

  /**
   * This tests executes an array of queries to be executed over the PR ,
   * benchmarking them over the time taken by the same when executed over the
   * Local Region with
   * One Accessor
   * One Datastore
   * Redundancy =0
   *
   */
  public void norun_testBenchmarkingQueryingOneAccessorOneDS_Redundancy0()
  throws Exception
 {

    LogWriter log = getLogWriter();
    log.info("BenchMarking PR Querying Test Started*****");
    Host host = Host.getHost(0);

    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);

    int redundancy = 0;

    try {
      setVMInfoLogLevel();

      // Creating Accessor PR's on the participating VM's
      log.info("Creating Accessor node on VM0");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRAccessorCreate(name,
          redundancy));
      log.info("Successfully Created Accessor node on VM0");

      log.info("Creating Datastores across  VM1");
      vm1.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      log.info("Successfully Created Datastores on VM1");

      // creating a local region on one of the JVM's
      log.info("Creating Local Region on VM0");
      vm0.invoke(PRQHelp
          .getCacheSerializableRunnableForLocalRegionCreation(localName));
      log.info("Successfully Created Local Region on VM0");

      // Generating portfolio object array to be populated across the PR's & Local
      // Regions

      final PortfolioData[] portfolio = PRQHelp.createPortfolioData(cnt, cntDest);

      // Putting the data into the accessor node
      log.info("Inserting Portfolio data through the accessor node");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(name, portfolio,
          cnt, cntDest));
      log.info("Successfully Inserted Portfolio data through the accessor node");

      // Putting the same data in the local region created
      log
          .info("Inserting Portfolio data on local node  VM0 for result " +
                        "set comparison");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(localName,
          portfolio, cnt, cntDest));
      log
          .info("Successfully Inserted Portfolio data on local node  VM0 for" +
                        " result set comparison");

      ResultsObject perfR = new ResultsObject();
      perfR.OperationDescription = "PR with 1 Accessor, 1 D.S., Redundancy =0,";
      perfR.NumberOfAccessors = 1;
      perfR.NumberOfDataStores = 1;
      perfR.redundancy = 0;

      if (SLEEP > 0) {
        Thread.sleep(SLEEP);
      }

      // querying the VM for data
      log.info("Querying on VM0 both on PR Region & local, also comparing the " +
                "Results sets from both");
      vm0.invoke(PRQHelp.PRQueryingVsLocalQuerying(name, localName, perfR));

      log.info("Benchmarking Querying between PR & local  ENDED*****");
    }
    finally {
      resetVMLogLevel();
    }
}

  /**
   * This tests executes an array of queries to be executed over the PR ,
   * benchmarking them over the time taken by the same when executed over the
   * Local Region with
   * One Accessor
   * Two Datastore
   * Redundancy =0
   *
   */

  public void norun_testBenchmarkingQueryingOneAccessorTwoDS_Redundancy0()
      throws Exception
  {
    LogWriter log = getLogWriter();

    log.info("BenchMarking PR Querying Test Started*****");
    Host host = Host.getHost(0);

    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);

    int redundancy = 0;

    try {
      setVMInfoLogLevel();

      // Creating Accessor PR's on the participating VM's
      log.info("Creating Accessor node on VM0");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRAccessorCreate(name,
          redundancy));
      log.info("Successfully Created Accessor node on VM0");

      log.info("Creating Datastores across  VM1 , VM2");
      vm1.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm2.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      log.info("Successfully Created Datastores on VM1 , VM2");

      // creating a local region on one of the JVM's
      log.info("Creating Local Region on VM0");
      vm0.invoke(PRQHelp
          .getCacheSerializableRunnableForLocalRegionCreation(localName));
      log.info("Successfully Created Local Region on VM0");

      // Generating portfolio object array to be populated across the PR's & Local
      // Regions

      final PortfolioData[] portfolio = PRQHelp.createPortfolioData(cnt, cntDest);

      // Putting the data into the accessor node
      log.info("Inserting Portfolio data through the accessor node");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(name, portfolio,
          cnt, cntDest));
      log.info("Successfully Inserted Portfolio data through the accessor node");

      // Putting the same data in the local region created
      log
          .info("Inserting Portfolio data on local node  VM0 for result set comparison");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(localName,
          portfolio, cnt, cntDest));
      log.info("Successfully Inserted Portfolio data on local node  VM0 for " +
                "result set comparison");

      ResultsObject perfR = new ResultsObject();
      perfR.OperationDescription = "PR with 1 Accessor, 2 D.S., Redundancy=0";
      perfR.NumberOfAccessors = 1;
      perfR.NumberOfDataStores = 2;
      perfR.redundancy = 0;

      if (SLEEP > 0) {
        Thread.sleep(SLEEP);
      }

      // querying the VM for data
      log.info("Querying on VM0 both on PR Region & local, also comparing the " +
                "results sets from both");
      vm0.invoke(PRQHelp.PRQueryingVsLocalQuerying(name, localName, perfR));

      log.info("Benchmarking Querying between PR & local  ENDED*****");
    }
    finally {
      resetVMLogLevel();
    }
  }

  /**
   * This tests executes an array of queries to be executed over the PR ,
   * benchmarking them over the time taken by the same when executed over the
   * Local Region with One Accessor Two Datastore  Redundancy =1
   *
   */

  public void norun_testBenchmarkingQueryingOneAccessorTwoDS_D_ACK_Redundancy1()
      throws Exception
  {
    LogWriter log = getLogWriter();
    log.info("BenchMarking PR Querying Test Started*****");
    Host host = Host.getHost(0);

    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);

    int redundancy = 1;

    try {
      setVMInfoLogLevel();

      // Creating Accessor PR's on the participating VM'sw
      log.info("Creating Accessor node on VM0");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRAccessorCreate(name,
          redundancy));
      log.info("Successfully Created Accessor node on VM0");

      log.info("Creating Datastores across  VM1 , VM2");
      vm1.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm2.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      log.info("Successfully Created Datastores on VM1 , VM2");

      // creating a local region on one of the JVM's
      log.info("Creating Local Region on VM0");
      vm0.invoke(PRQHelp
          .getCacheSerializableRunnableForLocalRegionCreation(localName));
      log.info("Successfully Created Local Region on VM0");

      // Generating portfolio object array to be populated across the PR's & Local
      // Regions

      final PortfolioData[] portfolio = PRQHelp.createPortfolioData(cnt, cntDest);

      // Putting the data into the accessor node
      log.info("Inserting Portfolio data through the accessor node");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(name, portfolio,
          cnt, cntDest));
      log.info("Successfully Inserted Portfolio data through the accessor node");

      // Putting the same data in the local region created
      log.info("Inserting Portfolio data on local node VM0 for result " +
                "set comparison");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(localName,
          portfolio, cnt, cntDest));
      log.info("Successfully Inserted Portfolio data on local node VM0 for " +
                "result set comparison");

      ResultsObject perfR = new ResultsObject();
      perfR.OperationDescription = "PR with 1 Accessor, 2 D.S., Redundancy=1";
      perfR.NumberOfAccessors = 1;
      perfR.NumberOfDataStores = 2;
      perfR.redundancy = 1;

      if (SLEEP > 0) {
        Thread.sleep(SLEEP);
      }

      // querying the VM for data
      log.info("Querying on VM0 both on PR Region & local, also comparing the " +
                "results sets from both");
      vm0.invoke(PRQHelp.PRQueryingVsLocalQuerying(name, localName, perfR));

      log.info("Benchmarking Querying between PR & local  ENDED*****");
    }
    finally {
      resetVMLogLevel();
    }
  }

  /**
   * This tests executes an array of queries to be executed over the PR ,
   * benchmarking them over the time taken by the same when executed over the
   * Local Region with One Accessor Three Datastore Redundancy =1
   *
   */

  public void norun_testBenchmarkingQueryingOneAccessorThreeDS_Redundancy1()
      throws Exception
  {
    LogWriter log = getLogWriter();
    log.info("BenchMarking PR Querying Test Started*****");
    Host host = Host.getHost(0);

    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    VM vm3 = host.getVM(3);

    int redundancy = 1;

    try {
      setVMInfoLogLevel();

      // Creating Accessor PR's on the participating VM's
      log.info("Creating Accessor node on VM0");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRAccessorCreate(name,
          redundancy));
      log.info("Successfully Created Accessor node on VM0");

      log.info("Creating Datastores across  VM1 , VM2 , VM3");
      vm1.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm2.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm3.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));

      log.info("Successfully Created Datastores on VM1 , VM2 ,VM3");

      // creating a local region on one of the JVM's
      log.info("Creating Local Region on VM0");
      vm0.invoke(PRQHelp
          .getCacheSerializableRunnableForLocalRegionCreation(localName));
      log.info("Successfully Created Local Region on VM0");

      // Generating portfolio object array to be populated across the PR's & Local
      // Regions

      final PortfolioData[] portfolio = PRQHelp.createPortfolioData(cnt, cntDest);

      // Putting the data into the accessor node
      log.info("Inserting Portfolio data through the accessor node");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(name, portfolio,
          cnt, cntDest));
      log.info("Successfully Inserted Portfolio data through the accessor node");

      // Putting the same data in the local region created
      log.info("Inserting Portfolio data on local node  VM0 for result set comparison");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(localName,
          portfolio, cnt, cntDest));
      log.info("Successfully Inserted Portfolio data on local node VM0 for " +
                "result set comparison");

      ResultsObject perfR = new ResultsObject();
      perfR.OperationDescription = "PR with 1 Accessor, 3 D.S., Redundancy=1";
      perfR.NumberOfAccessors = 1;
      perfR.NumberOfDataStores = 3;
      perfR.redundancy = 1;

      if (SLEEP > 0) {
        Thread.sleep(SLEEP);
      }

      // querying the VM for data
      log.info("Querying on VM0 both on PR Region & local, also comparing the " +
                "results sets from both");
      vm0.invoke(PRQHelp.PRQueryingVsLocalQuerying(name, localName, perfR));

      log.info("Benchmarking Querying between PR & local  ENDED*****");
    }
    finally {
      resetVMLogLevel();
    }
  }

  /**
   * This tests executes an array of queries to be executed over the PR ,
   * benchmarking them over the time taken by the same when executed over the
   * Local Region with One Accessor Three Datastore  Redundancy =2
   *
   */

  public void norun_testBenchmarkingQueryingOneAccessorThreeDS_Redundancy2()
      throws Exception
  {
    LogWriter log = getLogWriter();
    log.info("BenchMarking PR Querying Test Started*****");
    Host host = Host.getHost(0);

    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    VM vm3 = host.getVM(3);

    int redundancy = 2;

    try {
      setVMInfoLogLevel();

      // Creating Accessor PR's on the participating VM's
      log.info("Creating Accessor node on VM0");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRAccessorCreate(name,
          redundancy));
      log.info("Successfully Created Accessor node on VM0");

      log.info("Creating Datastores across  VM1 , VM2 , VM3");
      vm1.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm2.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));
      vm3.invoke(PRQHelp.getCacheSerializableRunnableForPRCreate(name, redundancy));

      log.info("Successfully Created Datastores on VM1 , VM2 , VM3");

      // creating a local region on one of the JVM's
      log.info("Creating Local Region on VM0");
      vm0.invoke(PRQHelp
          .getCacheSerializableRunnableForLocalRegionCreation(localName));
      log.info("Successfully Created Local Region on VM0");

      // Generating portfolio object array to be populated across the PR's & Local
      // Regions

      final PortfolioData[] portfolio = PRQHelp.createPortfolioData(cnt, cntDest);

      // Putting the data into the accessor node
      log.info("Inserting Portfolio data through the accessor node");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(name, portfolio,
          cnt, cntDest));
      log.info("Successfully Inserted Portfolio data through the accessor node");

      // Putting the same data in the local region created
      log.info("Inserting Portfolio data on local node  VM0 for result set comparison");
      vm0.invoke(PRQHelp.getCacheSerializableRunnableForPRPuts(localName,
          portfolio, cnt, cntDest));
      log.info("Successfully Inserted Portfolio data on local node VM0 for " +
                "result set comparison");

      ResultsObject perfR = new ResultsObject();
      perfR.OperationDescription = "PR with 1 Accessor, 3 D.S., Redundancy=2";
      perfR.NumberOfAccessors = 1;
      perfR.NumberOfDataStores = 3;
      perfR.redundancy = 2;

      if (SLEEP > 0) {
        Thread.sleep(SLEEP);
      }

      // querying the VM for data
      log.info("Querying on VM0 both on PR Region & local, also comparing the " +
                "results sets from both");
      vm0.invoke(PRQHelp.PRQueryingVsLocalQuerying(name, localName, perfR));

      log.info("Benchmarking Querying between PR & local  ENDED*****");
    }
    finally {
      resetVMLogLevel();
    }
  }

  /*
   * Inner class to for the ResultObject , displaying various attributes of the
   * Performance Report
   */
  class ResultsObject implements Serializable {
    String OperationDescription;
    long QueryingTimeLocal;
    long QueryingTimePR;
    int NumberOfDataStores = 0;
    int NumberOfAccessors = 0;
    int redundancy = 0;
  }

}


text:
<title>showresidual (Ezyfit Toolbox)</title>

<link rel=stylesheet href="docstyle1.css" type="text/css">

EzyFit Function Reference	<< Prev | Next >>

showresidual

Show the residuals of a fit

Description

showresidual(F) displays the residuals for the fit F in a new figure,
ie: plots the difference between the data and the fit.

showresidual is also available from the item 'Show Fit Residuals' in
the EzyFit menu (see efmenu).

If F is not specified, plots the residual for the last fit.

YRES = showresidual(...) returns the residuals (YRES = YDATA - YFIT).

showresidual(F, H) plots the residual in the figure H.

See Also

showfit, ezfit, efmenu.

Published output in the Help browser
   showdemo showresidual

 Previous: showfit	Next: showslope

2005-2014 EzyFit Toolbox 2.42


text:
/* Generated By:JJTree: Do not edit this line. SimpleNode.java */

package org.apache.el.parser;

import org.apache.el.lang.ELSupport;
import org.apache.el.lang.EvaluationContext;
import org.apache.el.util.MessageFactory;

import javax.el.ELException;
import javax.el.MethodInfo;
import javax.el.PropertyNotWritableException;
import javax.el.ValueReference;
import java.util.Arrays;

/**
 * @author Jacob Hookom [jacob@hookom.net]
 */
public abstract class SimpleNode extends ELSupport implements Node {
    protected Node parent;

    protected Node[] children;

    protected final int id;

    protected String image;

    public SimpleNode(int i) {
        id = i;
    }

    @Override
    public void jjtOpen() {
        // NOOP by default
    }

    @Override
    public void jjtClose() {
        // NOOP by default
    }

    @Override
    public void jjtSetParent(Node n) {
        parent = n;
    }

    @Override
    public Node jjtGetParent() {
        return parent;
    }

    @Override
    public void jjtAddChild(Node n, int i) {
        if (children == null) {
            children = new Node[i + 1];
        } else if (i >= children.length) {
            Node c[] = new Node[i + 1];
            System.arraycopy(children, 0, c, 0, children.length);
            children = c;
        }
        children[i] = n;
    }

    @Override
    public Node jjtGetChild(int i) {
        return children[i];
    }

    @Override
    public int jjtGetNumChildren() {
        return (children == null) ? 0 : children.length;
    }

    /*
     * You can override these two methods in subclasses of SimpleNode to
     * customize the way the node appears when the tree is dumped. If your
     * output uses more than one line you should override toString(String),
     * otherwise overriding toString() is probably all you need to do.
     */

    @Override
    public String toString() {
        if (this.image != null) {
            return ELParserTreeConstants.jjtNodeName[id] + "[" + this.image
                    + "]";
        }
        return ELParserTreeConstants.jjtNodeName[id];
    }

    @Override
    public String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    @Override
    public Class<?> getType(EvaluationContext ctx)
            throws ELException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Object getValue(EvaluationContext ctx)
            throws ELException {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean isReadOnly(EvaluationContext ctx)
            throws ELException {
        return true;
    }

    @Override
    public void setValue(EvaluationContext ctx, Object value)
            throws ELException {
        throw new PropertyNotWritableException(MessageFactory.get("error.syntax.set"));
    }

    @Override
    public void accept(NodeVisitor visitor) throws Exception {
        visitor.visit(this);
        if (this.children != null && this.children.length > 0) {
            for (int i = 0; i < this.children.length; i++) {
                this.children[i].accept(visitor);
            }
        }
    }

    @Override
    public Object invoke(EvaluationContext ctx, Class<?>[] paramTypes,
            Object[] paramValues) throws ELException {
        throw new UnsupportedOperationException();
    }

    @Override
    public MethodInfo getMethodInfo(EvaluationContext ctx,
            Class<?>[] paramTypes) throws ELException {
        throw new UnsupportedOperationException();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + Arrays.hashCode(children);
        result = prime * result + id;
        result = prime * result + ((image == null) ? 0 : image.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof SimpleNode)) {
            return false;
        }
        SimpleNode other = (SimpleNode) obj;
        if (!Arrays.equals(children, other.children)) {
            return false;
        }
        if (id != other.id) {
            return false;
        }
        if (image == null) {
            if (other.image != null) {
                return false;
            }
        } else if (!image.equals(other.image)) {
            return false;
        }
        return true;
    }

    /**
     * @since EL 2.2
     */
    @Override
    public ValueReference getValueReference(EvaluationContext ctx) {
        return null;
    }

    /**
     * @since EL 2.2
     */
    @Override
    public boolean isParametersProvided() {
        return false;
    }
}


text:
import { ElementRef, ViewContainerRef, Renderer2, ComponentFactoryResolver, NgZone, TemplateRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
import { AbstractControl, ControlValueAccessor, Validator } from '@angular/forms';
import { NgbDatepickerNavigateEvent } from './datepicker';
import { DayTemplateContext } from './datepicker-day-template-context';
import { NgbDateParserFormatter } from './ngb-date-parser-formatter';
import { PlacementArray } from '../util/positioning';
import { NgbDateStruct } from './ngb-date-struct';
import { NgbDateAdapter } from './adapters/ngb-date-adapter';
import { NgbCalendar } from './ngb-calendar';
import { NgbDatepickerService } from './datepicker-service';
/**
 * A directive that makes it possible to have datepickers on input fields.
 * Manages integration with the input field itself (data entry) and ngModel (validation etc.).
 */
export declare class NgbInputDatepicker implements OnChanges, OnDestroy, ControlValueAccessor, Validator {
    private _parserFormatter;
    private _elRef;
    private _vcRef;
    private _renderer;
    private _cfr;
    private _service;
    private _calendar;
    private _ngbDateAdapter;
    private _document;
    private _closed$;
    private _cRef;
    private _disabled;
    private _model;
    private _zoneSubscription;
    /**
     * Indicates whether the datepicker popup should be closed automatically after date selection or not.
     * If the value is 'false', the popup can be closed via 'close()' or 'toggle()' methods.
     *
     * @since 1.1.0
     */
    autoClose: boolean;
    /**
     * Reference for the custom template for the day display
     */
    dayTemplate: TemplateRef<DayTemplateContext>;
    /**
     * Number of months to display
     */
    displayMonths: number;
    /**
     * First day of the week. With default calendar we use ISO 8601: 1=Mon ... 7=Sun
     */
    firstDayOfWeek: number;
    /**
     * Callback to mark a given date as disabled.
     * 'Current' contains the month that will be displayed in the view
     */
    markDisabled: (date: NgbDateStruct, current: {
        year: number;
        month: number;
    }) => boolean;
    /**
     * Min date for the navigation. If not provided will be 10 years before today or `startDate`
     */
    minDate: NgbDateStruct;
    /**
     * Max date for the navigation. If not provided will be 10 years from today or `startDate`
     */
    maxDate: NgbDateStruct;
    /**
     * Navigation type: `select` (default with select boxes for month and year), `arrows`
     * (without select boxes, only navigation arrows) or `none` (no navigation at all)
     */
    navigation: 'select' | 'arrows' | 'none';
    /**
     * The way to display days that don't belong to current month: `visible` (default),
     * `hidden` (not displayed) or `collapsed` (not displayed with empty space collapsed)
     */
    outsideDays: 'visible' | 'collapsed' | 'hidden';
    /**
     * Placement of a datepicker popup accepts:
     *    "top", "top-left", "top-right", "bottom", "bottom-left", "bottom-right",
     *    "left", "left-top", "left-bottom", "right", "right-top", "right-bottom"
     * and array of above values.
     */
    placement: PlacementArray;
    /**
     * Whether to display days of the week
     */
    showWeekdays: boolean;
    /**
     * Whether to display week numbers
     */
    showWeekNumbers: boolean;
    /**
     * Date to open calendar with.
     * With default calendar we use ISO 8601: 'month' is 1=Jan ... 12=Dec.
     * If nothing or invalid date provided, calendar will open with current month.
     * Use 'navigateTo(date)' as an alternative
     */
    startDate: {
        year: number;
        month: number;
    };
    /**
     * A selector specifying the element the datepicker popup should be appended to.
     * Currently only supports "body".
     */
    container: string;
    /**
     * An event fired when user selects a date using keyboard or mouse.
     * The payload of the event is currently selected NgbDateStruct.
     *
     * @since 1.1.1
     */
    dateSelect: EventEmitter<NgbDateStruct>;
    /**
     * An event fired when navigation happens and currently displayed month changes.
     * See NgbDatepickerNavigateEvent for the payload info.
     */
    navigate: EventEmitter<NgbDatepickerNavigateEvent>;
    disabled: any;
    private _onChange;
    private _onTouched;
    private _validatorChange;
    constructor(_parserFormatter: NgbDateParserFormatter, _elRef: ElementRef<HTMLInputElement>, _vcRef: ViewContainerRef, _renderer: Renderer2, _cfr: ComponentFactoryResolver, ngZone: NgZone, _service: NgbDatepickerService, _calendar: NgbCalendar, _ngbDateAdapter: NgbDateAdapter<any>, _document: any);
    registerOnChange(fn: (value: any) => any): void;
    registerOnTouched(fn: () => any): void;
    registerOnValidatorChange(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    validate(c: AbstractControl): {
        [key: string]: any;
    };
    writeValue(value: any): void;
    manualDateChange(value: string, updateView?: boolean): void;
    isOpen(): boolean;
    /**
     * Opens the datepicker with the selected date indicated by the ngModel value.
     */
    open(): void;
    /**
     * Closes the datepicker popup.
     */
    close(): void;
    /**
     * Toggles the datepicker popup (opens when closed and closes when opened).
     */
    toggle(): void;
    /**
     * Navigates current view to provided date.
     * With default calendar we use ISO 8601: 'month' is 1=Jan ... 12=Dec.
     * If nothing or invalid date provided calendar will open current month.
     * Use 'startDate' input as an alternative
     */
    navigateTo(date?: {
        year: number;
        month: number;
    }): void;
    onBlur(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private _applyDatepickerInputs(datepickerInstance);
    private _applyPopupStyling(nativeElement);
    private _subscribeForDatepickerOutputs(datepickerInstance);
    private _writeModelValue(model);
    private _fromDateStruct(date);
}


text:
<?php
declare(strict_types=1);
namespace ParagonIE\Iaso;

use ParagonIE\ConstantTime\Binary;
use ParagonIE\Iaso\Contract\Blank;

/**
 * Class ParseState
 * @package ParagonIE\Iaso
 */
class ParseState
{
    /**
     * @var Contract
     */
    public $contract;

    /**
     * @var string
     */
    public $data = '';

    /**
     * @var int
     */
    public $length = 0;

    /**
     * @var int
     */
    public $pos = 0;

    /**
     * @var ResultSet
     */
    public $result;

    /**
     * @var array<mixed, array<mixed, mixed>>
     */
    public $stack = [];

    /**
     * @var int
     */
    public $start = 0;

    /**
     * ParseState constructor.
     * @param string $data
     * @param Contract|null $contract
     * @param int $start
     * @param int $len
     */
    public function __construct(
        string $data = '',
        Contract $contract = null,
        int $start = 0,
        int $len = 0
    ) {
        $this->data = $data;
        if (\is_null($contract)) {
            $contract = new Blank();
        }
        $this->contract = $contract;
        $this->start = $start;
        $this->length = $len;
    }

    /**
     * Get the current character.
     *
     * @return string
     */
    public function getChar(): string
    {
        if ($this->pos >= Binary::safeStrlen($this->data)) {
            return '';
        }
        return $this->data[$this->pos];
    }

    /**
     * @return bool
     */
    public function moreToRead(): bool
    {
        return $this->pos < $this->length;
    }

    /**
     * @return int
     */
    public function getLastIndex(): int
    {
        $keys = \array_keys($this->stack);
        return (int) \array_pop($keys);
    }

    /**
     * @param ResultSet $pop
     * @return ParseState
     * @throws JSONError
     */
    public function passToParent(ResultSet $pop): ParseState
    {
        if (empty($this->stack)) {
            // We're done parsing!
            $this->result = $pop;
            return $this;
        }

        $idx = $this->getLastIndex();
        if ($this->stack[$idx]['type'] === '[') {
            // Just append
            $this->stack[$idx]['obj'][] = clone $pop;
        } elseif ($this->stack[$idx]['type'] === '{') {
            // Specify its key value.
            if (empty($this->stack[$idx]['pending'])) {
                throw new JSONError('Unexpected value (no key)');
            }
            $key = $this->stack[$idx]['pending'];
            $this->stack[$idx]['obj'][$key] = clone $pop;
            unset($this->stack[$idx]['pending']);
        }
        return $this;
    }

    /**
     * Return the latest element of the array without removing it.
     *
     * @return array
     */
    public function softPop(): array
    {
        return $this->stack[$this->getLastIndex()];
    }
}


text:
declare module "react-smooth-marquee" {
  import * as React from "react";
  interface IProps {
    velocity?: number;
  }
  declare class Marquee extends React.Component<IProps>{}
  export default Marquee;
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Contr. Univ. Mich. Herb. 5: 23 (1941)

#### Original name
Mycena alnicola A.H. Sm.

### Remarks
null


text:
package com.esafirm.imagepicker.model;

import android.net.Uri;

import com.esafirm.imagepicker.helper.ImagePickerUtils;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class ImageFactory {

    public static List<Image> singleListFromPath(String path) {
        List<Image> images = new ArrayList<>();
        images.add(new Image(0, ImagePickerUtils.getNameFromFilePath(path), path, Uri.fromFile(new File(path)), true));
        return images;
    }
}