text:
// Type definitions for wolfy87-eventemitter v4.2.9
// Project: https://github.com/Wolfy87/EventEmitter
// Definitions by: ryiwamoto <https://github.com/ryiwamoto>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

declare class EventEmitter extends Wolfy87EventEmitter.EventEmitter {}
export = EventEmitter;
export as namespace EventEmitter;

declare namespace Wolfy87EventEmitter {

    /**
     * Hash Object for manipulating multiple events.
     */
    interface MultipleEvents {
        [event: string]: any //Function | Function[]
    }

    /**
     * Class for managing events.
     * Can be extended to provide event functionality in other classes.
     *
     * @class EventEmitter Manages event registering and emitting.
     */
    export class EventEmitter {
        /**
         * Reverts the global {@link EventEmitter} to its previous value and returns a reference to this version.
         * @return {Function} Non conflicting EventEmitter class.
         */
        static noConflict(): typeof EventEmitter;

        /**
         * Returns the listener array for the specified event.
         * Will initialise the event object and listener arrays if required.
         * Will return an object if you use a regex search. The object contains keys for each matched event.
         * So /ba[rz]/ might return an object containing bar and baz.
         * But only if you have either defined them with defineEvent or added some listeners to them.
         * Each property in the object response is an array of listener functions.
         *
         * @param {string|RegExp} event Name of the event to return the listeners from.
         * @return {Function[|Object]} All listener functions for the event.
         */
        getListeners(event: string): Function[];

        /**
         * Returns the listener array for the specified event.
         * Will initialise the event object and listener arrays if required.
         * Will return an object if you use a regex search. The object contains keys for each matched event.
         * So /ba[rz]/ might return an object containing bar and baz.
         * But only if you have either defined them with defineEvent or added some listeners to them.
         * Each property in the object response is an array of listener functions.
         *
         * @param {string|RegExp} event Name of the event to return the listeners from.
         * @return {Function[]|Object} All listener functions for the event.
         */
        getListeners(event: RegExp): {[event:string]: Function};

        /**
         * Adds a listener function to the specified event.
         * The listener will not be added if it is a duplicate.
         * If the listener returns true then it will be removed after it is called.
         * If you pass a regular expression as the event name then the listener will be added to all events that match it.
         *
         * @param {string|RegExp} event Name of the event to attach the listener to.
         * @param {Function} listener Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addListener(event: string, listener: Function): EventEmitter;

        /**
         * Adds a listener function to the specified event.
         * The listener will not be added if it is a duplicate.
         * If the listener returns true then it will be removed after it is called.
         * If you pass a regular expression as the event name then the listener will be added to all events that match it.
         *
         * @param {string|RegExp} event Name of the event to attach the listener to.
         * @param {Function} listener Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addListener(event: RegExp, listener: Function): EventEmitter;

        /**
         * Adds a listener function to the specified event.
         * The listener will not be added if it is a duplicate.
         * If the listener returns true then it will be removed after it is called.
         * If you pass a regular expression as the event name then the listener will be added to all events that match it.
         *
         * @param {string|RegExp} event Name of the event to attach the listener to.
         * @param {Function} listener Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        on(event: string, listener: Function): EventEmitter;

        /**
         * Adds a listener function to the specified event.
         * The listener will not be added if it is a duplicate.
         * If the listener returns true then it will be removed after it is called.
         * If you pass a regular expression as the event name then the listener will be added to all events that match it.
         *
         * @param {string|RegExp} event Name of the event to attach the listener to.
         * @param {Function} listener Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        on(event: RegExp, listener: Function): EventEmitter;

        /**
         * Takes a list of listener objects and flattens it into a list of listener functions.
         *
         * @param {Object[]} listeners Raw listener objects.
         * @return {Function[]} Just the listener functions.
         */
        flattenListeners(listeners: {listener: Function}[]): Function[];

        /**
         * Fetches the requested listeners via getListeners but will always return the results inside an object.
         * This is mainly for internal use but others may find it useful.
         *
         * @param event {string|RegExp} Name of the event to return the listeners from.
         * @return {Object} All listener functions for an event in object
         */
        getListenersAsObject(event: string): {[event:string]: Function};

        /**
         * Fetches the requested listeners via getListeners but will always return the results inside an object.
         * This is mainly for internal use but others may find it useful.
         *
         * @param event {string|RegExp} Name of the event to return the listeners from.
         * @return {Object} All listener functions for an event in object
         */
        getListenersAsObject(event: RegExp): {[event:string]: Function};

        /**
         * Semi-alias of addListener. It will add a listener that will be
         * automatically removed after it's first execution.
         *
         * @param event {string|RegExp} Name of the event to attach the listener to.
         * @param listener {Function} Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addOnceListener(event: string, listener: Function): EventEmitter;

        /**
         * Semi-alias of addListener. It will add a listener that will be
         * automatically removed after it's first execution.
         *
         * @param event {string|RegExp} Name of the event to attach the listener to.
         * @param listener {Function} Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addOnceListener(event: RegExp, listener: Function): EventEmitter;

        /**
         * Semi-alias of addListener. It will add a listener that will be
         * automatically removed after it's first execution.
         *
         * @param event {string|RegExp} Name of the event to attach the listener to.
         * @param listener {Function} Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        once(event: string, listener: Function): EventEmitter;

        /**
         * Semi-alias of addListener. It will add a listener that will be
         * automatically removed after it's first execution.
         *
         * @param event {string|RegExp} Name of the event to attach the listener to.
         * @param listener {Function} Method to be called when the event is emitted.
         * If the function returns true then it will be removed after calling.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        once(event: RegExp, listener: Function): EventEmitter;

        /**
         * Defines an event name.
         * This is required if you want to use a regex to add a listener to multiple events at once.
         * If you don't do this then how do you expect it to know what event to add to?
         * Should it just add to every possible match for a regex? No. That is scary and bad.
         * You need to tell it what event names should be matched by a regex.
         *
         * @param {string} event Name of the event to create.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        defineEvent(event: string): EventEmitter;

        /**
         * Defines an event name.
         * This is required if you want to use a regex to add a listener to multiple events at once.
         * If you don't do this then how do you expect it to know what event to add to?
         * Should it just add to every possible match for a regex? No. That is scary and bad.
         * You need to tell it what event names should be matched by a regex.
         *
         * @param {string[]} events Name of the event to create.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        defineEvents(events: string[]): EventEmitter;

        /**
         * Removes a listener function from the specified event.
         * When passed a regular expression as the event name, it will remove the listener from all events that match it.
         *
         * @param {String|RegExp} event Name of the event to remove the listener from.
         * @param {Function} listener Method to remove from the event.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeListener(event: string, listener: Function): EventEmitter;

        /**
         * Removes a listener function from the specified event.
         * When passed a regular expression as the event name, it will remove the listener from all events that match it.
         *
         * @param {String|RegExp} event Name of the event to remove the listener from.
         * @param {Function} listener Method to remove from the event.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeListener(event: RegExp, listener: Function): EventEmitter;

        /**
         * Removes a listener function from the specified event.
         * When passed a regular expression as the event name, it will remove the listener from all events that match it.
         *
         * @param {String|RegExp} event Name of the event to remove the listener from.
         * @param {Function} listener Method to remove from the event.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        off(event: string, listener: Function): EventEmitter;

        /**
         * Removes a listener function from the specified event.
         * When passed a regular expression as the event name, it will remove the listener from all events that match it.
         *
         * @param {String|RegExp} event Name of the event to remove the listener from.
         * @param {Function} listener Method to remove from the event.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        off(event: RegExp, listener: Function): EventEmitter;

        /**
         * Adds listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can add to multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added.
         * You can also pass it a regular expression to add the array of listeners to all events that match it.
         * Yeah, this function does quite a bit. That's probably a bad thing.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add to multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addListeners(event: string, listeners: Function[]): EventEmitter;

        /**
         * Adds listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can add to multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added.
         * You can also pass it a regular expression to add the array of listeners to all events that match it.
         * Yeah, this function does quite a bit. That's probably a bad thing.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add to multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addListeners(event: RegExp, listeners: Function[]): EventEmitter;

        /**
         * Adds listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can add to multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added.
         * You can also pass it a regular expression to add the array of listeners to all events that match it.
         * Yeah, this function does quite a bit. That's probably a bad thing.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add to multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        addListeners(event: MultipleEvents): EventEmitter;

        /**
         * Removes listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be removed.
         * You can also pass it a regular expression to remove the listeners from all events that match it.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeListeners(event: string, listeners: Function[]): EventEmitter;

        /**
         * Removes listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be removed.
         * You can also pass it a regular expression to remove the listeners from all events that match it.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeListeners(event: RegExp, listeners: Function[]): EventEmitter;

        /**
         * Removes listeners in bulk using the manipulateListeners method.
         * If you pass an object as the second argument you can remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be removed.
         * You can also pass it a regular expression to remove the listeners from all events that match it.
         *
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeListeners(event: MultipleEvents): EventEmitter;

        /**
         * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job.
         * You should really use those instead, this is a little lower level.
         * The first argument will determine if the listeners are removed (true) or added (false).
         * If you pass an object as the second argument you can add/remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added/removed.
         * You can also pass it a regular expression to manipulate the listeners of all events that match it.
         *
         * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add/remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        manipulateListeners(remove: boolean, event: string, listeners: Function[]): EventEmitter;

        /**
         * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job.
         * You should really use those instead, this is a little lower level.
         * The first argument will determine if the listeners are removed (true) or added (false).
         * If you pass an object as the second argument you can add/remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added/removed.
         * You can also pass it a regular expression to manipulate the listeners of all events that match it.
         *
         * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add/remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        manipulateListeners(remove: boolean, event: RegExp, listeners: Function[]): EventEmitter;

        /**
         * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job.
         * You should really use those instead, this is a little lower level.
         * The first argument will determine if the listeners are removed (true) or added (false).
         * If you pass an object as the second argument you can add/remove from multiple events at once.
         * The object should contain key value pairs of events and listeners or listener arrays.
         * You can also pass it an event name and an array of listeners to be added/removed.
         * You can also pass it a regular expression to manipulate the listeners of all events that match it.
         *
         * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
         * @param {String|Object|RegExp} event An event name if you will pass an array of listeners next.
         * An object if you wish to add/remove from multiple events at once.
         * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        manipulateListeners(remove: boolean, event: MultipleEvents): EventEmitter;

        /**
         * Removes all listeners from a specified event.
         * If you do not specify an event then all listeners will be removed.
         * That means every event will be emptied.
         * You can also pass a regex to remove all events that match it.
         *
         * @param {String|RegExp} [event] Optional name of the event to remove all listeners for.
         * Will remove from every event if not passed.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeEvent(event?: string): EventEmitter;

        /**
         * Removes all listeners from a specified event.
         * If you do not specify an event then all listeners will be removed.
         * That means every event will be emptied.
         * You can also pass a regex to remove all events that match it.
         *
         * @param {String|RegExp} [event] Optional name of the event to remove all listeners for.
         * Will remove from every event if not passed.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        removeEvent(event?: RegExp): EventEmitter;

        /**
         * Alias of removeEvent.
         *
         * Added to mirror the node API.
         */
        removeAllListeners(event?: string): EventEmitter;

