text:
package endpoints

import (
	"fmt"
	"net"
	"time"

	"github.com/lxc/lxd/lxd/util"
	"github.com/lxc/lxd/shared/logger"
)

// ClusterAddress returns the cluster addresss of the cluster endpoint, or an
// empty string if there's no cluster endpoint.
func (e *Endpoints) ClusterAddress() string {
	e.mu.RLock()
	defer e.mu.RUnlock()

	listener := e.listeners[cluster]
	if listener == nil {
		return ""
	}
	return listener.Addr().String()
}

// ClusterUpdateAddress updates the address for the cluster endpoint, shutting
// it down and restarting it.
func (e *Endpoints) ClusterUpdateAddress(address string) error {
	networkAddress := e.NetworkAddress()

	if address != "" {
		address = util.CanonicalNetworkAddress(address)
	}

	oldAddress := e.ClusterAddress()
	if address == oldAddress {
		return nil
	}

	logger.Infof("Update cluster address")

	e.mu.Lock()
	defer e.mu.Unlock()

	// Close the previous socket
	e.closeListener(cluster)

	// If turning off listening, we're done
	if address == "" || util.IsAddressCovered(address, networkAddress) {
		return nil
	}

	// Attempt to setup the new listening socket
	getListener := func(address string) (*net.Listener, error) {
		var err error
		var listener net.Listener

		for i := 0; i < 10; i++ { // Ten retries over a second seems reasonable.
			listener, err = net.Listen("tcp", address)
			if err == nil {
				break
			}

			time.Sleep(100 * time.Millisecond)
		}

		if err != nil {
			return nil, fmt.Errorf("cannot listen on https socket: %v", err)
		}

		return &listener, nil
	}

	// If setting a new address, setup the listener
	if address != "" {
		listener, err := getListener(address)
		if err != nil {
			// Attempt to revert to the previous address
			listener, err1 := getListener(oldAddress)
			if err1 == nil {
				e.listeners[cluster] = networkTLSListener(*listener, e.cert)
				e.serveHTTP(cluster)
			}

			return err
		}

		e.listeners[cluster] = networkTLSListener(*listener, e.cert)
		e.serveHTTP(cluster)
	}

	return nil
}

redpajama_set_name: RedPajamaGithub


text:
package de.pifpafpuf.web.urlparam;

/**
 * is a do-nothing (identity) codec for strings to be used as-is in a URL.
 */
public enum StringCodec implements ParamCodec<String> {
  INSTANCE;

  @Override
  public String get(String value) {
    return value;
  }

  @Override
  public String asString(String e) {
    if (e==null) {
      throw new NullPointerException("parameter is null");
    }
    return e;
  }

}


text:
<?php

/* OCEPIBundle:Form:insertFicheDeVie.html.twig */
class __TwigTemplate_02e83d21eb74ede2dcacdeedebed003318dde3a1830f715f51da9e02db9c5fec extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        // line 1
        $this->parent = $this->loadTemplate("OCEPIBundle::base.html.twig", "OCEPIBundle:Form:insertFicheDeVie.html.twig", 1);
        $this->blocks = array(
            'body' => array($this, 'block_body'),
        );
    }

    protected function doGetParent(array $context)
    {
        return "OCEPIBundle::base.html.twig";
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $this->parent->display($context, array_merge($this->blocks, $blocks));
    }

    // line 3
    public function block_body($context, array $blocks = array())
    {
        // line 4
        echo "
Ajouter une fiche de vie :

        ";
        // line 6
        echo         $this->env->getExtension('form')->renderer->renderBlock((isset($context["form"]) ? $context["form"] : $this->getContext($context, "form")), 'form_start', array("attr" => array("novalidate" => "novalidate")));
        echo "
        ";
        // line 7
        echo         $this->env->getExtension('form')->renderer->renderBlock((isset($context["form"]) ? $context["form"] : $this->getContext($context, "form")), 'form_end');
        echo "

";
    }

    public function getTemplateName()
    {
        return "OCEPIBundle:Form:insertFicheDeVie.html.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  39 => 7,  35 => 6,  31 => 4,  28 => 3,  11 => 1,);
    }
}


text:
exports.Object2D = require('./lib/object2d');
exports.Point2D = require('./lib/point2d');

exports.getCollision = require('./lib/getcollision');


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Redhead & Traquair, Mycotaxon 13(2): 392 (1981)

#### Original name
Coprinus austrofriesii Redhead & Pegler

### Remarks
null


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>The GNU C Library: Wordexp Example</title>

<meta name="description" content="The GNU C Library: Wordexp Example">
<meta name="keywords" content="The GNU C Library: Wordexp Example">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Concept-Index.html#Concept-Index" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Word-Expansion.html#Word-Expansion" rel="up" title="Word Expansion">
<link href="Tilde-Expansion.html#Tilde-Expansion" rel="next" title="Tilde Expansion">
<link href="Flags-for-Wordexp.html#Flags-for-Wordexp" rel="prev" title="Flags for Wordexp">

Next: Tilde Expansion, Previous: Flags for Wordexp, Up: Word Expansion   [Contents][Index]

10.4.4 wordexp Example

Here is an example of using wordexp to expand several strings
and use the results to run a shell command.  It also shows the use of
WRDE_APPEND to concatenate the expansions and of wordfree
to free the space allocated by wordexp.

int
expand_and_execute (const char *program, const char **options)
{
  wordexp_t result;
  pid_t pid
  int status, i;

  /* Expand the string for the program to run.  */
  switch (wordexp (program, &result, 0))
    {
    case 0:			/* Successful.  */
      break;
    case WRDE_NOSPACE:
      /* If the error was WRDE_NOSPACE,
         then perhaps part of the result was allocated.  */
      wordfree (&result);
    default:                    /* Some other error.  */
      return -1;
    }

  /* Expand the strings specified for the arguments.  */
  for (i = 0; options[i] != NULL; i++)
    {
      if (wordexp (options[i], &result, WRDE_APPEND))
        {
          wordfree (&result);
          return -1;
        }
    }

  pid = fork ();
  if (pid == 0)
    {
      /* This is the child process.  Execute the command. */
      execv (result.we_wordv[0], result.we_wordv);
      exit (EXIT_FAILURE);
    }
  else if (pid < 0)
    /* The fork failed.  Report failure.  */
    status = -1;
  else
    /* This is the parent process.  Wait for the child to complete.  */
    if (waitpid (pid, &status, 0) != pid)
      status = -1;

  wordfree (&result);
  return status;
}


text:
//
//  Copyright 2014 Gustavo J Knuppe (https://github.com/knuppe)
//
//   Licensed 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.
//
//   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//   - May you do good and not evil.                                         -
//   - May you find forgiveness for yourself and forgive others.             -
//   - May you share freely, never taking more than you give.                -
//   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//

using System.IO;
using NUnit.Framework;
using SharpNL.DocumentCategorizer;
using SharpNL.Tokenize;
using SharpNL.Utility;

namespace SharpNL.Tests.DocumentCategorizer {
    [TestFixture]
    internal class DocumentCategorizerFactoryTest {
        private static IObjectStream<DocumentSample> CreateSampleStream() {
            return new DocumentSampleStream(new PlainTextByLineStream(Tests.OpenFile("opennlp/tools/doccat/DoccatSample.txt")));
        }

        private static DocumentCategorizerModel Train(DocumentCategorizerFactory factory = null) {
            return DocumentCategorizerME.Train(
                "x-unspecified",
                CreateSampleStream(),
                TrainingParameters.DefaultParameters(),
                factory ?? new DocumentCategorizerFactory());
        }

        [Test]
        public void TestCustom() {
            var featureGenerators = new IFeatureGenerator[] {
                new BagOfWordsFeatureGenerator(),
                new NGramFeatureGenerator(),
                new NGramFeatureGenerator(2, 3)
            };
            var factory = new DocumentCategorizerFactory(SimpleTokenizer.Instance, featureGenerators);
            var model = Train(factory);

            Assert.NotNull(model);

            using (var data = new MemoryStream()) {
                model.Serialize(new UnclosableStream(data));

                data.Seek(0, SeekOrigin.Begin);

                var deserialized = new DocumentCategorizerModel(data);

                Assert.That(deserialized, Is.Not.Null);
                Assert.That(deserialized.Factory, Is.Not.Null);

                Assert.That(deserialized.Factory.FeatureGenerators.Length, Is.EqualTo(3));
                Assert.That(deserialized.Factory.FeatureGenerators[0], Is.InstanceOf<BagOfWordsFeatureGenerator>());
                Assert.That(deserialized.Factory.FeatureGenerators[1], Is.InstanceOf<NGramFeatureGenerator>());
                Assert.That(deserialized.Factory.FeatureGenerators[2], Is.InstanceOf<NGramFeatureGenerator>());

                Assert.That(deserialized.Factory.Tokenizer, Is.InstanceOf<SimpleTokenizer>());
            }
        }

        [Test]
        public void TestDefault() {
            var model = Train();

            Assert.NotNull(model);

            using (var data = new MemoryStream()) {
                model.Serialize(new UnclosableStream(data));

                data.Seek(0, SeekOrigin.Begin);

                var deserialized = new DocumentCategorizerModel(data);

                Assert.That(deserialized, Is.Not.Null);
                Assert.That(deserialized.Factory, Is.Not.Null);

                Assert.That(deserialized.Factory.FeatureGenerators.Length, Is.EqualTo(1));
                Assert.That(deserialized.Factory.FeatureGenerators[0], Is.InstanceOf<BagOfWordsFeatureGenerator>());

                Assert.That(deserialized.Factory.Tokenizer, Is.InstanceOf<WhitespaceTokenizer>());
            }
        }
    }
}


