text:
package org.aludratest.service.edifactfile;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.util.Map;

import org.aludratest.exception.AutomationException;
import org.aludratest.service.AttachParameter;
import org.aludratest.service.AttachResult;
import org.aludratest.service.ElementName;
import org.aludratest.service.ElementType;
import org.aludratest.service.Interaction;
import org.aludratest.service.TechnicalArgument;
import org.aludratest.service.TechnicalLocator;
import org.aludratest.service.file.FileFilter;
import org.databene.edifatto.EdiFormatSymbols;
import org.databene.edifatto.model.Interchange;

/**
 * Parses and saves EDIFACT and X12 documents from and to streams.
 * @author Volker Bergmann
 */
public interface EdifactFileInteraction extends Interaction {

    /** Polls the file system until a file at the given path is found or a timeout occurs.
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param filePath the path of the file to check */
    void waitUntilExists(
            @ElementType String elementType,
            @ElementName String elementName,
            @TechnicalLocator String filePath);

    /** Polls the given directory until the filter finds a match or a timeout is exceeded. Timeout and the maximum number of polls
     * are retrieved from the {@link org.aludratest.service.file.impl.FileServiceConfiguration}.
     * @param parentPath the path of the directory in which to search for the file
     * @param filter a filter object that decides which file is to be accepted
     * @return the file path of the first file that was accepted by the filter
     * @throws AutomationException if the file was not found within the timeout */
    String waitForFirstMatch(@TechnicalLocator String parentPath, FileFilter filter);

    /** Polls the file system until no file is found at the given path.
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param filePath the path of the file to check */
    void waitUntilNotExists(
            @ElementType String elementType,
            @ElementName String elementName,
            @TechnicalLocator String filePath);

    /** Deletes a file
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param filePath the path of the file to delete */
    void delete(
            @ElementType String elementType,
            @ElementName String elementName,
            @TechnicalLocator String filePath);

    /** Writes an EDIFACT or X12 interchange to an {@link OutputStream}.
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param interchange the interchange to persist
     * @param filePath the path of the file to write
     * @param overwrite flag that indicates whether a pre-existing file may be overwritten */
    void writeInterchange(
            @ElementType String elementType,
            @ElementName String elementName,
            @AttachParameter("Interchange") Interchange interchange,
            @TechnicalLocator String filePath,
            @TechnicalArgument boolean overwrite);

    /** Creates an {@link Interchange} based on a template file and a variable tree
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param templateUri the path of the template file
     * @param symbols the symbols to use
     * @param variables the variable tree
     * @return a new Interchange containing the information from the variable tree */
    @AttachResult("Created Interchange")
    Interchange createInterchange(
            @ElementType String elementType,
            @ElementName String elementName,
            @TechnicalLocator String templateUri,
            @TechnicalArgument EdiFormatSymbols symbols,
            @TechnicalArgument Map<String, Object> variables);

    /** Reads an {@link Interchange} from a file system.
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param filePath the full path of the file to read
     * @return an {@link Interchange} data structure that contains the EDI data mapped to a tree structure */
    @AttachResult("Read Interchange")
    Interchange readInterchange(
            @ElementType String elementType,
            @ElementName String elementName,
            @TechnicalLocator String filePath);

    /** Reads an {@link Interchange} from a {@link Reader}.
     * @param elementType the element type to log
     * @param elementName the element name to log
     * @param in an {@link InputStream} that provides the interchange's textual representation
     * @return an {@link Interchange} data structure that contains the EDI data mapped to a tree structure */
    @AttachResult("Read Interchange")
    Interchange readInterchange(@ElementType String elementType, @ElementName String elementName,
            @TechnicalArgument InputStream in);

}


text:
<?php
namespace Google\Service\Calendar\Acl;

/**
 * The "acl" collection of methods.
 * Typical usage is:
 *  <code>
 *   $calendarService = new Google_Service_Calendar(...);
 *   $acl = $calendarService->acl;
 *  </code>
 */
class Resource extends \Google\Service\Resource
{