        /**
         * Alias of removeEvent.
         *
         * Added to mirror the node API.
         */
        removeAllListeners(event?: RegExp): EventEmitter;

        /**
         * Emits an event of your choice.
         * When emitted, every listener attached to that event will be executed.
         * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
         * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
         * So they will not arrive within the array on the other side, they will be separate.
         * You can also pass a regular expression to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {Array} [args] Optional array of arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        emitEvent(event: string, ...args: any[]): EventEmitter;

        /**
         * Emits an event of your choice.
         * When emitted, every listener attached to that event will be executed.
         * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
         * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
         * So they will not arrive within the array on the other side, they will be separate.
         * You can also pass a regular expression to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {Array} [args] Optional array of arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        emitEvent(event: RegExp, ...args: any[]): EventEmitter;

        /**
         * Emits an event of your choice.
         * When emitted, every listener attached to that event will be executed.
         * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
         * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
         * So they will not arrive within the array on the other side, they will be separate.
         * You can also pass a regular expression to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {Array} [args] Optional array of arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        trigger(event: string, ...args: any[]): EventEmitter;

        /**
         * Emits an event of your choice.
         * When emitted, every listener attached to that event will be executed.
         * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
         * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
         * So they will not arrive within the array on the other side, they will be separate.
         * You can also pass a regular expression to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {Array} [args] Optional array of arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        trigger(event: RegExp, ...args: any[]): EventEmitter;

        /**
         * Subtly different from emitEvent in that it will pass its arguments on to the listeners,
         * as opposed to taking a single array of arguments to pass on.
         * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {... any[]} args Optional additional arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        emit(event: string, ...args: any[]): EventEmitter;

        /**
         * Subtly different from emitEvent in that it will pass its arguments on to the listeners,
         * as opposed to taking a single array of arguments to pass on.
         * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.
         *
         * @param {String|RegExp} event Name of the event to emit and execute listeners for.
         * @param {... any[]} args Optional additional arguments to be passed to each listener.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        emit(event: RegExp, ...args: any[]): EventEmitter;

        /**
         * Sets the current value to check against when executing listeners. If a
         * listeners return value matches the one set here then it will be removed
         * after execution. This value defaults to true.
         *
         * @param {any} value The new value to check for when executing listeners.
         * @return {EventEmitter} Current instance of EventEmitter for chaining.
         */
        setOnceReturnValue(value: any): EventEmitter;
    }
}


text:
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

namespace Apache.Arrow.Types
{
    public class BinaryType: ArrowType
    {
        public static readonly BinaryType Default = new BinaryType();

        public override ArrowTypeId TypeId => ArrowTypeId.Binary;
        public override string Name => "binary";

        public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor);
    }
}

redpajama_set_name: RedPajamaGithub


text:
title: Regional grants
description: Regional grants under the BID programme seek to establish or strengthen international collaborations that increase biodiversity data mobilization.
category: Calls
subCategory: Pacific 2016

---
# Regional grants

_Pacific, 2016_

Regional grants under the BID programme seek to establish or strengthen international collaborations that increase biodiversity data mobilization.

These guidelines are available in English, Spanish and French, of which the English version is the authoritative version. They are intended to assist applicants in completing the BID concept note template. General questions may be sent to [BID@gbif.org](mailto:bid@gbif.org).

<!-- toc -->
<!-- tocstop -->

-----------------------

## Submission procedure

The deadline for submitting initial concept notes from the Pacific is **10 November 2016**.

+ Applications must be submitted using the concept note template to [BID@gbif.org](mailto:bid@gbif.org) by 10 November 2016, 9:00am CET / 8:00am UTC/GMT.
+ Confirmed project partners must be copied when submitting the application.
+ As appropriate, include a statement of endorsement from a GBIF representative in submissions as an email attachment.
+ **Applications must be submitted in English and by using the** [**concept note template**](/raw/BID-Concept-Note-Template-Pacific.docx).  If you need help with this requirement, please contact [BID@gbif.org](mailto:bid@gbif.org) as early as possible and before 20 October 2016.

Please note that the evaluation panel will not be review late or incomplete applications.

-----------

## Objectives

The objectives of the BID regional biodiversity data mobilization grants are to:
+ Establish or strengthen international collaborations to mobilize biodiversity data
+ Increase available biodiversity data, within and beyond the grant period
+ Apply biodiversity data in response to conservation priorities

The overall BID programme targets two key outcomes:
1. Enhanced capacity for effective mobilization and use of biodiversity information
2. Enhanced availability of information resources and best practice guidance for mobilization and application of biodiversity information for key policy needs

-----------

## Key documents

+ [Concept note template](/raw/BID-Concept-Note-Template-Pacific.docx)

-----------

## Evaluation criteria

Proposals will be assessed using the following criteria:

1. Alignment of the project with BID objectives and priorities.
2. Alignment of the project with clearly stated needs for biodiversity information and capacity development within the proposal.
3. The project's complementary contributions to regional data needs.
4. Likelihood that the project will provide examples of best practice in the application of biodiversity information in decision-making.
5. Quantity, quality and relevance of the biodiversity data proposed for mobilization, with preference given to projects that mobilize biodiversity data relating to protected areas, threatened species and invasive alien species.
6. Level of national support and cost-effectiveness of the proposed actions; the balance between the level of funding requested from BID and the co-funding contributed by the project partners.
7. Anticipated value of the project deliverables to both the national and regional context and the broader GBIF community.
8. Choice and diversity of project partners, with preference given to projects that have the confirmed involvement of a diverse network of data holders and data users.

NOTE: Full proposals will also assess a) project management skills of coordinating team based on previous experience, b) quality of project design and risk assessment; c) monitoring and evaluation plans; and d) sustainability plan.

-----------

## Project duration

Selected projects may begin their activities in April 2017.

Projects may run for up to 18 months and must end by September 2018, followed by a final three-month reporting and evaluation period ending in December 2018.

Grantees must complete all projects by 31 December 2018.

-----------

## Funding