text:
"""
Some utilities for aliases. Used to change dataframe column names to a standard
 set of names.
"""
from __future__ import division, absolute_import, print_function
from future.builtins import dict
__all__ = ['aliasDictionary', 'mapSeq2Standard']

def aliasDictionary(sequence, aliases):
    """
    Given a dictionary of
    aliases of the form {standard_string_names: list of possible aliases}
    this finds occurances of aliases (ignoring capitalization) in the sequence
    of strings called sequence and returns a dictionary
    Dict(alias: standard_string_name)

    Parameters
    ----------
    sequence : a sequence of strings
    aliases : Dictionary with list-valued values
        dictionary with keys = standard desired names, value = possible aliases
        It is assumed that a single alias only works for a single key

    Returns
    -------
    Dictionary with keys in the sequence of strings that have been identified
    as a possible alias of standard_string_names with
    value =standard_string_names

    Examples
    --------
    >>> aliases = dict(time=['mjd','expmjd'], flux=['counts'],\
                       fluxerr=['flux_err', 'fluxerror'], zpsys=['magsys'])
    >>> testSeq = ['mJd', 'band', 'zp', 'Flux', 'fluxError', 'zpsys']
    >>> aliasDictionary(testSeq, aliases) == {'Flux': 'flux', \
                                              'fluxError': 'fluxerr',\
                                              'mJd': 'time'}
    True

    Notes:
    -----
    1. It is obviously imperative that the list of possible aliases combined
    for all keys should not have duplicates
    2. The dictionary can be used to change non-standard column names in a
    `pd.DataFrame` through the use of `dataFrame.rename(columns=aliasDictionary,
    inplace=True)`
    """

    # Check that there is no string which might be the alias of more than one
    # variable
    _valueList = list(x for l in aliases.values() for x in l)
    assert len(set(_valueList)) == len(_valueList)

    # insert the standard name in the list of values
    # (necesary for the case where variable names are std names with caps)
    _ = [aliases.update({key: [key] + aliases[key]}) for key in aliases.keys()]

    # invert aliases dictionary to get
    inverse_dict = dict()
    _ = [inverse_dict.update({alias:aliastuple[0]})
         for aliastuple in aliases.items() for alias in aliastuple[1]]

    # Account for capitalization issues
    testDict = dict((s.lower(), s) for s in sequence)
    aliasedSet = set(inverse_dict.keys()) & set(testDict.keys())

    # return the dictionary
    aliasDict = dict((testDict[key], inverse_dict[key]) for key in aliasedSet
                     if testDict[key] != inverse_dict[key])

    return aliasDict

def mapSeq2Standard(sequence, aliasDict):
    """
    given a sequence of strings return a list of the strings, replacing those
    strings in the input sequence which are keys in the dictionary by their
    dictionary values

    Parameters
    ---------
    sequence : sequence of strings

    aliasDict : Dictionary
        Dictionary of aliases where the keys are strings in the sequence and
        the values are the standard names associated with those strings

    Returns
    -------
    list of strings

    Examples
    --------
    >>> aliases = dict(time=['mjd','expmjd'], flux=['counts'], fluxerr=['flux_err', 'fluxerror'])
    >>> testSeq = ['mJd', 'band', 'zp', 'Flux', 'fluxError']
    >>> aliasDict = aliasDictionary(testSeq, aliases)
    >>> mapSeq2Standard(testSeq, aliasDict) == ['time', 'band', 'zp', 'flux', 'fluxerr']
    True

    Notes
    -----

    """
    std = [aliasDict[x] if x in aliasDict else x for x in sequence]
    return std


text:
package gov.va.med.imaging.exchange.business.dicom.importer;

import gov.va.med.imaging.exchange.business.Patient;

import java.util.List;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class ImporterWorkItemDetails
{

    private int networkLocationIen;
    private int parentWorkItemIen;
    private String mediaBundleStagingRootDirectory;
    private String dicomCorrectReason;
    private String instrumentNickName;
    private String instrumentService;
    private String instrumentAcqLocation;
	private Patient vaPatientFromStaging;
    private boolean isMediaBundleStaged;
    private boolean mediaHasDicomDir;
    private String workstationName;
    private int mediaValidationStatusCode;
    private String mediaValidationMessage;
    private String importErrorMessage;

    private String reconcilingTechnicianDuz;
    private List<String> workItemProcessingErrors;

    private List<Study> studies;
    private List<Reconciliation> reconciliations;
    private List<String> dicomDirPaths;

    private MediaCategory mediaCategory;
    private List<NonDicomFile> nonDicomFiles;
    private String reconcilerNotes;

	public boolean hasImportErrors()
	{
		for (Study study : getStudies())
		{

			// If the study has a reconciliation, check the study to see if there were any errors.
			if (study.getReconciliation() != null)
			{
				// Check the study, stopping if it has an error
				if (study.getFailedImport())
					return true;

				// Check each of the SOP Instances, stopping as soon as we find one with an error
				for (Series series : study.getSeries())
				{
					for (SopInstance instance : series.getSopInstances())
					{
						if (!instance.isImportedSuccessfully())
							return true;
					}
				}

				// Check the non-DICOM files, if any, stopping as soon as we find one with an error
				List<NonDicomFile> nonDicomFiles = study.getReconciliation().getNonDicomFiles();
				if (nonDicomFiles != null)
				{
					for (NonDicomFile file : nonDicomFiles)
					{
						if (!file.isImportedSuccessfully())
						{
							return true;
						}
					}
				}
			}
		}

		return false;
	}

	public String getImportErrorSummary()
	{
		StringBuilder sb = new StringBuilder();

		sb.append("Importer item with IEN '" + this.getParentWorkItemIen() + "' failed processing.\n\n");
		sb.append("Please navigate to Failed Imports in the Administration area of the Importer GUI for more details.\n\n");

		// Get the summary information for each failed study
		for (Study study : this.getStudies())
		{
			boolean studyHasErrors = false;

			// If the study itself failed (i.e. bad order, etc), note it.
			if (study.getFailedImport())
			{
				studyHasErrors = true;
			}

			int failedImageCount = 0;
			for (Series series : study.getSeries())
			{
				for (SopInstance instance : series.getSopInstances())
				{
					if (!instance.isImportedSuccessfully())
					{
						failedImageCount++ ;
					}
				}
			}

			// Add on the count of failed non-DICOM files, if any
			List<NonDicomFile> nonDicomFiles = study.getReconciliation().getNonDicomFiles();
			if (nonDicomFiles != null)
			{
				for (NonDicomFile file : nonDicomFiles)
				{
					if (!file.isImportedSuccessfully())
					{
						failedImageCount++;
					}
				}
			}

			// Only instance failures...
			if (!studyHasErrors && failedImageCount > 0)
			{
				sb.append("  * Study " + study.getIdInMediaBundle() + ": " + getImageString(failedImageCount) + " failed to process.\n");
			}

			// Only a study level failure...
			if (studyHasErrors && failedImageCount == 0)
			{
				sb.append("  * Study " + study.getIdInMediaBundle() + ": A study-level failure occurred.\n");
			}

			// Both study and instance failures...
			if (studyHasErrors && failedImageCount > 0)
			{
				sb.append("  * Study " + study.getIdInMediaBundle() + ": A study-level failure occurred. Also, " + getImageString(failedImageCount) + " failed to process.\n");
			}

		}

		return sb.toString();

	}

	private String getImageString(int failedImageCount)
	{
		if (failedImageCount == 1)
		{
			return "1 image";
		}
		else
		{
			return failedImageCount + " images";
		}
	}

	public String getImportErrorDetails()
	{
		StringBuilder sb = new StringBuilder();

		sb.append("*********************************************************\n");
		sb.append("Importer item with IEN '" + this.getParentWorkItemIen() + "' failed processing...\n");
		sb.append("*********************************************************\n");
		sb.append("The media bundle can be found here: " + getNetworkLocationIen() + "\n");
		sb.append("  Network Location IEN: " + getNetworkLocationIen() + "\n");
		sb.append("  Root path: " + getMediaBundleStagingRootDirectory() + "\n");
		sb.append("*********************************************************\n");

		for (Study study : this.getStudies())
		{
			sb.append("Errors processing study:\n");
			sb.append("  UID: " + study.getUid() + "\n");

			// If the study itself failed (i.e. bad order, etc), write out the failure reason
			if (study.getFailedImport())
			{
				sb.append("  Study failure reason: " + study.getImportErrorMessage() + "\n");
			}

			for (Series series : study.getSeries())
			{
				for (SopInstance instance : series.getSopInstances())
				{
					if (!instance.isImportedSuccessfully())
					{
						sb.append("    Instance failure reason: " + instance.getImportErrorMessage() + "\n");
						sb.append("      Instance UID: " + instance.getUid() + "\n");
					}
				}
			}

			// Add on the non-DICOM file failure information
			List<NonDicomFile> nonDicomFiles = study.getReconciliation().getNonDicomFiles();
			if (nonDicomFiles != null)
			{
				for (NonDicomFile file : nonDicomFiles)
				{
					if (!file.isImportedSuccessfully())
					{
						sb.append("    Non-DICOM file failure reason: " + file.getImportErrorMessage() + "\n");
					}
				}
			}

		}
		sb.append("*********************************************************\n");

		return sb.toString();

	}

	public String getImportErrorMessage() {
		return importErrorMessage;
	}

	public void getImportErrorMessage(String importErrorMessage) {
		this.importErrorMessage = importErrorMessage;
	}

    public List<Study> getStudies() {
        return studies;
    }

    public void setStudies(List<Study> value) {
        this.studies = value;
    }

    public List<Reconciliation> getReconciliations() {
        return reconciliations;
    }

    public void setReconciliations(List<Reconciliation> value) {
        this.reconciliations = value;
    }

	public void setMediaBundleStagingRootDirectory(
			String mediaBundleStagingRootDirectory) {
		this.mediaBundleStagingRootDirectory = mediaBundleStagingRootDirectory;
	}

	public String getMediaBundleStagingRootDirectory() {
		return mediaBundleStagingRootDirectory;
	}

	public void setNetworkLocationIen(int networkLocationIen) {
		this.networkLocationIen = networkLocationIen;
	}

	public int getNetworkLocationIen() {
		return networkLocationIen;
	}

	public String getDicomCorrectReason() {
		return dicomCorrectReason;
	}

	public void setDicomCorrectReason(String dicomCorrectReason) {
		this.dicomCorrectReason = dicomCorrectReason;
	}

	public void setInstrumentNickName(String instrumentNickName) {
		this.instrumentNickName = instrumentNickName;
	}

	public String getInstrumentNickName() {
		return instrumentNickName;
	}

	public void setVaPatientFromStaging(Patient vaPatientFromStaging) {
		this.vaPatientFromStaging = vaPatientFromStaging;
	}

	public Patient getVaPatientFromStaging() {
		return vaPatientFromStaging;
	}

	public void setMediaBundleStaged(boolean isMediaBundleStaged) {
		this.isMediaBundleStaged = isMediaBundleStaged;
	}

	public boolean isMediaBundleStaged() {
		return isMediaBundleStaged;
	}

	public void setDicomDirPaths(List<String> dicomDirPaths) {
		this.dicomDirPaths = dicomDirPaths;
	}

	public List<String> getDicomDirPaths() {
		return dicomDirPaths;
	}

	public void setMediaHasDicomDir(boolean mediaHasDicomDir) {
		this.mediaHasDicomDir = mediaHasDicomDir;
	}

	public boolean isMediaHasDicomDir() {
		return mediaHasDicomDir;
	}

	public void setReconcilingTechnicianDuz(String reconcilingTechnicianDuz) {
		this.reconcilingTechnicianDuz = reconcilingTechnicianDuz;
	}

	public String getReconcilingTechnicianDuz() {
		return reconcilingTechnicianDuz;
	}

	public void setWorkItemProcessingErrors(List<String> workItemProcessingErrors) {
		this.workItemProcessingErrors = workItemProcessingErrors;
	}

	public List<String> getWorkItemProcessingErrors() {
		return workItemProcessingErrors;
	}

	public void setParentWorkItemIen(int parentWorkItemIen) {
		this.parentWorkItemIen = parentWorkItemIen;
	}

	public int getParentWorkItemIen() {
		return parentWorkItemIen;
	}

	public void setWorkstationName(String workstationName) {
		this.workstationName = workstationName;
	}

	public String getWorkstationName() {
		return workstationName;
	}

	public void setMediaValidationStatusCode(int mediaValidationStatusCode) {
		this.mediaValidationStatusCode = mediaValidationStatusCode;
	}

	public int getMediaValidationStatusCode() {
		return mediaValidationStatusCode;
	}

	public void setMediaValidationMessage(String mediaValidationMessage) {
		this.mediaValidationMessage = mediaValidationMessage;
	}

	public String getMediaValidationMessage() {
		return mediaValidationMessage;
	}

	public void setInstrumentService(String instrumentService) {
		this.instrumentService = instrumentService;
	}

	public String getInstrumentService() {
		return instrumentService;
	}

	public String getInstrumentAcqLocation() {
		return instrumentAcqLocation;
	}

	public void setInstrumentAcqLocation(String instrumentAcqLocation) {
		this.instrumentAcqLocation = instrumentAcqLocation;
	}

	/**
	 * @return the reconcilerNotes
	 */
	public String getReconcilerNotes() {
		return reconcilerNotes;
	}

	/**
	 * @param reconcilerNotes the reconcilerNotes to set
	 */
	public void setReconcilerNotes(String reconcilerNotes) {
		this.reconcilerNotes = reconcilerNotes;
	}

	/**
	 * @return the mediaCategory
	 */
	public MediaCategory getMediaCategory() {
		return mediaCategory;
	}

	/**
	 * @param mediaCategory the mediaCategory to set
	 */
	public void setMediaCategory(MediaCategory mediaCategory) {
		this.mediaCategory = mediaCategory;
	}

	/**
	 * @return the nonDicomFiles
	 */
	public List<NonDicomFile> getNonDicomFiles() {
		return nonDicomFiles;
	}

	/**
	 * @param nonDicomFiles the nonDicomFiles to set
	 */
	public void setNonDicomFiles(List<NonDicomFile> nonDicomFiles) {
		this.nonDicomFiles = nonDicomFiles;
	}
}


