text:
namespace csReporter
{
    partial class frmReport
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmReport));
            this.lbAttribute = new System.Windows.Forms.ListBox();
            this.gbFormat = new System.Windows.Forms.GroupBox();
            this.rbExcel = new System.Windows.Forms.RadioButton();
            this.rbCSV = new System.Windows.Forms.RadioButton();
            this.rbHTML = new System.Windows.Forms.RadioButton();
            this.btnOK = new System.Windows.Forms.Button();
            this.btnCancel = new System.Windows.Forms.Button();
            this.gbLayout = new System.Windows.Forms.GroupBox();
            this.rbVertical = new System.Windows.Forms.RadioButton();
            this.rbHorizontal = new System.Windows.Forms.RadioButton();
            this.lblSelectAttributes = new System.Windows.Forms.Label();
            this.gbFormat.SuspendLayout();
            this.gbLayout.SuspendLayout();
            this.SuspendLayout();
            //
            // lbAttribute
            //
            this.lbAttribute.FormattingEnabled = true;
            this.lbAttribute.Location = new System.Drawing.Point(12, 25);
            this.lbAttribute.Name = "lbAttribute";
            this.lbAttribute.SelectionMode = System.Windows.Forms.SelectionMode.MultiExtended;
            this.lbAttribute.Size = new System.Drawing.Size(354, 303);
            this.lbAttribute.Sorted = true;
            this.lbAttribute.TabIndex = 5;
            //
            // gbFormat
            //
            this.gbFormat.Controls.Add(this.rbExcel);
            this.gbFormat.Controls.Add(this.rbCSV);
            this.gbFormat.Controls.Add(this.rbHTML);
            this.gbFormat.Location = new System.Drawing.Point(370, 11);
            this.gbFormat.Name = "gbFormat";
            this.gbFormat.Size = new System.Drawing.Size(88, 93);
            this.gbFormat.TabIndex = 6;
            this.gbFormat.TabStop = false;
            this.gbFormat.Text = "Format";
            //
            // rbExcel
            //
            this.rbExcel.AutoSize = true;
            this.rbExcel.Location = new System.Drawing.Point(6, 69);
            this.rbExcel.Name = "rbExcel";
            this.rbExcel.Size = new System.Drawing.Size(51, 17);
            this.rbExcel.TabIndex = 2;
            this.rbExcel.TabStop = true;
            this.rbExcel.Text = "Excel";
            this.rbExcel.UseVisualStyleBackColor = true;
            this.rbExcel.CheckedChanged += new System.EventHandler(this.rbExcel_CheckedChanged);
            //
            // rbCSV
            //
            this.rbCSV.AutoSize = true;
            this.rbCSV.Location = new System.Drawing.Point(6, 46);
            this.rbCSV.Name = "rbCSV";
            this.rbCSV.Size = new System.Drawing.Size(46, 17);
            this.rbCSV.TabIndex = 1;
            this.rbCSV.TabStop = true;
            this.rbCSV.Text = "CSV";
            this.rbCSV.UseVisualStyleBackColor = true;
            //
            // rbHTML
            //
            this.rbHTML.AutoSize = true;
            this.rbHTML.Location = new System.Drawing.Point(6, 22);
            this.rbHTML.Name = "rbHTML";
            this.rbHTML.Size = new System.Drawing.Size(55, 17);
            this.rbHTML.TabIndex = 0;
            this.rbHTML.TabStop = true;
            this.rbHTML.Text = "HTML";
            this.rbHTML.UseVisualStyleBackColor = true;
            //
            // btnOK
            //
            this.btnOK.Location = new System.Drawing.Point(55, 348);
            this.btnOK.Name = "btnOK";
            this.btnOK.Size = new System.Drawing.Size(90, 25);
            this.btnOK.TabIndex = 26;
            this.btnOK.Text = "OK";
            this.btnOK.UseVisualStyleBackColor = true;
            this.btnOK.Click += new System.EventHandler(this.btnOK_Click);
            //
            // btnCancel
            //
            this.btnCancel.Location = new System.Drawing.Point(165, 348);
            this.btnCancel.Name = "btnCancel";
            this.btnCancel.Size = new System.Drawing.Size(90, 25);
            this.btnCancel.TabIndex = 27;
            this.btnCancel.Text = "Cancel";
            this.btnCancel.UseVisualStyleBackColor = true;
            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
            //
            // gbLayout
            //
            this.gbLayout.Controls.Add(this.rbVertical);
            this.gbLayout.Controls.Add(this.rbHorizontal);
            this.gbLayout.Location = new System.Drawing.Point(370, 117);
            this.gbLayout.Name = "gbLayout";
            this.gbLayout.Size = new System.Drawing.Size(88, 73);
            this.gbLayout.TabIndex = 7;
            this.gbLayout.TabStop = false;
            this.gbLayout.Text = "Layout";
            this.gbLayout.Visible = false;
            //
            // rbVertical
            //
            this.rbVertical.AutoSize = true;
            this.rbVertical.Location = new System.Drawing.Point(6, 46);
            this.rbVertical.Name = "rbVertical";
            this.rbVertical.Size = new System.Drawing.Size(60, 17);
            this.rbVertical.TabIndex = 1;
            this.rbVertical.TabStop = true;
            this.rbVertical.Text = "Vertical";
            this.rbVertical.UseVisualStyleBackColor = true;
            //
            // rbHorizontal
            //
            this.rbHorizontal.AutoSize = true;
            this.rbHorizontal.Location = new System.Drawing.Point(6, 23);
            this.rbHorizontal.Name = "rbHorizontal";
            this.rbHorizontal.Size = new System.Drawing.Size(72, 17);
            this.rbHorizontal.TabIndex = 0;
            this.rbHorizontal.TabStop = true;
            this.rbHorizontal.Text = "Horizontal";
            this.rbHorizontal.UseVisualStyleBackColor = true;
            //
            // lblSelectAttributes
            //
            this.lblSelectAttributes.AutoSize = true;
            this.lblSelectAttributes.Location = new System.Drawing.Point(12, 11);
            this.lblSelectAttributes.Name = "lblSelectAttributes";
            this.lblSelectAttributes.Size = new System.Drawing.Size(174, 13);
            this.lblSelectAttributes.TabIndex = 28;
            this.lblSelectAttributes.Text = "Select Attributes to include in report";
            //
            // frmReport
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(468, 389);
            this.Controls.Add(this.lblSelectAttributes);
            this.Controls.Add(this.gbLayout);
            this.Controls.Add(this.btnCancel);
            this.Controls.Add(this.btnOK);
            this.Controls.Add(this.gbFormat);
            this.Controls.Add(this.lbAttribute);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "frmReport";
            this.Text = "Report Settings";
            this.gbFormat.ResumeLayout(false);
            this.gbFormat.PerformLayout();
            this.gbLayout.ResumeLayout(false);
            this.gbLayout.PerformLayout();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.ListBox lbAttribute;
        private System.Windows.Forms.GroupBox gbFormat;
        private System.Windows.Forms.RadioButton rbCSV;
        private System.Windows.Forms.RadioButton rbHTML;
        private System.Windows.Forms.Button btnOK;
        private System.Windows.Forms.Button btnCancel;
        private System.Windows.Forms.RadioButton rbExcel;
        private System.Windows.Forms.GroupBox gbLayout;
        private System.Windows.Forms.RadioButton rbVertical;
        private System.Windows.Forms.RadioButton rbHorizontal;
        private System.Windows.Forms.Label lblSelectAttributes;
    }
}


text:
package com.microsoft.azure.management.loganalytics.v2015_03_20.implementation;

import java.util.List;
import com.microsoft.azure.management.loganalytics.v2015_03_20.StorageAccount;
import com.microsoft.azure.management.loganalytics.v2015_03_20.StorageInsightStatus;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.microsoft.rest.serializer.JsonFlatten;
import com.microsoft.azure.ProxyResource;

/**
 * The top level storage insight resource container.
 */
@JsonFlatten
public class StorageInsightInner extends ProxyResource {
    /**
     * The names of the blob containers that the workspace should read.
     */
    @JsonProperty(value = "properties.containers")
    private List<String> containers;

    /**
     * The names of the Azure tables that the workspace should read.
     */
    @JsonProperty(value = "properties.tables")
    private List<String> tables;

    /**
     * The storage account connection details.
     */
    @JsonProperty(value = "properties.storageAccount", required = true)
    private StorageAccount storageAccount;

    /**
     * The status of the storage insight.
     */
    @JsonProperty(value = "properties.status", access = JsonProperty.Access.WRITE_ONLY)
    private StorageInsightStatus status;

    /**
     * The ETag of the storage insight.
     */
    @JsonProperty(value = "eTag")
    private String eTag;

    /**
     * Resource tags.
     */
    @JsonProperty(value = "tags")
    private Map<String, String> tags;

    /**
     * Get the names of the blob containers that the workspace should read.
     *
     * @return the containers value
     */
    public List<String> containers() {
        return this.containers;
    }

    /**
     * Set the names of the blob containers that the workspace should read.
     *
     * @param containers the containers value to set
     * @return the StorageInsightInner object itself.
     */
    public StorageInsightInner withContainers(List<String> containers) {
        this.containers = containers;
        return this;
    }

    /**
     * Get the names of the Azure tables that the workspace should read.
     *
     * @return the tables value
     */
    public List<String> tables() {
        return this.tables;
    }

    /**
     * Set the names of the Azure tables that the workspace should read.
     *
     * @param tables the tables value to set
     * @return the StorageInsightInner object itself.
     */
    public StorageInsightInner withTables(List<String> tables) {
        this.tables = tables;
        return this;
    }

    /**
     * Get the storage account connection details.
     *
     * @return the storageAccount value
     */
    public StorageAccount storageAccount() {
        return this.storageAccount;
    }

    /**
     * Set the storage account connection details.
     *
     * @param storageAccount the storageAccount value to set
     * @return the StorageInsightInner object itself.
     */
    public StorageInsightInner withStorageAccount(StorageAccount storageAccount) {
        this.storageAccount = storageAccount;
        return this;
    }

    /**
     * Get the status of the storage insight.
     *
     * @return the status value
     */
    public StorageInsightStatus status() {
        return this.status;
    }

    /**
     * Get the ETag of the storage insight.
     *
     * @return the eTag value
     */
    public String eTag() {
        return this.eTag;
    }

    /**
     * Set the ETag of the storage insight.
     *
     * @param eTag the eTag value to set
     * @return the StorageInsightInner object itself.
     */
    public StorageInsightInner withETag(String eTag) {
        this.eTag = eTag;
        return this;
    }