A regional consortium must involve partners from a minimum of three different countries or overseas territories from the region. The consortium coordinator and at least one other partner must be located in an [eligible Pacific ACP country](../eligible-countries). Each partner may receive up to €20,000, and one consortium coordinator may receive up to €10,000 in additional funding to coordinate the activities of the partners.

Regional consortia may include one partner from outside the region. Institutions from [countries outside the region](../eligible-countries/#regional) may apply for up to €10,000 in funding from the BID programme as part of a regional consortium. Institutions from [limited-eligibility countries](../eligible-countries/#limited) may apply for up to €10,000 in funding **only if** a) their regional consortium includes at least one partner from Kiribati, Samoa, Timor-Leste, Tuvalu or Vanuatu, **and** b) they are the consortium's only partner from outside the region.

During the course of the BID programme, the maximum total project funding that any single applicant can receive is €60,000.

-----------

## Regional grant activity types

Regional grants must include activities contributing to each of three component categories. Each category presented below includes a non-exclusive list of possible types of activity:

**1. Establishing or strengthening networks to support long-term data mobilization and inter-institutional data sharing**
+ Assessing biodiversity data holdings and user needs through a survey or study to develop a strategy for the consortium
+ Organizing regional workshops to promote inter-institutional collaboration.
+ Formalizing partnerships through institutional agreements, data sharing policies and public endorsement of mobilization strategies
+ Adopting a data publishing process, possibly including installing data publishing informatics tools (e.g. [GBIF Integrated Publishing Toolkit](https://www.gbif.org/ipt))
+ Training data managers and collections staff within key data holding institutions on data mobilization and management, for example, through workshops to share the knowledge gained through attending the two BID capacity enhancement workshops

**2. Activities to mobilize biodiversity data relevant to protected areas, invasive alien species and/or threatened species**
+ Compiling inventories of biodiversity data holdings (for example, implementing metadata catalogues)
+ Digitizing and publishing natural history collections and biodiversity information from literature
+ Mobilizing species occurrence and sampling-event data from observation networks and monitoring systems, such as invasive alien species, Red Listed species or endemic species
+ Validating and publishing regional, national and local species checklists, invasive species lists or threatened species lists
+ Preparing [data papers](https://www.gbif.org/publishing-data/data-papers) to improve the reusability of the mobilized biodiversity data

**3. Integrating biodiversity information into policy and decision-making processes**
+ Leading surveys or workshops to understand the biodiversity data requirements for specific use cases.
+ Setting up user groups to guide project implementation on identified priority themes, such as agrobiodiversity, urban biodiversity and protected areas.
+ Directing workshops and advocacy actions that promote the use of openly accessible data, for example, in national-level biodiversity reporting.
+ Hosting workshops on data analysis techniques.
+ Applying biodiversity data in decision-making processes.
+ Documenting use cases and sharing them with partners in the region.

-----------

## General recommendations for preparing concept notes

+ **Ensure that your project meets the eligibility criteria and aligns well with the overall objectives for the programme**. Consider the evaluation criteria used by the evaluation panel to assess your proposal.
+ **Be brief**. Try to provide the shortest responses possible and only add background information if really needed, using links to external resources rather than long explanations.
+ **Prepare your submissions in English**. The evaluation panel will use English as their working language and therefore applicants are requested to make submissions in English. Remember that if you have particular difficulties with this requirement, contact [BID@gbif.org](mailto:bid@gbif.org) for support as early as possible, and before 20 October 2016.
+ **Review the FAQ**. [This page](../faq) will be updated throughout the project application period. Send any unanswered questions to [BID@gbif.org](mailto:bid@gbif.org).
+ **Submit as early as possible to avoid problems**. Early submission will give a chance for some follow-up to resolve any issues that arise ahead of the deadline. The deadline for submissions is a hard deadline, and projects received late or incomplete will not be reviewed by the evaluation panel.

___________

```styledYaml
templates:
- path: eufund.html
```


text:
import { sep } from 'path'
import { readFileSync } from 'fs'
import { parse as parseAST } from '@babel/parser'
import { compareString } from 'dr-js/module/common/compare'
import { objectSortKey } from 'dr-js/module/common/mutable/Object'
import { getPathStat, getPathTypeFromStat } from 'dr-js/module/node/file/File'
import { getDirectoryInfoTree, walkDirectoryInfoTree } from 'dr-js/module/node/file/Directory'

const getExportListFromParsedAST = (fileString, sourceFilename, parserPluginList) => {
  const resultAST = parseAST(fileString, {
    sourceFilename,
    sourceType: 'module',
    plugins: parserPluginList || [
      'objectRestSpread',
      'classProperties',
      'exportDefaultFrom',
      'exportNamespaceFrom',
      'jsx'
    ]
  })
  const exportNodeList = resultAST.program.body.filter(({ type }) => type === 'ExportNamedDeclaration')
  return [].concat(...exportNodeList.map(({ specifiers, declaration }) => !declaration ? specifiers.map(({ exported: { name } }) => name)
    : declaration.declarations ? declaration.declarations.map(({ id: { name } }) => name)
      : [ declaration.id.name ]
  ))
}

const sortSourceRouteMap = (sourceRouteMap) => {
  Object.values(sourceRouteMap).forEach(({ routeList, directoryList, fileList }) => {
    directoryList.sort(compareString)
    fileList.sort(({ name: a }, { name: b }) => compareString(a, b))
    fileList.forEach(({ exportList }) => exportList.sort(compareString))
  })
  objectSortKey(sourceRouteMap)
  return sourceRouteMap
}

const createExportParser = ({ parserPluginList, logger }) => {
  let sourceRouteMap = {
    // 'source/route': {
    //   routeList: [ 'source' ],
    //   directoryList: [ /* name */ ],
    //   fileList: [ /* { name, exportList: [ name ] } */ ]
    // }
  }

  const getRoute = (routeList) => {
    const key = routeList.join('/')
    if (!sourceRouteMap[ key ]) sourceRouteMap[ key ] = { routeList, directoryList: [], fileList: [] }
    return sourceRouteMap[ key ]
  }

  const parseExport = async (path) => {
    const fileStat = await getPathStat(path)
    const routeList = path.split(sep)
    const name = routeList.pop()

    if (fileStat.isDirectory()) {
      logger.devLog(`[directory] ${path}`)
      getRoute(routeList).directoryList.push(name)
    } else if (fileStat.isFile() && name.endsWith('.js')) {
      const fileString = readFileSync(path, { encoding: 'utf8' })
      const exportList = getExportListFromParsedAST(fileString, path, parserPluginList)

      logger.devLog(`[file] ${path}`)
      if (!exportList.length) return

      getRoute(routeList).fileList.push({ name: name.slice(0, -3), exportList }) // remove `.js` from name
      logger.devLog(`  export [${exportList.length}]: ${exportList.join(', ')}`)
    } else logger.devLog(`[skipped] ${path} (${getPathTypeFromStat(fileStat)})`)
  }

  return {
    parseExport,
    getSourceRouteMap: () => {
      const result = sortSourceRouteMap(sourceRouteMap)
      sourceRouteMap = {}
      return result
    }
  }
}

const collectSourceRouteMap = async ({
  pathRootList = [],
  pathInfoFilter = (info) => true, // return true to keep
  logger
}) => {
  const { parseExport, getSourceRouteMap } = createExportParser({ logger })
  const parseWalkExport = (info) => pathInfoFilter(info) && parseExport(info.path)
  for (const pathRoot of pathRootList) await walkDirectoryInfoTree(await getDirectoryInfoTree(pathRoot), parseWalkExport)
  return getSourceRouteMap()
}

export {
  createExportParser,
  collectSourceRouteMap
}


text:
@class ScrollImage;
@protocol ScrollImageDelegate <NSObject>

@optional
- (void)scrollImage:(ScrollImage *)scrollImage clickedAtIndex:(NSInteger)index;

@end

@interface ScrollImage : UIViewController

@property (nonatomic, weak) id<ScrollImageDelegate> delegate;

@property (nonatomic, assign) NSTimeInterval timeInterval;
@property (nonatomic, strong) UIPageControl  *pageControl;
@property (nonatomic, strong) UIImage        *placeholderImage;

- (instancetype)initWithCurrentController:(UIViewController *)viewcontroller urlString:(NSArray *)urls viewFrame:(CGRect)frame placeholderImage:(UIImage *)image;
- (instancetype)initWithCurrentController:(UIViewController *)viewcontroller imageNames:(NSArray *)images viewFrame:(CGRect)frame placeholderImage:(UIImage *)image;

@end

@interface NSString (MD5)
- (id)MD5;
@end


text:
from Decorators import Rename

@Rename('+')
def add(*args):
	'''Add numbers.'''
	result = 0
	for arg in args:
		result += arg
	return result

@Rename('-')
def sub(*args):
	'''Subtract numbers.'''
	if len(args) < 1:
		raise ValueError('- expects at least 1 argument, given %d' % len(args))
	result = args[0]
	for arg in args[1:]:
		result -= arg
	return result

@Rename('*')
def mul(*args):
	'''Multiply numbers.'''
	result = 1
	for arg in args:
		result *= arg
	return result

@Rename('/')
def div(*args):
	'''Divide numbers.'''
	if len(args) < 1:
		raise ValueError('/ expects at least 1 argument, given %d' % len(args))
	result = args[0]
	for arg in args[1:]:
		result /= arg
	return result

def add1(n):
	'''Add one to a number.'''
	return n + 1

def sub1(n):
	'''Subtract one from a number.'''
	return n - 1


text:
    position: relative;
    top: 0px;
    left: 0;
    width: 390px;
    padding: 5px;
    background-color: white;
    border: solid 5px black;
    border-radius: 3px 3px 3px 3px;
    -webkit-border-radius: 3px 3px 3px 3px;
    -moz-border-radius: 3px 3px 3px 3px;
    visibility: hidden;
    z-index: 2;
}

#context-menu-vertical-connector {
    position: absolute;
    top: 0px;
    left: 178px;
    height: 8px;
    width: 6px;
    background-color: black;
}

#context-menu-holder hr {
    margin-top: 0;
    margin-bottom: 5px;
}

.context-menu-wheelchair-icons {
    cursor: default;
    width: 30px;
    height: 30px;
}

#severity-menu .radio-inline {
    font-size: 10pt;
    padding-bottom: 5px;
    padding-left: 27px;
    margin-left: 3px;
    text-align: center;
}