text:
/**
 * @module Joy
 */
var DisplayObjectContainer = require('./display_object_container');

var Parallax = DisplayObjectContainer.extend({
  /**
   * @class Parallax
   * @constructor
   * @param {Object} options
   */
  init: function(options) {
    this._super(options);

    /**
     * Viewport that parallax effect will be based on.
     * @attribute viewport
     * @type {Viewport}
     */
    this.viewport = options.viewport || null;

    /**
     * Distance between each parallax child.
     * @attribute distance
     * @type {Number}
     */
    this.distance = options.distance || 1;

    /**
     * Amount of velocity that will increase by child.
     * @attribute velocity
     * @type {Number}
     */
    this.velocity = options.velocity || 1;

    // Bind on added to Container
    this.bind(Joy.Events.ADDED, this._setup);
  },

  _setup: function (scene) {
    if (!(scene instanceof Joy.Scene)) {
      throw new Error("'Parallax' instance must be added into a 'Scene'.");
    }
    this.viewport = scene.viewport;

    var parallax = this;

    // Add repeatable parts
    this.viewport.bind('setup', function() {
      var i, length, layer, child;

      for (i=0, length=parallax.numChildren; i < length; ++i) {

        if (parallax.getChildAt(i).position) {
          layer = parallax.getChildAt(i);

          // Empty previous setup
          while (layer.numChildren > 0) {
            layer.removeChildAt(0);
          }

          for (var j=0, childsToFill = Math.ceil(layer.width / this.width) - 1; j<childsToFill; ++j) {
            child = layer.clone();
            child.children = [];
            child.position.x = layer.width;
            layer.addChild(child);
          }
        }

      }
    });

    this.viewport.bind('translate', function() {
      var velocity = parallax.distance;

      for (var i=0, length=parallax.numChildren; i < length; ++i) {
        velocity *= parallax.velocity * (i + 1);
        if (parallax.getChildAt(i).position) {
          parallax.getChildAt(i).position.x += (this.translation.x * velocity) / this.width;
          parallax.getChildAt(i).position.y += (this.translation.y * velocity) / (this.height / 2);
        }
      }
    });
  }

});

module.exports = Parallax;


text:
\begin {figure}[hbtp]
\centering
\includegraphics[width=\textwidth]{output/R4_1000_ONLY_1_LINEAR_NCORE/plot_R4_1000.eps}
\caption{Completion time vs ncores for query R4 with datasize 1000GB}
\label{fig:only_1_linear_R4_1000}
\end {figure}


text:
- Add lints to project and fix issues found from `dart analyze`
- Upping version to `1.0.0` due to change to APIs with fixing of linting issues

## 0.4.1

- Fix spelling errors

## 0.4.0

- Rework internal logic and clean up APIs
- Documentation cleanup and adding examples

## 0.3.0

- Upgrading code to be usable in Dart 2.14.0 or greater


text:
package io.divide.client;

import com.google.inject.Inject;
import io.divide.client.auth.AuthManager;
import io.divide.client.auth.SignInResponse;
import io.divide.client.auth.SignUpResponse;
import io.divide.client.auth.credentials.LocalCredentials;
import io.divide.client.auth.credentials.LoginCredentials;
import io.divide.client.auth.credentials.SignUpCredentials;
import io.divide.client.auth.credentials.ValidCredentials;
import io.divide.shared.logging.Logger;
import io.divide.shared.transitory.Credentials;
import rx.Observable;
import sun.reflect.generics.reflectiveObjects.NotImplementedException;

public final class BackendUser extends Credentials {

    private static Logger logger = Logger.getLogger(BackendUser.class);
    @Inject private static AuthManager authManager;

    private static final String ANONYMOUS_KEY = "anonymous_key";

    public BackendUser(){ }

    public BackendUser(String username, String email, String password){
        this();
        this.setUsername(username);
        this.setEmailAddress(email);
        this.setPassword(password);
    }

    /**
     * Convience method to access the authManager
     * @return authManager
     */

    private static AuthManager getAM(){
        if(authManager==null) throw new RuntimeException("Backend not initialized!");
        return authManager;
    }

    /**
     * Convience method to initialize BackendUser from ValidCredentials
     * @param credentials
     * @return
     */

    public static BackendUser from(ValidCredentials credentials){
        BackendUser beu = new BackendUser();
        beu.initFrom(credentials);
        return beu;
    }

    /**
     * @return Currently logged in user.
     */
    public static BackendUser getUser(){
        return getAM().getUser();
    }