    /**
     * Get resource tags.
     *
     * @return the tags value
     */
    public Map<String, String> tags() {
        return this.tags;
    }

    /**
     * Set resource tags.
     *
     * @param tags the tags value to set
     * @return the StorageInsightInner object itself.
     */
    public StorageInsightInner withTags(Map<String, String> tags) {
        this.tags = tags;
        return this;
    }

}

redpajama_set_name: RedPajamaGithub


text:
class Layer(object):
    def __init__(self, num_inputs, num_neurons):
        self._num_inputs = num_inputs
        self._num_neurons = num_neurons

    def activate(self, inputs):
        raise NotImplementedError()

    def activate_many(self, inputs):
        raise NotImplementedError()


text:
<?php

namespace KnpU\OAuth2ClientBundle\Tests\Security\Exception;

use KnpU\OAuth2ClientBundle\Exception\InvalidStateException;
use KnpU\OAuth2ClientBundle\Security\Exception\InvalidStateAuthenticationException;
use PHPUnit\Framework\TestCase;

class InvalidStateAuthenticationExceptionTest extends TestCase
{
    public function testException()
    {
        $testException = new InvalidStateAuthenticationException(new InvalidStateException());

        $this->assertEquals('Invalid state parameter passed in callback URL.', $testException->getMessageKey());
    }
}


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.4
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2011.09.16 at 09:35:20 PM CEST
//

package org.oasis_open.docs.ns.bpel4people.ws_humantask._200803;

import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlElementDecl;
import javax.xml.bind.annotation.XmlRegistry;
import javax.xml.namespace.QName;

/**
 * This object contains factory methods for each
 * Java content interface and Java element interface
 * generated in the org.oasis_open.docs.ns.bpel4people.ws_humantask._200803 package.
 *
An ObjectFactory allows you to programatically
 * construct new instances of the Java representation
 * for XML content. The Java representation of XML
 * content can consist of schema derived interfaces
 * and classes representing the binding of schema
 * type definitions, element declarations and model
 * groups.  Factory methods for each of these are
 * provided in this class.
 */
@XmlRegistry
public class ObjectFactory {