#severity-menu input[type="radio"] {
    width: 20px;
    height: 20px;
    display: inline;
}

#severity-menu #column-not-passable, #severity-menu #column-passable {
    cursor: default;
    position: relative;
    top: 8px;
    margin-left: 0;
    padding: 5px;
    text-align: center;
}

#severity-menu .radio-inline label {
    position: relative;

}

#severity-menu .radio-inline label div {
    font-weight: 600;
    left: -14px;
    position: relative;
    top: 25px;
}

#severity-radio-holder span {
    font-size: 10pt;
    padding: 0 5px 0 5px;
}

#severity-radio-holder > .radio-inline > .example-image > label > input {
    visibility: hidden;
    position: absolute;
}

#severity-radio-holder > .radio-inline > label > input {
    visibility: hidden;
    position: absolute;
}

#severity-radio-holder > .radio-inline > .example-image > label > input + img {
    cursor: pointer;
    left: -23px;
    top: 2px;
    position: absolute;
    width: 25px;
}

#severity-radio-holder .example-image{
  display: block;
  margin: auto;
  color: black;
  text-decoration: none;
  text-align: center;
  width: 100%;
}

#severity-radio-holder > .radio-inline > label > input + img {
    cursor: pointer;
    left: -23px;
    top: 2px;
    position: absolute;
    width: 25px;
}

.tooltip.in {
    opacity: 1;
    filter:alpha(opacity=100);
}

#context-menu-close-button-holder {
    position: absolute;
    top: 0;
    right: 5px;
}

#problem-property-menu {
    position: relative;
}

.label-severity-axis-label {
    cursor: default;
    font-size: 7.8pt;
}

#context-menu-problem-description-text-box {
    height: 30px;
    margin: 13px 5px 5px 5px;
    width: 355px;
}

#context-menu-temporary-problem-checkbox-holder {
    margin: 5px 5px 5px 5px;
    width: 310px;
}

#context-menu-temporary-problem-checkbox-holder label {
    color: #888;
    font-weight: normal;
}

#context-menu-temporary-problem-checkbox {
    cursor: pointer;
}

#problem-property-menu button {
    background: none;
    border: none;
    color: #888;
    position: inherit;
}

#context-menu-tag-holder {
    width: 311px;
    margin: -27px 0px 0px 48px;
}

.add-tags-label {
    display: inline-grid;
    position: inherit;
    font-size: 10px;
    width: 50px;
    height: 25px;
}

#context-menu-tag-holder button {
    display: inline-block;
    position: inherit;
    margin: 0px 0px 3px 0px;
    padding: 2px 3px 2px 3px;
    border-radius: 5px;
    border: 1px solid rgb(200, 200, 200);
    font-size: 10px;
    outline: none;
}

tag-underline {
    text-decoration: underline;
    pointer-events: none;
}


text:
/**
 * This package contains additional statistics classes which are not available
 * in the Java core library. Java only includes classes for calculating the sum
 * and the average of a given numeric stream (e. g.
 * {@code DoubleSummaryStatistics}). With the additions in this package it is
 * also possible to calculate the variance, skewness and kurtosis---using the
 * {@code DoubleMomentStatistics} class. The {@code EvolutionStatistics} object,
 * which can be calculated for every generation, relies on the classes of this
 * package.
 *
 * @author Franz Wilhelmstötter
 * @since 1.0
 * @version 3.0
 */
package io.jenetics.stat;


text:
``` md
## Appendix E : Product Survey

####Google Calendar

#####Pros:
> Help to organise schedules and pre-planned them in advance
> Able to show schedules in multiple view (3 days, day, month or week) format
> Easy to synchronise planned schedules across multiple devices

#####Cons:
> Unable to use single line command to add new events
> Each event creation take up around 2 minutes of the user time to fill up the details
> Unable to do partial search for a particular event name
> Confusing timing display on each event. (E.g 11p for night event and 11 for morning event)

####Any.Do

#####Pros:
> Help to add a quick task to the list
> Able to invite friends in the same event or task
> Able to send notification to the user before the event start
> Able to add new task(s) to personalised folder

```
###### /UserGuide.md
``` md
## Features

> **Command Format**
> * Words in `square brackets ([])` are the parameters.
> * Items within `arrow signs (<>)` are optional.
> * Items with `...` after them can have multiple instances.
> * The order of parameters is fixed except for edit command.

#### Adding a task: `add`
#### Shortcut : `a`
Adds a task to the FlexiTrack.<br>
Format: `add [task title] < by/ [deadline] >`

Examples:
* `add CS2103 tutorial 3 `
* `add CS2103 tutorial 3 by/ Saturday`
* `a CS2103 tutorial 3 by/ tmr 9am`

#### Adding an event: `add`
#### Shortcut : `a`
Adds a event to the FlexiTrack.<br>
Format: `add [event title] from/ [starting time] to/ [ending time]`

Examples:
* `add Bintan trip from/ Saturday to/ Sunday`
* `a CS2103 Lecture from/ Friday 2pm to/ Friday 4pm `

```
###### /UserGuide.md
``` md
#### Finding a task or an event containing any keyword in their title: `find`
#### Shortcut : `f`
Finds a task ot an event whose title contain any of the given keywords.<br>
Format: `find KEYWORD [MORE_KEYWORDS]`

> * The search is non case sensitive. e.g `soccer` will match `Soccer`
> * The order of the keywords does not matter. e.g. `soccer dinner` will match `dinner soccer`
> * Only the task/event title is searched.
> * Only full words will be matched e.g. `socc` will not match `soccer` (unless 'f/' keyword is used)
> * Task or event matching at least one keyword will be returned (i.e. `OR` search).
    e.g. `soccer` will match `soccer training`
> * Search by exact task name can be activated with the shortcut 'f/' before the task name.

Examples:
* `find Soccer`<br>
  Returns `Soccer training` but not `soccer training`
* `find assignment dinner mid-term`<br>
  Returns Any task/event having `assignment`, `dinner`, or `mid-term` in the title
* `f attend CS2103 lecture`<br>
  Returns Any task/event having `attend`, `CS2103`, or `lecture`

#### Finding a specific task or an event containing an exact phrase in their title: `find f/`
#### Shortcut : `f f/`
Finds a task of an event whose title contain any of the given keywords.<br>
Format: `find f/ EXACT PHRASE`

```
###### /UserGuide.md
``` md
## Time Format
FlexiTrack support various timing input. Here are some examples!

#### Exact timing
User Input | Timing information read by FlexiTrack
---------- | :---------------
21 June 2018 4pm | Jun 21 16:00:00
1st January 7.20 | Jan 01 07:20
April 22nd 5am | Apr 22 05:00

#### Relative timing
If today is 1st of February a relative timing input is also possible with FlexiTrack

User Input | Timing information read by FlexiTrack
---------- | :---------------
Tomorrow 4pm | Feb 02 16:00:00
Next week 720am | Feb 08 07:20
3 weeks 2 pm  | Feb 22 14:00
next month 8am | Mar 01 08:00

#### Notes on FlexiTrack timing
1. FlexiTrack does support year. However, make sure that you also specify the hour of the timing
	as FlexiTrack will choose timing over year when it is uncertain.
2. When you do not specify the exact timing, FlexiTrack will assign your task to be 8:00 for due
	date and starting time, and 17:00 for ending time.

## FAQ

**Q**: How do I transfer my data to another Computer?<br>
**A**: Install the app in the other computer and overwrite the empty data file it creates with
       the file that contains the data of your previous FlexiTrack folder.

```