    /**
     * @return True if user is logged in, false if not
     */
    public static boolean isLoggedIn(){
        return getAM().getUser() != null;
    }

//    public static ServerResponse<BackendUser> getAnonymousUser(){
//        String id = UserUtils.getDeviceIdUnique(Backend.get().app);
//        ServerResponse<BackendUser> response;
//
//        response = signIn(id, id);
//        if(!response.getStatus().isSuccess()){
//            response = signUp(id, id, id);
//            if(response.getStatus().isSuccess()){
//                BackendUser user = response.get();
//                user.put(ANONYMOUS_KEY,true);
//                user.saveASync();
//            }
//        }
//
//        return response;
//    }

    /**
     * Used to access the stored credentials.
     * @return Locally stored credentials for the logged in user.
     */
    public static LocalCredentials getStoredAccount(){
        return authManager.getStoredAccount();
    }

//    protected final Credentials getLoggedInUser(){
//        return getUser();
//    }

    @Override
    protected final boolean isSystemUser(){
        return false;
    }

    private void initFrom(Credentials credentials){
        logger.debug("initFrom: " + credentials);
        try {
            this.meta_data = credentials.getMetaData();
            this.user_data = credentials.getUserData();
        } catch (Exception e) {
            logger.error("Failed to init BackendUser from Credentials",e);
        }
    }

    /**
     * Login using an authtoken
     * @param token
     * @return BackendUser for the sent token.
     */
    public static BackendUser fromToken(String token){
        return getAM().getUserFromAuthToken(token).toBlockingObservable().first();
    }

    /**
     * Perform syncronously login attempt.
     * @param loginCredentials credentials used for login attempt.
     * @return login results.
     */
    public static SignInResponse signIn(LoginCredentials loginCredentials){
        return getAM().login(loginCredentials);
    }

    /**
     * Perform syncronously login attempt.
     * @param email user email address
     * @param password user password
     * @return login results.
     */
    public static SignInResponse signIn(String email, String password){
        return signIn(new LoginCredentials(email,password));
    }

    /**
     * Perform syncronously sign up attempt.
     * @param signUpCredentials credentials used for sign up attempt.
     * @return signup results.
     */
    public static SignUpResponse signUp(SignUpCredentials signUpCredentials){
        return getAM().signUp(signUpCredentials);
    }

    /**
     * Perform syncronously sign up attempt.
     * @param username user name user will be identified by.
     * @param email user email address
     * @param password user password
     * @return login results.
     */
    public static SignUpResponse signUp(String username, String email, String password){
        return signUp(new SignUpCredentials(username,email,password));
    }

    /**
     * Perform asyncronously login attempt.
     * @param email user email address
     * @param password user password
     * @return login results as observable.
     */
    public static Observable<BackendUser> signInInBackground(String email, String password){
        return getAM().loginASync(new LoginCredentials(email, password));
    }

    /**
     * Perform asyncronously sign up attempt.
     * @param username user name user will be identified by.
     * @param email user email address
     * @param password user password
     * @return login results as observable.
     */
    public static Observable<BackendUser> signUpInBackground(String username, String email, String password){
        return getAM().signUpASync(new SignUpCredentials(username, email, password));
    }

    public static void logout(){
        getAM().logout();
    }

    public void	requestPasswordReset(String email){
        throw new NotImplementedException();
    }
    public Observable<Boolean> requestPasswordResetInBackground(String email){
        throw new NotImplementedException();
    }

    /**
     * Synchronously sign up using credentials provided via constructor or setters.
     * @return boolean indicating sign up success
     */
    public boolean signUp(){
        SignUpCredentials creds = new SignUpCredentials(getUsername(),getEmailAddress(),getPassword());
        SignUpResponse response = getAM().signUp(creds);
        if(response.getStatus().isSuccess()){
            this.initFrom(response.get());
            return true;
        } else return false;
    }

    private void save(BackendUser user){
        getAM().sendUserData(user).subscribe();
    }

    private Observable<Void> saveASync(BackendUser user){
        return getAM().sendUserData(user);
    }

    /**
     *  Asynchronously saves this user object. Saving any data added via the put() method.
     *  put("1");
     *  put(1);
     *  etc.
     */
    public void save(){
        save(this);
    }

    /**
     *  Asynchronously saves this user object return an Observable to monitor. Saving any data added via the put() method.
     *  put("1");
     *  put(1);
     *  etc.
     *  @return Obserable to monitor operation.
     */
    public Observable<Void> saveASync(){
        return saveASync(this);
    }

    @Override
    public String toString() {
        return "BackendUser{" +
                "emailAddress='" + getEmailAddress() + '\'' +
                ", password='" + getPassword() + '\'' +
                ", userKey='" + getOwnerId() + '\'' +
                ", authToken='" + getAuthToken() + '\'' +
                ", createDate=" + getCreateDate() +
//                ", authTokenExpireDate=" + getAuthTokenExpireDate() +
                ", validation='" + getValidation() + '\'' +
                '}';
    }

}


text:
				Nowy magazyn

		<form role="form" action="/warehouse/warehouse_add/<?php echo $customer->id ?>" method="POST" id="add_warehouse_form">

				<button class="close" data-close="alert"></button>
				Popraw błędy w formularzu

						Nazwa
							 *

							<input type="text" placeholder="Nazwa" class="form-control" name="name" value="" />

						Opis
							 *

						<textarea class="form-control" name="description" placeholder="Opis magzynu"></textarea>

						Klient
							 *

							<select class="form-control" name="customer_id">
								<option>-- Wybierz --</option>
								<?php foreach ($customers as $customer):?>
								<?php
										echo "<option value=\"".$customer->id."\"".$checked." >".$customer->name."</option>";
								?>
								<?php endforeach;?>
							</select>

						Zapisz zmiany

						Anuluj

		</form>


text:
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using Microsoft.AspNetCore.Http;
using NakedFramework.Facade.Contexts;
using NakedFramework.Facade.Interface;
using NakedFramework.Rest.Snapshot.Constants;
using NakedFramework.Rest.Snapshot.RelTypes;
using NakedFramework.Rest.Snapshot.Utility;

namespace NakedFramework.Rest.Snapshot.Representation;

[DataContract]
public class StaticServiceRepresentation : Representation {
    protected StaticServiceRepresentation(IFrameworkFacade frameworkFacade, HttpRequest req, IMenuFacade menu, RestControlFlags flags)
        : base(frameworkFacade.OidStrategy, flags) {
        var helper = new UriMtHelper(frameworkFacade.OidStrategy, req, menu);
        SetScalars(menu);
        SelfRelType = new ServiceRelType(RelValues.Self, helper);
        SetLinksAndMembers(req, frameworkFacade, menu);
        SetExtensions(menu);
        SetHeader(menu);
    }

    [DataMember(Name = JsonPropertyNames.Title)]
    public string Title { get; set; }

    [DataMember(Name = JsonPropertyNames.ServiceId)]
    public string ServiceId { get; set; }

    [DataMember(Name = JsonPropertyNames.Links)]
    public LinkRepresentation[] Links { get; set; }

    [DataMember(Name = JsonPropertyNames.Extensions)]
    public MapRepresentation Extensions { get; set; }

    [DataMember(Name = JsonPropertyNames.Members)]
    public MapRepresentation Members { get; set; }

    private void SetScalars(IMenuFacade menu) {
        Title = menu.Name;
        ServiceId = menu.Id;
    }

    private void SetHeader(IMenuFacade menu) => Caching = CacheType.NonExpiring;

    private void SetLinksAndMembers(HttpRequest req, IFrameworkFacade frameworkFacade, IMenuFacade menu) {
        var tempLinks = new List<LinkRepresentation> { LinkRepresentation.Create(OidStrategy, SelfRelType, Flags) };

        SetMembers(frameworkFacade, menu, req);
        Links = tempLinks.ToArray();
    }

    private static (string name, ActionContextFacade action)[] GetMenuItem(IFrameworkFacade frameworkFacade, IMenuItemFacade item, string parent = "") => frameworkFacade.GetMenuItem(item, parent);

    private static bool IsVisibleAndUsable(ActionContextFacade actionContextFacade) =>
        actionContextFacade.Action.IsVisible(actionContextFacade.Target) &&
        actionContextFacade.Action.IsUsable(actionContextFacade.Target).IsAllowed;

    private void SetMembers(IFrameworkFacade frameworkFacade, IMenuFacade menu, HttpRequest req) {
        ActionContextFacade SetMenuId(ActionContextFacade action) {
            action.MenuId = menu.Id;
            action.IsStaticService = true;

            foreach (var p in action.VisibleParameters) {
                p.MenuId = menu.Id;
            }

            return action;
        }

        var actionFacades = menu.MenuItems.SelectMany(i => GetMenuItem(frameworkFacade, i, i.Grouping)).Where(af => IsVisibleAndUsable(af.action)).ToArray();

        var actions = actionFacades.Select(a => InlineActionRepresentation.Create(OidStrategy, req, SetMenuId(a.action), Flags)).ToArray();

        var actionComparer = new ActionComparer();
        actions = actions.Distinct(actionComparer).ToArray();

        Members = RestUtils.CreateMap(actions.ToDictionary(m => m.Id, m => (object)m));
    }

    private void SetExtensions(IMenuFacade menu) => Extensions = MapRepresentation.Create();

    public static StaticServiceRepresentation Create(IFrameworkFacade frameworkFacade, IMenuFacade menu, HttpRequest req, RestControlFlags flags) => new(frameworkFacade, req, menu, flags);

    #region Nested type: ActionComparer

    private class ActionComparer : IEqualityComparer<InlineActionRepresentation> {
        #region IEqualityComparer<InlineActionRepresentation> Members