  /**
   * Deletes an access control rule. (acl.delete)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param string $ruleId
   * ACL rule identifier.
   * @param array $optParams Optional parameters.
   */
  public function delete($calendarId, $ruleId, $optParams = array())
  {
    $params = array('calendarId' => $calendarId, 'ruleId' => $ruleId);
    $params = array_merge($params, $optParams);
    return $this->call('delete', array($params));
  }
  /**
   * Returns an access control rule. (acl.get)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param string $ruleId
   * ACL rule identifier.
   * @param array $optParams Optional parameters.
   * @return \Google\Service\Calendar\AclRule
   */
  public function get($calendarId, $ruleId, $optParams = array())
  {
    $params = array('calendarId' => $calendarId, 'ruleId' => $ruleId);
    $params = array_merge($params, $optParams);
    return $this->call('get', array($params), "\Google\Service\Calendar\AclRule");
  }
  /**
   * Creates an access control rule. (acl.insert)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param \Google\AclRule $postBody
   * @param array $optParams Optional parameters.
   * @return \Google\Service\Calendar\AclRule
   */
  public function insert($calendarId, \Google\Service\Calendar\AclRule $postBody, $optParams = array())
  {
    $params = array('calendarId' => $calendarId, 'postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('insert', array($params), "\Google\Service\Calendar\AclRule");
  }
  /**
   * Returns the rules in the access control list for the calendar. (acl.listAcl)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param array $optParams Optional parameters.
   * @return \Google\Service\Calendar\Acl
   */
  public function listAcl($calendarId, $optParams = array())
  {
    $params = array('calendarId' => $calendarId);
    $params = array_merge($params, $optParams);
    return $this->call('list', array($params), "\Google\Service\Calendar\Acl");
  }
  /**
   * Updates an access control rule. This method supports patch semantics.
   * (acl.patch)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param string $ruleId
   * ACL rule identifier.
   * @param \Google\AclRule $postBody
   * @param array $optParams Optional parameters.
   * @return \Google\Service\Calendar\AclRule
   */
  public function patch($calendarId, $ruleId, \Google\Service\Calendar\AclRule $postBody, $optParams = array())
  {
    $params = array('calendarId' => $calendarId, 'ruleId' => $ruleId, 'postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('patch', array($params), "\Google\Service\Calendar\AclRule");
  }
  /**
   * Updates an access control rule. (acl.update)
   *
   * @param string $calendarId
   * Calendar identifier.
   * @param string $ruleId
   * ACL rule identifier.
   * @param \Google\AclRule $postBody
   * @param array $optParams Optional parameters.
   * @return \Google\Service\Calendar\AclRule
   */
  public function update($calendarId, $ruleId, \Google\Service\Calendar\AclRule $postBody, $optParams = array())
  {
    $params = array('calendarId' => $calendarId, 'ruleId' => $ruleId, 'postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('update', array($params), "\Google\Service\Calendar\AclRule");
  }
}

redpajama_set_name: RedPajamaGithub


text:
// Set slideShowSpeed (milliseconds)
var slideShowSpeed = 300

// Duration of crossfade (seconds)
var crossFadeDuration = 3

// =======================================
// do not edit anything below this line
// =======================================

isIE=document.all;
isNN=!document.all&&document.getElementById;
isN4=document.layers;
isHot=false;

function ddInit(e){
  topDog=isIE ? "BODY" : "HTML";
  whichDog=document.getElementById("theLayer");
  hotDog=isIE ? event.srcElement : e.target;
  while (hotDog.id!="titleBar" && hotDog.tagName!=topDog){
    hotDog=isIE ? hotDog.parentElement : hotDog.parentNode;
  }
  if (hotDog.id=="titleBar"){
    offsetx=isIE ? event.clientX : e.clientX;
    offsety=isIE ? event.clientY : e.clientY;
    nowX=whichDog.offsetLeft;
    nowY=whichDog.offsetTop;
    ddEnabled=true;
    document.onmousemove=dd;
    return false;
  }
  else ddEnabled = false;
}

function dd(e){
  if (!ddEnabled) return;
  selection = null;
  x = isIE ? nowX+event.clientX-offsetx : nowX+e.clientX-offsetx;
  whichDog.style.left=x+"px";
  y = isIE ? nowY+event.clientY-offsety : nowY+e.clientY-offsety;
  whichDog.style.top=y+"px";
  return false;
}

function ddN4(whatDog){
  if (!isN4) return;
  N4=eval(whatDog);
  N4.captureEvents(Event.MOUSEDOWN|Event.MOUSEUP);
  N4.onmousedown=function(e){
    N4.captureEvents(Event.MOUSEMOVE);
    N4x=e.x;
    N4y=e.y;
  }
  N4.onmousemove=function(e){
    if (isHot){
      N4.moveBy(e.x-N4x,e.y-N4y);
      return false;
    }
  }
  N4.onmouseup=function(){
    N4.releaseEvents(Event.MOUSEMOVE);
  }
}

// Hide the SlideShow
function hideMe(){
  if (isIE||isNN) whichDog.style.visibility="hidden";
  else if (isN4) document.theLayer.visibility="hide";
}

// Show the SlideShow
function showMe(){
  if (isIE||isNN) whichDog.style.visibility="visible";
  else if (isN4) document.theLayer.visibility="show";
}

document.onmousedown=ddInit;	// Called when the mouse has been clicked
document.onmouseup=Function("ddEnabled=false");	// Called when the mouse has been released

var t;
var j = 0;
var p = Pic.length;
var pattern = /\'/g;
var curImage = 0;
var curImage2 = 0;
var repeat = 0;
var preLoad = new Array()
preLoadImages();

function preLoadImages(){
	for (i = 0; i < 5; i++){
 	   if(curImage < Pic.length){
		   preLoad[curImage] = new Image();
		   preLoad[curImage].src = Pic[curImage].replace(pattern, "\'");
		   curImage++;
		}
	}
}

function runSlideShow(){
   if(repeat==0){
   if (document.all){
      document.images.SlideShow.style.filter="blendTrans(duration=2)";
      document.images.SlideShow.style.filter="blendTrans(duration=crossFadeDuration)";
      document.images.SlideShow.filters.blendTrans.Apply();
   }
   if (!isN4) document.images.SlideShow.src = preLoad[j].src;
   if (isN4) document.layers['theLayer'].document.images['SlideShow'].src = preLoad[j].src;
   if (document.all){
      document.images.SlideShow.filters.blendTrans.Play();
   }

      getImageInfo(preLoad[j]);
 		j = j + 1;
		if(j > 4){
			preLoadImages();
		}
		curImage2++;
		if(curImage2==(p)){
			//--always repeat
			restartBox = document.getElementById("cbx");
			if(restartBox==null || restartBox.checked==true){
				repeat = 0;
				curImage=0;
				j=0;
				curImage2=0;
				preLoadImages()
			}
		else{
 			repeat=1;
 			pauseClick=0;
			}
		}
   		t = setTimeout('runSlideShow()', slideShowSpeed);
}
}

// Set the current images to the preview image
function previewImage(p){
   //document.images.SlideShow.src = myImages[p];
   clearTimeout(t);
   j = p;
   if (!preLoad[p]) {
     curImage = p;
     preLoadImages();
   }
   runSlideShow();
}

var pauseClick=0;
// Pause the slideshow
function btnPauseClick(){
	pauseClick=1;
    clearTimeout(t)
    getImageInfo();
}

// Start the slideshow
function btnStartClick(){
	if(pauseClick==0){
		repeat = 0;
		curImage=0;
		j=0;
		curImage2=0;
		preLoadImages()
	}
    t = setTimeout('runSlideShow()', slideShowSpeed);
}

// View Previous image
function btnPreviousClick(){
    clearTimeout(t);
    if(j == 0){
        j = preLoad.length - 1;
    }
    else{
        j = j - 1;
    }
    document.images.SlideShow.src = preLoad[j].src;
    getImageInfo(preLoad[j]);
    t = setTimeout('runSlideShow()', slideShowSpeed);
    btnPauseClick();
}

// View next image
function btnNextClick(){
    clearTimeout(t);
    if(j == preLoad.length - 1){
        j = 0;
    }
    else
    {
        j = j + 1;
    }
    document.images.SlideShow.src = preLoad[j].src;
    getImageInfo(preLoad[j]);
    t = setTimeout('runSlideShow()', slideShowSpeed);
    btnPauseClick();
}

/////////////////////////////////////////////////////////////////
// END SLIDESHOW SCRIPT
//////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////
// SCROLL IMAGES SCRIPT
//////////////////////////////////////////////////////////////////

dir=1 // 0 = left 1 = right
speed=0
imageSize=0  // % set to zero to use fixedWidth and fixedHeight values
fixedWidth=40 // set a fixed width
fixedHeight=40 // set a fixed height
spacerWidth=5 // space between images

popupLeft= 100 // pixels
popupTop= 100 // pixels

biggest=0;
ieBorder=0;
totalWidth=0;
hs3Timer=null;

preload=new Array();
for(var i=0;i<myImages.length;i++){
	preload[i]=new Image();
	preload[i].src=myImages[i];
}

function initHS3(){
	scroll1=document.getElementById("scroller1")

	for(var j=0;j<myImages.length;j++){
		//
		scroll1.innerHTML+=''
		if(imageSize!=0){ // use percentage size
			newWidth=preload[j].width/2000*imageSize;
			newHeight=preload[j].height/1600*imageSize;
		}
		else{ // use fixed size
			newWidth=fixedWidth;
			newHeight=fixedHeight;
		}

		document.getElementById("pic"+j).style.width=newWidth+"px"
		//document.getElementById("pic"+j).style.height=newHeight+"px"

		if(document.getElementById("pic"+j).offsetHeight>biggest){
			biggest=document.getElementById("pic"+j).offsetHeight
		}

		document.getElementById("pic"+j).style.marginLeft=spacerWidth+"px"

		totalWidth+=document.getElementById("pic"+j).offsetWidth+spacerWidth
	}

	totalWidth+=1

	for(var k=0;k<myImages.length;k++){ // vertically center images
		document.getElementById("pic"+k).style.marginBottom = (biggest-document.getElementById("pic"+k).offsetHeight)/2+"px"
	}

	if(document.getElementById&&document.all){
		ieBorder=parseInt(document.getElementById("scrollbox").style.borderTopWidth)*2
	}

	document.getElementById("scrollbox").style.height=biggest+ieBorder+"px"

	scroll1.style.width=totalWidth+"px"

	scroll2=document.getElementById("scroller2")
	scroll2.innerHTML=scroll1.innerHTML
	scroll2.style.left= (-scroll1.offsetWidth)+"px"
	scroll2.style.top= -scroll1.offsetHeight+"px"
	scroll2.style.width=totalWidth+"px"

	if(dir==1){
	speed= -speed
	}
	//
}

function scrollHS3(){
if(paused==1){return}
clearTimeout(hs3Timer)

//speed=-3
scroll1Pos=parseInt(scroll1.style.left)
scroll2Pos=parseInt(scroll2.style.left)

scroll1Pos-=speed
scroll2Pos-=speed

scroll1.style.left=scroll1Pos+"px"
scroll2.style.left=scroll2Pos+"px"

hs3Timer=setTimeout("scrollHS3()",50)

if(dir==0){
if(scroll1Pos< -scroll1.offsetWidth){
scroll1.style.left=scroll1.offsetWidth+"px"
}

if(scroll2Pos< -scroll1.offsetWidth){
scroll2.style.left=scroll1.offsetWidth+"px"
}
}

if(dir==1){
if(scroll1Pos>parseInt(document.getElementById("scrollbox").style.width)){
scroll1.style.left=-scroll1.offsetWidth+"px"
}

if(scroll2Pos>parseInt(document.getElementById("scrollbox").style.width)){
//scroll2.style.left=scroll1Pos+ (-scroll2.offsetWidth)+"px"
scroll2.style.left=-scroll1.offsetWidth+"px"
}
}

}

function pause(){
clearTimeout(hs3Timer)
}

paused=0
picWin=null
chkTimer=null

function showBigPic(p){

if(myImages[p]!=""){
paused=1

if(picWin&&picWin.open&&!picWin.closed){picWin.close()} // if picWin exists close it

if(myImages[p].indexOf("htm")==-1){
bigImg=new Image()
bigImg.src=myImages[p]
data="\n\n\n\n"

var winProps = "left= "+popupLeft+", top = "+popupTop+", width="+(bigImg.width+20)+", height="+(bigImg.height+20)+", scrollbars=no, toolbar=no, directories=no, menu bar=no, resizable=yes, status=no"

picWin=window.open("","win1",winProps)
picWin.document.write("\n\n<TITLE></TITLE>\n")
picWin.document.write("\n")
picWin.document.write("\n")
picWin.document.write("
"+data+"
")
picWin.document.write("\n\n")
}
else{
picWin=window.open(myImages[p][1])
}

}
clearTimeout(chkTimer)
}

window.onfocus=function(){
clearTimeout(chkTimer)
if(picWin&&picWin.open&&!picWin.closed){
}
paused=0

}

function setDirLeft(){
dir=0
speed=3
scrollHS3()
}

function setDirRight(){
dir=1
speed=-3
scrollHS3()
}

// Get and display information about the current image
function getImageInfo(someImage){
	if (!someImage) return;
    var strName = someImage.src;
    strName = strName.substr(strName.lastIndexOf("/") + 1, strName.length - strName.lastIndexOf("/"));

    var strSize = someImage.width + "x" + someImage.height;
//    var strFileSize = someImage.fileSize + " bytes";
    nameCell = document.getElementById("imgName");
    if (nameCell) nameCell.innerHTML = "Name: "+ decodeURI(strName) +
    "

" + "Dimensions: " + strSize;
//    "

" + "Size: " + strFileSize;

}
//////////////////////////////////////////////////////////////////////
// END SCROLL IMAGES SCRIPT
//////////////////////////////////////////////////////////////////////


text:
package com.imageintelligence.pix.api.http.domain

import scalaz._
import argonaut._

import com.imageintelligence.galahad.argonaut.ArgonautHelpers._

case class ImageUploadRequestDto(
  images: NonEmptyList[String]
)

object ImageUploadRequestDto {
  implicit val ImageUploadRequestDtoDecodeJson: DecodeJson[ImageUploadRequestDto] =
    DecodeJson(c => c.get[NonEmptyList[String]]("images").map(ImageUploadRequestDto.apply))
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Lecidea albocaerulescens var. vulgaris Schaer.

### Remarks
null


text:
import React, { Component } from 'react';
import { View, BackHandler, Platform } from 'react-native';

import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';

import { addNavigationHelpers } from 'react-navigation';

import Navigator from './containers/navigator';

import StatusBarAlert from 'react-native-statusbar-alert';

import ProgressOverlay      from './components/shared/progressOverlay';
import FetchOverlay         from './components/shared/fetchOverlay';
import PopupNotifyOverlay   from './components/shared/popupNotifyOverlay';

class App extends Component {

    androidBackButtonListener = null;

    componentWillUnmount() {
        if (Platform.OS === "android" && this.androidBackButtonListener !== null) {
            BackHandler.removeEventListener("hardwareBackPress", this.androidBackButtonListene);
        }
    }

    __handleBackAndroid = (globalNavigator) => {
        globalNavigator.goBack();
        return true;
    }

	render () {
        const isLoading = !!this.props.sync.loading;
        const isFetching = !!this.props.sync.fetching;
        const isPopupNotification = !!this.props.notification.active;

        const loadingMsg = this.props.sync.loading;
        const fetchMsg = this.props.sync.fetching;

        const globalNavigator = addNavigationHelpers({
            dispatch: 	this.props.dispatch,
            state:		this.props.nav,
        });

        if (Platform.OS === "android" && this.androidBackButtonListener === null) {
            this.androidBackButtonListener = BackHandler.addEventListener("hardwareBackPress", this.__handleBackAndroid.bind(this, globalNavigator));
        }

        return (
            <View
                style={{
                    backgroundColor: '#2A2F3A',
                    height:'100%',
                    width:'100%',
                }}
            >
                <Navigator
                    navigation={globalNavigator}
                />
                {
                    isLoading ?
                    (<ProgressOverlay
                        msg={loadingMsg}
                    />) : null
                }
                {   isFetching ?
                    (<FetchOverlay
                        msg={fetchMsg}
                    />) : null
                }
                {
                    isPopupNotification ?
                    (
                        <PopupNotifyOverlay
                            msg={this.props.notification.msg}
                            isError={this.props.notification.error}
                        />
                    ) : null
                }
            </View>
        );
    }
}

const mapStateToProps = (state) => ({
  nav: 			state.nav,
  sync:         state.sync,
  notification: state.notification
});

export default connect(mapStateToProps)(App);


text:
package com.adobe.acs.commons.httpcache.exception;

/**
 * Custom exception representing failure conditions in persistence of cached items.
 */
public class HttpCachePersistenceException extends HttpCacheException {
    public HttpCachePersistenceException() {
    }

    public HttpCachePersistenceException(String message) {
        super(message);
    }

    public HttpCachePersistenceException(String message, Throwable cause) {
        super(message, cause);
    }

    public HttpCachePersistenceException(Throwable cause) {
        super(cause);
    }

    public HttpCachePersistenceException(String message, Throwable cause, boolean enableSuppression, boolean
            writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


text:
<? defined('C5_EXECUTE') or die("Access Denied."); ?>

<?
$assignments = $cp->getAllTimedAssignmentsForPage();
if (count($assignments) > 0) { ?>

<?
foreach($assignments as $ppc) {
	$pk = $ppc->getPermissionKeyObject();
	?>

	<?=$pk->getPermissionKeyDisplayName()?>
	<?=t('Permission on ')?><?
		if ($pk instanceof AreaPermissionKey) {  ?>
			<?=$pk->getPermissionObject()->getAreaHandle() ?>.
		<? } else if ($pk instanceof BlockPermissionKey) {
			$bt = BlockType::getByID($pk->getPermissionObject()->getBlockTypeID());
			$obj = $pk->getPermissionObject();
			if ($obj->getBlockName() != '') { ?>

			<?=t('the %s block named %s in %s Area. ', t($bt->getBlockTypeName()), $obj->getBlockName(), $pk->getPermissionObject()->getAreaHandle())?>

			<? } else { ?>

			<?=t('%s Block in %s Area. ', t($bt->getBlockTypeName()), $pk->getPermissionObject()->getAreaHandle())?>

			<? } ?>
		<? } else { ?>
			<?=t('Entire Page')?>.
		<? } ?>
		<?
		$pd = $ppc->getDurationObject();
		?>

		<?
		$assignee = t('Nobody');
		$pae = $ppc->getAccessEntityObject();
		if (is_object($pae)) {
			$assignee = $pae->getAccessEntityLabel();
		}?>
		<?=t('Assigned to %s. ', $assignee)?>
		<?=$pd->getTextRepresentation()?>

<? } ?>

<? } else { ?>

<?=t('No timed permission assignments')?>

<? } ?>


text:
import './styles.css'
import { connect } from '@cerebral/inferno'
import { state, signal } from 'cerebral/tags'
import classnames from 'classnames'
import { nameToColors } from '../../../common/utils'
import Mutation from '../Signals/Signal/Action/Mutation'
import Provider from '../Signals/Signal/Action/Provider'
import connector from 'connector'

function getWatcherIcon(record) {
  if (record.data.watcher.type === 'View') {
    return
  } else if (record.data.watcher.type === 'Compute') {
    return
  } else if (record.data.watcher.type === 'Reaction') {
    return
  }
  return null
}

export default connect(
  {
    port: state`config.port`,
    history: state`history`,
    watchUpdates: state`watchUpdates`,
    currentRememberedMutationIndex: state`currentRememberedMutationIndex`,
    searchValue: state`searchValue`,
    showProvidersInHistory: state`storage.showProvidersInHistory`,
    showActionNamesInHistory: state`storage.showActionNamesInHistory`,
    showStateEffectsInHistory: state`storage.showStateEffectsInHistory`,
    executingSignalsCount: state`executingSignalsCount`,
    showProvidersInHistoryToggled: signal`showProvidersInHistoryToggled`,
    showActionNamesInHistoryToggled: signal`showActionNamesInHistoryToggled`,
    showStateEffectsInHistoryToggled: signal`showStateEffectsInHistoryToggled`,
    mutationDoubleClicked: signal`mutationDoubleClicked`,
    mutationClicked: signal`mutationClicked`,
    signalClicked: signal`signalClicked`,
    pathClicked: signal`pathClicked`,
  },
  function History({
    port,
    history,
    currentRememberedMutationIndex,
    searchValue,
    executingSignalsCount,
    showProvidersInHistory,
    showActionNamesInHistory,
    showStateEffectsInHistory,
    showProvidersInHistoryToggled,
    showActionNamesInHistoryToggled,
    showStateEffectsInHistoryToggled,
    mutationDoubleClicked,
    mutationClicked,
    signalClicked,
    pathClicked,
  }) {
    const filteredHistory = history
      .filter(
        record =>
          record.data.type === 'mutation' ||
          (showProvidersInHistory && record.data.type === 'provider') ||
          (showStateEffectsInHistory && record.data.type === 'watcher')
      )
      .sort((a, b) => {
        if (a.data.datetime  b.data.datetime) {
          return -1
        }

        return 0
      })

    const mutations = history.filter(record => record.data.type === 'mutation')
    const counts = history.reduce(
      (currentCounts, record) => {
        return {
          mutations:
            record.data.type === 'mutation'
              ? currentCounts.mutations + 1
              : currentCounts.mutations,
          providers:
            record.data.type === 'provider'
              ? currentCounts.providers + 1
              : currentCounts.providers,
          watchers:
            record.data.type === 'watcher'
              ? currentCounts.watchers + 1
              : currentCounts.watchers,
        }
      },
      {
        mutations: 0,
        providers: 0,
        watchers: 0,
      }
    )

    const getRecordComponent = record => {
      if (record.data.type === 'mutation') {
        return (

            <Mutation
              mutation={record.data}
              onMutationClick={path => mutationClicked({ path })}
              pathClicked={pathClicked}
            />
            {currentRememberedMutationIndex === mutations.indexOf(record) ? (
              <button disabled className="timetravel-button active">
                now
              </button>
            ) : (
              <button
                disabled={executingSignalsCount}
                onClick={() => {
                  const mutationIndex = mutations.indexOf(record)
                  mutationDoubleClicked({
                    index: mutationIndex,
                  })
                  connector.sendEvent(port, 'remember', mutationIndex)
                }}
                className="timetravel-button"
              >
                travel
              </button>
            )}

        )
      } else if (record.data.type === 'provider') {
        return (
          <Provider
            showReturnValue
            service={record.data}
            pathClicked={pathClicked}
          />
        )
      } else if (record.data.type === 'watcher') {
        return
{record.data.watcher.name}

      }

      return null
    }

    return (

          Mutations:
          {` ${counts.mutations}`}
          |
          Provider calls:
          {`${counts.providers}`}
          |
          State effects:
          {`${counts.watchers}`}

              action names:{' '}
              <input
                type="checkbox"
                onChange={() => showActionNamesInHistoryToggled()}
                checked={showActionNamesInHistory}
              />

              providers:{' '}
              <input
                type="checkbox"
                onChange={() => showProvidersInHistoryToggled()}
                checked={showProvidersInHistory}
              />

              state effects:{' '}
              <input
                type="checkbox"
                onChange={() => showStateEffectsInHistoryToggled()}
                checked={showStateEffectsInHistory}
              />

          {filteredHistory.map((record, index) => {
            if (
              record.data.type === 'mutation' ||
              record.data.type === 'provider'
            ) {
              const namePath = record.signalName.split('.')
              const name = namePath.pop()
              const colors = nameToColors(record.signalName, name)
              const hex = colors.backgroundColor
              const signalStyle = {
                backgroundColor: hex,
              }
              const isSearchHit =
                searchValue &&
                record.data.type === 'mutation' &&
                record.data.args[0].join('.').indexOf(searchValue) >= 0

              return (

                      signalClicked({ executionId: record.executionId })
                    }
                  >
                    {record.signalName}

                    {showActionNamesInHistory ? (

{record.actionName}

                    ) : null}
                    {getRecordComponent(record)}

              )
            }

            return (

                  {getWatcherIcon(record)} {record.data.watcher.type}

                  {getRecordComponent(record)}

            )
          })}

    )
  }
)


text:
package org.apache.reef.runtime.local.driver;

import org.apache.commons.lang.Validate;
import org.apache.reef.annotations.audience.DriverSide;
import org.apache.reef.annotations.audience.Private;
import org.apache.reef.client.FailedRuntime;
import org.apache.reef.proto.ReefServiceProtos;
import org.apache.reef.runtime.common.driver.api.ResourceRequestEvent;
import org.apache.reef.runtime.common.driver.api.RuntimeParameters;
import org.apache.reef.runtime.common.driver.resourcemanager.NodeDescriptorEvent;
import org.apache.reef.runtime.common.driver.resourcemanager.NodeDescriptorEventImpl;
import org.apache.reef.runtime.common.files.REEFFileNames;
import org.apache.reef.runtime.common.utils.Constants;
import org.apache.reef.runtime.common.utils.RemoteManager;
import org.apache.reef.runtime.local.client.parameters.DefaultMemorySize;
import org.apache.reef.runtime.local.client.parameters.DefaultNumberOfCores;
import org.apache.reef.runtime.local.client.parameters.MaxNumberOfEvaluators;
import org.apache.reef.runtime.local.client.parameters.RackNames;
import org.apache.reef.runtime.local.client.parameters.RootFolder;
import org.apache.reef.runtime.local.process.ReefRunnableProcessObserver;
import org.apache.reef.tang.annotations.Parameter;
import org.apache.reef.util.CollectionUtils;
import org.apache.reef.util.MemoryUtils;
import org.apache.reef.util.Optional;
import org.apache.reef.wake.EventHandler;
import org.apache.reef.wake.remote.RemoteMessage;
import org.apache.reef.wake.remote.address.LocalAddressProvider;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.inject.Inject;

/**
 * Manages a set of Containers that each reference a Thread.
 */
@Private
@DriverSide
final class ContainerManager implements AutoCloseable {

  private static final Logger LOG = Logger.getLogger(ContainerManager.class.getName());

  private static final Collection<String> DEFAULT_RACKS = Arrays.asList(RackNames.DEFAULT_RACK_NAME);

  /**
   * Map from containerID -> Container.
   */
  private final Map<String, Container> containers = new HashMap<>();

  /**
   * Map of free, unallocated nodes by rack, by their Node ID.
   * <RackName,<NodeId, True>>
   * Used a map instead of a list as the value for faster lookup
   */
  private final Map<String, Map<String, Boolean>> freeNodesPerRack = new HashMap<>();

  /**
   * Inverted index, map of <NodeId, RackName>.
   */
  private final Map<String, String> racksPerNode = new HashMap<>();

  /**
   * Capacity of each rack (as even as possible).
   */
  private final Map<String, Integer> capacitiesPerRack = new HashMap<>();

  private final int capacity;
  private final int defaultMemorySize;
  private final int defaultNumberOfCores;
  private final String errorHandlerRID;
  private final EventHandler<NodeDescriptorEvent> nodeDescriptorHandler;
  private final File rootFolder;
  private final REEFFileNames fileNames;
  private final ReefRunnableProcessObserver processObserver;
  private final String localAddress;
  private final Collection<String> availableRacks;

  @Inject
  ContainerManager(
      final RemoteManager remoteManager,
      final REEFFileNames fileNames,
      @Parameter(MaxNumberOfEvaluators.class) final int capacity,
      @Parameter(RootFolder.class) final String rootFolderName,
      @Parameter(RuntimeParameters.NodeDescriptorHandler.class) final
      EventHandler<NodeDescriptorEvent> nodeDescriptorHandler,
      @Parameter(RackNames.class) final Set<String> rackNames,
      final ReefRunnableProcessObserver processObserver,
      final LocalAddressProvider localAddressProvider,
      @Parameter(DefaultMemorySize.class) final int defaultMemorySize,
      @Parameter(DefaultNumberOfCores.class) final int defaultNumberOfCores) {
    this.capacity = capacity;
    this.defaultMemorySize = defaultMemorySize;
    this.defaultNumberOfCores = defaultNumberOfCores;
    this.fileNames = fileNames;
    this.processObserver = processObserver;
    this.errorHandlerRID = remoteManager.getMyIdentifier();
    this.nodeDescriptorHandler = nodeDescriptorHandler;
    this.rootFolder = new File(rootFolderName);
    this.localAddress = localAddressProvider.getLocalAddress();
    this.availableRacks = normalize(rackNames);

    LOG.log(Level.FINEST, "Initializing Container Manager with {0} containers", capacity);

    remoteManager.registerHandler(ReefServiceProtos.RuntimeErrorProto.class,
        new EventHandler<RemoteMessage<ReefServiceProtos.RuntimeErrorProto>>() {
          @Override
          public void onNext(final RemoteMessage<ReefServiceProtos.RuntimeErrorProto> value) {
            final FailedRuntime error = new FailedRuntime(value.getMessage());
            LOG.log(Level.SEVERE, "FailedRuntime: " + error, error.getReason().orElse(null));
            release(error.getId());
          }
        });

    init();

    LOG.log(Level.FINE, "Initialized Container Manager with {0} containers", capacity);
  }

  private Collection<String> normalize(final Collection<String> rackNames) {
    return normalize(rackNames, true);
  }

  /**
   * Normalizes the rack names.
   *
   * @param rackNames
   *          the rack names to normalize
   * @param validateEnd
   *          if true, throws an exception if the name ends with ANY (*)
   * @return a normalized collection
   */
  private Collection<String> normalize(final Collection<String> rackNames,
      final boolean validateEnd) {
    final List<String> normalizedRackNames = new ArrayList<>(rackNames.size());
    final Iterator<String> it = rackNames.iterator();
    while (it.hasNext()) {
      String rackName = it.next().trim();
      Validate.notEmpty(rackName, "Rack names cannot be empty");
      // should start with a separator
      if (!rackName.startsWith(Constants.RACK_PATH_SEPARATOR)) {
        rackName = Constants.RACK_PATH_SEPARATOR + rackName;
      }
      // remove the ending separator
      if (rackName.endsWith(Constants.RACK_PATH_SEPARATOR)) {
        rackName = rackName.substring(0, rackName.length() - 1);
      }
      if (validateEnd) {
        Validate.isTrue(!rackName.endsWith(Constants.ANY_RACK));
      }
      normalizedRackNames.add(rackName);
    }
    return normalizedRackNames;
  }

  private void init() {
    // evenly distribute the containers among the racks
    // if rack names are not specified, the default rack will be used, so the denominator will always be > 0
    final int capacityPerRack = capacity / availableRacks.size();
    int missing = capacity % availableRacks.size();
    // initialize the freeNodesPerRackList and the capacityPerRack
    for (final String rackName : availableRacks) {
      this.freeNodesPerRack.put(rackName, new HashMap<String, Boolean>());
      this.capacitiesPerRack.put(rackName, capacityPerRack);
      if (missing > 0) {
        this.capacitiesPerRack.put(rackName, this.capacitiesPerRack.get(rackName) + 1);
        missing--;
      }
    }
  }

  synchronized void start() {
    sendNodeDescriptors();
  }

  private void sendNodeDescriptors() {
    final IDMaker idmaker = new IDMaker("Node-");
    int j = 0;
    for (final String rackName : this.availableRacks) {
      final int rackCapacity = this.capacitiesPerRack.get(rackName);
      for (int i = 0; i < rackCapacity; i++) {
        final String id = idmaker.getNextID();
        this.racksPerNode.put(id, rackName);
        this.freeNodesPerRack.get(rackName).put(id, Boolean.TRUE);

        final int totalMemorySizeInMB = MemoryUtils.getTotalPhysicalMemorySizeInMB();
        final int nodeMemorySizeInMB  = (-1 == totalMemorySizeInMB) ? this.defaultMemorySize : totalMemorySizeInMB;

        this.nodeDescriptorHandler.onNext(NodeDescriptorEventImpl.newBuilder()
                .setIdentifier(id)
                .setRackName(rackName)
                .setHostName(this.localAddress)
                .setPort(j)
                .setMemorySize(nodeMemorySizeInMB)
                .build());
        j++;
      }
    }
  }

  private Collection<String> getRackNamesOrDefault(final List<String> rackNames) {
    return CollectionUtils.isNotEmpty(rackNames) ? normalize(rackNames, false)
        : DEFAULT_RACKS;
  }

  /**
   * Returns the node name of the container to be allocated if it's available, selected from the list of preferred
   * node names. If the list is empty, then an empty optional is returned
   *
   * @param nodeNames
   *          the list of preferred nodes
   * @return the node name where to allocate the container
   */
  private Optional<String> getPreferredNode(final List<String> nodeNames) {
    if (CollectionUtils.isNotEmpty(nodeNames)) {
      for (final String nodeName : nodeNames) {
        final String possibleRack = racksPerNode.get(nodeName);
        if (possibleRack != null
            && freeNodesPerRack.get(possibleRack).containsKey(nodeName)) {
          return Optional.of(nodeName);
        }
      }
    }
    return Optional.empty();
  }

  /**
   * Returns the rack where to allocate the container, selected from the list of
   * preferred rack names. If the list is empty, and there's space in the default
   * rack, then the default rack is returned. The relax locality semantic is
   * enabled if the list of rack names contains '/*', otherwise relax locality
   * is considered disabled
   *
   * @param rackNames
   *          the list of preferred racks
   * @return the rack name where to allocate the container
   */
  private Optional<String> getPreferredRack(final List<String> rackNames) {
    final Collection<String> normalized = getRackNamesOrDefault(rackNames);
    for (final String rackName : normalized) {
      // if it does not end with the any modifier,
      // then we should do an exact match
      if (!rackName.endsWith(Constants.ANY_RACK)) {
        if (freeNodesPerRack.containsKey(rackName)
            && freeNodesPerRack.get(rackName).size() > 0) {
          return Optional.of(rackName);
        }
      } else {
        // if ends with the any modifier, we do a prefix match
        final Iterator<String> it = availableRacks.iterator();
        while (it.hasNext()) {
          final String possibleRackName = it.next();
          // remove the any modifier
          final String newRackName = rackName.substring(0,
              rackName.length() - 1);
          if (possibleRackName.startsWith(newRackName)) {
            if (freeNodesPerRack.get(possibleRackName).size() > 0) {
              return Optional.of(possibleRackName);
            }
          }
        }
      }
    }
    return Optional.empty();
  }

  /**
   * Allocates a container based on a request event. First it tries to match a
   * given node, if it cannot, it tries to get a spot in a rack
   *
   * @param requestEvent
   *          the request event
   * @return an optional with the container if allocated
   */
  Optional<Container> allocateContainer(final ResourceRequestEvent requestEvent) {
    Container container = null;
    final Optional<String> nodeName = getPreferredNode(requestEvent
        .getNodeNameList());
    if (nodeName.isPresent()) {
      container = allocateBasedOnNode(
          requestEvent.getMemorySize().orElse(this.defaultMemorySize),
          requestEvent.getVirtualCores().orElse(this.defaultNumberOfCores),
          nodeName.get());
    } else {
      final Optional<String> rackName = getPreferredRack(requestEvent
          .getRackNameList());
      if (rackName.isPresent()) {
        container = allocateBasedOnRack(
            requestEvent.getMemorySize().orElse(this.defaultMemorySize),
            requestEvent.getVirtualCores().orElse(this.defaultNumberOfCores),
            rackName.get());
      }
    }
    return Optional.ofNullable(container);
  }

  private Container allocateBasedOnNode(final int megaBytes,
      final int numberOfCores, final String nodeId) {
    synchronized (this.containers) {
      // get the rack name
      final String rackName = this.racksPerNode.get(nodeId);
      // remove if from the free map
      this.freeNodesPerRack.get(rackName).remove(nodeId);
      // allocate
      return allocate(megaBytes, numberOfCores, nodeId, rackName);
    }
  }

  private Container allocateBasedOnRack(final int megaBytes,
      final int numberOfCores, final String rackName) {
    synchronized (this.containers) {
      // get the first free nodeId in the rack
      final Set<String> freeNodes = this.freeNodesPerRack.get(rackName)
          .keySet();
      final Iterator<String> it = freeNodes.iterator();
      if (!it.hasNext()) {
        throw new IllegalArgumentException(
            "There should be a free node in the specified rack " + rackName);
      }
      final String nodeId = it.next();
      // remove it from the free map
      this.freeNodesPerRack.get(rackName).remove(nodeId);
      // allocate
      return allocate(megaBytes, numberOfCores, nodeId, rackName);
    }
  }

  private Container allocate(final int megaBytes, final int numberOfCores,
      final String nodeId, final String rackName) {
    final String processID = nodeId + "-"
        + String.valueOf(System.currentTimeMillis());
    final File processFolder = new File(this.rootFolder, processID);
    processFolder.mkdirs();
    final ProcessContainer container = new ProcessContainer(
        this.errorHandlerRID, nodeId, processID, processFolder, megaBytes,
        numberOfCores, rackName, this.fileNames, this.processObserver);
    this.containers.put(container.getContainerID(), container);
    LOG.log(Level.FINE, "Allocated {0}", container.getContainerID());
    return container;
  }

  void release(final String containerID) {
    synchronized (this.containers) {
      final Container ctr = this.containers.get(containerID);
      if (null != ctr) {
        LOG.log(Level.INFO, "Releasing Container with containerId [{0}]", ctr);
        if (ctr.isRunning()) {
          ctr.close();
        }
        this.freeNodesPerRack.get(ctr.getRackName()).put(ctr.getNodeID(), Boolean.TRUE);
        this.containers.remove(ctr.getContainerID());
      } else {
        LOG.log(Level.INFO, "Ignoring release request for unknown containerID [{0}]", containerID);
      }
    }
  }

  Container get(final String containedID) {
    synchronized (this.containers) {
      return this.containers.get(containedID);
    }
  }

  /**
   * @return a List of the IDs of currently allocated Containers.
   */
  Iterable<String> getAllocatedContainerIDs() {
    return this.containers.keySet();
  }

  @Override
  public synchronized void close() {
    synchronized (this.containers) {
      if (this.containers.isEmpty()) {
        LOG.log(Level.FINEST, "Clean shutdown with no outstanding containers.");
      } else {
        LOG.log(Level.WARNING, "Dirty shutdown with outstanding containers.");
        for (final Container c : this.containers.values()) {
          LOG.log(Level.WARNING, "Force shutdown of: {0}", c);
          c.close();
        }
      }
    }
  }

}


text:
package net.androidsensei.pokedex.provider;

import android.annotation.TargetApi;
import android.content.Context;
import android.database.DatabaseErrorHandler;
import android.database.DefaultDatabaseErrorHandler;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Build;
import android.util.Log;

import net.androidsensei.pokedex.BuildConfig;
import net.androidsensei.pokedex.provider.pokemon.PokemonColumns;

public class PokedexSQLiteOpenHelper extends SQLiteOpenHelper {
    private static final String TAG = PokedexSQLiteOpenHelper.class.getSimpleName();

    public static final String DATABASE_FILE_NAME = "pokedex.db";
    private static final int DATABASE_VERSION = 1;
    private static PokedexSQLiteOpenHelper sInstance;
    private final Context mContext;
    private final PokedexSQLiteOpenHelperCallbacks mOpenHelperCallbacks;

    // @formatter:off
    public static final String SQL_CREATE_TABLE_POKEMON = "CREATE TABLE IF NOT EXISTS "
            + PokemonColumns.TABLE_NAME + " ( "
            + PokemonColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
            + PokemonColumns.NAME + " TEXT, "
            + PokemonColumns.UUID + " TEXT NOT NULL, "
            + PokemonColumns.AVATAR + " INTEGER, "
            + PokemonColumns.HEIGHT + " REAL, "
            + PokemonColumns.WEIGHT + " REAL "
            + ", CONSTRAINT unique_uuid UNIQUE (uuid) ON CONFLICT REPLACE"
            + " );";

    public static final String SQL_CREATE_INDEX_POKEMON_AVATAR = "CREATE INDEX IDX_POKEMON_AVATAR "
            + " ON " + PokemonColumns.TABLE_NAME + " ( " + PokemonColumns.AVATAR + " );";

    // @formatter:on

    public static PokedexSQLiteOpenHelper getInstance(Context context) {
        // Use the application context, which will ensure that you
        // don't accidentally leak an Activity's context.
        // See this article for more information: http://bit.ly/6LRzfx
        if (sInstance == null) {
            sInstance = newInstance(context.getApplicationContext());
        }
        return sInstance;
    }

    private static PokedexSQLiteOpenHelper newInstance(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
            return newInstancePreHoneycomb(context);
        }
        return newInstancePostHoneycomb(context);
    }

    /*
     * Pre Honeycomb.
     */

    private static PokedexSQLiteOpenHelper newInstancePreHoneycomb(Context context) {
        return new PokedexSQLiteOpenHelper(context, DATABASE_FILE_NAME, null, DATABASE_VERSION);
    }

    private PokedexSQLiteOpenHelper(Context context, String name, CursorFactory factory, int version) {
        super(context, name, factory, version);
        mContext = context;
        mOpenHelperCallbacks = new PokedexSQLiteOpenHelperCallbacks();
    }

    /*
     * Post Honeycomb.
     */

    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    private static PokedexSQLiteOpenHelper newInstancePostHoneycomb(Context context) {
        return new PokedexSQLiteOpenHelper(context, DATABASE_FILE_NAME, null, DATABASE_VERSION, new DefaultDatabaseErrorHandler());
    }

    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    private PokedexSQLiteOpenHelper(Context context, String name, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
        super(context, name, factory, version, errorHandler);
        mContext = context;
        mOpenHelperCallbacks = new PokedexSQLiteOpenHelperCallbacks();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        if (BuildConfig.DEBUG) Log.d(TAG, "onCreate");
        mOpenHelperCallbacks.onPreCreate(mContext, db);
        db.execSQL(SQL_CREATE_TABLE_POKEMON);
        db.execSQL(SQL_CREATE_INDEX_POKEMON_AVATAR);
        mOpenHelperCallbacks.onPostCreate(mContext, db);
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        super.onOpen(db);
        if (!db.isReadOnly()) {
            setForeignKeyConstraintsEnabled(db);
        }
        mOpenHelperCallbacks.onOpen(mContext, db);
    }

    private void setForeignKeyConstraintsEnabled(SQLiteDatabase db) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
            setForeignKeyConstraintsEnabledPreJellyBean(db);
        } else {
            setForeignKeyConstraintsEnabledPostJellyBean(db);
        }
    }

    private void setForeignKeyConstraintsEnabledPreJellyBean(SQLiteDatabase db) {
        db.execSQL("PRAGMA foreign_keys=ON;");
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    private void setForeignKeyConstraintsEnabledPostJellyBean(SQLiteDatabase db) {
        db.setForeignKeyConstraintsEnabled(true);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        mOpenHelperCallbacks.onUpgrade(mContext, db, oldVersion, newVersion);
    }
}


text:
import express from 'express';
import { triviaService } from '../service';
import createCachedRouterCallback from '../helper/routerHelper';
import config from '../config';

const router = express.Router();

const triviaWidgetTTL = config.cache.triviaWidgetTTL;

router.get('/today', createCachedRouterCallback(triviaService.getTodaysTrivia.bind(triviaService), triviaWidgetTTL));

export default router;