text:
<!DOCTYPE html>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Perber</title>
    <meta name="keywords" content="Perber">
    <meta name="description" content="Perber">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <link rel="icon" type="image/png" href="images/favicon.png">

    <link rel="stylesheet" type="text/css" href="css/semantic.min.css"/>
    <link rel="stylesheet" type="text/css" href="css/font-awesome.min.css"/>
    <link rel="stylesheet" type="text/css" href="css/perber.css"/>
    <link rel="stylesheet" type="text/css" href="player/css/player.zen.css"/>

Perber

正在修复发布虾米音乐功能。听首歌先~

预计下午5点之前重新开放。

2014-04-4


text:
Developer's Guide

These pages assume you've completed
the Getting Started tutorial
and Overview.

Changing the Google Chrome chrome

     Browser Actions
     Add icons to the toolbar (extensions only)

     Desktop Notifications
     Notify users of important events

     Omnibox
     Add a keyword to the address bar

     Options Pages
     Let users customize your extension

     Override Pages
     Implement your own version of standard browser pages
         such as the New Tab page

     Page Actions
     Add temporary icons inside the address bar (extensions only)

     Themes
     Change the overall appearance of the browser

Interacting with Google Chrome in other ways

     Bookmarks
     Create, organize, and otherwise manipulate the user's bookmarks

     Cookies
     Explore and modify the browser's cookie system

     Developer Tools
     Add features to Chrome Developer Tools

     Events
     Detect when something interesting happens

     History
     Interact with the browser's record of visited pages

     Tabs
     Create, modify, and rearrange tabs in the browser

     Windows
     Create, modify, and rearrange windows in the browser

Implementing the innards of your extension

     Accessibility (a11y)
     Make your extension accessible to people with disabilities

     Event Pages
     Put all the common code for your extension in a single place

     Content Scripts
     Run JavaScript code in the context of web pages

     Cross-Origin XHR
     Use XMLHttpRequest to send and receive data from remote servers

     Internationalization
     Deal with language and locale

     Message Passing
     Communicate from a content script to its parent extension,
         or vice versa

     Optional Permissions
     Modify your extension's permissions

     NPAPI Plugins
     Load native binary code

Finishing and distributing your extension

     Autoupdating
     Update extensions automatically

     Hosting
     Host extensions on Google servers or your own

     Other Deployment Options
     Distribute extensions on your network or with other software

     Packaging
     Create a .crx file so you can distribute your extension


text:
(function () {
    var inBrowser = typeof amber !== "undefined" && typeof amber.load === "function";
    function init() {
        smalltalk.initialize();

        /* Similar to jQuery(document).ready() */

        if (inBrowser && amber.smalltalkReady) {
            amber.smalltalkReady();
        }
    }

    if (inBrowser) {
        // init is lengthy process done in JavaScript.
        // setTimeout here postpones it, so DOM ready
        // event can occur sooner, thus load process
        // may appear optically faster.
        setTimeout(init, 0);
    } else {
        // In certain configurations, setTimeout is not feasible.
        // It is mainly for `amberc`-produced concatenated
        // node.js programs. There, the actual "main" appears
        // immediately after init, so it must happens synchronously.
        init();
    }
})();


text:
layout: lab
key: dresden
lang: en

# metadata is in: _labs/dresden.yml
# german text is in dresden/index.html
---

Currently, there is no english translation available. The german text is available [here](/dresden/).


text:
package org.apache.camel.component.ignite;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.Lists;
import com.google.common.collect.Range;

import org.apache.camel.Consumer;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.component.ignite.messaging.IgniteMessagingComponent;
import org.apache.ignite.lang.IgniteBiPredicate;
import org.junit.After;
import org.junit.Test;

import static com.google.common.truth.Truth.assert_;
import static com.jayway.awaitility.Awaitility.await;
import static com.jayway.awaitility.Awaitility.to;
import static org.hamcrest.Matchers.equalTo;

public class IgniteMessagingTest extends AbstractIgniteTest implements Serializable {

    private static final long serialVersionUID = 3967738538216977749L;

    private static final String TOPIC1 = "TOPIC1";
    private static final String TOPIC2 = "TOPIC2";
    private UUID uuid;

    @Override
    protected String getScheme() {
        return "ignite-messaging";
    }

    @Override
    protected AbstractIgniteComponent createComponent() {
        return IgniteMessagingComponent.fromConfiguration(createConfiguration());
    }

    @Test
    public void testProducerSendMessage() {
        List<Object> messages = Lists.newArrayList();
        setupMessageListener(TOPIC1, messages);

        template.requestBody("ignite-messaging:TOPIC1", 1);

        await().atMost(5, TimeUnit.SECONDS).untilCall(to(messages).size(), equalTo(1));
        assert_().that(messages.get(0)).isEqualTo(1);
    }

    @Test
    public void testProducerSendMessageTopicInHeader() throws Exception {
        List<Object> messages1 = Lists.newArrayList();
        setupMessageListener(TOPIC1, messages1);

        List<Object> messages2 = Lists.newArrayList();
        setupMessageListener(TOPIC2, messages2);

        template.requestBodyAndHeader("ignite-messaging:TOPIC1", 1, IgniteConstants.IGNITE_MESSAGING_TOPIC, "TOPIC2");

        Thread.sleep(1000);
        assert_().that(messages1.size()).isEqualTo(0);
        assert_().that(messages2.size()).isEqualTo(1);
    }

    @Test
    public void testProducerSendManyMessages() {
        List<Object> messages = Lists.newArrayList();
        setupMessageListener(TOPIC1, messages);

        Set<Integer> request = ContiguousSet.create(Range.closedOpen(0, 100), DiscreteDomain.integers());
        template.requestBody("ignite-messaging:TOPIC1", request);

        await().atMost(5, TimeUnit.SECONDS).untilCall(to(messages).size(), equalTo(100));
        assert_().that(messages).containsAllIn(request);
    }

    @Test
    public void testProducerSendManyMessagesOrdered() {
        List<Object> messages = Lists.newArrayList();
        setupMessageListener(TOPIC1, messages);

        ContiguousSet<Integer> set = ContiguousSet.create(Range.closedOpen(0, 100), DiscreteDomain.integers());
        for (int i : set) {
            template.requestBody("ignite-messaging:TOPIC1?sendMode=ORDERED&timeout=1000", i);
        }

        await().atMost(5, TimeUnit.SECONDS).untilCall(to(messages).size(), equalTo(100));
        assert_().that(messages).containsAllIn(set);
    }

    @Test
    public void testProducerSendCollectionAsObject() {
        List<Object> messages = Lists.newArrayList();
        setupMessageListener(TOPIC1, messages);

        Set<Integer> request = ContiguousSet.create(Range.closedOpen(0, 100), DiscreteDomain.integers());
        template.requestBody("ignite-messaging:TOPIC1?treatCollectionsAsCacheObjects=true", request);

        await().atMost(5, TimeUnit.SECONDS).untilCall(to(messages).size(), equalTo(1));
        assert_().that(messages.get(0)).isEqualTo(request);
    }

    @Test
    public void testConsumerManyMessages() throws Exception {
        List<Object> messages = Lists.newArrayList();
        Consumer consumer = context.getEndpoint("ignite-messaging:TOPIC1").createConsumer(storeBodyInListProcessor(messages));
        consumer.start();

        Set<Integer> messagesToSend = ContiguousSet.create(Range.closedOpen(0, 100), DiscreteDomain.integers());
        ignite().message().send(TOPIC1, messagesToSend);

        await().atMost(5, TimeUnit.SECONDS).untilCall(to(messages).size(), equalTo(100));

        consumer.stop();
    }

    private void setupMessageListener(String topic, final List<Object> messages) {
        uuid = ignite().message().remoteListen(topic, new IgniteBiPredicate<UUID, Object>() {
            private static final long serialVersionUID = 1L;

            @Override
            public boolean apply(UUID uuid, Object message) {
                messages.add(message);
                return true;
            }
        });
    }

    @After
    public void stopMessageListener() {
        if (uuid == null) {
            return;
        }

        ignite().message().stopRemoteListen(uuid);
        uuid = null;
    }