        public bool Equals(InlineActionRepresentation x, InlineActionRepresentation y) => x.Id == y.Id;

        public int GetHashCode(InlineActionRepresentation obj) => obj.Id.GetHashCode();

        #endregion
    }

    #endregion
}


text:
module RSpec
  module Core
    # @private
    class FilterManager
      attr_reader :exclusions, :inclusions

      def initialize
        @exclusions, @inclusions = FilterRules.build
      end

      # @api private
      #
      # @param file_path [String]
      # @param line_numbers [Array]
      def add_location(file_path, line_numbers)
        # locations is a hash of expanded paths to arrays of line
        # numbers to match against. e.g.
        #   { "path/to/file.rb" => [37, 42] }
        locations = inclusions.delete(:locations) || Hash.new { |h, k| h[k] = [] }
        locations[File.expand_path(file_path)].push(*line_numbers)
        inclusions.add(:locations => locations)
      end

      def empty?
        inclusions.empty? && exclusions.empty?
      end

      def prune(examples)
        examples = prune_conditionally_filtered_examples(examples)

        if inclusions.standalone?
          examples.select { |e| include?(e) }
        else
          locations = inclusions.fetch(:locations) { Hash.new([]) }
          examples.select { |e| priority_include?(e, locations) || (!exclude?(e) && include?(e)) }
        end
      end

      def exclude(*args)
        exclusions.add(args.last)
      end

      def exclude_only(*args)
        exclusions.use_only(args.last)
      end

      def exclude_with_low_priority(*args)
        exclusions.add_with_low_priority(args.last)
      end

      def include(*args)
        inclusions.add(args.last)
      end

      def include_only(*args)
        inclusions.use_only(args.last)
      end

      def include_with_low_priority(*args)
        inclusions.add_with_low_priority(args.last)
      end

    private

      def exclude?(example)
        exclusions.include_example?(example)
      end

      def include?(example)
        inclusions.include_example?(example)
      end

      def prune_conditionally_filtered_examples(examples)
        examples.reject do |ex|
          meta = ex.metadata
          !meta.fetch(:if, true) || meta[:unless]
        end
      end

      # When a user specifies a particular spec location, that takes priority
      # over any exclusion filters (such as if the spec is tagged with `:slow`
      # and there is a `:slow => true` exclusion filter), but only for specs
      # defined in the same file as the location filters. Excluded specs in
      # other files should still be excluded.
      def priority_include?(example, locations)
        return false if locations[example.metadata[:absolute_file_path]].empty?
        MetadataFilter.filter_applies?(:locations, locations, example.metadata)
      end
    end

    # @private
    class FilterRules
      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
      PROJECT_DIR = File.expand_path('.')

      attr_accessor :opposite
      attr_reader :rules

      def self.build
        exclusions = ExclusionRules.new
        inclusions = InclusionRules.new
        exclusions.opposite = inclusions
        inclusions.opposite = exclusions
        [exclusions, inclusions]
      end

      def initialize(*args, &block)
        @rules = Hash.new(*args, &block)
      end

      def add(updated)
        @rules.merge!(updated).each_key { |k| opposite.delete(k) }
      end

      def add_with_low_priority(updated)
        updated = updated.merge(@rules)
        opposite.each_pair { |k, v| updated.delete(k) if updated[k] == v }
        @rules.replace(updated)
      end

      def use_only(updated)
        updated.each_key { |k| opposite.delete(k) }
        @rules.replace(updated)
      end

      def clear
        @rules.clear
      end

      def delete(key)
        @rules.delete(key)
      end

      def fetch(*args, &block)
        @rules.fetch(*args, &block)
      end

      def [](key)
        @rules[key]
      end

      def empty?
        rules.empty?
      end

      def each_pair(&block)
        @rules.each_pair(&block)
      end

      def description
        rules.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)', '')
      end

      def include_example?(example)
        MetadataFilter.apply?(:any?, @rules, example.metadata)
      end
    end

    # @private
    ExclusionRules = FilterRules

    # @private
    class InclusionRules < FilterRules
      def add(*args)
        apply_standalone_filter(*args) || super
      end

      def add_with_low_priority(*args)
        apply_standalone_filter(*args) || super
      end

      def use(*args)
        apply_standalone_filter(*args) || super
      end

      def include_example?(example)
        @rules.empty? || super
      end

      def standalone?
        is_standalone_filter?(@rules)
      end

    private

      def apply_standalone_filter(updated)
        return true if standalone?
        return nil unless is_standalone_filter?(updated)

        replace_filters(updated)
        true
      end

      def replace_filters(new_rules)
        @rules.replace(new_rules)
        opposite.clear
      end

      def is_standalone_filter?(rules)
        rules.key?(:full_description)
      end
    end
  end
end


text:
import { expect, renderComponent, sinon } from '../test-helper'
import LivePlayground from '../../src/components/LivePlayground'

describe('LivePlayground', () => {
  let component

  beforeEach(() => {
    const props = {
      code: {},
      updateCode: sinon.stub(),
    }
    component = renderComponent(LivePlayground, props)
  })

  it('should have a correct class', () => {
    expect(component).to.have.class('live-playground')
  })

  it('should have a LiveEditor', () => {
    expect(component.find('.live-editor')).to.have.length(1)
  })

  it('should have a LivePreview', () => {
    expect(component.find('.live-preview')).to.have.length(1)
  })
})


text:
module ExperiencesHelper
end


text:
@echo off
setlocal enableextensions

mkdir ReformatUtils 2> NUL
copy /y ..\src\ReformatUtils\bin\Release\* ReformatUtils


text:
def factorial_recursive(num):
    """returns the factorial of num using a recursive method."""
    return 1 if num == 0 else num * factorial_recursive(num -  1)


text:
(function($){

    esock = io.connect( document.location.origin );

    $.fn.callService = function (serviceName, serviceData, successCallback, options) {
        var callService = function (serviceName, serviceData, successCallback) {
            var type = 'GET';
            var data = {};
            var serviceUrl = (options && options.url) ? options.url : 'service';
            if (serviceData && typeof serviceData === 'object') {
                type = 'POST';
                data = serviceData;
            } else {
                successCallback = serviceData;
            }
            $.ajax({
                type: type,
                url: serviceUrl + '/' + serviceName,
                data: JSON.stringify(data),
                context: document.body
            }).done(function(response) {
                    if (successCallback) {
                        successCallback(response);
                    }
                });
        };
        callService(serviceName, serviceData, successCallback);
        return this;
    };

    $.fn.initSocket = function (callback) {
        esock.on('connect', function () {
            callback();
        });
    };

    $.fn.callSocket = function (serviceName, serviceData, successCallback) {
        esock.emit(serviceName, serviceData);
        esock.on(serviceName, function (data) {
            successCallback(data);
        });
    };

})(jQuery);


text:
package net.firejack.platform.service.deployment.broker;

import net.firejack.platform.api.deployment.domain.NavigationChanges;
import net.firejack.platform.core.broker.ServiceBroker;
import net.firejack.platform.core.domain.SimpleIdentifier;
import net.firejack.platform.core.model.registry.RegistryNodeModel;
import net.firejack.platform.core.model.registry.domain.PackageChangesModel;
import net.firejack.platform.core.request.ServiceRequest;
import net.firejack.platform.core.response.ServiceResponse;
import net.firejack.platform.core.store.registry.IPackageChangesStore;
import net.firejack.platform.web.statistics.annotation.TrackDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@TrackDetails
@Component
public class LastNavigationChangesBroker extends ServiceBroker<ServiceRequest<SimpleIdentifier<Long>>, ServiceResponse<NavigationChanges>> {

    @Autowired
    private IPackageChangesStore changesStore;

    @Override
    protected ServiceResponse<NavigationChanges> perform(ServiceRequest<SimpleIdentifier<Long>> request) throws Exception {
        Long timestamp = request.getData().getIdentifier();

        List<PackageChangesModel> changes = changesStore.findAllLastChanges(timestamp);

        List<String> lookupList = new ArrayList<String>();
        for (PackageChangesModel packageChangesModel : changes) {
            RegistryNodeModel registryNodeModel = packageChangesModel.getEntity();
            if (registryNodeModel != null) {
                lookupList.add(registryNodeModel.getLookup());
            } /*else {
                lookupList.add(packageChangesModel.getPackageModel().getLookup());
            }*/
        }

        NavigationChanges navigationChanges = new NavigationChanges();
        navigationChanges.setLookup(lookupList);
        navigationChanges.setTimestamp(new Date().getTime());

        return new ServiceResponse<NavigationChanges>(navigationChanges, "Read package changes successfully", true);
    }
}


text:
namespace Nektar
{
    namespace SolverUtils
    {

	class DriverModifiedArnoldi: public DriverArnoldi
	{
	public:
	    friend class MemoryManager<DriverModifiedArnoldi>;

	    /// Creates an instance of this class
	    static DriverSharedPtr create(
		const LibUtilities::SessionReaderSharedPtr& pSession)
	    {
		DriverSharedPtr p = MemoryManager<DriverModifiedArnoldi>
		::AllocateSharedPtr(pSession);
		p->InitObject();
		return p;
	    }

	    ///Name of the class
	    static std::string className;

	protected:

	    /// Constructor
	    DriverModifiedArnoldi(const LibUtilities::SessionReaderSharedPtr pSession);

	    /// Destructor
	    virtual ~DriverModifiedArnoldi();

	    /// Virtual function for initialisation implementation.
	    virtual void v_InitObject(ostream &out = cout );