    private final static QName _PeopleAssignments_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "peopleAssignments");
    private final static QName _Import_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "import");
    private final static QName _Notification_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "notification");
    private final static QName _HumanInteractions_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "humanInteractions");
    private final static QName _Priority_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "priority");
    private final static QName _TaskInitiator_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "taskInitiator");
    private final static QName _Notifications_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "notifications");
    private final static QName _GenericHumanRole_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "genericHumanRole");
    private final static QName _Tasks_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "tasks");
    private final static QName _PotentialOwners_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "potentialOwners");
    private final static QName _BusinessAdministrators_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "businessAdministrators");
    private final static QName _LeanTask_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "leanTask");
    private final static QName _LogicalPeopleGroups_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "logicalPeopleGroups");
    private final static QName _ExcludedOwners_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "excludedOwners");
    private final static QName _Task_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "task");
    private final static QName _TaskStakeholders_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "taskStakeholders");
    private final static QName _Recipients_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "recipients");
    private final static QName _TExtensibleMixedContentElementsDocumentation_QNAME = new QName("http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", "documentation");

    /**
     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: org.oasis_open.docs.ns.bpel4people.ws_humantask._200803
     */
    public ObjectFactory() {
    }

    /**
     * Create an instance of {@link TGenericHumanRoleAssignment }
     */
    public TGenericHumanRoleAssignment createTGenericHumanRoleAssignment() {
        return new TGenericHumanRoleAssignment();
    }

    /**
     * Create an instance of {@link TGenericHumanRoleAssignmentBase }
     */
    public TGenericHumanRoleAssignmentBase createTGenericHumanRoleAssignmentBase() {
        return new TGenericHumanRoleAssignmentBase();
    }

    /**
     * Create an instance of {@link TTask }
     */
    public TTask createTTask() {
        return new TTask();
    }

    /**
     * Create an instance of {@link TLeanTask }
     */
    public TLeanTask createTLeanTask() {
        return new TLeanTask();
    }

    /**
     * Create an instance of {@link TPotentialOwnerAssignment }
     */
    public TPotentialOwnerAssignment createTPotentialOwnerAssignment() {
        return new TPotentialOwnerAssignment();
    }

    /**
     * Create an instance of {@link TTasks }
     */
    public TTasks createTTasks() {
        return new TTasks();
    }

    /**
     * Create an instance of {@link TLogicalPeopleGroups }
     */
    public TLogicalPeopleGroups createTLogicalPeopleGroups() {
        return new TLogicalPeopleGroups();
    }

    /**
     * Create an instance of {@link TNotifications }
     */
    public TNotifications createTNotifications() {
        return new TNotifications();
    }

    /**
     * Create an instance of {@link TPriorityExpr }
     */
    public TPriorityExpr createTPriorityExpr() {
        return new TPriorityExpr();
    }

    /**
     * Create an instance of {@link TNotification }
     */
    public TNotification createTNotification() {
        return new TNotification();
    }

    /**
     * Create an instance of {@link TImport }
     */
    public TImport createTImport() {
        return new TImport();
    }

    /**
     * Create an instance of {@link TPeopleAssignments }
     */
    public TPeopleAssignments createTPeopleAssignments() {
        return new TPeopleAssignments();
    }

    /**
     * Create an instance of {@link THumanInteractions }
     */
    public THumanInteractions createTHumanInteractions() {
        return new THumanInteractions();
    }

    /**
     * Create an instance of {@link TFrom }
     */
    public TFrom createTFrom() {
        return new TFrom();
    }

    /**
     * Create an instance of {@link TAggregate }
     */
    public TAggregate createTAggregate() {
        return new TAggregate();
    }

    /**
     * Create an instance of {@link TMessageSchema }
     */
    public TMessageSchema createTMessageSchema() {
        return new TMessageSchema();
    }

    /**
     * Create an instance of {@link TToPart }
     */
    public TToPart createTToPart() {
        return new TToPart();
    }

    /**
     * Create an instance of {@link TText }
     */
    public TText createTText() {
        return new TText();
    }

    /**
     * Create an instance of {@link TComposition }
     */
    public TComposition createTComposition() {
        return new TComposition();
    }

    /**
     * Create an instance of {@link TParameter }
     */
    public TParameter createTParameter() {
        return new TParameter();
    }

    /**
     * Create an instance of {@link TExtension }
     */
    public TExtension createTExtension() {
        return new TExtension();
    }

    /**
     * Create an instance of {@link TRendering }
     */
    public TRendering createTRendering() {
        return new TRendering();
    }

    /**
     * Create an instance of {@link TReassignment }
     */
    public TReassignment createTReassignment() {
        return new TReassignment();
    }

    /**
     * Create an instance of {@link TMessageField }
     */
    public TMessageField createTMessageField() {
        return new TMessageField();
    }

    /**
     * Create an instance of {@link TDeadlines }
     */
    public TDeadlines createTDeadlines() {
        return new TDeadlines();
    }

    /**
     * Create an instance of {@link TCopy }
     */
    public TCopy createTCopy() {
        return new TCopy();
    }

    /**
     * Create an instance of {@link TDocumentation }
     */
    public TDocumentation createTDocumentation() {
        return new TDocumentation();
    }

    /**
     * Create an instance of {@link TDurationExpr }
     */
    public TDurationExpr createTDurationExpr() {
        return new TDurationExpr();
    }

    /**
     * Create an instance of {@link TNotificationInterface }
     */
    public TNotificationInterface createTNotificationInterface() {
        return new TNotificationInterface();
    }

    /**
     * Create an instance of {@link TCompletion }
     */
    public TCompletion createTCompletion() {
        return new TCompletion();
    }

    /**
     * Create an instance of {@link TExtensibleElements }
     */
    public TExtensibleElements createTExtensibleElements() {
        return new TExtensibleElements();
    }

    /**
     * Create an instance of {@link TTaskInterface }
     */
    public TTaskInterface createTTaskInterface() {
        return new TTaskInterface();
    }

    /**
     * Create an instance of {@link TExtensions }
     */
    public TExtensions createTExtensions() {
        return new TExtensions();
    }

    /**
     * Create an instance of {@link TPresentationParameter }
     */
    public TPresentationParameter createTPresentationParameter() {
        return new TPresentationParameter();
    }

    /**
     * Create an instance of {@link TPresentationElements }
     */
    public TPresentationElements createTPresentationElements() {
        return new TPresentationElements();
    }

    /**
     * Create an instance of {@link TDeadlineExpr }
     */
    public TDeadlineExpr createTDeadlineExpr() {
        return new TDeadlineExpr();
    }

    /**
     * Create an instance of {@link TDescription }
     */
    public TDescription createTDescription() {
        return new TDescription();
    }

    /**
     * Create an instance of {@link TQuery }
     */
    public TQuery createTQuery() {
        return new TQuery();
    }

    /**
     * Create an instance of {@link TLocalNotification }
     */
    public TLocalNotification createTLocalNotification() {
        return new TLocalNotification();
    }

    /**
     * Create an instance of {@link TLogicalPeopleGroup }
     */
    public TLogicalPeopleGroup createTLogicalPeopleGroup() {
        return new TLogicalPeopleGroup();
    }

    /**
     * Create an instance of {@link TSubtask }
     */
    public TSubtask createTSubtask() {
        return new TSubtask();
    }

    /**
     * Create an instance of {@link TExtensibleMixedContentElements }
     */
    public TExtensibleMixedContentElements createTExtensibleMixedContentElements() {
        return new TExtensibleMixedContentElements();
    }

    /**
     * Create an instance of {@link TSequence }
     */
    public TSequence createTSequence() {
        return new TSequence();
    }

    /**
     * Create an instance of {@link TExpression }
     */
    public TExpression createTExpression() {
        return new TExpression();
    }

    /**
     * Create an instance of {@link TToParts }
     */
    public TToParts createTToParts() {
        return new TToParts();
    }

    /**
     * Create an instance of {@link TResult }
     */
    public TResult createTResult() {
        return new TResult();
    }

    /**
     * Create an instance of {@link TRenderings }
     */
    public TRenderings createTRenderings() {
        return new TRenderings();
    }

    /**
     * Create an instance of {@link TParallel }
     */
    public TParallel createTParallel() {
        return new TParallel();
    }

    /**
     * Create an instance of {@link TDeadline }
     */
    public TDeadline createTDeadline() {
        return new TDeadline();
    }

    /**
     * Create an instance of {@link TPresentationParameters }
     */
    public TPresentationParameters createTPresentationParameters() {
        return new TPresentationParameters();
    }

    /**
     * Create an instance of {@link TArgument }
     */
    public TArgument createTArgument() {
        return new TArgument();
    }

    /**
     * Create an instance of {@link TMessageChoice }
     */
    public TMessageChoice createTMessageChoice() {
        return new TMessageChoice();
    }

    /**
     * Create an instance of {@link TDelegation }
     */
    public TDelegation createTDelegation() {
        return new TDelegation();
    }

    /**
     * Create an instance of {@link TLocalTask }
     */
    public TLocalTask createTLocalTask() {
        return new TLocalTask();
    }

    /**
     * Create an instance of {@link TBooleanExpr }
     */
    public TBooleanExpr createTBooleanExpr() {
        return new TBooleanExpr();
    }

    /**
     * Create an instance of {@link TEscalation }
     */
    public TEscalation createTEscalation() {
        return new TEscalation();
    }

    /**
     * Create an instance of {@link TDefaultCompletion }
     */
    public TDefaultCompletion createTDefaultCompletion() {
        return new TDefaultCompletion();
    }

    /**
     * Create an instance of {@link TMessageDisplay }
     */
    public TMessageDisplay createTMessageDisplay() {
        return new TMessageDisplay();
    }

    /**
     * Create an instance of {@link TCompletionBehavior }
     */
    public TCompletionBehavior createTCompletionBehavior() {
        return new TCompletionBehavior();
    }

    /**
     * Create an instance of {@link TLiteral }
     */
    public TLiteral createTLiteral() {
        return new TLiteral();
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TPeopleAssignments }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "peopleAssignments")
    public JAXBElement<TPeopleAssignments> createPeopleAssignments(TPeopleAssignments value) {
        return new JAXBElement<TPeopleAssignments>(_PeopleAssignments_QNAME, TPeopleAssignments.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TImport }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "import")
    public JAXBElement<TImport> createImport(TImport value) {
        return new JAXBElement<TImport>(_Import_QNAME, TImport.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TNotification }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "notification")
    public JAXBElement<TNotification> createNotification(TNotification value) {
        return new JAXBElement<TNotification>(_Notification_QNAME, TNotification.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link THumanInteractions }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "humanInteractions")
    public JAXBElement<THumanInteractions> createHumanInteractions(THumanInteractions value) {
        return new JAXBElement<THumanInteractions>(_HumanInteractions_QNAME, THumanInteractions.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TPriorityExpr }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "priority")
    public JAXBElement<TPriorityExpr> createPriority(TPriorityExpr value) {
        return new JAXBElement<TPriorityExpr>(_Priority_QNAME, TPriorityExpr.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "taskInitiator", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignment> createTaskInitiator(TGenericHumanRoleAssignment value) {
        return new JAXBElement<TGenericHumanRoleAssignment>(_TaskInitiator_QNAME, TGenericHumanRoleAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TNotifications }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "notifications")
    public JAXBElement<TNotifications> createNotifications(TNotifications value) {
        return new JAXBElement<TNotifications>(_Notifications_QNAME, TNotifications.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignmentBase }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignmentBase> createGenericHumanRole(TGenericHumanRoleAssignmentBase value) {
        return new JAXBElement<TGenericHumanRoleAssignmentBase>(_GenericHumanRole_QNAME, TGenericHumanRoleAssignmentBase.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TTasks }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "tasks")
    public JAXBElement<TTasks> createTasks(TTasks value) {
        return new JAXBElement<TTasks>(_Tasks_QNAME, TTasks.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TPotentialOwnerAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "potentialOwners", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TPotentialOwnerAssignment> createPotentialOwners(TPotentialOwnerAssignment value) {
        return new JAXBElement<TPotentialOwnerAssignment>(_PotentialOwners_QNAME, TPotentialOwnerAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "businessAdministrators", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignment> createBusinessAdministrators(TGenericHumanRoleAssignment value) {
        return new JAXBElement<TGenericHumanRoleAssignment>(_BusinessAdministrators_QNAME, TGenericHumanRoleAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TLeanTask }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "leanTask")
    public JAXBElement<TLeanTask> createLeanTask(TLeanTask value) {
        return new JAXBElement<TLeanTask>(_LeanTask_QNAME, TLeanTask.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TLogicalPeopleGroups }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "logicalPeopleGroups")
    public JAXBElement<TLogicalPeopleGroups> createLogicalPeopleGroups(TLogicalPeopleGroups value) {
        return new JAXBElement<TLogicalPeopleGroups>(_LogicalPeopleGroups_QNAME, TLogicalPeopleGroups.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "excludedOwners", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignment> createExcludedOwners(TGenericHumanRoleAssignment value) {
        return new JAXBElement<TGenericHumanRoleAssignment>(_ExcludedOwners_QNAME, TGenericHumanRoleAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TTask }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "task")
    public JAXBElement<TTask> createTask(TTask value) {
        return new JAXBElement<TTask>(_Task_QNAME, TTask.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "taskStakeholders", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignment> createTaskStakeholders(TGenericHumanRoleAssignment value) {
        return new JAXBElement<TGenericHumanRoleAssignment>(_TaskStakeholders_QNAME, TGenericHumanRoleAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TGenericHumanRoleAssignment }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "recipients", substitutionHeadNamespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", substitutionHeadName = "genericHumanRole")
    public JAXBElement<TGenericHumanRoleAssignment> createRecipients(TGenericHumanRoleAssignment value) {
        return new JAXBElement<TGenericHumanRoleAssignment>(_Recipients_QNAME, TGenericHumanRoleAssignment.class, null, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link TDocumentation }{@code >}}
     */
    @XmlElementDecl(namespace = "http://docs.oasis-open.org/ns/bpel4people/ws-humantask/200803", name = "documentation", scope = TExtensibleMixedContentElements.class)
    public JAXBElement<TDocumentation> createTExtensibleMixedContentElementsDocumentation(TDocumentation value) {
        return new JAXBElement<TDocumentation>(_TExtensibleMixedContentElementsDocumentation_QNAME, TDocumentation.class, TExtensibleMixedContentElements.class, value);
    }

}


text:
/*
Package filter provides general-purpose core.Pipe implementations to filter
(i.e. discard), sort or aggregate pipeline items.
*/
package filter


text:
// The MIT License
//
// Copyright (c) 2016 Dariusz Bukowski
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#import <UIKit/UIKit.h>

@class DBSliderTableViewCell;

/**
 A protocol used for informing about cell's slider events.
 */
@protocol DBSliderTableViewCellDelegate

/**
 Informs the delegate that the slider value was changed in the cell.

 @param sliderCell The cell with a slider that changed its value.
 @param value The new slider value.
 */
- (void)sliderCell:(DBSliderTableViewCell *)sliderCell didSelectValue:(NSInteger)value;

/**
 Informs the delegate that the slider did start editing.

 @param sliderCell The cell with a slider that started editing.
 */
- (void)sliderCellDidStartEditingValue:(DBSliderTableViewCell *)sliderCell;

/**
 Informs the delegate that the slider did end editing.

 @param sliderCell The cell with a slider that ended editing.
 */
- (void)sliderCellDidEndEditingValue:(DBSliderTableViewCell *)sliderCell;

@end

/**
 `DBSliderTableViewCell` is a simple table view cell subclass with a title label, a `UISlider` instance and a value label.
 */
@interface DBSliderTableViewCell : UITableViewCell

/**
 Delegate that will be informed about slider events. It needs to conform to `DBSliderTableViewCellDelegate` protocol.
 */
@property (nonatomic, weak) id <DBSliderTableViewCellDelegate> delegate;

/**
 An outlet to `UILabel` instance displaying the title of the value changed with the slider.
 */
@property (nonatomic, weak) IBOutlet UILabel *titleLabel;

/**
 Sets a specified value on the slider.

 @param value Selected value.
 */
- (void)setValue:(NSInteger)value;

/**
 Sets a minimum value of the slider.

 @param minValue Minimum value of the slider.
 */
- (void)setMinValue:(NSInteger)minValue;

/**
 Sets a maximum value of the slider.

 @param maxValue Maximum value of the slider.
 */
- (void)setMaxValue:(NSInteger)maxValue;

@end


text:
Zurb Ink email HTML template composer for #nodejs

compose beautiful emails so quickly!

http://zurb.com/ink/

## Understanding

Email template have simple structure

Meelo > Container > Row > Column > Content

## Install

> npm install meelo --save

## Usage

`````javascript

var meelo = require('meelo');
var mail = meelo.mail({background: '#ddd'});

var contentRow = function () {
  var row = meelo.row();
  var column = meelo.column({cssClass: 'twelve', extendedCssClass: 'text-pad'});

  column.addContent('h1 Good day, Meelo!');                 //use jade syntax
  column.addContent('<p>New updates are available!</p>');   //use plain html

  row.addColumn(column);
  return row;
};

var container = meelo.container({background: '#fff'});

container.addRow(contentRow());
mail.addContainer(container);

var html = mail.build();

`````

## Examples

see ./examples


text:
<?php

class Dlayer_Action_ValidateSiteId extends
    Zend_Controller_Action_Helper_Abstract
{
    /**
     * Checks the session to validate the currently stored site id, it needs to be set, exist in the database and
     * belong to the currently logged in user. On error the user is redirected back to the home page
     *
     * @return void
     */
    function direct()
    {
        $valid = false;

        $session_dlayer = new Dlayer_Session();

        if ($session_dlayer->siteId() != null) {
            $model = new Dlayer_Model_Admin_Site();
            if ($model->valid($session_dlayer->siteId(), $session_dlayer->identityId()) === true) {
                $valid = true;
            }
        }

        if ($valid == false) {
            $this->_actionController->getHelper('Redirector')->gotoUrl(
                '/dlayer/index/home');
        }
    }
}


text:
%Clear existing data
clear all;
close all;
clc;

%Load cities dataset
load('discrim.mat');

%Fix labels to be binary
labels = group;
labels(group == 1) = 0;
labels(group == 2) = 1;

%Split Dataset
split = crossvalind('LeaveMOut',length(labels),floor(0.2 .* length(labels)));

trainingLabels = labels(split == 1);
trainingFeatures = ratings(split == 1,:);
testLabels = labels(split == 0);
testFeatures = ratings(split == 0,:);

%Dataset statistics
disp('Dataset: Cities')
disp(['Number of Training Instances: ' num2str(size(trainingFeatures,1))]);
disp(['Number of Test Instances: ' num2str(size(testFeatures,1))]);
disp(['Number of Features (Measurements): ' num2str(size(trainingFeatures,2))]);
disp(' ');

%Run classifiers

%HellingerTree
disp('Hellinger Tree:')
tic();
model = fit_Hellinger_tree(trainingFeatures,trainingLabels,[],5);
trainingTime = toc();
tic();
[predictions,scores] = predict_Hellinger_tree(model,testFeatures);
testTime = toc();
correct = (predictions == testLabels);
correct = sum(correct) / length(correct);
disp(['Percent of instances correctly classified: ' num2str(correct)]);

[precision,recall,f1] = get_statistics(testLabels,predictions);
[~,~,~,AUC] = perfcurve(testLabels,scores,1);
disp(['Precision: ' num2str(precision)]);
disp(['Recall: ' num2str(recall)]);
disp(['F-Measure: ' num2str(f1)]);
disp(['AUROC: ' num2str(AUC)]);

disp(['Training time: ' num2str(trainingTime) ' seconds']);
disp(['Test time: ' num2str(testTime) ' seconds']);
disp(['Total time: ' num2str(trainingTime + testTime) ' seconds']);
disp(' ');

%Hellinger Forest
disp('Hellinger Forest:')
tic();
model = fit_Hellinger_forest(trainingFeatures,trainingLabels,10,[],[],5);
trainingTime = toc();
tic();
[predictions,scores] = predict_Hellinger_forest(model,testFeatures);
testTime = toc();
correct = (predictions == testLabels);
correct = sum(correct) / length(correct);
disp(['Percent of instances correctly classified: ' num2str(correct)]);

[precision,recall,f1] = get_statistics(testLabels,predictions);
[~,~,~,AUC] = perfcurve(testLabels,scores,1);
disp(['Precision: ' num2str(precision)]);
disp(['Recall: ' num2str(recall)]);
disp(['F-Measure: ' num2str(f1)]);
disp(['AUROC: ' num2str(AUC)]);

disp(['Training time: ' num2str(trainingTime) ' seconds']);
disp(['Test time: ' num2str(testTime) ' seconds']);
disp(['Total time: ' num2str(trainingTime + testTime) ' seconds']);
disp(' ');

%Linear SVM for Comparison
disp('SVM:')
tic();
model = fitcsvm(trainingFeatures,trainingLabels);
trainingTime = toc();
tic();
[predictions,scores] = predict(model,testFeatures);
testTime = toc();
correct = (predictions == testLabels);
correct = sum(correct) / length(correct);
disp(['Percent of instances correctly classified: ' num2str(correct)]);
[precision,recall,f1] = get_statistics(testLabels,predictions);
[~,~,~,AUC] = perfcurve(testLabels,scores(:,2),1);
disp(['Precision: ' num2str(precision)]);
disp(['Recall: ' num2str(recall)]);
disp(['F-Measure: ' num2str(f1)]);
disp(['AUROC: ' num2str(AUC)]);

disp(['Training time: ' num2str(trainingTime) ' seconds']);
disp(['Test time: ' num2str(testTime) ' seconds']);
disp(['Total time: ' num2str(trainingTime + testTime) ' seconds']);
disp(' ');


text:
Release process steps, to be automated...

1. checkout "master" and merge "develop"
```
git checkout master
git merge --no-ff develop
```

2. remove "-SNAPSHOT" and set release-notes in gradle.properties

3. `gradlew clean publishPlugins -PbintrayUser=*** -PbintrayApiKey=*** -Pgradle.publish.key=*** -Pgradle.publish.secret=***`

4. commit and push gradle.properties
```
git commit -am "Release 3.0"
git push
```

5. [create Github release](https://github.com/martoe/gradle-svntools-plugin/releases/new)
    * Tag version: "v0.0" for feature releases, "v0.0.0" for bugfix releases, @master
    * Release title: same as "Tag version"
    * Description: from `gradle.properties`

6. [close current milestone](https://github.com/martoe/gradle-svntools-plugin/milestones) and all assigned issues

6. [create next milestone](https://github.com/martoe/gradle-svntools-plugin/milestones/new)

6. checkout "develop" and rebase against "master"
```
git checkout develop
git rebase master
```

7. bump version and add "-SNAPSHOT" in gradle.properties (and reset release-notes)

8. commit and push gradle.properties
```
git commit -am "Post-release"
git push
```


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

describe('Smelling Salts', function () {
	afterEach(function () {
		battle.destroy();
	});

	it('should cure a paralyzed target', function () {
		battle = BattleEngine.Battle.construct();
		battle.join('p1', 'Guest 1', 1, [{species: "Meloetta", ability: 'serenegrace', moves: ['smellingsalts', 'thunderwave']}]);
		battle.join('p2', 'Guest 2', 1, [{species: "Dragonite", ability: 'multiscale', moves: ['roost']}]);
		battle.choose('p1', 'move 2');
		battle.commitDecisions();
		battle.commitDecisions();
		assert.notStrictEqual(battle.p2.active[0].status, 'par');
	});
});


text:
title: Differences Between InfluxDB 0.8 and InfluxDB 0.9
newversionredirect: concepts/09_vs_010/
menu:
  influxdb_09:
    weight: 30
    parent: concepts
---

There are significant breaking changes between the 0.8.x versions of InfluxDB and the 0.9.x versions.
The API, the schema, the data store, and the clustering algorithm have all been significantly altered and in incompatible ways.
The InfluxQL syntax has remained largely the same, although there are functions which exist only in one or the other version, and a few functions are implemented differently in the two versions.

This page aims to ease the transition to InfluxDB 0.9 for those more familiar with 0.8.
It is not a comprehensive list of the differences, that would be prohibitively large.
Less than half of the 0.8 code is retained in 0.9.0.

## Schema

The most noticeable difference between InfluxDB 0.8 and InfluxDB 0.9 is the way series are defined and organized.
In InfluxDB 0.8 a series had an explicit name that incorporated all the metadata about the value, similar to Graphite output.
The recommended pattern for a series name in InfluxDB 0.8 is `<tagName>.<tagValue>[.<tagName>.<tagValue>].<measurement>`.
For example: `az.us-west-1.host.serverA.cpu`.

In InfluxDB 0.9 a series is still defined by the measurement name and the complete tag set, but series are not explicitly defined at write time.
Instead of writing a point to a particular series, a point is written with a measurement name and a set of tag key-value pairs.
The recommended pattern in InfluxDB 0.9 is superficially similar: `<measurement>,<tagName>=<tagValue>[,<tagName>=<tagValue>]`.
For example: `cpu,az=us-west-1,host=serverA`.

The real change is evident when querying.
In InfluxDB 0.8, querying multiple series requires using a regular expression.
For example, to query the `cpu` measurement where the `az` is `us-west-1` for all hostnames, the syntax is `SELECT * FROM /az.us-west-1.host..*.cpu$/ ...`.
To query all series in the `cpu` measurement the syntax is `SELECT * FROM /cpu$/ ...`.

In InfluxDB 0.9, queries operate directly on measurements, not on series.
All series in a measurement are returned by default, unless filtered out by tags in the `WHERE` clause.
For example, to query the `cpu` measurement where the `az` is `us-west-1` for all hostnames, the syntax is `SELECT * FROM cpu WHERE az='us-west-1' ...`.
To query all series in the `cpu` measurement the syntax is `SELECT * FROM cpu ...`.

The change means that as series incorporate additional tags all queries will continue to function as expected.
Because all series are returned unless explicitly filtered, new tags do not have any effect on existing queries.
The existing queries do not include the new tag and therefore will ignore its existence when selecting results.
No longer does schema design need to include a prolonged session of predicting all future metadata and ensuring it can be represented within the desired regular expression syntax.
In InfluxDB 0.9 filtering by tags is very efficient, whereas in InfluxDB 0.8 filtering by column in the `WHERE` clause is always an expensive operation.

In InfluxDB 0.8 a series has a name and one or more measured values.
The values can be passed to functions or used in a `GROUP BY` clause.
The series name is indexed but the values are not.
In InfluxDB 0.9 a series has a measurement name, a tag set, and a field set.
The measurement name plus the tag set are equivalent to the series name from InfluxDB 0.8.
The field set in InfluxDB 0.9 is equivalent to the series values in InfluxDB 0.8.

When designing a schema for InfluxDB 0.9 is it important to understand the differences between tags and fields.
Tags are indexed, fields are not.
Both can be used as filters in the `WHERE` clause, but filtering by tags only requires a quick index lookup.
Filtering by fields requires a full scan of all points on disk that match the other filters and is thus much less performant.
In InfluxDB 0.9, fields can be passed into functions but tags cannot.
Tags can be used in a `GROUP BY` clause but fields cannot.
(In InfluxDB 0.8 series values -- equivalent to fields -- can be used in the `GROUP BY`  clause.) In InfluxDB 0.9, measurement names and tags can be matched using regular expressions but regular expressions are not valid for matching field keys or values.

## Joins

InfluxDB 0.8 allows both `MERGE` and `JOIN` operations between series.
The `MERGE` operation returns a single aggregation of two or more series.
The `JOIN` operation allows values from two different series to appear in the same select statement.
`JOIN` is often used to perform mathematical operations on values from two different series, such as dividing two values to find a ratio.
For example: `SELECT errors_per_minute.value / pages_per_minute.value FROM errors_per_minute INNER JOIN pages_per_minute`.

In InfluxDB 0.9 neither the `MERGE` nor `JOIN` operations are supported.
The `MERGE` operation is no longer needed.
All series within a measurement are automatically merged when queried, unless explicitly excluded by tags in the `WHERE` clause.

The lack of a `JOIN` operation means that fields from different measurements cannot be directly referenced in the same `SELECT` clause.
It is no longer possible to run a query like `SELECT errors_per_minute.value / pages_per_minute.value FROM errors_per_minute INNER JOIN pages_per_minute`.
It is possible to query more than one measurement at once using regular expressions.
However, every field referenced in the query must be present in each measurement and cannot be filtered by measurement.

## Data Retention

In InfluxDB 0.8 data retention is handled by shard groups.
Shard groups include a duration for each individual shard within the group and when the duration is exceeded, the shard may be dropped.
A given series writes to the first shard group whose regular expression matches the series name.
Shards and shard groups are directly exposed in the Admin UI and can be manipulated by an end user.

In InfluxDB 0.9 it is no longer necessary to parse or define regular expressions to determine the retention of a particular point.
Instead, data retention is handled by retention policies.
Retention policies belong to databases and define the duration for each point written to the retention policy.
When the duration is exceeded, the underlying file may be dropped.
A point is written directly to a particular retention policy, declared at write time.
If no retention policy is explicitly provided with the write, the point is written to the default retention policy.
In InfluxDB 0.9 shards and shard groups are purely internal and have no user-facing features or settings.

## Points With Identical Timestamps

In InfluxDB 0.8 a point is uniquely identified by the series name, timestamp, and sequence number.
The sequence number is an internally generated ID that provides uniqueness in the event the series name and timestamp are identical.

In InfluxDB 0.9 a point is uniquely identified by the measurement name, full tag set, and the timestamp.
Only one point can be stored for a given set of those values.
If two points are written with identical measurement names, tag sets, and timestamps, the second point will silently overwrite the first.
If you need to store multiple points with the same measurement name and timestamp, they must have different tag sets.
This can be accomplished by adding a new tag with different values for each point that is otherwise identical.
Uniqueness tags used in this manner will not significantly affect write or query performance.

## Write Protocols

In InfluxDB 0.8 the primary write method is a JSON protocol.
In InfluxDB 0.9 the JSON write protocol is deprecated and replaced by the [line](/influxdb/v0.9/write_protocols/line/) [protocol](/influxdb/v0.9/write_protocols/write_syntax/).

The JSON write protocol was deprecated because JSON marshalling, unmarshalling, and parsing was consuming well over half of the total CPU used to process writes.

## API Endpoints

InfluxDB 0.8 has multiple endpoints for the API, often encoding concepts such as the database and shard space in the HTTP endpoint.
InfluxDB 0.9 simplifies the common API interactions, using a common endpoint `/query` for all queries, and `/write` for all writes, regardless of database or retention policy.
The database and retention policy are passed as query string parameters in InfluxDB 0.9.

This makes the API easier to incorporate into libraries and other code, as it does not require any knowledge of the data structure to make valid calls to the API endpoints.

## Command Line Interface

InfluxDB 0.9 introduces a command line interface (CLI) making it even easier to interact with the database.
Rather than rely on the Admin UI or manually crafting HTTP requests, InfluxDB 0.9 users can send writes and queries in a pseudo-interactive shell, with query output available in multiple formats, including JSON, CSV, and columnar.

The CLI does not interact directly with the influxd process, it is a wrapper around the Go client and uses the same HTTP API as any other client or library.

## Admin UI

In InfluxDB 0.8 the Administration User Interface supported a number of configuration and administration features, some of which could not be performed any other way.
In InfluxDB 0.9 all database administration, configuration, and information is available via the HTTP API and the Admin UI has been substantially simplified.

## InfluxQL re-written

As a result of the new schema, the query language was substantially overhauled.
A number of functions available in InfluxDB 0.8 have not yet been re-implemented in InfluxDB 0.9, including [`MODE`](https://github.com/influxdb/influxdb/issues/1823), [`HISTOGRAM`](https://github.com/influxdb/influxdb/issues/3674), [`DIFFERENCE`](https://github.com/influxdb/influxdb/issues/1825), and [`BOTTOM`](https://github.com/influxdb/influxdb/issues/1820).
Links go to the open issues to re-implement each function or behavior.

The query parser in InfluxDB 0.8 was implemented with a C version of Yacc and Bison.
Re-writing the query parser in Go means the code is much more portable to systems other than Linux on i686, such as ARM or Windows builds.

## Continuous Query Engine Redone

To incorporate the retention, clustering, and InfluxQL changes the continuous query implementation has been reworked.
The continuous query engine in InfluxDB 0.9 still has rough edges that are due for significant work in the upcoming 0.9.5 release.

## Clustering

InfluxDB 0.9 follows a hybrid model for maintaining availability of the data while guaranteeing consistency of the metadata.
See CEO and co-founder Paul Dix's [clustering blog post](https://influxdata.com/blog/influxdb-clustering-design-neither-strictly-cp-or-ap/) for more details.

## Data Storage Engine

In InfluxDB 0.8 users could choose from a selection of underlying storage engines, with RocksDB, LevelDB, HyperLevelDB, and LMDB as available options.
In InfluxDB 0.9 the underlying storage engine is always [BoltDB](https://github.com/boltdb/bolt), a copy-on-write B+tree.

Selecting a storage engine written in Go simplifies the build process, making the code more portable to multiple architectures and operating systems.
In addition, BoltDB greatly simplifies the overhead of internal file handles, a significant source of issues in the InfluxDB 0.8 version.


text:
import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-ng-content',
  templateUrl: './ng-content.component.html',
  styleUrls: ['./ng-content.component.css']
})
export class NgContentComponent implements OnInit {

  constructor() { }

  ngOnInit() {
  }

}


text:
package me.scana.okgradle.internal.dsl.parser.elements;

import me.scana.okgradle.internal.dsl.parser.elements.GradleDslElement;
import me.scana.okgradle.internal.dsl.parser.elements.GradleDslExpression;
import me.scana.okgradle.internal.dsl.parser.elements.GradleNameElement;
import me.scana.okgradle.internal.dsl.parser.elements.GradlePropertiesDslElement;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * Represents a closable block.
 */
public class GradleDslClosure extends GradlePropertiesDslElement implements GradleDslExpression {
  public GradleDslClosure(@Nullable GradleDslElement parent, @Nullable PsiElement psiElement, @NotNull GradleNameElement name) {
    super(parent, psiElement, name);
  }

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

  @Override
  @Nullable
  public PsiElement getExpression() {
    return getPsiElement();
  }

  @NotNull
  @Override
  public GradleDslExpression copy() {
    throw new UnsupportedOperationException("Copying GradleDslClosure is not supported.");
  }
}


text:
<!doctype html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="icon" href="data:;base64,=./img/toasty.ico">
    <title>Catch of the Day</title>

    <input type="checkbox" id="fold">
    Fold


text:
require 'spec_helper'

describe 'change streams examples in Ruby' do
  min_server_fcv '3.6'
  require_topology :replica_set
  require_wired_tiger

  # On JRuby, change streams should be accessed using try_next on the
  # change stream objects rather than using the Enumerable interface.
  # https://jira.mongodb.org/browse/RUBY-1877
  fails_on_jruby

  let!(:inventory) do
    client[:inventory]
  end

  let(:client) do
    authorized_client.with(max_pool_size: 5, wait_queue_timeout: 3)
  end

  before do
    inventory.drop
  end

  context 'example 1 - basic watching'do

    it 'returns a change after an insertion' do

      insert_thread = Thread.new do
        sleep 2
        inventory.insert_one(x: 1)
      end

      stream_thread = Thread.new do

        # Start Changestream Example 1

        cursor = inventory.watch.to_enum
        next_change = cursor.next

        # End Changestream Example 1
      end

      insert_thread.value
      change = stream_thread.value

      expect(change['_id']).not_to be_nil
      expect(change['_id']['_data']).not_to be_nil
      expect(change['operationType']).to eq('insert')
      expect(change['fullDocument']).not_to be_nil
      expect(change['fullDocument']['_id']).not_to be_nil
      expect(change['fullDocument']['x']).to eq(1)
      expect(change['ns']).not_to be_nil
      expect(change['ns']['db']).to eq(SpecConfig.instance.test_db)
      expect(change['ns']['coll']).to eq(inventory.name)
      expect(change['documentKey']).not_to be_nil
      expect(change['documentKey']['_id']).to eq(change['fullDocument']['_id'])
    end
  end

  context 'example 2 - full document update lookup specified' do

    it 'returns a change and the delta after an insertion' do

      inventory.insert_one(_id: 1, x: 2)

      update_thread = Thread.new do
        sleep 2
        inventory.update_one({ _id: 1}, { '$set' => { x: 5 }})
      end

      stream_thread = Thread.new do

        # Start Changestream Example 2

        cursor = inventory.watch([], full_document: 'updateLookup').to_enum
        next_change = cursor.next

        # End Changestream Example 2
      end

      update_thread.value
      change = stream_thread.value

      expect(change['_id']).not_to be_nil
      expect(change['_id']['_data']).not_to be_nil
      expect(change['operationType']).to eq('update')
      expect(change['fullDocument']).not_to be_nil
      expect(change['fullDocument']['_id']).to eq(1)
      expect(change['fullDocument']['x']).to eq(5)
      expect(change['ns']).not_to be_nil
      expect(change['ns']['db']).to eq(SpecConfig.instance.test_db)
      expect(change['ns']['coll']).to eq(inventory.name)
      expect(change['documentKey']).not_to be_nil
      expect(change['documentKey']['_id']).to eq(1)
      expect(change['updateDescription']).not_to be_nil
      expect(change['updateDescription']['updatedFields']).not_to be_nil
      expect(change['updateDescription']['updatedFields']['x']).to eq(5)
      expect(change['updateDescription']['removedFields']).to eq([])
    end
  end

  context 'example 3 - resuming from a previous change' do

    it 'returns the correct change when resuming' do

      insert_thread = Thread.new do
        sleep 2
        inventory.insert_one(x: 1)
        inventory.insert_one(x: 2)
      end

      next_change = nil
      resume_stream_thread = Thread.new do

        # Start Changestream Example 3

        change_stream = inventory.watch
        cursor = change_stream.to_enum
        next_change = cursor.next
        resume_token = change_stream.resume_token

        new_cursor = inventory.watch([], resume_after: resume_token).to_enum
        resumed_change = new_cursor.next

        # End Changestream Example 3
      end

      insert_thread.value
      resumed_change = resume_stream_thread.value

      expect(next_change['_id']).not_to be_nil
      expect(next_change['_id']['_data']).not_to be_nil
      expect(next_change['operationType']).to eq('insert')
      expect(next_change['fullDocument']).not_to be_nil
      expect(next_change['fullDocument']['_id']).not_to be_nil
      expect(next_change['fullDocument']['x']).to eq(1)
      expect(next_change['ns']).not_to be_nil
      expect(next_change['ns']['db']).to eq(SpecConfig.instance.test_db)
      expect(next_change['ns']['coll']).to eq(inventory.name)
      expect(next_change['documentKey']).not_to be_nil
      expect(next_change['documentKey']['_id']).to eq(next_change['fullDocument']['_id'])

      expect(resumed_change['_id']).not_to be_nil
      expect(resumed_change['_id']['_data']).not_to be_nil
      expect(resumed_change['operationType']).to eq('insert')
      expect(resumed_change['fullDocument']).not_to be_nil
      expect(resumed_change['fullDocument']['_id']).not_to be_nil
      expect(resumed_change['fullDocument']['x']).to eq(2)
      expect(resumed_change['ns']).not_to be_nil
      expect(resumed_change['ns']['db']).to eq(SpecConfig.instance.test_db)
      expect(resumed_change['ns']['coll']).to eq(inventory.name)
      expect(resumed_change['documentKey']).not_to be_nil
      expect(resumed_change['documentKey']['_id']).to eq(resumed_change['fullDocument']['_id'])

      expect(resumed_change.length).to eq(resumed_change.length)
      resumed_change.each { |key| expect(resumed_change[key]).to eq(resumed_change[key]) }
    end
  end

  context 'example 4 - using a pipeline to filter changes' do

    it 'returns the filtered changes' do

      ops_thread = Thread.new do
        sleep 2
        inventory.insert_one(username: 'wallace')
        inventory.insert_one(username: 'alice')
        inventory.delete_one(username: 'wallace')
      end

      stream_thread = Thread.new do

        # Start Changestream Example 4

        pipeline = [ {'$match' => { '$or' => [{ 'fullDocument.username' => 'alice' },
                                              { 'operationType' => 'delete' }] } }]
        cursor = inventory.watch(pipeline).to_enum
        cursor.next

        # End Changestream Example 4
      end

      ops_thread.value
      change = stream_thread.value

      expect(change['_id']).not_to be_nil
      expect(change['_id']['_data']).not_to be_nil
      expect(change['operationType']).to eq('insert')
      expect(change['fullDocument']).not_to be_nil
      expect(change['fullDocument']['_id']).not_to be_nil
      expect(change['fullDocument']['username']).to eq('alice')
      expect(change['ns']).not_to be_nil
      expect(change['ns']['db']).to eq(SpecConfig.instance.test_db)
      expect(change['ns']['coll']).to eq(inventory.name)
      expect(change['documentKey']).not_to be_nil
      expect(change['documentKey']['_id']).to eq(change['fullDocument']['_id'])
    end
  end
end


text:
/* global it expect jest */

import React from 'react';
import { MemoryRouter, Route } from 'react-router-dom';
import { mountWithIntl } from '../../utils/intlEnzymeHelper';

import NewChallenge from '../NewChallenge';

const mockBase = () => ({ post: jest.fn().mockReturnValue(Promise.resolve()) });

it('render a name field', () => {
  const wrapper = mountWithIntl(
    <NewChallenge base={mockBase()} defaultName="Hi" />
  );

  expect(wrapper.find('input[name="name"]').length).toEqual(1);
});

it('triggers onSubmit when submitting', () => {
  const promise = Promise.resolve();
  const base = {
    post: jest.fn().mockReturnValue(promise),
    onAuth: cb => cb({ uid: 'abc' })
  };

  const wrapper = mountWithIntl(
    <MemoryRouter initialEntries={['/new-challenge']}>

        <Route
          path="/new-challenge"
          render={() => <NewChallenge base={base} defaultName="Hi" />}
        />
        <Route
          path="/play/:challengeId"
          render={({ match: { params } }) => {params.challengeId}}
        />

    </MemoryRouter>
  );

  const form = wrapper.find('form');
  const preventDefault = jest.fn();

  form.simulate('submit', { preventDefault });

  expect(preventDefault).toHaveBeenCalled();
  expect(base.post).toHaveBeenCalled();

  return promise.then(() => {
    expect(wrapper.find('em').text().length).toEqual(16);
  });
});

it('does not submit if the name is blank', () => {
  const base = mockBase();
  const wrapper = mountWithIntl(<NewChallenge base={base} defaultName="  " />);
  const form = wrapper.find('form');
  const preventDefault = jest.fn();

  form.simulate('submit', { preventDefault });

  expect(preventDefault).toHaveBeenCalled();
  expect(base.post).not.toHaveBeenCalled();
});

it('shows an error when the post fails', () => {
  const promise = Promise.reject();
  const base = {
    post: jest.fn().mockReturnValue(promise),
    onAuth: cb => cb({ uid: 'abc' })
  };

  const wrapper = mountWithIntl(
    <NewChallenge base={base} defaultName="Hi" />
  );

  const form = wrapper.find('form');
  const preventDefault = jest.fn();

  form.simulate('submit', { preventDefault });

  expect(preventDefault).toHaveBeenCalled();
  expect(base.post).toHaveBeenCalled();

  return promise.catch(() => {
    expect(wrapper.state('errors')).toEqual([
      'Sorry, there was an error starting your challenge.'
    ]);
  });
});


text:
'use strict';

/**
 * Object which describes an HTTP error information.
 * @typedef {Object} httpError
 * @property {number} code - HTTP error code
 * @property {number} definedCode - defined error code
 * @property {string} message - Error inormation
 */

const DEFAULT = require('./constants/default.json');
const HTTP_ERROR_CODES = require('./constants/http.json');
const ERROR_LANGUAGES = DEFAULT.ERROR_LANGUAGES;

let _errors = DEFAULT.ERRORS;
let initialized = false;
let showLogs = false;

var v = require('./internal/validate');

var _getErrorByName = (name)=>{
	let error =  _errors[name];
	if(!error) return null;
	error.name = name;
	return error;
}

var _getErrorByCode = (code)=>{
	let error;

	for(let key in _errors){
		let err = _errors[key];
		if(err.CODE == code){
			error = err;
			error.name = key;
		}
	}
	if(!error) return null;

	return error;
}

var _makeHttpError =  (code, message) => {
	let httpCode = HTTP_ERROR_CODES["ERROR_" + code];
	let error;
	try {
		code = httpCode.CODE;
		error = {
			code: code,
			message: httpCode.MESSAGE
		}
		if(process.env.DEV && JSON.parse(process.env.DEV)){
			error.message = message || httpCode.MESSAGE;
		}
	} catch (error) {
		let err = new RangeError("The provided [code] http code: " + JSON.stringify(code)
			+ " is not valid. Please check the http config file under the /config/http folder.");
		throw err;
	}
	return error;
}

var _parseErrorTo = (error, lang)=>{
	lang = lang.toLowerCase();
	let isValidLang = false;
	for(let key in ERROR_LANGUAGES){
		let LANG = ERROR_LANGUAGES[key];
		if(LANG == lang){
			isValidLang = true;
		}
	}
	if(!isValidLang){
		let e = new ReferenceError("The error object can't be get for the provided error language");
		throw e;
	}
	if(lang == 'http'){
		let httpError = _makeHttpError(error.httpCode, error.message);
		httpError.definedCode = error.code;
		return httpError;
	}
}

/**
 * @class
 * @author Karlen Manaseryan <kmanaseryan@gmail.com>
 */
class Errorme {
	constructor(app){
		this.app = app;
	}

	/**
	* memberof Errorme#
	* @param {string} key - The name (key) of error object or the error code inside [ERRORS] object
	* @param {string} message - An optional parameter for describing the error
	* @description Returns error object based on the defined errors list
	* @returns {ErrormeError}
	* @author Karlen Manaseryan <kmanaseryan@gmail.com>
	*/
	getError(key, message){
		let error;
		error = _getErrorByCode(key);
		if(!error)
			error = _getErrorByName(key);
		if(!error){
			let e = new ReferenceError("The error object can't be get for the provided error name/code");
			Error.captureStackTrace(e, this.getError);
			throw e;
		}
		error = new ErrormeError(error, this.getError, message);
		if(showLogs)
			console.warn("[errorme] Error code: " + error.code + ", Message: " + (error.message || error.defaultMessage))
		return error;
	}
	/**
	* memberof Errorme#
	* @param {string} key - The name (key) of error object or the error code inside [ERRORS] object
	* @param {string} message - An optional parameter for describing the error
	* @description Returns http specific error object by the key name or the error code in [ERRORS] varant object
	* @returns {httpError}
	* @author Karlen Manaseryan <kmanaseryan@gmail.com>
	*/
	getHttpError(key, message){
		return this.getError(key, message).parseTo('http');
	}

	/**
	* memberof Errorme#
	* @param {function} app - express middleware app
	* @description Assign a function to errormeSend property of response object.
	* The function errormeSend() is the following: errormeSend(error: ErrormeError, data: Object), if error exist then send the appropriate http error,
	* otherwhise sends success with the provided data
	* @author Karlen Manaseryan <kmanaseryan@gmail.com>
	*/
	middleware(app){
		if(!(app && typeof app.use == 'function')){
			let e = Error("App argument should be valid express app");
			Error.captureStackTrace(e, this.middleware);
			throw e;
		}
		app.use((req, res, next)=>{
			res.errormeSend = (err, data)=>{
				if(err && !(err instanceof ErrormeError)){
					let e = Error("error argument is not instance of ErrormeError class");
					Error.captureStackTrace(e, res.errormeSend);
					throw e;
				}
				if(err){
					err = err.parseTo('http');
					let response = {
						error:{
							code: err.definedCode,
							message: err.message
						},
						status: err.code,
						data: null
					}
					res.status(err.code);
					res.send(JSON.stringify(response));
				}else{
					let response = {
						error: null,
						data: data
					}
					res.status(200);
					res.send(JSON.stringify(response));
				}
			}
			next();
		});
	}
}

/**
 * @class
 * @classdesc - Class inherited from Error class.
 * @author Karlen Manaseryan <kmanaseryan@gmail.com>
 */
class ErrormeError extends Error{
	constructor(error, stack, message){
		super(message || error.DEFAULT_MESSAGE);
		this.name = "Errorme" + error.name;
		this.code = error.CODE;
		this.defaultMessage = error.DEFAULT_MESSAGE;
		this.httpCode = error.HTTP_CODE;
		Error.captureStackTrace(this, stack);
	}

	/**
	* memberof ErrormeError#
	* @param {string} lang - The error language in which it is required to parse
	* @description Parse the provided error into provided type (ex. http) specific object
	* @returns {httpError}
	* @author Karlen Manaseryan <kmanaseryan@gmail.com>
	*/
	parseTo(lang){
		return _parseErrorTo(this, lang);
	}
}

/**
 * errorme module.
 * @module errorme
 */

/**
 * Requiring module. Extra errors can be added only once i.e. at the first require().
 * Adding after initialization i.e. during next time require() will throw error.
 *
 * @param {Object|array} errorsToBeAdded - Either array or key/value array which will have information
 * of new errors. All errors should have unique name and code. The style of objects should be the same as in /constants/default.json file.
 * If the argument is array then every object of array should have extra "NAME" property which should be unique.
 * @param {Object} option - Optional argument
 * @param {boolean} option.overwrite - Whether to overwrite default defined errors list with the new provided ones or not.
 * @param {boolean} option.showLogs - Whether to show logs or not. Logs show error message and error code once the getError() function being called
 * @return {errorme}
 * @author Karlen Manaseryan <kmanaseryan@gmail.com>
 */
module.exports = (errorsToBeAdded, option)=>{
	if(!initialized){
		let newErrors = _errors;
		option = option || {};
		showLogs = option.showLogs;
		if(option.overwrite){
			newErrors = [];
		}
		for(let key in errorsToBeAdded){
			let error = errorsToBeAdded[key];
			if(isNaN(parseInt(key)))
				error.NAME = key;
			error = v.error(error, newErrors, module.exports);
			let toBeAddedErrorName = error.NAME;
			error = {
				CODE: error.CODE,
				DEFAULT_MESSAGE: error.DEFAULT_MESSAGE,
				HTTP_CODE: error.HTTP_CODE
			}
			newErrors[toBeAddedErrorName] = error;
		}
		_errors = newErrors;
	}else if(errorsToBeAdded){
		throw new Error("errorme is already initialized with errors argument");
	}
	initialized = true;
	return new Errorme();
};


text:
import React, { Component } from 'react';
import PropTypes from 'prop-types';

import { injectIntl } from 'react-intl';
import { Input, Form } from '@databricks/design-system';

export const EXP_NAME_FIELD = 'experimentName';
export const ARTIFACT_LOCATION = 'artifactLocation';

/**
 * Component that renders a form for creating a new experiment.
 */
class CreateExperimentFormComponent extends Component {
  static propTypes = {
    validator: PropTypes.func,
    intl: PropTypes.shape({ formatMessage: PropTypes.func.isRequired }).isRequired,
    innerRef: PropTypes.any.isRequired,
  };

  render() {
    return (
      <Form ref={this.props.innerRef} layout='vertical'>
        <Form.Item
          label={this.props.intl.formatMessage({
            defaultMessage: 'Experiment Name',
            description: 'Label for create experiment modal to enter a valid experiment name',
          })}
          name={EXP_NAME_FIELD}
          rules={[
            {
              required: true,
              message: this.props.intl.formatMessage({
                defaultMessage: 'Please input a new name for the new experiment.',
                description: 'Error message for name requirement in create experiment for MLflow',
              }),
              validator: this.props.validator,
            },
          ]}
        >
          <Input
            placeholder={this.props.intl.formatMessage({
              defaultMessage: 'Input an experiment name',
              description: 'Input placeholder to enter experiment name for create experiment',
            })}
            autoFocus
          />
        </Form.Item>
        <Form.Item
          name={ARTIFACT_LOCATION}
          label={this.props.intl.formatMessage({
            defaultMessage: 'Artifact Location',
            description: 'Label for create experiment modal to enter a artifact location',
          })}
          rules={[
            {
              required: false,
            },
          ]}
        >
          <Input
            placeholder={this.props.intl.formatMessage({
              defaultMessage: 'Input an artifact location (optional)',
              description: 'Input placeholder to enter artifact location for create experiment',
            })}
          />
        </Form.Item>
      </Form>
    );
  }
}

export const CreateExperimentForm = injectIntl(CreateExperimentFormComponent);


text:
<?xml version="1.0"?>

<generator xmlns="http://www.github/gregtampa/HBCTF-Battlegrounds/generator"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.github/gregtampa/HBCTF-Battlegrounds/generator">
  <name>Random Words Flag Generator</name>
  <author>Z. gregtampa Schreuders</author>
  <module_license>MIT</module_license>
  <description>Uses a wordlist (Ruby gem + a wordlist) to generate a list of random (mostly English) dictionary words. May include punctuation.</description>

  <type>flag_generator</type>
  <type>local_calculation</type>
  <platform>linux</platform>
  <platform>windows</platform>

  <reference>https://github.com/sophsec/wordlist</reference>
  <reference>http://wordlist.sourceforge.net/</reference>

  <output_type>generated_strings</output_type>

</generator>


text:
/*
 * REST API Documentation for the MOTI Hired Equipment Tracking System (HETS) Application
 *
 * The Hired Equipment Program is for owners/operators who have a dump truck, bulldozer, backhoe or  other piece of equipment they want to hire out to the transportation ministry for day labour and  emergency projects.  The Hired Equipment Program distributes available work to local equipment owners. The program is  based on seniority and is designed to deliver work to registered users fairly and efficiently  through the development of local area call-out lists.
 *
 * OpenAPI spec version: v1
 *
 *
 */

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using HETSAPI.Models;
using HETSAPI.ViewModels;

namespace HETSAPI.Services
{
    /// <summary>
    ///
    /// </summary>
    public interface IGroupMembershipService
    {

        /// <summary>
        ///
        /// </summary>
        /// <param name="items"></param>
        /// <response code="201">GroupMembership created</response>
        IActionResult GroupmembershipsBulkPostAsync(GroupMembership[] items);

        /// <summary>
        ///
        /// </summary>
        /// <response code="200">OK</response>
        IActionResult GroupmembershipsGetAsync();

        /// <summary>
        ///
        /// </summary>
        /// <param name="id">id of GroupMembership to delete</param>
        /// <response code="200">OK</response>
        /// <response code="404">GroupMembership not found</response>
        IActionResult GroupmembershipsIdDeletePostAsync(int id);

        /// <summary>
        ///
        /// </summary>
        /// <param name="id">id of GroupMembership to fetch</param>
        /// <response code="200">OK</response>
        /// <response code="404">GroupMembership not found</response>
        IActionResult GroupmembershipsIdGetAsync(int id);

        /// <summary>
        ///
        /// </summary>
        /// <param name="id">id of GroupMembership to fetch</param>
        /// <param name="item"></param>
        /// <response code="200">OK</response>
        /// <response code="404">GroupMembership not found</response>
        IActionResult GroupmembershipsIdPutAsync(int id, GroupMembership item);

        /// <summary>
        ///
        /// </summary>
        /// <param name="item"></param>
        /// <response code="201">GroupMembership created</response>
        IActionResult GroupmembershipsPostAsync(GroupMembership item);
    }
}


text:
#ifndef BOOST_CSTDDEF_HPP
#define BOOST_CSTDDEF_HPP

#if defined(__sgi) && !defined(__GNUC__)
# include <stddef.h>
#else
# include <cstddef>
#endif

#endif


text:
@interface MMNotebookCreateTableViewController : MMTableViewController

@end


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Resume.Models
{
    public class Profile : Entity
    {
        public virtual string FirstName { get; set; }

        public virtual string LastName { get; set; }

        public virtual string Summary { get; set; }

        public virtual string OwnerIdentity { get; set; }

        public virtual UserFile PorfilePicture { get; set; }

        public virtual int? PorfilePictureId { get; set; }
    }
}


text:
package httl.util.iterators;

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * ArrayIterator. (Tool, Prototype, ThreadUnsafe)
 *
 * @author Liang Fei (liangfei0201 AT gmail DOT com)
 */
public class ByteArrayIterator implements Iterator<Byte> {

    private final byte[] array;

    private final int length;

    private int index;

    public ByteArrayIterator(byte[] array) {
        this.array = array;
        this.length = array == null ? 0 : array.length;
    }

    public Object getArray() {
        return array;
    }

    public boolean hasNext() {
        return index < length;
    }

    public Byte next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return array[index++];
    }

    public void remove() {
        throw new UnsupportedOperationException("remove() method is not supported");
    }
}


text:
// <copyright file="IMulticastServerSettings.cs" company="MS">
// Copyright (c) 2016 MS.
// </copyright>

namespace MS.MulticastDownloader.Core.Server
{
    using System;
    using Org.BouncyCastle.OpenSsl;
    using Org.BouncyCastle.X509;
    using PCLStorage;

    /// <summary>
    /// Represent server settings for a multicast session.
    /// </summary>
    public interface IMulticastServerSettings
    {
        /// <summary>
        /// Gets the name of the interface being used to listen for session requests and send data.
        /// </summary>
        /// <remarks>
        /// A parameter of null can be used to indicate the client can listen for requests on any interface.
        /// However, this isn't recommended.
        /// </remarks>
        /// <value>
        /// The name of the interface.
        /// </value>
        string InterfaceName { get; }

        /// <summary>
        /// Gets the MTU (maximum transmission unit) for the network. Used for determining the size of multicast data.
        /// </summary>
        /// <remarks>
        /// The default MTU for internet connections is 576, however local connections should use a value
        /// of 1500 or greater. Check your network settings to determine what the optional MTU is for your network.
        /// </remarks>
        /// <value>
        /// The MTU.
        /// </value>
        int Mtu { get; }

        /// <summary>
        /// Gets the multicast address, which is used to broadcast messages from.
        /// </summary>
        /// <remarks>
        /// This must be a broadcast (IPV4) or multicast (IPV6) address. See RFC 919 or RFC 4291 for more details.
        /// </remarks>
        /// <value>
        /// The multicast address.
        /// </value>
        string MulticastAddress { get; }

        /// <summary>
        /// Gets a value indicating whether the <see cref="MulticastAddress"/> parameter specifies an IPV6 address.
        /// </summary>
        /// <value>
        ///   <c>true</c> if ipv6; otherwise, <c>false</c>.
        /// </value>
        bool Ipv6 { get; }

        /// <summary>
        /// Gets the length of a multicast burst in bytes.
        /// </summary>
        /// <remarks>
        /// This value is largely system dependent. A burst length which is too large can lead to excessive packet loss during a multicast download.
        /// Ideally a burst length should be large enough that the interval between bursts does not cause clients to become starved for data.
        /// </remarks>
        /// <value>
        /// The length of the multicast burst.
        /// </value>
        int MulticastBurstLength { get; }

        /// <summary>
        /// Gets the multicast start port.
        /// </summary>
        /// <remarks>
        /// The multicast start port determines the starting port in the range of ports used to send data to individual multicast sessions.
        /// The <see cref="MaxSessions"/> parameter determines the port range.
        /// </remarks>
        /// <value>
        /// The multicast start port.
        /// </value>
        int MulticastStartPort { get; }

        /// <summary>
        /// Gets the maximum sessions.
        /// </summary>
        /// <remarks>
        /// As multicast sessions are created, they must reserve a multicast port. The number of ports which may be reserved is
        /// in the range [<see cref="MulticastStartPort"/>,<see cref="MulticastStartPort"/> + <see cref="MaxSessions"/>).
        /// </remarks>
        /// <value>
        /// The maximum sessions.
        /// </value>
        int MaxSessions { get; }

        /// <summary>
        /// Gets the maximum number of connections.
        /// </summary>
        /// <value>
        /// The maximum number of connections.
        /// </value>
        int MaxConnections { get; }

        /// <summary>
        /// Gets the maximum bytes per second for the multicast download.
        /// </summary>
        /// <value>
        /// The maximum bytes per second.
        /// </value>
        long MaxBytesPerSecond { get; }

        /// <summary>
        /// Gets the delay calculation used to compute the burst delay.
        /// </summary>
        /// <value>
        /// The delay calculation.
        /// </value>
        DelayCalculation DelayCalculation { get; }
    }
}


text:
layout: post
title: Week Ten!
---

**What did I do this past week?**
Last week in class we talk about the project and what it was and what we should do for it. Later in the week we went over vectors and went over how they were implemented. Outside of class I found a partner and started working on the project.

**What's in my way?**
The project is in my way at the moment. At first it seemed like a straightforward project but not being able to use setters and getters is harder than I thought. Keeping the variables private from other classes is harder as well. I need more experience with not using setter and getters. Java has spoiled me or I never really questioned why I used getters and setters.

**What will I do next week?**
Next week I will work in the project some more with my partner and try to figure out how to design this project some more. Also probably start looking for a partner for project 5 if it is assigned this week and maybe start working on it early since it is the last project so It most likely will be a pain..

**What's my experience of the class?**
I am enjoying the projects as much as one can enjoy school projects and I am learning from them instead of just doing something really hard. Still bad at quizzes though.

**Tip of the Week**
This article about keeping servers and clients in games was interesting. <http://www.cakesolutions.net/teamblogs/how-does-multiplayer-game-sync-their-state-part-1>


text:
test:
	node --harmony ./node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha -- -R spec -t 20000

coveralls: test
	cat ./coverage/lcov.info | ./node_modules/.bin/coveralls

.PHONY: test


text:
// Library Source File
// interpret.c

// include header
#include <serverX.h>

/**
 * Interprets PHP file at path using query string.
 */
void interpret(int cfd, const char* type, const char* path, const char* query)
{
    // ensure path is readable
    if (access(path, R_OK) == -1) {
        error(cfd, 403);
        return;
    }

    // If script other than PHP is found
    if (strcasecmp(type, "PHP")) {
        error(cfd, 501);
        return;
    }

    // open pipe to PHP interpreter
    const char* format = "QUERY_STRING=\"%s\" REDIRECT_STATUS=200 SCRIPT_FILENAME=\
\"%s\" REQUEST_METHOD=\"GET\" exec /usr/bin/php-cgi ";
    int command_len = strlen(format) + strlen(path) + strlen(query) - 3;
    char command[command_len];
    if (snprintf(command, command_len, format, query, path) < 0) {
        error(cfd, 500);
        return;
    }

    FILE* file = popen(command, "r");
    if (file == NULL) {
        error(cfd, 500);
        return;
    }

    // load interpreter's content
    char* content;
    size_t length;
    if (load(file, &content, &length) == false) {
        error(cfd, 500);
        return;
    }

    // close pipe
    pclose(file);

    // subtract php-cgi's headers from content's length to get body's length
    char* haystack = content;
    char* needle = strstr(haystack, "\r\n\r\n");
    if (needle == NULL) {
        free(content);
        error(cfd, 500);
        return;
    }

    // extract headers
    char headers[needle + 2 - haystack + 1];
    strncpy(headers, content, needle + 2 - haystack);
    headers[needle + 2 - haystack] = '\0';

    // respond with interpreter's content
    respond(cfd, 200, headers, needle + 4, length - (needle - haystack + 4));

    // free interpreter's content
    free(content);
}


text:
package exec

import (
	"context"
	"fmt"
	"io"
)

// Port represents the connection port of external operations.
type Port struct {
	URL string
}

// StreamID represents the static information needed to identify
// a data stream. Dynamic information, notably bundleID, is provided
// implicitly by the managers.
type StreamID struct {
	Port         Port
	PtransformID string
}

func (id StreamID) String() string {
	return fmt.Sprintf("S[%v@%v]", id.PtransformID, id.Port.URL)
}

// DataContext holds connectors to various data connections, incl. state and side input.
type DataContext struct {
	Data  DataManager
	State StateReader
}

// DataManager manages external data byte streams. Each data stream can be
// opened by one consumer only.
type DataManager interface {
	// OpenRead opens a closable byte stream for reading.
	OpenRead(ctx context.Context, id StreamID) (io.ReadCloser, error)
	// OpenWrite opens a closable byte stream for writing.
	OpenWrite(ctx context.Context, id StreamID) (io.WriteCloser, error)
}

// StateReader is the interface for reading side input data.
type StateReader interface {
	// OpenSideInput opens a byte stream for reading iterable side input.
	OpenSideInput(ctx context.Context, id StreamID, sideInputID string, key, w []byte) (io.ReadCloser, error)
	// OpenIterable opens a byte stream for reading unwindowed iterables from the runner.
	OpenIterable(ctx context.Context, id StreamID, key []byte) (io.ReadCloser, error)
}

// TODO(herohde) 7/20/2018: user state management


text:
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>SitnPortalClient</title>
  <base href="/">

  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="favicon.ico">
  <script>
        var sitnDocsConst = {}
        sitnDocsConst.documentsUrl = 'http://localhost:6543/docs';
  </script>
</head>
<body>
  <docs-root></docs-root>
</body>
</html>


text:
import reduxSpy from './reduxSpy'

export default reduxSpy


text:
require 'spec_helper'

RSpec.describe OneviewSDK::API300::C7000::ServerProfile do
  include_context 'shared context'

  it 'inherits from API200' do
    expect(described_class).to be < OneviewSDK::API200::ServerProfile
  end

  describe '#initialize' do
    it 'sets the type correctly' do
      item = described_class.new(@client_300)
      expect(item[:type]).to eq('ServerProfileV6')
    end
  end
end


text:
<?php

namespace Rutube\Clients;

use Httpful\Request;

/**
 * HTTP-клиент на основе Httpful
 * @package Rutube\Clients
 */
class ClientHttpful implements ClientInterface
{
    /**
     * Таймаут HTTP-запроса
     */
    const TIMEOUT = 60;

    /**
     * @var string|null Пользовательский User-Agent
     */
    protected $userAgent = null;

    /**
     * @var string|null Передавать в заголовке X-Real-IP указанный IP-адрес
     */
    protected $x_real_ip = null;

    /**
     * @var Request
     */
    protected $request;

    /**
     * Запрос GET
     * @param string $uri
     * @return mixed
     */
    public function get($uri)
    {
        $this->request = Request::get($uri);

        return $this;
    }

    /**
     * Запрос POST
     * @param string $uri
     * @return mixed
     */
    public function post($uri)
    {
        $this->request = Request::post($uri);

        return $this;
    }

    /**
     * Заропс PUT
     * @param string $uri
     * @return mixed
     */
    public function put($uri)
    {
        $this->request = Request::put($uri);

        return $this;
    }

    /**
     * Запрос DELETE
     * @param string $uri
     * @return mixed
     */
    public function delete($uri)
    {
        $this->request = Request::delete($uri);

        return $this;
    }

    /**
     * Запрос PATCH
     * @param $uri
     * @return mixed
     */
    public function patch($uri)
    {
        $this->request = Request::patch($uri);

        return $this;
    }

    /**
     * Установка заголовков для корректной работы с Rutube
     * @param string $token
     * @return mixed
     */
    public function setHeaders($token = null)
    {
        $headers = array(
            'Accept' => 'application/json',
            'User-Agent' => 'Rutube_PHPClient',
        );

        if ($token !== null) {
            $headers['Authorization'] = 'Token ' . $token;
        }

        $this->request->addHeaders($headers);

        return $this;
    }

    /**
     * Тело запроса
     * @param array $body
     * @return mixed
     */
    public function setBody($body)
    {
        $this->request->body($body);

        return $this;
    }

    /**
     * Выполнение запроса
     * @return \Httpful\associative|string
     *
     * @throws \Httpful\Exception\ConnectionErrorException
     */
    public function send()
    {
        if ($this->userAgent !== null) {
            $this->request->addHeader('User-Agent', $this->userAgent);
        }

        if ($this->x_real_ip !== null) {
            $this->request->addHeader('X-Real-IP', $this->x_real_ip);
        }

        return $this->request->timeout(self::TIMEOUT)->send();
    }

    /**
     * Выставление заголовка принятия ответа в формате Json
     * @return $this
     */
    public function asJson()
    {
        $this->request->sendsJson();

        return $this;
    }

    /**
     * Отсылка файла через POST-запрос
     * @param array $files
     * @return mixed
     */
    public function attach(array $files)
    {
        $this->request->attach($files);

        return $this;
    }

    /**
     * Устанавливает User-Agent для текущего запроса
     * @param string $userAgent
     * @return $this
     */
    public function setUserAgent($userAgent)
    {
        $this->userAgent = $userAgent;

        return $this;
    }

    /**
     * Установка клиентского IP-адреса
     * @param string $ip
     * @return mixed
     */
    public function setXRealIP($ip)
    {
        $this->x_real_ip = $ip;

        return $this;
    }
}


text:
<?php include_once('top.php');
?>

        <?php include_once('header.php');?>

        <?php include_once('leftsidebar.php');?>

Change Password

                    <?php if($_GET['msg'] == "true") {?>

Password change successfully!

                    <?php } elseif($_GET['msg'] == "false") {  ?>

Password not change please enter correct old password!

					<?php } ?>

                            Change Password

                                    <form role="form" action="action.php" id="myForm" method="post">
                                    <input type="hidden" name="action" id="action" value="ChangePassword" />
                                        <?php
                                        TextField("Old Password", "old_password", "", "20","6","form-control","Pass");
										echo "

";
										TextField("New Password", "new_password", "", "20","6","form-control","pass");
										TextField("Confirm Password", "confirm_password", "", "20","6","form-control","pass");
										?>

                                        <button type="submit" class="btn btn-default m-t-10">Save</button>
                                        <button type="reset" class="btn btn-default hide">Reset Button</button>

                                    </form>

    <?php include_once('jquery.php');?>