    @Override
    public boolean isCreateCamelContextPerClass() {
        return true;
    }

    private Processor storeBodyInListProcessor(final List<Object> list) {
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                list.add(exchange.getIn().getBody());
            }
        };
    }

}


text:
namespace ui {

class TestWindowTree;
class WindowManagerDelegate;
class WindowTreeClient;
class WindowTreeClientDelegate;

// TestWindowTreeClientSetup is used to create a WindowTreeClient that is not
// connected to mus.
class TestWindowTreeClientSetup {
 public:
  TestWindowTreeClientSetup();
  ~TestWindowTreeClientSetup();

  // Initializes the WindowTreeClient.
  void Init(WindowTreeClientDelegate* window_tree_delegate);
  void InitForWindowManager(WindowTreeClientDelegate* window_tree_delegate,
                            WindowManagerDelegate* window_manager_delegate);

  // The WindowTree that WindowTreeClient talks to.
  TestWindowTree* window_tree() { return window_tree_.get(); }

  // Returns ownership of WindowTreeClient to the caller.
  std::unique_ptr<WindowTreeClient> OwnWindowTreeClient();

  WindowTreeClient* window_tree_client();

 private:
  // Called by both implementations of init to perform common initialization.
  void CommonInit(WindowTreeClientDelegate* window_tree_delegate,
                  WindowManagerDelegate* window_manager_delegate);

  std::unique_ptr<TestWindowTree> window_tree_;

  std::unique_ptr<WindowTreeClient> window_tree_client_;

  DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClientSetup);
};

}  // namespace ui

#endif  // SERVICES_UI_PUBLIC_CPP_TESTS_TEST_WINDOW_TREE_CLIENT_SETUP_H_


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Slamby.TAU.Enum
{
    public enum ActiveSourceEnum
    {
        Filter,
        Sample
    }
}


text:
module XMonad.Actions.WindowMenu (
                             -- * Usage
                             -- $usage
                             windowMenu
                              ) where

import XMonad
import qualified XMonad.StackSet as W
import XMonad.Actions.GridSelect
import XMonad.Layout.Maximize
import XMonad.Layout.Minimize
import XMonad.Util.XUtils (fi)

-- $usage
--
-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
--
-- >    import XMonad.Actions.WindowMenu
--
-- Then add a keybinding, e.g.
--
-- >    , ((modm,               xK_o ), windowMenu)

colorizer :: a -> Bool -> X (String, String)
colorizer _ isFg = do
    fBC <- asks (focusedBorderColor . config)
    nBC <- asks (normalBorderColor . config)
    return $ if isFg
                then (fBC, nBC)
                else (nBC, fBC)

windowMenu :: X ()
windowMenu = withFocused $ \w -> do
    tags <- asks (workspaces . config)
    Rectangle x y wh ht <- getSize w
    Rectangle sx sy swh sht <- gets $ screenRect . W.screenDetail . W.current . windowset
    let originFractX = (fi x - fi sx + fi wh / 2) / fi swh
        originFractY = (fi y - fi sy + fi ht / 2) / fi sht
        gsConfig = (buildDefaultGSConfig colorizer)
                    { gs_originFractX = originFractX
                    , gs_originFractY = originFractY }
        actions = [ ("Cancel menu", return ())
                  , ("Close"      , kill)
                  , ("Maximize"   , sendMessage $ maximizeRestore w)
                  , ("Minimize"   , minimizeWindow w)
                  ] ++
                  [ ("Move to " ++ tag, windows $ W.shift tag)
                    | tag <- tags ]
    runSelectedAction gsConfig actions

getSize :: Window -> X (Rectangle)
getSize w = do
  d  <- asks display
  wa <- io $ getWindowAttributes d w
  let x = fi $ wa_x wa
      y = fi $ wa_y wa
      wh = fi $ wa_width wa
      ht = fi $ wa_height wa
  return (Rectangle x y wh ht)


text:
{% load i18n %}{% autoescape off %}

You're receiving this email because you requested a password reset for your user account at Classijango

{% trans "Please go to the following page and choose a new password:" %}
{% block reset_link %}
    {{ protocol }}://{{ domain }}{% url 'django.contrib.auth.views.password_reset_confirm' uidb36=uid token=token %}
{% endblock %}
{% trans "Your username:" %} {{ user.get_username }}

{% endautoescape %}


text:
package com.travelpro.services;

import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.media.RingtoneManager;
import android.net.Uri;
import android.support.v4.app.NotificationCompat;
import android.util.Log;

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;
import com.travelpro.MainActivity;
import com.travelpro.R;

/**
 * Created by neo on 25-02-2017.
 */

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    private static final String TAG = "MyFirebaseMsgService";

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        //Displaying data in log
        //It is optional
        Log.d(TAG, "From: " + remoteMessage.getFrom());
        Log.d(TAG, "Notification Message Body: " + remoteMessage.getNotification().getBody());

        //Calling method to generate notification
        sendNotification(remoteMessage.getNotification().getTitle(), remoteMessage.getNotification().getBody());
    }

    //This method is only generating push notification
    //It is same as we did in earlier posts
    private void sendNotification(String title, String messageBody) {
        Intent intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent,
                PendingIntent.FLAG_ONE_SHOT);

        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle(title)
                .setContentText(messageBody)
                .setAutoCancel(true)
                .setSound(defaultSoundUri)
                .setContentIntent(pendingIntent).setStyle(new NotificationCompat.BigTextStyle()
                        .bigText(messageBody));

        NotificationManager notificationManager =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        notificationManager.notify(0, notificationBuilder.build());
    }
}


text:
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>Minimalist starter - Angular 2</title>
  <base href="<%= APP_BASE %>">
  <meta name="description" content="">
  <meta name="viewport" content="width=device-width, initial-scale=1">

  <!-- inject:css -->
  <!-- endinject -->

</head>
<body data-app-version="<%= APP_VERSION %>">

  <app>Loading...</app>

  <!-- inject:js -->
  <!-- endinject -->

  <script>
    System.import('bootstrap')
      .catch(function (e) {
        console.error(e);
      });
  </script>

</body>
</html>


text:
"""
Helper classes for Ironic HTTP PATCH creation.
"""

from oslo_config import cfg

CONF = cfg.CONF
CONF.import_opt('default_ephemeral_format', 'nova.virt.driver')

def create(node):
    """Create an instance of the appropriate DriverFields class.

    :param node: a node object returned from ironicclient
    :returns: GenericDriverFields or a subclass thereof, as appropriate
              for the supplied node.
    """
    if 'pxe' in node.driver:
        return PXEDriverFields(node)
    else:
        return GenericDriverFields(node)

class GenericDriverFields(object):

    def __init__(self, node):
        self.node = node

    def get_deploy_patch(self, instance, image_meta, flavor,
                         preserve_ephemeral=None):
        """Build a patch to add the required fields to deploy a node.

        :param instance: the instance object.
        :param image_meta: the metadata associated with the instance
                           image.
        :param flavor: the flavor object.
        :param preserve_ephemeral: preserve_ephemeral status (bool) to be
                                   specified during rebuild.
        :returns: a json-patch with the fields that needs to be updated.

        """
        patch = []
        patch.append({'path': '/instance_info/image_source', 'op': 'add',
                      'value': image_meta['id']})
        patch.append({'path': '/instance_info/root_gb', 'op': 'add',
                      'value': str(instance.root_gb)})
        patch.append({'path': '/instance_info/swap_mb', 'op': 'add',
                      'value': str(flavor['swap'])})

        if instance.ephemeral_gb:
            patch.append({'path': '/instance_info/ephemeral_gb',
                          'op': 'add',
                          'value': str(instance.ephemeral_gb)})
            if CONF.default_ephemeral_format:
                patch.append({'path': '/instance_info/ephemeral_format',
                              'op': 'add',
                              'value': CONF.default_ephemeral_format})

        if preserve_ephemeral is not None:
            patch.append({'path': '/instance_info/preserve_ephemeral',
                          'op': 'add', 'value': str(preserve_ephemeral)})

        return patch

    def get_cleanup_patch(self, instance, network_info, flavor):
        """Build a patch to clean up the fields.

        :param instance: the instance object.
        :param network_info: the instance network information.
        :param flavor: the flavor object.
        :returns: a json-patch with the fields that needs to be updated.

        """
        return []