	    /// Virtual function for solve implementation.
	    virtual void v_Execute(ostream &out = cout);

	private:
	    /// Generates a new vector in the sequence by applying the linear operator.
	    void EV_update(Array<OneD, NekDouble> &src,
			   Array<OneD, NekDouble> &tgt);

	    /// Generates the upper Hessenberg matrix H and computes its eigenvalues.
	    void EV_small(Array<OneD, Array<OneD, NekDouble> > &Kseq,
			  const int ntot,
		   const Array<OneD, NekDouble> &alpha,
		   const int kdim,
		   Array<OneD, NekDouble> &zvec,
		   Array<OneD, NekDouble> &wr,
		   Array<OneD, NekDouble> &wi,
		   NekDouble &resnorm);

	    /// Tests for convergence of eigenvalues of H.
	    int EV_test(const int itrn,
			const int kdim,
		 Array<OneD, NekDouble> &zvec,
		 Array<OneD, NekDouble> &wr,
		 Array<OneD, NekDouble> &wi,
		 const NekDouble resnorm,
		 const int nvec,
		 ofstream &evlout,
		 NekDouble &resid0);

	    /// Sorts a sequence of eigenvectors/eigenvalues by magnitude.
	    void EV_sort(Array<OneD, NekDouble> &evec,
			 Array<OneD, NekDouble> &wr,
		  Array<OneD, NekDouble> &wi,
		  Array<OneD, NekDouble> &test,
		  const int dim);

	    void EV_post(Array<OneD, Array<OneD, NekDouble> > &Tseq,
			 Array<OneD, Array<OneD, NekDouble> > &Kseq,
		  const int ntot,
		  const int kdim,
		  const int nvec,
		  Array<OneD, NekDouble> &zvec,
		  Array<OneD, NekDouble> &wr,
		  Array<OneD, NekDouble> &wi,
		  const int icon);

	    void EV_big(Array<OneD, Array<OneD, NekDouble> > &bvecs,
			Array<OneD, Array<OneD, NekDouble> > &evecs,
		 const int ntot,
		 const int kdim,
		 const int nvec,
		 Array<OneD, NekDouble> &zvec,
		 Array<OneD, NekDouble> &wr,
		 Array<OneD, NekDouble> &wi);

	    static std::string driverLookupId;
	};

    }
}

#endif //NEKTAR_SOLVERS_AUXILIARY_ADRBASE_H


text:
var flow = require('nimble');

flow.series([
    function (callback) {
        setTimeout(function() {
            console.log('I execute first.');
            callback();
        }, 1000);
    },
    function (callback) {
        setTimeout(function() {
            console.log('I execute next.');
            callback();
        }, 500);
    },
    function (callback) {
        setTimeout(function() {
            console.log('I execute last.');
            callback();
        }, 100);
    }
]);


text:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>restfuljersey</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
  	<servlet-name>Jersey REST Service</servlet-name>
  	<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
  	<init-param>
  		<param-name>com.sun.jersey.config.property.packages</param-name>
  		<param-value>br.com.restfuljersey.controller</param-value>
  	</init-param>
  	<load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  	<servlet-name>Jersey REST Service</servlet-name>
  	<url-pattern>/*</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>CorsFilter</filter-name>
    <filter-class>com.thetransactioncompany.cors.CORSFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>CorsFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>


text:
MongoDB\BSON\Int64 unserialization requires "int" string field to be valid
--FILE--
<?php

require_once __DIR__ . '/../utils/tools.php';

echo throws(function() {
    unserialize('C:18:"MongoDB\BSON\Int64":36:{a:1:{s:7:"integer";s:9:"1234.5678";}}');
}, 'MongoDB\Driver\Exception\InvalidArgumentException'), "\n";

?>
===DONE===
<?php exit(0); ?>
--EXPECT--
OK: Got MongoDB\Driver\Exception\InvalidArgumentException
Error parsing "1234.5678" as 64-bit integer for MongoDB\BSON\Int64 initialization
===DONE===


text:
const errors = require('../../errors').default;

const BucketInfo = require('../../models/BucketInfo').default;

const BucketClientInterface = require('./bucketclient/BucketClientInterface');
const BucketFileInterface = require('./file/BucketFileInterface');
const MongoClientInterface = require('./mongoclient/MongoClientInterface');
const metastore = require('./in_memory/metastore');

let CdmiMetadata;
try {
    CdmiMetadata = require('cdmiclient').CdmiMetadata;
} catch (err) {
    CdmiMetadata = null;
}

let bucketNotificationHook;

/** _parseListEntries - parse the values returned in a listing by metadata
 * @param {object[]} entries - Version or Content entries in a metadata listing
 * @param {string} entries[].key - metadata key
 * @param {string} entries[].value - stringified object metadata
 * @return {object} - mapped array with parsed value or JSON parsing err
 */
function _parseListEntries(entries) {
    return entries.map(entry => {
        const tmp = JSON.parse(entry.value);
        return {
            key: entry.key,
            value: {
                Size: tmp['content-length'],
                ETag: tmp['content-md5'],
                VersionId: tmp.versionId,
                IsNull: tmp.isNull,
                IsDeleteMarker: tmp.isDeleteMarker,
                LastModified: tmp['last-modified'],
                Owner: {
                    DisplayName: tmp['owner-display-name'],
                    ID: tmp['owner-id'],
                },
                StorageClass: tmp['x-amz-storage-class'],
                // MPU listing properties
                Initiated: tmp.initiated,
                Initiator: tmp.initiator,
                EventualStorageBucket: tmp.eventualStorageBucket,
                partLocations: tmp.partLocations,
                creationDate: tmp.creationDate,
                ingestion: tmp.ingestion,
            },
        };
    });
}

/** parseListEntries - parse the values returned in a listing by metadata
 * @param {object[]} entries - Version or Content entries in a metadata listing
 * @param {string} entries[].key - metadata key
 * @param {string} entries[].value - stringified object metadata
 * @param {function} parser - Parser for object data
 * @return {(object|Error)} - mapped array with parsed value or JSON parsing err
 */
function parseListEntries(entries, parser) {
    // wrap private function in a try/catch clause
    // just in case JSON parsing throws an exception
    try {
        return parser(entries);
    } catch (e) {
        return e;
    }
}

class MetadataWrapper {
    constructor(clientName, params, bucketclient, logger) {
        if (clientName === 'mem') {
            this.client = metastore;
            this.implName = 'memorybucket';
        } else if (clientName === 'file') {
            this.client = new BucketFileInterface(params, logger);
            this.implName = 'bucketfile';
        } else if (clientName === 'scality') {
            this.client = new BucketClientInterface(params, bucketclient,
                logger);
            this.implName = 'bucketclient';
        } else if (clientName === 'mongodb') {
            this.client = new MongoClientInterface({
                replicaSetHosts: params.mongodb.replicaSetHosts,
                writeConcern: params.mongodb.writeConcern,
                replicaSet: params.mongodb.replicaSet,
                readPreference: params.mongodb.readPreference,
                database: params.mongodb.database,
                replicationGroupId: params.replicationGroupId,
                path: params.mongodb.path,
                authCredentials: params.mongodb.authCredentials,
                shardCollections: params.mongodb.shardCollections,
                config: params.config,
                logger,
            });
            this.implName = 'mongoclient';
        } else if (clientName === 'cdmi') {
            if (!CdmiMetadata) {
                throw new Error('Unauthorized backend');
            }

            this.client = new CdmiMetadata({
                path: params.cdmi.path,
                host: params.cdmi.host,
                port: params.cdmi.port,
                readonly: params.cdmi.readonly,
            });
            this.implName = 'cdmi';
        }
        this._listingParser = params.customListingParser || _parseListEntries;
    }

    setup(done) {
        if (this.client.setup) {
            return this.client.setup(done);
        }
        return process.nextTick(done);
    }