class PXEDriverFields(GenericDriverFields):

    def _get_kernel_ramdisk_dict(self, flavor):
        """Get the deploy ramdisk and kernel IDs from the flavor.

        :param flavor: the flavor object.
        :returns: a dict with the pxe options for the deploy ramdisk and
            kernel if the IDs were found in the flavor, otherwise an empty
            dict is returned.

        """
        extra_specs = flavor['extra_specs']
        deploy_kernel = extra_specs.get('baremetal:deploy_kernel_id')
        deploy_ramdisk = extra_specs.get('baremetal:deploy_ramdisk_id')
        deploy_ids = {}
        if deploy_kernel and deploy_ramdisk:
            deploy_ids['pxe_deploy_kernel'] = deploy_kernel
            deploy_ids['pxe_deploy_ramdisk'] = deploy_ramdisk
        return deploy_ids

    def get_deploy_patch(self, instance, image_meta, flavor,
                         preserve_ephemeral=None):
        """Build a patch to add the required fields to deploy a node.

        Build a json-patch to add the required fields to deploy a node
        using the PXE driver.

        :param instance: the instance object.
        :param image_meta: the metadata associated with the instance
                           image.
        :param flavor: the flavor object.
        :param preserve_ephemeral: preserve_ephemeral status (bool) to be
                                   specified during rebuild.
        :returns: a json-patch with the fields that needs to be updated.

        """
        patch = super(PXEDriverFields, self).get_deploy_patch(
                    instance, image_meta, flavor, preserve_ephemeral)

        # TODO(lucasagomes): Remove it in Kilo. This is for backwards
        # compatibility with Icehouse. If flavor contains both ramdisk
        # and kernel ids, use them.
        for key, value in self._get_kernel_ramdisk_dict(flavor).items():
            patch.append({'path': '/driver_info/%s' % key,
                          'op': 'add', 'value': value})

        return patch

    def get_cleanup_patch(self, instance, network_info, flavor):
        """Build a patch to clean up the fields.

        Build a json-patch to remove the fields used to deploy a node
        using the PXE driver. Note that the fields added to the Node's
        instance_info don't need to be removed because they are purged
        during the Node's tear down.

        :param instance: the instance object.
        :param network_info: the instance network information.
        :param flavor: the flavor object.
        :returns: a json-patch with the fields that needs to be updated.

        """
        patch = super(PXEDriverFields, self).get_cleanup_patch(
                    instance, network_info, flavor)

        # TODO(lucasagomes): Remove it in Kilo. This is for backwards
        # compatibility with Icehouse. If flavor contains a ramdisk and
        # kernel id remove it from nodes as part of the tear down process
        for key in self._get_kernel_ramdisk_dict(flavor):
            if key in self.node.driver_info:
                patch.append({'op': 'remove',
                              'path': '/driver_info/%s' % key})
        return patch


text:
import React from "react";
import GridCore from "../views/Sensors/gridCore";
import {css} from "styled-components/macro";

const parseActions = ({timelineItems}) => {
  return timelineItems.map(t => ({...t, args: JSON.parse(t.args)}));
};
const getArmyContacts = steps => {
  return steps
    .reduce((acc, step) => {
      const actions = parseActions(step);
      return acc.concat(
        actions
          .filter(e => e.event === "setArmyContacts")
          .map(e => e.args.armyContacts),
      );
    }, [])
    .flat();
};
const getContacts = (steps, currentStep, stepId, delay) => {
  // Get the last step where sensors contacts were updated.
  const stepIndex = steps.findIndex(s => s.id === currentStep);
  const sensorGrid = steps.reduce((acc, step, i) => {
    if (i > stepIndex) return acc;
    const actions = parseActions(step);
    const sensorGrids = actions.filter(
      a =>
        a.event === "updateSensorGrid" &&
        a.id !== stepId &&
        (stepIndex > i || a.delay < delay),
    );
    if (sensorGrids.length === 0) return acc;
    return sensorGrids[0];
  }, null);
  if (sensorGrid)
    return sensorGrid.args.contacts.map(c => ({
      ...c,
      location: c.destination,
      destination: c.destination,
    }));
  return [];
};
export default ({
  id,
  steps = [],
  currentStep,
  updateArgs,
  args,
  client,
  delay,
  lite,
}) => {
  const armyContacts = getArmyContacts(steps, currentStep, id, delay);
  const {contacts} = args;
  if (!contacts) {
    updateArgs("contacts", getContacts(steps, currentStep));
    return null;
  }
  return (
    <div
      css={css`
        height: 60vh;
      `}
    >
      <GridCore
        simulator={{}}
        lite
        ultraLite={lite}
        defaultSensors={{id: "sensors", armyContacts}}
        contacts={contacts}
        updateContacts={contacts => updateArgs("contacts", contacts)}
      />
      <small>
        Note: Use a "Set Army Sensor Contacts" timeline action to configure the
        available sensor contacts. Lots of features are still missing. If there
        is something this timeline action doesn't do, submit an issue describing
        what you want it to do.
      </small>
    </div>
  );
};


text:
title: Morning Dew
date: 2010-02-14 00:00:00 Z
categories:
- photograph
layout: photograph
comments: true
photograph: IMG_7917.jpg
photograph_max_width: 940
photograph_max_height: 627
subject: macro
attribute: b_w
camera: Canon EOS 20D
lens: Canon 100.0 mm
exposure: 1/15 sec at f / 20
iso: ISO 200
---

This is one of my first macro shots. Macro is still pretty new to me, but I like how it opens up a whole new environment to discover.


text:
package javax.batch.api.partition;

import javax.batch.runtime.BatchStatus;
import java.io.Serializable;

/**
 * @author Brent Douglas
 * @since 1.0
 */
public interface PartitionAnalyzer {

    void analyzeCollectorData(Serializable data) throws Exception;

    void analyzeStatus(BatchStatus batchStatus, String exitStatus) throws Exception;
}


text:
import * as types from '../../src/constants/ActionTypes'
import * as actions from '../../src/actions/RegistrationActions'

describe('RegistrationActions', () => {
  it('should create an action to register a user', () => {
    const user = {
      name: 'Gandalf',
      email: 'gandalfTheGrey@theHire.com',
      password: 'aWizardIsNeverLate',
      password_confirmation: 'aWizardIsNeverLate',
    };
    const expectedAction = {
      type: types.REGISTER_USER,
      payload: new Promise((resolve, reject) => {})
    };
    expect(actions.registerUser(user)).toEqual(expectedAction)
  });

  it('should create an action to handle changes in the registration form', () => {
    const inputValue = {name: "Frodo"};
    const expectedAction = {
      type: types.REGISTER_FORM_HANDLE_CHANGE,
      payload: inputValue
    };
    expect(actions.registerFormHandleChange(inputValue)).toEqual(expectedAction)
  });
});


text:
<!DOCTYPE html>

    <title></title>

    <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css"/>

    <link rel="stylesheet" href="redactor/redactor.css"/>


text:
package org.hl7.fhir.dstu3.model.codesystems;

// Generated on Tue, Dec 6, 2016 09:42-0500 for FHIR v1.8.0

import org.hl7.fhir.dstu3.model.EnumFactory;

public class V3ActRelationshipSplitEnumFactory implements EnumFactory<V3ActRelationshipSplit> {

  public V3ActRelationshipSplit fromCode(String codeString) throws IllegalArgumentException {
    if (codeString == null || "".equals(codeString))
      return null;
    if ("E1".equals(codeString))
      return V3ActRelationshipSplit.E1;
    if ("EW".equals(codeString))
      return V3ActRelationshipSplit.EW;
    if ("I1".equals(codeString))
      return V3ActRelationshipSplit.I1;
    if ("IW".equals(codeString))
      return V3ActRelationshipSplit.IW;
    throw new IllegalArgumentException("Unknown V3ActRelationshipSplit code '"+codeString+"'");
  }

  public String toCode(V3ActRelationshipSplit code) {
    if (code == V3ActRelationshipSplit.E1)
      return "E1";
    if (code == V3ActRelationshipSplit.EW)
      return "EW";
    if (code == V3ActRelationshipSplit.I1)
      return "I1";
    if (code == V3ActRelationshipSplit.IW)
      return "IW";
    return "?";
  }

    public String toSystem(V3ActRelationshipSplit code) {
      return code.getSystem();
      }

}


text:
<!doctype html>

	<meta charset="utf-8">
	<link rel="stylesheet" href="../css/fsa-card/front.css">

twitter @Joseph

irc.mozilla.org Joseph

Joseph D. Cary

Chemical equipment tender







German, English, Chinese

community building, visual design, l10n, public relations, evangelism

724-696-2183

JosephDCary@inbound.plus

www.mozillians.org/u/JosephDCary

Volunteer

Firefox

Student Ambassadors


text:
import unittest

#
#  Vacuum all input from a string and then treat it like a buffer.
#
from antlr4.Token import Token
from antlr4.CodePoints import from_unicode, to_unicode
import sys

class InputStream (object):

    def __init__(self, data, encoding = "ascii"):
        self.name = "<empty>"
        self.strdata = data if isinstance(data, unicode) else unicode(data, encoding)
        self._loadString()

    def _loadString(self):
        self._index = 0
        self.data = list(from_unicode(self.strdata))
        self._size = len(self.data)

    @property
    def index(self):
        return self._index

    @property
    def size(self):
        return self._size

    # Reset the stream so that it's in the same state it was
    #  when the object was created *except* the data array is not
    #  touched.
    #
    def reset(self):
        self._index = 0

    def consume(self):
        if self._index >= self._size:
            assert self.LA(1) == Token.EOF
            raise Exception("cannot consume EOF")
        self._index += 1

    def LA(self, offset):
        if offset==0:
            return 0 # undefined
        if offset<0:
            offset += 1 # e.g., translate LA(-1) to use offset=0
        pos = self._index + offset - 1
        if pos < 0 or pos >= self._size: # invalid
            return Token.EOF
        return self.data[pos]

    def LT(self, offset):
        return self.LA(offset)

    # mark/release do nothing; we have entire buffer
    def mark(self):
        return -1

    def release(self, marker):
        pass

    # consume() ahead until p==_index; can't just set p=_index as we must
    # update line and column. If we seek backwards, just set p
    #
    def seek(self, _index):
        if _index<=self._index:
            self._index = _index # just jump; don't update stream state (line, ...)
            return
        # seek forward
        self._index = min(_index, self._size)

    def getText(self, start, stop):
        if stop >= self._size:
            stop = self._size-1
        if start >= self._size:
            return u""
        else:
            return to_unicode(self.data[start:stop+1])

    def __str__(self):
        return unicode(self)

    def __unicode__(self):
        return self.strdata

class TestInputStream(unittest.TestCase):

    def testStream(self):
        stream = InputStream("abcde")
        self.assertEqual(0, stream.index)
        self.assertEqual(5, stream.size)
        self.assertEqual(ord("a"), stream.LA(1))
        stream.consume()
        self.assertEqual(1, stream.index)
        stream.seek(5)
        self.assertEqual(Token.EOF, stream.LA(1))
        self.assertEqual("bcd", stream.getText(1, 3))
        stream.reset()
        self.assertEqual(0, stream.index)


text:
import React from 'react';
import autobind from 'class-autobind';
import styled from 'styled-components';
import RequestPersistedEditor from './Request-persisted';
import PersistedResultEditor from './Result-persisted';
import IconButton from '../../../styled/components/IconButton';
import '../css/style-persisted.css';
import runIcon from '../../../icons/controller-play.svg';
import prettifyIcon from '../../../icons/flash.svg';
import refreshIcon from '../../../icons/ccw.svg';
import saveIcon from '../../../icons/save.svg';
import infoIcon from '../../../icons/info.svg';
import Editor from '../../shared/components/Editor/Editor-shared';
import Connection from '../../shared/components/Connection-shared';
import Variables from './Editor-variables';

const EditorToolbar = styled.ul`
  position: absolute;
  left: 230px;
  top: 80px;
  padding: 0 20px 0 0;
  margin: 0;
`;

const EditorToolbarItem = styled.li`display: inline;`;

const Container = styled.div`
  position: absolute;
  bottom: 0;
  left: 230px;
  right: 0;
  top: 120px;
  overflow: hidden;
  display: flex;
`;

const Result = styled.div`
  flex: 1;
  border-left: ${props => props.theme.borders.thinSecondary};
  width: 50%;
`;

const Request = styled.div`
  flex: 1;
  width: 50%;
  display: flex;
  flex-direction: column;
`;

const ResultFooter = styled.div`
  position: fixed;
  bottom: 0;
  right: 0;
  padding: 4px 20px;
  background: ${props => props.theme.colors.background}
`;

const HistoryInfo = props =>

Use the query editor to left to send persisted queries to the server.

      Queries are list with

An example query might look like:

      {`[
  {
    "id: "cj5uyf8ni"
    "variables: {
      "_id": "1"
    }
  }
]`}

      Keyboard shortcuts:

      Run Persisted: Ctrl-Enter or press the play button above the query editor.

      Auto Complete: Ctrl-Space or just start typing.`}

;

const CollectionInfo = props =>
Save persisted queries to create collections
;

export default class PersistedEditor extends React.PureComponent {
  constructor () {
    super(...arguments);
    autobind(this);
  }

  render () {
    const {
      fetcher,
      forms,
      getGraphqlSchema,
      handleChangeCollection,
      handleChangeInputCollection,
      handleClickPrettify,
      handleClickRest,
      handleClickSave,
      handleOnChangePersisted,
      handleOnChangeRequest,
      handleOnVariableChange,
      handlePersistedCollectionItemClick,
      handlePersistedHistoryItemClick,
      isConnected,
      persistedCollection,
      persistedCollectionAll,
      persistedHistoryAll,
      selectedPersisted,
      setGraphqlSchema,
      setSaveFormFields,
      setSchemaIsConnected,
      setSelectedPersistedProps,
      setSettingsModal,
      showSidebarPersistedCollection,
      showSidebarPersistedHistory,
      uiPersistedEditor,
      validateSaveModule
    } = this.props;

    const { sidebarPersistedContent } = uiPersistedEditor;
    const { status, time } = selectedPersisted.results || {};

    return (
      <Editor
        collectionInfo={<CollectionInfo />}
        collections={persistedCollectionAll}
        history={persistedHistoryAll}
        historyInfo={<HistoryInfo />}

        onCollectionItemClick={handlePersistedCollectionItemClick}
        onHistoryItemClick={handlePersistedHistoryItemClick}
        showSidebarCollection={showSidebarPersistedCollection}
        showSidebarHistory={showSidebarPersistedHistory}
        sidebarType={sidebarPersistedContent}

        selectedItem={selectedPersisted}
        setSettingsModal={setSettingsModal}
        getGraphqlSchema={getGraphqlSchema}
        setEndpoint={setSelectedPersistedProps}
        setGraphqlSchema={setGraphqlSchema}
        setSchemaIsConnected={setSchemaIsConnected}

        collection={persistedCollection}
        forms={forms}
        handleChangeCollection={handleChangeCollection}
        handleChangeInputCollection={handleChangeInputCollection}
        handleClickSave={handleClickSave}
        saveModalHeader="Save persisted"
        saveModalOpened={uiPersistedEditor.isSaveModalOpen}
        setSaveFormFields={setSaveFormFields}
        setSaveModel={this.props.openSaveModel}
        validation={validateSaveModule}

        infoModalOpened={uiPersistedEditor.isInfoModalOpen}
        infoModalHeader="Persisted Info"
        result={selectedPersisted.results}
        setInfoModal={this.props.openInfoModal}
      >
      <EditorToolbar>
        <EditorToolbarItem className="Editor-toolbar-item">
          <IconButton
            title="Execute Persisted"
            onClick={fetcher}
            src={runIcon}
          />
        </EditorToolbarItem>
        <EditorToolbarItem className="Editor-toolbar-item">
          <IconButton
            title="Prettify Persisted"
            src={prettifyIcon}
            onClick={handleClickPrettify}
          >
            
          </IconButton>
        </EditorToolbarItem>
        <EditorToolbarItem className="Editor-toolbar-item">
          <IconButton
            title="Save Persisted"
            src={saveIcon}
            onClick={this.props.openSaveModel}
          >
            
          </IconButton>
        </EditorToolbarItem>
        <EditorToolbarItem className="Editor-toolbar-item">
          <IconButton
            title="Reset Persisted"
            src={refreshIcon}
            onClick={handleClickRest}
          >
            
          </IconButton>
        </EditorToolbarItem>
        <EditorToolbarItem className="Editor-toolbar-item">
          <IconButton
            title="Persisted Information"
            src={infoIcon}
            onClick={this.props.openInfoModal}
          >
            
          </IconButton>
        </EditorToolbarItem>
      </EditorToolbar>
      <Container>
          <Request>
            <RequestPersistedEditor
              selectedPersisted={selectedPersisted}
              handleOnChange={handleOnChangePersisted}

            />
            <Variables
              value={selectedPersisted.variables}
              handleOnChange={handleOnVariableChange}
              />
          </Request>
          <Result>
            <PersistedResultEditor
              selectedPersisted={selectedPersisted}
              handleOnChange={handleOnChangeRequest}
            />
            <ResultFooter>
              <Connection
                isConnected={isConnected}
                status={status}
                time={time}
              />
            </ResultFooter>
          </Result>

        </Container>
      </Editor>

    );
  }
}