    createBucket(bucketName, bucketMD, log, cb) {
        log.debug('creating bucket in metadata');
        this.client.createBucket(bucketName, bucketMD, log, err => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    error: err });
                return cb(err);
            }
            log.trace('bucket created in metadata');
            if (bucketNotificationHook) {
                setTimeout(bucketNotificationHook);
            }
            return cb(err);
        });
    }

    updateBucket(bucketName, bucketMD, log, cb) {
        log.debug('updating bucket in metadata');
        this.client.putBucketAttributes(bucketName, bucketMD, log, err => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    error: err });
                return cb(err);
            }
            log.trace('bucket updated in metadata');
            return cb(err);
        });
    }

    getBucket(bucketName, log, cb) {
        log.debug('getting bucket from metadata');
        this.client.getBucketAttributes(bucketName, log, (err, data) => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    error: err });
                return cb(err);
            }
            log.trace('bucket retrieved from metadata');
            return cb(err, BucketInfo.fromObj(data));
        });
    }

    deleteBucket(bucketName, log, cb) {
        log.debug('deleting bucket from metadata');
        this.client.deleteBucket(bucketName, log, err => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    error: err });
                return cb(err);
            }
            log.debug('Deleted bucket from Metadata');
            if (bucketNotificationHook) {
                setTimeout(bucketNotificationHook);
            }
            return cb(err);
        });
    }

    putObjectMD(bucketName, objName, objVal, params, log, cb) {
        log.debug('putting object in metadata');
        const value = typeof objVal.getValue === 'function' ?
            objVal.getValue() : objVal;
        this.client.putObject(bucketName, objName, value, params, log,
            (err, data) => {
                if (err) {
                    log.debug('error from metadata', { implName: this.implName,
                        error: err });
                    return cb(err);
                }
                if (data) {
                    log.debug('object version successfully put in metadata',
                        { version: data });
                } else {
                    log.debug('object successfully put in metadata');
                }
                return cb(err, data);
            });
    }

    getBucketAndObjectMD(bucketName, objName, params, log, cb) {
        log.debug('getting bucket and object from metadata',
            { database: bucketName, object: objName });
        this.client.getBucketAndObject(bucketName, objName, params, log,
            (err, data) => {
                if (err) {
                    log.debug('error from metadata', { implName: this.implName,
                        err });
                    return cb(err);
                }
                log.debug('bucket and object retrieved from metadata',
                    { database: bucketName, object: objName });
                return cb(err, data);
            });
    }

    getObjectMD(bucketName, objName, params, log, cb) {
        log.debug('getting object from metadata');
        this.client.getObject(bucketName, objName, params, log, (err, data) => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    err });
                return cb(err);
            }
            log.debug('object retrieved from metadata');
            return cb(err, data);
        });
    }

    deleteObjectMD(bucketName, objName, params, log, cb) {
        log.debug('deleting object from metadata');
        this.client.deleteObject(bucketName, objName, params, log, err => {
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    err });
                return cb(err);
            }
            log.debug('object deleted from metadata');
            return cb(err);
        });
    }

    listObject(bucketName, listingParams, log, cb) {
        if (listingParams.listingType === undefined) {
            // eslint-disable-next-line
            listingParams.listingType = 'Delimiter';
        }
        this.client.listObject(bucketName, listingParams, log, (err, data) => {
            log.debug('getting object listing from metadata');
            if (err) {
                log.debug('error from metadata', { implName: this.implName,
                    err });
                return cb(err);
            }
            log.debug('object listing retrieved from metadata');
            if (listingParams.listingType === 'DelimiterVersions') {
                // eslint-disable-next-line
                data.Versions = parseListEntries(data.Versions, this._listingParser);
                if (data.Versions instanceof Error) {
                    log.error('error parsing metadata listing', {
                        error: data.Versions,
                        listingType: listingParams.listingType,
                        method: 'listObject',
                    });
                    return cb(errors.InternalError);
                }
                return cb(null, data);
            }
            // eslint-disable-next-line
            data.Contents = parseListEntries(data.Contents, this._listingParser);
            if (data.Contents instanceof Error) {
                log.error('error parsing metadata listing', {
                    error: data.Contents,
                    listingType: listingParams.listingType,
                    method: 'listObject',
                });
                return cb(errors.InternalError);
            }
            return cb(null, data);
        });
    }

    listMultipartUploads(bucketName, listingParams, log, cb) {
        this.client.listMultipartUploads(bucketName, listingParams, log,
            (err, data) => {
                log.debug('getting mpu listing from metadata');
                if (err) {
                    log.debug('error from metadata', { implName: this.implName,
                        err });
                    return cb(err);
                }
                log.debug('mpu listing retrieved from metadata');
                return cb(err, data);
            });
    }

    switch(newClient, cb) {
        this.client = newClient;
        return cb();
    }

    getRaftBuckets(raftId, log, cb) {
        if (!this.client.getRaftBuckets) {
            return cb();
        }
        return this.client.getRaftBuckets(raftId, log, cb);
    }

    checkHealth(log, cb) {
        if (!this.client.checkHealth) {
            const defResp = {};
            defResp[this.implName] = { code: 200, message: 'OK' };
            return cb(null, defResp);
        }
        return this.client.checkHealth(this.implName, log, cb);
    }

    getUUID(log, cb) {
        if (!this.client.getUUID) {
            log.debug('returning empty uuid as fallback', {
                implName: this.implName });
            return cb(null, '');
        }
        return this.client.getUUID(log, cb);
    }

    getDiskUsage(log, cb) {
        if (!this.client.getDiskUsage) {
            log.debug('returning empty disk usage as fallback', {
                implName: this.implName });
            return cb(null, {});
        }
        return this.client.getDiskUsage(cb);
    }

    countItems(log, cb) {
        if (!this.client.countItems) {
            log.debug('returning zero item counts as fallback', {
                implName: this.implName });
            return cb(null, {
                buckets: 0,
                objects: 0,
                versions: 0,
            });
        }
        return this.client.countItems(log, cb);
    }

    getIngestionBuckets(log, cb) {
        if (this.implName !== 'mongoclient') {
            log.debug('error getting ingestion buckets', {
                implName: this.implName });
            return cb(errors.NotImplemented);
        }
        return this.client.getIngestionBuckets(log, cb);
    }

    notifyBucketChange(cb) {
        bucketNotificationHook = cb;
    }

    close(cb) {
        if (typeof this.client.close === 'function') {
            return this.client.close(cb);
        }
        return cb();
    }

    /**
     * deletes an object that matches the given conditions
     * @param{string} bucketName -
     * @param{string} objName -
     * @param{object} params -
     * @param{object} params.conditions - conditions object
     * @param{werelogs.RequestLogger} log -
     * @param{function} cb -
     * @returns{undefined}
     */
    deleteObjectWithCond(bucketName, objName, params, log, cb) {
        log.debug('find and delete object from metadata');
        if (typeof this.client.deleteObjectWithCond !== 'function') {
            log.debug('backend does not support deletions with conditions', {
                implName: this.implName,
            });
            return cb(errors.NotImplemented);
        }
        return this.client.deleteObjectWithCond(bucketName, objName,
            params, log, err => {
                if (err) {
                    log.debug('error from metadata', {
                        implName: this.implName,
                    });
                    return cb(err);
                }
                log.debug('object deleted from metadata');
                return cb();
            });
    }

    /**
     * updates(insert, if missing) an object that matches the given conditions
     * @param{string} bucketName -
     * @param{string} objName -
     * @param{object} objVal -
     * @param{object} params -
     * @param{object} params.conditions - conditions object
     * @param{werelogs.RequestLogger} log -
     * @param{function} cb -
     * @returns{undefined}
     */
    putObjectWithCond(bucketName, objName, objVal, params, log, cb) {
        log.debug('find and update object in metadata');
        if (typeof this.client.putObjectWithCond !== 'function') {
            log.debug('backend does not support updates with conditions', {
                implName: this.implName,
            });
            return cb(errors.NotImplemented);
        }
        return this.client.putObjectWithCond(bucketName, objName, objVal,
            params, log, err => {
                if (err) {
                    log.debug('error from metadata', {
                        implName: this.implName,
                    });
                    return cb(err);
                }
                log.debug('object successfully updated in metadata');
                return cb();
            });
    }
}

module.exports = MetadataWrapper;


text:
{{guide?.name}}

    <doc-viewer class="docs-guide-content"
                (contentRendered)="toc.addHeaders('Guide Content', $event); toc.updateScrollPosition()"
                [documentUrl]="guide?.document"
                focusOnNavigation
                id="guide-content"
                aria-label="Guide content"></doc-viewer>

<app-footer></app-footer>


text:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using HoloToolkit.Unity.InputModule;
using Academy.HoloToolkit.Unity;
using System.Linq;

public class ChartManager : MonoBehaviour
{
    // public GameObject Detail;
	private string charTag;
    // Use this for initialization

	// TODO: Remove this once we have a DB working
	private string[] string_col = new string[]{
		"policyID","statecode","county","line","construction"
	};

	private string[] datetime_col = new string[]{
		"ValidUntil", "CreatedAt"
	};

	private string[] num_col = new string[]{
		"eq_site_limit","hu_site_limit","fl_site_limit","fr_site_limit","tiv_2011","tiv_2012","eq_site_deductible","hu_site_deductible","fl_site_deductible", "fr_site_deductible","point_latitude","point_longitude","point_granularity"
	};

    void Start () {

	}

	// Update is called once per frame
	void Update () {

	}

    public void Show()
    {
		/*
        if (Detail == null)
        {
            return;
        }
        */

		GameObject parent = GameObject.FindGameObjectWithTag("Table1");
		string tableName = parent.tag;
		// Debug.Log("last highlighted column: " + SelectedColumnInfo.getLastColumnName());
		/*
		foreach(string cn in SelectedColumnInfo.getColumnNameSet(tableName))
		{
			 Debug.Log("here " + cn);
		}
		*/
		string lastHighlightedColumn = SelectedColumnInfo.getLastColumnName ();
		if (string_col.Contains (lastHighlightedColumn)) {
			charTag = "BarChart";
			var chartToShow = GameObject.FindObjectOfType (typeof(BarChartManage)) as BarChartManage;
			chartToShow.Show ();
		} else if (datetime_col.Contains (lastHighlightedColumn)) {
			charTag = "GraphChart";
			Debug.Log ("Show a graph chart");
			var chartToShow = GameObject.FindObjectOfType (typeof(GraphChartManage)) as GraphChartManage;
			chartToShow.Show ();
		} else if (num_col.Contains (lastHighlightedColumn)) {
			charTag = "BubbleChart";
			Debug.Log ("Show a bubble chart");
			var chartToShow = GameObject.FindObjectOfType (typeof(BubbleChartManage)) as BubbleChartManage;
			chartToShow.Show ();
		} else {
			Debug.Log ("Chart for target column type not implemented.");
		}

		/*
        // Recommend having only one tagalong.
        GameObject existingDetail = GameObject.FindGameObjectWithTag("BarChart");
        if (existingDetail != null)
        {
            //existingDetail.SetActive(false);
            return;
        }

        GameObject instantiatedDetail = GameObject.Instantiate(Detail);
		//instantiatedDetail.transform.position = Camera.main.transform.position + Camera.main.transform.forward * 0.85f;
		instantiatedDetail.transform.position = Camera.main.transform.position - Camera.main.transform.right * 0.75f - Camera.main.transform.up * 0.3f + Camera.main.transform.forward * 2.3f;
        instantiatedDetail.SetActive(true);
        instantiatedDetail.AddComponent<Billboard>();
        instantiatedDetail.AddComponent<SimpleTagalong>();
        /*if (Detail.activeSelf == false)
        {
            Detail.transform.position = Camera.main.transform.position + Camera.main.transform.forward * 0.85f;
            Detail.SetActive(true);
        }
        */

    }

    public void Dismiss()
    {
		// GameObject existingDetail = GameObject.FindGameObjectWithTag(charTag);
        // if (existingDetail != null)
        // {
        //     existingDetail.SetActive(false);
        // }

		if (charTag == "BarChart") {
			var chartToShow = GameObject.FindObjectOfType (typeof(BarChartManage)) as BarChartManage;
			if (chartToShow != null)
				chartToShow.Dismiss ();
		} else if (charTag == "GraphChart") {
			Debug.Log ("graph chart");
			var chartToShow = GameObject.FindObjectOfType (typeof(GraphChartManage)) as GraphChartManage;
			if (chartToShow != null)
				chartToShow.Dismiss ();
		} else if (charTag == "BubbleChart") {
			Debug.Log ("bubble chart");
			var chartToShow = GameObject.FindObjectOfType (typeof(BubbleChartManage)) as BubbleChartManage;
			if (chartToShow != null)
				chartToShow.Dismiss ();
		} else {
			Debug.Log ("Not implemented.");
		}
    }

    /*
    public void OnSelect()
    {
        Detail.GetComponent<MeshRenderer>().material.color = new
            Color(Random.Range(0, 255) / 255f, Random.Range(0, 255) / 255f,
            Random.Range(0, 255) / 255f);
    }
    */
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Pestalotia eriobotryae McAlpine

### Remarks
null


text:
layout: fallout4rec
title: fopdoc
---
Attack Animations
=================

Value | Meaning
------|--------
26 | AttackLeft
27 | AttackLeftUp
28 | AttackLeftDown
29 | AttackLeftIS
30 | AttackLeftISUp
31 | AttackLeftISDown
32 | AttackRight
33 | AttackRightUp
34 | AttackRightDown
35 | AttackRightIS
36 | AttackRightISUp
37 | AttackRightISDown
38 | Attack3
39 | Attack3Up
40 | Attack3Down
41 | Attack3IS
42 | Attack3ISUp
43 | Attack3ISDown
44 | Attack4
45 | Attack4Up
46 | Attack4Down
47 | Attack4IS
48 | Attack4ISUp
49 | Attack4ISDown
50 | Attack5
51 | Attack5Up
52 | Attack5Down
53 | Attack5IS
54 | Attack5ISUp
55 | Attack5ISDown
56 | Attack6
57 | Attack6Up
58 | Attack6Down
59 | Attack6IS
60 | Attack6ISUp
61 | Attack6ISDown
62 | Attack7
63 | Attack7Up
64 | Attack7Down
65 | Attack7IS
66 | Attack7ISUp
67 | Attack7ISDown
68 | Attack8
69 | Attack8Up
70 | Attack8Down
71 | Attack8IS
72 | Attack8ISUp
73 | Attack8ISDown
74 | AttackLoop
75 | AttackLoopUp
76 | AttackLoopDown
77 | AttackLoopIS
78 | AttackLoopISUp
79 | AttackLoopISDown
80 | AttackSpin
81 | AttackSpinUp
82 | AttackSpinDown
83 | AttackSpinIS
84 | AttackSpinISUp
85 | AttackSpinISDown
86 | AttackSpin2
87 | AttackSpin2Up
88 | AttackSpin2Down
89 | AttackSpin2IS
90 | AttackSpin2ISUp
91 | AttackSpin2ISDown
92 | AttackPower
93 | AttackForwardPower
94 | AttackBackPower
95 | AttackLeftPower
96 | AttackRightPower
97 | PlaceMine
98 | PlaceMineUp
99 | PlaceMineDown
100 | PlaceMineIS
101 | PlaceMineISUp
102 | PlaceMineISDown
103 | PlaceMine2
104 | PlaceMine2Up
105 | PlaceMine2Down
106 | PlaceMine2IS
107 | PlaceMine2ISUp
108 | PlaceMine2ISDown
109 | AttackThrow
110 | AttackThrowUp
111 | AttackThrowDown
112 | AttackThrowIS
113 | AttackThrowISUp
114 | AttackThrowISDown
115 | AttackThrow2
116 | AttackThrow2Up
117 | AttackThrow2Down
118 | AttackThrow2IS
119 | AttackThrow2ISUp
120 | AttackThrow2ISDown
121 | AttackThrow3
122 | AttackThrow3Up
123 | AttackThrow3Down
124 | AttackThrow3IS
125 | AttackThrow3ISUp
126 | AttackThrow3ISDown
127 | AttackThrow4
128 | AttackThrow4Up
129 | AttackThrow4Down
130 | AttackThrow4IS
131 | AttackThrow4ISUp
132 | AttackThrow4ISDown
133 | AttackThrow5
134 | AttackThrow5Up
135 | AttackThrow5Down
136 | AttackThrow5IS
137 | AttackThrow5ISUp
138 | AttackThrow5ISDown
167 | PipBoy
178 | PipBoyChild
255 |  ANY


text:
set serveroutput on;
set feedback on;
spool install_korreksjon.log;

define environment = preprod;

-- Logg inn med din favoritt-bruker
--connect korreksjon/&&korreksjon_pw@&&oracle_sid
alter session set current_schema=KORREKSJON;

-- NB! migration 6 og 7 er utført manuelt på PP

@migration/8/schema.sql;
@migration/8/users.sql;
@migration/8/grants.sql;
@migration/8/properties-&&environment..sql;
@migration/8/data.sql;

commit;
spool off;


text:
app.config(['$stateProvider', function(stateProvider) {

	stateProvider
		.state('app.public.blog', {
			controller: 'BlogCtrl',
			templateUrl: '../templates/public/blog/main.tpl.html',
		})
			.state('app.public.blog.list', {
				url: '/',
				templateUrl: '../templates/public/blog/list.tpl.html',
				controller: 'BlogListCtrl'
			})
			.state('app.public.blog.post', {
				url: '/blog/:post_id',
				templateUrl: '../templates/public/blog/post.tpl.html',
				controller: 'BlogPostCtrl'
			})
		.state('app.public.music', {
			controller: 'MusicCtrl',
			templateUrl: '../templates/public/music/main.tpl.html',
		})
			.state('app.public.music.list', {
				url: '/music',
				controller: 'MusicListCtrl',
				templateUrl: '../templates/public/music/list.tpl.html',
			})
			.state('app.public.music.playlist', {
				url: '/playlist/:playlist_id',
				controller: 'PlaylistCtrl',
				templateUrl: '../templates/public/music/playlist.tpl.html',
			})
		.state('app.public.travel', {
			url: '/travel',
			templateUrl: '../templates/public/travel/index.tpl.html',
			controller: 'TravelCtrl'
		})
		;

}]);


text:
<?php

namespace Sonata\Bundle\DemoBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;

use Symfony\Component\OptionsResolver\OptionsResolverInterface;

class CarType extends AbstractType
{
    public function buildForm(FormBuilderInterface $formBuilder, array $options)
    {
        $formBuilder
            ->add('createdAt', 'datetime')
            ->add('name')
            ->add('engine', 'sonata_demo_form_type_engine', array(
                'data_class' => 'Sonata\Bundle\DemoBundle\Model\Engine'
            ))
        ;
    }

    public function getName()
    {
        return 'sonata_demo_car';
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'Sonata\Bundle\DemoBundle\Model\Car'
        ));
    }
}


text:
var assert = require('assert');

module.exports = function () {
    this.When(/^I request \/(.*)$/, (path, callback) => {
        this.reprocessAndLoadData((e) => {
            if (e) return callback(e);
            this.requestPath(path, {}, (err, res, body) => {
                this.response = res;
                callback(err, res, body);
            });
        });
    });

    this.Then(/^I should get a response/, () => {
        this.ShouldGetAResponse();
    });

    this.Then(/^response should be valid JSON$/, (callback) => {
        this.ShouldBeValidJSON(callback);
    });

    this.Then(/^response should be well-formed$/, () => {
        this.ShouldBeWellFormed();
    });

    this.Then(/^status code should be (\d+)$/, (code, callback) => {
        try {
            this.json = JSON.parse(this.response.body);
        } catch(e) {
            return callback(e);
        }
        assert.equal(this.json.status, parseInt(code));
        callback();
    });

    this.Then(/^status message should be "(.*?)"$/, (message, callback) => {
        try {
            this.json = JSON.parse(this.response.body);
        } catch(e) {
            return callback(e);
        }
        assert(this.json.status_message, message);
        callback();
    });

    this.Then(/^response should be a well-formed route$/, () => {
        this.ShouldBeWellFormed();
        assert.equal(this.json.code, 'ok');
        assert.ok(Array.isArray(this.json.routes));
        assert.ok(Array.isArray(this.json.waypoints));
    });

    this.Then(/^"([^"]*)" should return code (\d+)$/, (binary, code) => {
        assert.ok(this.processError instanceof Error);
        assert.equal(this.processError.process, binary);
        assert.equal(parseInt(this.processError.code), parseInt(code));
    });
};