text:
<?php

/**
 * This code was generated by
 * \ / _    _  _|   _  _
 * | (_)\/(_)(_|\/| |(/_  v1.0.0
 * /       /
 */

namespace Twilio\Rest\Video\V1;

use Twilio\Options;
use Twilio\Values;

/**
 * PLEASE NOTE that this class contains preview products that are subject to change. Use them with caution. If you currently do not have developer preview access, please contact help@twilio.com.
 */
abstract class CompositionOptions {
    /**
     * @param string $status The status
     * @param \DateTime $dateCreatedAfter The date_created_after
     * @param \DateTime $dateCreatedBefore The date_created_before
     * @param string $roomSid The room_sid
     * @return ReadCompositionOptions Options builder
     */
    public static function read($status = Values::NONE, $dateCreatedAfter = Values::NONE, $dateCreatedBefore = Values::NONE, $roomSid = Values::NONE) {
        return new ReadCompositionOptions($status, $dateCreatedAfter, $dateCreatedBefore, $roomSid);
    }

    /**
     * @param string $audioSources The audio_sources
     * @param string $videoSources The video_sources
     * @param string $videoLayout The video_layout
     * @param string $resolution The resolution
     * @param string $format The format
     * @param integer $desiredBitrate The desired_bitrate
     * @param integer $desiredMaxDuration The desired_max_duration
     * @param string $statusCallback The status_callback
     * @param string $statusCallbackMethod The status_callback_method
     * @param boolean $trim The trim
     * @param boolean $reuse The reuse
     * @return CreateCompositionOptions Options builder
     */
    public static function create($audioSources = Values::NONE, $videoSources = Values::NONE, $videoLayout = Values::NONE, $resolution = Values::NONE, $format = Values::NONE, $desiredBitrate = Values::NONE, $desiredMaxDuration = Values::NONE, $statusCallback = Values::NONE, $statusCallbackMethod = Values::NONE, $trim = Values::NONE, $reuse = Values::NONE) {
        return new CreateCompositionOptions($audioSources, $videoSources, $videoLayout, $resolution, $format, $desiredBitrate, $desiredMaxDuration, $statusCallback, $statusCallbackMethod, $trim, $reuse);
    }
}

class ReadCompositionOptions extends Options {
    /**
     * @param string $status The status
     * @param \DateTime $dateCreatedAfter The date_created_after
     * @param \DateTime $dateCreatedBefore The date_created_before
     * @param string $roomSid The room_sid
     */
    public function __construct($status = Values::NONE, $dateCreatedAfter = Values::NONE, $dateCreatedBefore = Values::NONE, $roomSid = Values::NONE) {
        $this->options['status'] = $status;
        $this->options['dateCreatedAfter'] = $dateCreatedAfter;
        $this->options['dateCreatedBefore'] = $dateCreatedBefore;
        $this->options['roomSid'] = $roomSid;
    }

    /**
     * The status
     *
     * @param string $status The status
     * @return $this Fluent Builder
     */
    public function setStatus($status) {
        $this->options['status'] = $status;
        return $this;
    }

    /**
     * The date_created_after
     *
     * @param \DateTime $dateCreatedAfter The date_created_after
     * @return $this Fluent Builder
     */
    public function setDateCreatedAfter($dateCreatedAfter) {
        $this->options['dateCreatedAfter'] = $dateCreatedAfter;
        return $this;
    }

    /**
     * The date_created_before
     *
     * @param \DateTime $dateCreatedBefore The date_created_before
     * @return $this Fluent Builder
     */
    public function setDateCreatedBefore($dateCreatedBefore) {
        $this->options['dateCreatedBefore'] = $dateCreatedBefore;
        return $this;
    }

    /**
     * The room_sid
     *
     * @param string $roomSid The room_sid
     * @return $this Fluent Builder
     */
    public function setRoomSid($roomSid) {
        $this->options['roomSid'] = $roomSid;
        return $this;
    }

    /**
     * Provide a friendly representation
     *
     * @return string Machine friendly representation
     */
    public function __toString() {
        $options = array();
        foreach ($this->options as $key => $value) {
            if ($value != Values::NONE) {
                $options[] = "$key=$value";
            }
        }
        return '[Twilio.Video.V1.ReadCompositionOptions ' . implode(' ', $options) . ']';
    }
}

class CreateCompositionOptions extends Options {
    /**
     * @param string $audioSources The audio_sources
     * @param string $videoSources The video_sources
     * @param string $videoLayout The video_layout
     * @param string $resolution The resolution
     * @param string $format The format
     * @param integer $desiredBitrate The desired_bitrate
     * @param integer $desiredMaxDuration The desired_max_duration
     * @param string $statusCallback The status_callback
     * @param string $statusCallbackMethod The status_callback_method
     * @param boolean $trim The trim
     * @param boolean $reuse The reuse
     */
    public function __construct($audioSources = Values::NONE, $videoSources = Values::NONE, $videoLayout = Values::NONE, $resolution = Values::NONE, $format = Values::NONE, $desiredBitrate = Values::NONE, $desiredMaxDuration = Values::NONE, $statusCallback = Values::NONE, $statusCallbackMethod = Values::NONE, $trim = Values::NONE, $reuse = Values::NONE) {
        $this->options['audioSources'] = $audioSources;
        $this->options['videoSources'] = $videoSources;
        $this->options['videoLayout'] = $videoLayout;
        $this->options['resolution'] = $resolution;
        $this->options['format'] = $format;
        $this->options['desiredBitrate'] = $desiredBitrate;
        $this->options['desiredMaxDuration'] = $desiredMaxDuration;
        $this->options['statusCallback'] = $statusCallback;
        $this->options['statusCallbackMethod'] = $statusCallbackMethod;
        $this->options['trim'] = $trim;
        $this->options['reuse'] = $reuse;
    }

    /**
     * The audio_sources
     *
     * @param string $audioSources The audio_sources
     * @return $this Fluent Builder
     */
    public function setAudioSources($audioSources) {
        $this->options['audioSources'] = $audioSources;
        return $this;
    }

    /**
     * The video_sources
     *
     * @param string $videoSources The video_sources
     * @return $this Fluent Builder
     */
    public function setVideoSources($videoSources) {
        $this->options['videoSources'] = $videoSources;
        return $this;
    }

    /**
     * The video_layout
     *
     * @param string $videoLayout The video_layout
     * @return $this Fluent Builder
     */
    public function setVideoLayout($videoLayout) {
        $this->options['videoLayout'] = $videoLayout;
        return $this;
    }

    /**
     * The resolution
     *
     * @param string $resolution The resolution
     * @return $this Fluent Builder
     */
    public function setResolution($resolution) {
        $this->options['resolution'] = $resolution;
        return $this;
    }

    /**
     * The format
     *
     * @param string $format The format
     * @return $this Fluent Builder
     */
    public function setFormat($format) {
        $this->options['format'] = $format;
        return $this;
    }

    /**
     * The desired_bitrate
     *
     * @param integer $desiredBitrate The desired_bitrate
     * @return $this Fluent Builder
     */
    public function setDesiredBitrate($desiredBitrate) {
        $this->options['desiredBitrate'] = $desiredBitrate;
        return $this;
    }

    /**
     * The desired_max_duration
     *
     * @param integer $desiredMaxDuration The desired_max_duration
     * @return $this Fluent Builder
     */
    public function setDesiredMaxDuration($desiredMaxDuration) {
        $this->options['desiredMaxDuration'] = $desiredMaxDuration;
        return $this;
    }

    /**
     * The status_callback
     *
     * @param string $statusCallback The status_callback
     * @return $this Fluent Builder
     */
    public function setStatusCallback($statusCallback) {
        $this->options['statusCallback'] = $statusCallback;
        return $this;
    }

    /**
     * The status_callback_method
     *
     * @param string $statusCallbackMethod The status_callback_method
     * @return $this Fluent Builder
     */
    public function setStatusCallbackMethod($statusCallbackMethod) {
        $this->options['statusCallbackMethod'] = $statusCallbackMethod;
        return $this;
    }

    /**
     * The trim
     *
     * @param boolean $trim The trim
     * @return $this Fluent Builder
     */
    public function setTrim($trim) {
        $this->options['trim'] = $trim;
        return $this;
    }

    /**
     * The reuse
     *
     * @param boolean $reuse The reuse
     * @return $this Fluent Builder
     */
    public function setReuse($reuse) {
        $this->options['reuse'] = $reuse;
        return $this;
    }

    /**
     * Provide a friendly representation
     *
     * @return string Machine friendly representation
     */
    public function __toString() {
        $options = array();
        foreach ($this->options as $key => $value) {
            if ($value != Values::NONE) {
                $options[] = "$key=$value";
            }
        }
        return '[Twilio.Video.V1.CreateCompositionOptions ' . implode(' ', $options) . ']';
    }
}


text:
/*
 * Created on Mar 15, 2005
 */
package gov.nasa.arc.spife.ui.timeline.part;

import gov.nasa.arc.spife.timeline.provider.TreeTimelineContentProvider;
import gov.nasa.arc.spife.ui.timeline.Timeline;
import gov.nasa.arc.spife.ui.timeline.TimelineViewer;
import gov.nasa.arc.spife.ui.timeline.model.ExpansionModel;
import gov.nasa.arc.spife.ui.timeline.model.TimelineMarkerManager;
import gov.nasa.arc.spife.ui.timeline.preference.TimelinePreferencePage;
import gov.nasa.arc.spife.ui.timeline.util.TimelineUtils;
import gov.nasa.ensemble.common.CommonUtils;
import gov.nasa.ensemble.common.ui.color.ColorMap;
import gov.nasa.ensemble.common.ui.color.ColorUtils;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.Layer;
import org.eclipse.draw2d.LayeredPane;
import org.eclipse.draw2d.LayoutAnimator;
import org.eclipse.draw2d.LineBorder;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.XYLayout;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPolicy;
import org.eclipse.jface.resource.StringConverter;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;

public class TreeTimelineDataEditPart<T> extends AbstractTimelineDataEditPart<T> implements IPropertyChangeListener {

	public static final String LAYER_DATA_ROWS_LAYER = "Data Rows Layer";

	private Color alternatingColor;
	private Color alternatingBorderColor;
	private Color horizontalLineColor;
	private boolean isHorizontalLinesHidden;

	private Listener listener = new Listener();

    public TreeTimelineDataEditPart() {
		createAlternatingColors();
		createHorizontalLineColor();
		setHideHorizontalLinesCheck();
	}

	@Override
	protected List getModelChildren() {
		List<Object> children = new ArrayList<Object>();
		children.addAll(getModelChildren(getModel()));
		if (children.size() == 0) {
			children.add(getModel());
		}
		TimelineMarkerManager markerManager = CommonUtils.getAdapter(getViewer(), TimelineMarkerManager.class);
		if (markerManager != null) {
			children.add(markerManager);
		}
		return children;
	}

	private Collection<? extends Object> getModelChildren(Object model) {
		return TimelineUtils.getModelChildren(getViewer(), this, model);
	}

	@Override
	protected void registerModel() {
		TimelineUtils.registerAsList(this);
	}

	@Override
	protected void unregisterModel() {
		TimelineUtils.unregisterAsList(this);
	}

	@Override
	protected void createLayers(LayeredPane layeredPane) {
		Layer rowsLayer = new Layer();
		rowsLayer.setLayoutManager(new XYLayout());
		rowsLayer.setOpaque(false);
		layeredPane.add(rowsLayer, LAYER_DATA_ROWS_LAYER);
		getViewer().registerLayer(LAYER_DATA_ROWS_LAYER, rowsLayer);
		super.createLayers(layeredPane);
	}

	/**
	 * Upon activation, attach to the model element as a property change listener.
	 */
	@Override
	public void activate() {
		if (!isActive()) {
			super.activate();
			TIMELINE_PREFERENCES.addPropertyChangeListener(this);
			TimelineViewer viewer = getViewer();
			viewer.addPropertyChangeListener(listener);
			if (viewer.isAnimated()) {
				figure.addLayoutListener(LayoutAnimator.getDefault());
			}
			ExpansionModel expansion = (ExpansionModel) getViewer().getProperty(ExpansionModel.ID);
			if (expansion != null) {
				expansion.addPropertyChangeListener(listener);
			}
			TreeTimelineContentProvider cp = getViewer().getTreeTimelineContentProvider();
			if (cp != null) {
				cp.addListener(listener);
			}
			refreshVisuals();
		}
	}

	/**
	 * Upon deactivation, detach from the model element as a property change listener.
	 */
	@Override
	public void deactivate() {
		if (isActive()) {
			TIMELINE_PREFERENCES.removePropertyChangeListener(this);
			TimelineViewer viewer = getViewer();
			viewer.removePropertyChangeListener(listener);
			if (viewer.isAnimated()) {
				figure.removeLayoutListener(LayoutAnimator.getDefault());
			}
			ExpansionModel expansion = (ExpansionModel) getViewer().getProperty(ExpansionModel.ID);
			if (expansion != null) {
				expansion.removePropertyChangeListener(listener);
			}
			if (alternatingColor != null) {
				//alternatingColor.dispose();
				alternatingColor = null;
			}
			if (alternatingBorderColor != null) {
				alternatingBorderColor = null;
			}
			if (horizontalLineColor != null) {
				horizontalLineColor = null;
			}
			TreeTimelineContentProvider cp = getViewer().getTreeTimelineContentProvider();
			if (cp != null) {
				cp.removeListener(listener);
			}
			super.deactivate();
		}
	}

	@Override
	protected Layer createPrimaryFigure() {
		Layer primaryLayer = new Layer();
		primaryLayer.setOpaque(false);
		primaryLayer.setLayoutManager(new ToolbarLayout(false));
		primaryLayer.setBackgroundColor(ColorConstants.white);
		return primaryLayer;
	}

	@Override
	public IFigure getContentPane() {
		return getLayer(LAYER_DATA_PRIMARY_LAYER);
	}

	@Override
	protected void createEditPolicies() {
		super.createEditPolicies();
		installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, null);
	}

	private void createAlternatingColors() {
		alternatingColor = ColorMap.RGB_INSTANCE.getColor(StringConverter.asRGB(TIMELINE_PREFERENCES.getString(TimelinePreferencePage.P_ALTERNATING_COLOR)));

		final RGB rgbBase = alternatingColor.getRGB();
		final float hsb[] = ColorUtils.getHSB(rgbBase);
		final float h = hsb[0];
		final float s = hsb[1];
		final float b = hsb[2];
		alternatingBorderColor = ColorMap.RGB_INSTANCE.getColor(new RGB(h, s, b*0.8f));
	}

	private void createHorizontalLineColor() {
		horizontalLineColor = ColorMap.RGB_INSTANCE.getColor(StringConverter.asRGB(TIMELINE_PREFERENCES.getString(TimelinePreferencePage.P_HORIZONTAL_LINES_COLOR)));
	}

	private void setHideHorizontalLinesCheck() {
		isHorizontalLinesHidden = TIMELINE_PREFERENCES.getBoolean(TimelinePreferencePage.P_HORIZONTAL_LINES_HIDE);
	}

	@Override
	protected void refreshVisuals() {
		updateChildVisuals(0);
		super.refreshVisuals();
	}

	@Override
	protected void addChildVisual(EditPart childEditPart, int index) {
		super.addChildVisual(childEditPart, index);
		updateChildVisuals(index);
	}

	@Override
	protected void removeChildVisual(EditPart childEditPart) {
		super.removeChildVisual(childEditPart);
		int index = getContentPane().getChildren().indexOf(childEditPart);
		if (index == -1) {
			index = 0;
		}
		updateChildVisuals(index);
	}

	private void updateChildVisuals(int index) {
		List children = getContentPane().getChildren();
		for (int i=index; i<children.size(); i++) {
			IFigure child = (IFigure) children.get(i);
			if (i%2 == 0) child.setBackgroundColor(ColorConstants.white);
			else		  child.setBackgroundColor(alternatingColor);
			child.setBorder(new LineBorder(alternatingBorderColor, 1) {

				@Override
				public void paint(IFigure figure, Graphics graphics, Insets insets) {
					tempRect.setBounds(getPaintRectangle(figure, insets));
					if (getWidth() % 2 == 1) {
						tempRect.width--;
						tempRect.height--;
					}
					tempRect.shrink(getWidth() / 2, getWidth() / 2);
					graphics.setLineWidth(getWidth());
					// Set the timeline horizontal line color
					if(horizontalLineColor != null) {
						graphics.setForegroundColor(horizontalLineColor);
						graphics.setBackgroundColor(horizontalLineColor);
					}
					else if (getColor() != null) {
						graphics.setForegroundColor(getColor());
						graphics.setBackgroundColor(getColor());
					}
					if(!isHorizontalLinesHidden) {
						// The timeline horizontal grid line
						graphics.drawLine(tempRect.getBottomLeft(), tempRect.getBottomRight());
					}
				}

			});
		}
	}

	@Override
	public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) {
		if (event.getProperty().equals(TimelinePreferencePage.P_ALTERNATING_COLOR)) {
			createAlternatingColors();
			refreshVisuals();
		}
		else if (event.getProperty().equals(TimelinePreferencePage.P_HORIZONTAL_LINES_COLOR)) {
			createHorizontalLineColor();
			refreshVisuals();
		}
		else if (event.getProperty().equals(TimelinePreferencePage.P_HORIZONTAL_LINES_HIDE)) {
			setHideHorizontalLinesCheck();
			refreshVisuals();
		}
		else if (event.getProperty().equals(TimelinePreferencePage.P_VERTICAL_LINES_COLOR)) {
			refreshVisuals();
		}
	}

	private class Listener implements PropertyChangeListener, TreeTimelineContentProvider.Listener {

		@Override
		public void propertyChange(PropertyChangeEvent evt) {
			String p = evt.getPropertyName();
			Timeline timeline = TimelineUtils.getTimeline(TreeTimelineDataEditPart.this);
			if (timeline == null) {
				return;
			}
			if (ExpansionModel.EXPANDED.equals(p)) {
				refreshInDisplayThread();
				timeline.layoutTimelineContentInDisplayThread();
			} else if (TimelineViewer.CONTENT_PROVIDER.equals(p)) {
				TreeTimelineContentProvider oldValue = (TreeTimelineContentProvider) evt.getOldValue();
				if (oldValue != null) {
					oldValue.removeListener(this);
				}

				TreeTimelineContentProvider newValue = (TreeTimelineContentProvider) evt.getNewValue();
				if (newValue != null) {
					newValue.addListener(this);
				}
				refreshInDisplayThread();
			} else if (TIMELINE_GROUP_ELEMENTS.equals(p)) {
				refreshInDisplayThread();
				timeline.layoutTimelineContentInDisplayThread();
			}
		}

		@Override
		public void contentRefresh(Set<? extends Object> element) {
			refresh();
		}

		@Override
		public void labelUpdate(Set<? extends Object> element) {
			// do nothing
		}

	}

}

redpajama_set_name: RedPajamaGithub


text:
/**
 * The PHP Code Sniffer integration plugin
 * @module PHPCS
 */
"use strict";

var request = require('request');

/**
 * @class PhpCs
 * @param config {Object} The plugins configs
 * @param mergeatron {Mergeatron} An instance of the main Mergeatron object
 * @constructor
 */
var PhpCs = function(config, mergeatron) {
	this.config = config;
	this.mergeatron = mergeatron;
};

/**
 * Processes a PHPCS CSV file. Will determine if any of the entries within the file are for files
 * that were modified as part of the provided pull request and are within the diffs for those files.
 * An event will be dispatched for each violation.
 *
 * @method process
 * @param build {String}
 * @param pull {Object}
 * @param artifact_url {String}
 */
PhpCs.prototype.process = function(build, pull, artifact) {
	var self = this,
		violations = self.parseCsvFile(artifact);

	pull.files.forEach(function(file) {
		if (file.status != 'modified' && file.status != 'added') {
			return;
		}

		violations.forEach(function(violation) {
			if (violation.file.indexOf(file.filename) == -1) {
				return;
			}

			var line_number = parseInt(violation.line, 10);
			if (file.reported.indexOf(line_number) != -1) {
				return;
			}

			file.ranges.forEach(function(range) {
				if (line_number >= range[0] && line_number <= range[1]) {
					var diff_offset = range[3] + (line_number - range[0]) + 1;
					if (range[4] && range[4].length > 0) {
						range[4].forEach(function(deletion) {
							if (deletion <= line_number) {
								diff_offset += 1;
							}
						});
					}

					file.reported.push(line_number);
					self.mergeatron.emit('pull.inline_status', pull, file.sha, file.filename, diff_offset, violation.message);
					self.mergeatron.db.insertLineStatus(pull, file.filename , line_number);
				}
			});
		});
	});
};

/**
 * Parses a PHPCS CSV file and returns the result as an array of objects.
 *
 * @method parseCsvFile
 * @param data {String}
 * @returns {Array}
 */
PhpCs.prototype.parseCsvFile = function(data) {
	var iteration = 0,
		header = [],
		records = [],
		pattern = /(?:^|,)("(?:[^"]+)*"|[^,]*)/g,
		parts = data.split('\n');

	for (var x in parts) {
		var line = parts[x];

		if (!line) {
			continue;
		}

		if (iteration++ === 0) {
			header = line.split(pattern);
		} else {
			records.push(buildRecord(line));
		}
	}

	function buildRecord(str){
		var record = {},
			fields = str.split(pattern);

		for (var y in fields) {
			if (header[y]) {
				record[header[y].toLowerCase()] = fields[y].replace(/"/g, '');
			}
		}

		return record;
	}

	return records;
};

exports.init = function(config, mergeatron) {
	var phpcs = new PhpCs(config, mergeatron);

	mergeatron.on('build.artifact_found', function (build, pull, artifact) {
		if (artifact.relativePath == config.artifact) {
			mergeatron.emit('build.download_artifact', build, pull, artifact);
		}
	});

	mergeatron.on('build.artifact_downloaded', function(build, pull, name, artifact) {
		if (name == config.artifact) {
			phpcs.process(build, pull, artifact);
		}
	});
};


text:
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ./azure.pem -out ./azure.pem

openssl pkcs12 -export -out ./azure.pfx -in ./azure.pem -name "LinuxManagmenet"

#cer file
openssl x509 -inform pem -in ./azure.pem -outform der -out ./azure.cer


text:
<?$this->load->view('layout/v_sidebar')?>

        <?$this->load->view('layout/v_vertical_menu')?>

<a href="<?=base_url('home')?>">Home

Belanjaan

Belanjaan

                        Image
                        Nama Produk
                        Model
                        Ukuran
                        Quantity
                        Harga Satuan
                        Total

			<?php error_reporting(E_ERROR);?>
                        <?php foreach($items as $item):?>

                                <img width="200px" src="<?=$item->path?>" alt="<?=$item->nama?>">

                            <?=$item->nama?>
                            <?=$item->warna?>
                            <?=$item->ukuran?>

                                        Qty
                                        <input name="quantity" type="number" class="form-control" value="<?=$item->jumlah?>" onchange="updateQuantity(this, <?=$item->itemId?>)">

                                <button class="btn btn-info hidden-xs" data-toggle="tooltip" data-placement="top" title="Update"></button>
                                <button name="removeItem" class="btn btn-danger hidden-xs" data-toggle="tooltip" data-placement="top" title="Buang" onclick="removeFromCart(this, <?=$item->itemId?>)"></button>

                            Rp. <?=number_format($item->harga,0,",",".");?>
                            Rp. <?=number_format(($item->harga*$item->jumlah),0,",",".");?>

                        <?php endforeach;?>

                        <a href="<?=base_url('home')?>" type="submit" class="btn btn-default"> Tambah Produk Lainnya

		    <?php if(!empty($items)>0){?>

                        <a href="<?=base_url('checkout')?>"  style="float: right" type="submit" class="btn btn-default">Selesaikan Belanjaan

		    <?php }?>


text:
<?php

error_reporting( E_ALL | E_STRICT ); // now required for each test suite
// define('TESTS_ZEND_LOCALE_BCMATH_ENABLED', false); // uncomment to disable use of bcmath extension by Zend_Date

if (!defined('PHPUnit_MAIN_METHOD')) {
    define('PHPUnit_MAIN_METHOD', 'Zend_Date_AllTests::main');
}

require_once 'PHPUnit/Framework/TestSuite.php';
require_once 'PHPUnit/TextUI/TestRunner.php';

require_once 'Zend/Date/DateObjectTest.php';

class Zend_Date_AllTests
{
    public static function main()
    {
        PHPUnit_TextUI_TestRunner::run(self::suite());
    }

    public static function suite()
    {
        $suite = new PHPUnit_Framework_TestSuite('Zend Framework - Zend_Date_DateObject');

        $suite->addTestSuite('Zend_Date_DateObjectTest');

        return $suite;
    }
}

if (PHPUnit_MAIN_METHOD == 'Zend_Date_AllTests::main') {
    Zend_Date_AllTests::main();
}


text:
namespace remoting {

using protocol::MockClientStub;

using testing::_;
using testing::Return;

namespace {

// Test gnubby request data.
const unsigned char request_data[] = {
    0x00, 0x00, 0x00, 0x9a, 0x65, 0x1e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
    0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x60, 0x90,
    0x24, 0x71, 0xf8, 0xf2, 0xe5, 0xdf, 0x7f, 0x81, 0xc7, 0x49, 0xc4, 0xa3,
    0x58, 0x5c, 0xf6, 0xcc, 0x40, 0x14, 0x28, 0x0c, 0xa0, 0xfa, 0x03, 0x18,
    0x38, 0xd8, 0x7d, 0x77, 0x2b, 0x3a, 0x00, 0x00, 0x00, 0x20, 0x64, 0x46,
    0x47, 0x2f, 0xdf, 0x6e, 0xed, 0x7b, 0xf3, 0xc3, 0x37, 0x20, 0xf2, 0x36,
    0x67, 0x6c, 0x36, 0xe1, 0xb4, 0x5e, 0xbe, 0x04, 0x85, 0xdb, 0x89, 0xa3,
    0xcd, 0xfd, 0xd2, 0x4b, 0xd6, 0x9f, 0x00, 0x00, 0x00, 0x40, 0x38, 0x35,
    0x05, 0x75, 0x1d, 0x13, 0x6e, 0xb3, 0x6b, 0x1d, 0x29, 0xae, 0xd3, 0x43,
    0xe6, 0x84, 0x8f, 0xa3, 0x9d, 0x65, 0x4e, 0x2f, 0x57, 0xe3, 0xf6, 0xe6,
    0x20, 0x3c, 0x00, 0xc6, 0xe1, 0x73, 0x34, 0xe2, 0x23, 0x99, 0xc4, 0xfa,
    0x91, 0xc2, 0xd5, 0x97, 0xc1, 0x8b, 0xd0, 0x3c, 0x13, 0xba, 0xf0, 0xd7,
    0x5e, 0xa3, 0xbc, 0x02, 0x5b, 0xec, 0xe4, 0x4b, 0xae, 0x0e, 0xf2, 0xbd,
    0xc8, 0xaa};

class MockStreamListenSocket : public net::StreamListenSocket {
 public:
  explicit MockStreamListenSocket(net::StreamListenSocket::Delegate* delegate)
      : StreamListenSocket(net::kInvalidSocket, delegate) {}

  virtual void Accept() OVERRIDE { NOTREACHED(); }

 private:
  virtual ~MockStreamListenSocket() {}
};

}  // namespace

class GnubbyAuthHandlerPosixTest : public testing::Test {
 public:
  GnubbyAuthHandlerPosixTest() {}

  virtual void SetUp() OVERRIDE;

 protected:
  // Object under test.
  scoped_ptr<GnubbyAuthHandlerPosix> auth_handler_posix_;

  // GnubbyAuthHandler interface for |auth_handler_posix_|.
  GnubbyAuthHandler* auth_handler_;

  // Stream delegate interface for |auth_handler_posix_|.
  net::StreamListenSocket::Delegate* delegate_;

  // Mock client stub.
  MockClientStub client_stub_;

  base::MessageLoop message_loop_;

 private:
  void OnConnect(int result);
};

void GnubbyAuthHandlerPosixTest::SetUp() {
  auth_handler_posix_.reset(new GnubbyAuthHandlerPosix(&client_stub_));
  auth_handler_ = auth_handler_posix_.get();
  delegate_ = auth_handler_posix_.get();
}

MATCHER_P2(EqualsDataMessage, id, data, "") {
  std::string connection_id = base::StringPrintf("\"connectionId\":%d", id);
  std::string data_message = base::StringPrintf("\"data\":%s", data);

  return (arg.type() == "gnubby-auth" &&
          arg.data().find("\"type\":\"data\"") != std::string::npos &&
          arg.data().find(connection_id) != std::string::npos &&
          arg.data().find(data_message) != std::string::npos);
}

TEST_F(GnubbyAuthHandlerPosixTest, HostDataMessageDelivered) {
  // Expects a JSON array of the ASCII character codes for "test_msg".
  EXPECT_CALL(client_stub_,
              DeliverHostMessage(
                  EqualsDataMessage(42, "[116,101,115,116,95,109,115,103]")));

  auth_handler_->DeliverHostDataMessage(42, "test_msg");
}

TEST_F(GnubbyAuthHandlerPosixTest, DidClose) {
  net::StreamListenSocket* socket = new MockStreamListenSocket(delegate_);

  delegate_->DidAccept(NULL, make_scoped_ptr(socket));
  ASSERT_TRUE(auth_handler_posix_->HasActiveSocketForTesting(socket));

  delegate_->DidClose(socket);
  ASSERT_FALSE(auth_handler_posix_->HasActiveSocketForTesting(socket));
}

TEST_F(GnubbyAuthHandlerPosixTest, DidRead) {
  EXPECT_CALL(client_stub_, DeliverHostMessage(_));

  net::StreamListenSocket* socket = new MockStreamListenSocket(delegate_);

  delegate_->DidAccept(NULL, make_scoped_ptr(socket));
  delegate_->DidRead(socket,
                     reinterpret_cast<const char*>(request_data),
                     sizeof(request_data));
}

TEST_F(GnubbyAuthHandlerPosixTest, DidReadByteByByte) {
  EXPECT_CALL(client_stub_, DeliverHostMessage(_));

  net::StreamListenSocket* socket = new MockStreamListenSocket(delegate_);

  delegate_->DidAccept(NULL, make_scoped_ptr(socket));
  for (unsigned int i = 0; i < sizeof(request_data); ++i) {
    delegate_->DidRead(
        socket, reinterpret_cast<const char*>(request_data + i), 1);
  }
}

TEST_F(GnubbyAuthHandlerPosixTest, DidReadTimeout) {
  net::StreamListenSocket* socket = new MockStreamListenSocket(delegate_);

  delegate_->DidAccept(NULL, make_scoped_ptr(socket));
  ASSERT_TRUE(auth_handler_posix_->HasActiveSocketForTesting(socket));

  base::MockTimer* mock_timer = new base::MockTimer(false, false);
  auth_handler_posix_->GetGnubbySocketForTesting(socket)
      ->SetTimerForTesting(scoped_ptr<base::Timer>(mock_timer));
  delegate_->DidRead(socket, reinterpret_cast<const char*>(request_data), 1);
  mock_timer->Fire();

  ASSERT_FALSE(auth_handler_posix_->HasActiveSocketForTesting(socket));
}

TEST_F(GnubbyAuthHandlerPosixTest, ClientErrorMessageDelivered) {
  net::StreamListenSocket* socket = new MockStreamListenSocket(delegate_);

  delegate_->DidAccept(NULL, make_scoped_ptr(socket));

  std::string error_json = base::StringPrintf(
      "{\"type\":\"error\",\"connectionId\":%d}",
      auth_handler_posix_->GetConnectionIdForTesting(socket));

  ASSERT_TRUE(auth_handler_posix_->HasActiveSocketForTesting(socket));
  auth_handler_->DeliverClientMessage(error_json);
  ASSERT_FALSE(auth_handler_posix_->HasActiveSocketForTesting(socket));
}

}  // namespace remoting


text:
#ifndef __TUNNEL_TYPES_API_H__
#define __TUNNEL_TYPES_API_H__

/**
 * Conversion functions to/from (decode/encode) API types to VPP internal types
 */

#include <vnet/tunnel/tunnel.h>
#include <vnet/tunnel/tunnel_types.api_types.h>

/**
 * These enum decode/encodes use 'int' as the type for the enum because
 * one cannot forward declare an enum
 */
extern int tunnel_encap_decap_flags_decode (vl_api_tunnel_encap_decap_flags_t
					    _f,
					    tunnel_encap_decap_flags_t * out);
extern vl_api_tunnel_encap_decap_flags_t
tunnel_encap_decap_flags_encode (tunnel_encap_decap_flags_t f);

extern int tunnel_mode_decode (vl_api_tunnel_mode_t in, tunnel_mode_t * out);
extern vl_api_tunnel_mode_t tunnel_mode_encode (tunnel_mode_t in);

#endif

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */


text:
<?php
if ( ! defined( 'PB_IMPORTBUDDY' ) || ( true !== PB_IMPORTBUDDY ) ) {
	die( '' );
}
Auth::require_authentication(); // Die if not logged in.

$page_title = 'Database Text Replace Tool';
require_once( '_header.php' );
?>

<?php
$configFile = '';
if ( ! file_exists( ABSPATH . 'wp-config.php' ) ) { // Normal config file not found so warn or see if parent config may exist.
	$parentConfigMessage = '';
	$parentConfig =  dirname( ABSPATH ) . '/wp-config.php';
	if ( @file_exists( $parentConfig ) ) { // Parent config exists so offer it as an option or possibly use it if user has selected to do so.
		if ( pb_backupbuddy::_GET( 'parent_config' ) == 'true' ) { // User opted to use parent config.
			$configFile = $parentConfig;
		} else { // User has not opted to use parent config yet so set message to offer it.
			$parentConfigMessage = '

However, a wp-config.php file was found in the parent directory as `' . $parentConfig . '`. Click here if you would like to run this tool using this wp-config.php file in the parent directory.';
		}
	}
	if ( '' == $configFile ) {
		pb_backupbuddy::alert( 'Error: This tool requires an existing WordPress installation to perform database replacements on. No WordPress wp-config.php configuration file was found in the same directory as importbuddy.php. ' . $parentConfigMessage . '

 Note: ImportBuddy automatically handles migrating & replacing your site URLs and file paths during restore/migration; this tool is not needed for normal backup / restore operations.', true );
	}
} else { // Use normal config file.
	$configFile = ABSPATH . 'wp-config.php';
}

if ( '' != $configFile ) {

	// Read in wp-config.php file contents.
	$configContents = file_get_contents( $configFile );
	if ( false === $configContents ) {
		pb_backupbuddy::alert( 'Error: Unable to read wp-config.php configuration file.' );
		return;
	}

	// Grab database settings from wp-config.php contents.
	preg_match( '/define\([\s]*(\'|")DB_NAME(\'|"),[\s]*(\'|")(.*)(\'|")[\s]*\);/i', $configContents, $matches );
	$databaseSettings['name'] = $matches[4];
	preg_match( '/define\([\s]*(\'|")DB_USER(\'|"),[\s]*(\'|")(.*)(\'|")[\s]*\);/i', $configContents, $matches );
	$databaseSettings['username'] = $matches[4];
	preg_match( '/define\([\s]*(\'|")DB_PASSWORD(\'|"),[\s]*(\'|")(.*)(\'|")[\s]*\);/i', $configContents, $matches );
	$databaseSettings['password'] = $matches[4];
	preg_match( '/define\([\s]*(\'|")DB_HOST(\'|"),[\s]*(\'|")(.*)(\'|")[\s]*\);/i', $configContents, $matches );
	$databaseSettings['host'] = $matches[4];
	preg_match( '/\$table_prefix[\s]*=[\s]*(\'|")(.*)(\'|");/i', $configContents, $matches );
	$databaseSettings['prefix'] = $matches[2];

	//print_r( $databaseSettings );

	// Connect to database.
	global $wpdb;
	if ( false === ( $wpdb->dbh = @mysql_connect( $databaseSettings['host'], $databaseSettings['username'], $databaseSettings['password'] ) ) ) { // CONNECT failed.
		pb_backupbuddy::alert( 'Error #848383. Unable to connect to database with wp-config.php database settings.' );
		return;
	}
	if ( false === @mysql_select_db( $databaseSettings['name'] ) ) { // SELECT failed.
		pb_backupbuddy::alert( 'Error #3479302. Unable to select database with wp-config.php database settings.' );
		return;
	}

	require_once( '_dbreplace.php' );
}
?>

<?php
require_once( '_footer.php' );


text:
  Ormes est
       un village
       situé dans le département de l'Eure en Haute-Normandie. Elle comptait 437 habitants en 2008.

À coté de Ormes sont situées les communes de
Le Tilleul-Lambert à 4 km, 177 habitants,
Ferrières-Haut-Clocher située à 3 km, 996 habitants,
Émanville située à 3 km, 524 habitants,
Graveron-Sémerville située à 4 km, 289 habitants,
Tournedos-Bois-Hubert située à 3 km, 312 habitants,
Bernienville localisée à 5 km, 261 habitants,
 entre autres. De plus, Ormes est située à seulement quatorze km de Évreux.

Le parc d'habitations, à Ormes, était réparti en 2011 en zero appartements et 189 maisons soit
 un marché plutôt équilibré.

Si vous pensez venir habiter à Ormes, vous pourrez facilement trouver une maison à acheter.


text:
package org.jfrog.hudson.plugins.artifactory.generic;

import hudson.Extension;
import hudson.Launcher;
import hudson.model.AbstractBuild;
import hudson.model.AbstractProject;
import hudson.model.Action;
import hudson.model.BuildListener;
import hudson.model.FreeStyleProject;
import hudson.model.Hudson;
import hudson.model.Result;
import hudson.tasks.BuildWrapper;
import hudson.tasks.BuildWrapperDescriptor;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.jfrog.build.api.Artifact;
import org.jfrog.build.api.Dependency;
import org.jfrog.build.api.dependency.BuildDependency;
import org.jfrog.build.client.ArtifactoryBuildInfoClient;
import org.jfrog.build.client.ArtifactoryDependenciesClient;
import org.jfrog.build.client.ProxyConfiguration;
import org.jfrog.hudson.plugins.artifactory.ArtifactoryBuilder;
import org.jfrog.hudson.plugins.artifactory.BuildInfoAwareConfigurator;
import org.jfrog.hudson.plugins.artifactory.DeployerOverrider;
import org.jfrog.hudson.plugins.artifactory.action.ActionableHelper;
import org.jfrog.hudson.plugins.artifactory.action.BuildInfoResultAction;
import org.jfrog.hudson.plugins.artifactory.config.ArtifactoryServer;
import org.jfrog.hudson.plugins.artifactory.config.Credentials;
import org.jfrog.hudson.plugins.artifactory.config.ServerDetails;
import org.jfrog.hudson.plugins.artifactory.util.IncludesExcludes;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.StaplerRequest;

import java.io.IOException;
import java.util.Collection;
import java.util.List;

/**
 * Freestyle Generic configurator
 *
 * @author Shay Yaakov
 */
public class ArtifactoryGenericConfigurator extends BuildWrapper implements DeployerOverrider,
        BuildInfoAwareConfigurator {

    private final ServerDetails details;
    private final Credentials overridingDeployerCredentials;
    private final String deployPattern;
    private final String resolvePattern;
    private final String matrixParams;

    private final boolean deployBuildInfo;
    /**
     * Include environment variables in the generated build info
     */
    private final boolean includeEnvVars;
    private final IncludesExcludes envVarsPatterns;
    private final boolean discardOldBuilds;
    private final boolean discardBuildArtifacts;
    private transient List<Dependency> publishedDependencies;
    private transient List<BuildDependency> buildDependencies;

    @DataBoundConstructor
    public ArtifactoryGenericConfigurator(ServerDetails details, Credentials overridingDeployerCredentials,
            String deployPattern, String resolvePattern, String matrixParams, boolean deployBuildInfo,
            boolean includeEnvVars, IncludesExcludes envVarsPatterns, boolean discardOldBuilds,
            boolean discardBuildArtifacts) {
        this.details = details;
        this.overridingDeployerCredentials = overridingDeployerCredentials;
        this.deployPattern = deployPattern;
        this.resolvePattern = resolvePattern;
        this.matrixParams = matrixParams;
        this.deployBuildInfo = deployBuildInfo;
        this.includeEnvVars = includeEnvVars;
        this.envVarsPatterns = envVarsPatterns;
        this.discardOldBuilds = discardOldBuilds;
        this.discardBuildArtifacts = discardBuildArtifacts;
    }

    public String getArtifactoryName() {
        return details != null ? details.artifactoryName : null;
    }

    public String getArtifactoryUrl() {
        return details != null ? details.getArtifactoryUrl() : null;
    }

    public boolean isOverridingDefaultDeployer() {
        return getOverridingDeployerCredentials() != null;
    }

    public String getRepositoryKey() {
        return details.repositoryKey;
    }

    public Credentials getOverridingDeployerCredentials() {
        return overridingDeployerCredentials;
    }

    public String getDeployPattern() {
        return deployPattern;
    }

    public String getResolvePattern() {
        return resolvePattern;
    }

    public String getMatrixParams() {
        return matrixParams;
    }

    public boolean isDeployBuildInfo() {
        return deployBuildInfo;
    }

    public boolean isIncludeEnvVars() {
        return includeEnvVars;
    }

    public IncludesExcludes getEnvVarsPatterns() {
        return envVarsPatterns;
    }

    public boolean isRunChecks() {
        // There is no use of license checks in a generic build
        return false;
    }

    public String getViolationRecipients() {
        return null;
    }

    public boolean isIncludePublishArtifacts() {
        return false;
    }

    public String getScopes() {
        return null;
    }

    public boolean isLicenseAutoDiscovery() {
        return false;
    }

    public boolean isDiscardOldBuilds() {
        return discardOldBuilds;
    }

    public boolean isDiscardBuildArtifacts() {
        return discardBuildArtifacts;
    }

    public boolean isEnableIssueTrackerIntegration() {
        return false;
    }

    public boolean isAggregateBuildIssues() {
        return false;
    }

    public String getAggregationBuildStatus() {
        return null;
    }

    public ArtifactoryServer getArtifactoryServer() {
        List<ArtifactoryServer> servers = getDescriptor().getArtifactoryServers();
        for (ArtifactoryServer server : servers) {
            if (server.getName().equals(getArtifactoryName())) {
                return server;
            }
        }
        return null;
    }

    @Override
    public Collection<? extends Action> getProjectActions(AbstractProject project) {
        return ActionableHelper.getArtifactoryProjectAction(details.getArtifactoryUrl(), project);
    }

    @Override
    public Environment setUp(final AbstractBuild build, Launcher launcher, BuildListener listener)
            throws IOException, InterruptedException {
        final String artifactoryServerName = getArtifactoryName();
        if (StringUtils.isBlank(artifactoryServerName)) {
            return super.setUp(build, launcher, listener);
        }
        final ArtifactoryServer artifactoryServer = getArtifactoryServer();
        if (artifactoryServer == null) {
            listener.getLogger().format("[JFROG] No Artifactory server configured for %s. " +
                    "Please check your configuration.", artifactoryServerName).println();
            build.setResult(Result.FAILURE);
            throw new IllegalArgumentException("No Artifactory server configured for " + artifactoryServerName);
        }

        Credentials preferredDeployer;
        ArtifactoryServer server = getArtifactoryServer();
        if (isOverridingDefaultDeployer()) {
            preferredDeployer = getOverridingDeployerCredentials();
        } else {
            preferredDeployer = server.getResolvingCredentials();
        }

        hudson.ProxyConfiguration proxy = Hudson.getInstance().proxy;
        ProxyConfiguration proxyConfiguration = null;
        if (proxy != null && proxy.getName() != null) {
            proxyConfiguration = new ProxyConfiguration();
            proxyConfiguration.host = proxy.name;
            proxyConfiguration.port = proxy.port;
            proxyConfiguration.username = proxy.getUserName();
            proxyConfiguration.password = proxy.getPassword();
        }
        ArtifactoryDependenciesClient dependenciesClient = server.createArtifactoryDependenciesClient(
                preferredDeployer.getUsername(), preferredDeployer.getPassword(), proxyConfiguration,
                listener);
        try {
            GenericArtifactsResolver artifactsResolver = new GenericArtifactsResolver(build, listener,
                    dependenciesClient, getResolvePattern());
            publishedDependencies = artifactsResolver.retrievePublishedDependencies();
            buildDependencies = artifactsResolver.retrieveBuildDependencies();

            return createEnvironmentOnSuccessfulSetup();
        } catch (Exception e) {
            e.printStackTrace(listener.error(e.getMessage()));
        } finally {
            dependenciesClient.shutdown();
        }

        return null;
    }

    private Environment createEnvironmentOnSuccessfulSetup() {
        return new Environment() {
            @Override
            public boolean tearDown(AbstractBuild build, BuildListener listener)
                    throws IOException, InterruptedException {
                Result result = build.getResult();
                if (result != null && result.isWorseThan(Result.SUCCESS)) {
                    return true;    // build failed. Don't publish
                }

                Credentials preferredDeployer;
                ArtifactoryServer server = getArtifactoryServer();
                if (isOverridingDefaultDeployer()) {
                    preferredDeployer = getOverridingDeployerCredentials();
                } else {
                    preferredDeployer = server.getResolvingCredentials();
                }
                ArtifactoryBuildInfoClient client = server.createArtifactoryClient(preferredDeployer.getUsername(),
                        preferredDeployer.getPassword(), server.createProxyConfiguration(Hudson.getInstance().proxy));
                try {
                    GenericArtifactsDeployer artifactsDeployer = new GenericArtifactsDeployer(build,
                            ArtifactoryGenericConfigurator.this, listener, preferredDeployer);
                    artifactsDeployer.deploy();

                    List<Artifact> deployedArtifacts = artifactsDeployer.getDeployedArtifacts();
                    if (deployBuildInfo) {
                        new GenericBuildInfoDeployer(ArtifactoryGenericConfigurator.this, client, build,
                                listener, deployedArtifacts, buildDependencies, publishedDependencies).deploy();
                        // add the result action (prefer always the same index)
                        build.getActions().add(0, new BuildInfoResultAction(getArtifactoryUrl(), build));
                    }

                    return true;
                } catch (Exception e) {
                    e.printStackTrace(listener.error(e.getMessage()));
                } finally {
                    client.shutdown();
                }

                // failed
                build.setResult(Result.FAILURE);
                return true;
            }
        };
    }

    @Override
    public DescriptorImpl getDescriptor() {
        return (DescriptorImpl) super.getDescriptor();
    }

    @Extension(optional = true)
    public static class DescriptorImpl extends BuildWrapperDescriptor {
        public DescriptorImpl() {
            super(ArtifactoryGenericConfigurator.class);
            load();
        }

        @Override
        public boolean isApplicable(AbstractProject<?, ?> item) {
            return item.getClass().isAssignableFrom(FreeStyleProject.class);
        }

        @Override
        public String getDisplayName() {
            return "Generic-Artifactory Integration";
        }

        @Override
        public boolean configure(StaplerRequest req, JSONObject json) throws FormException {
            req.bindParameters(this, "generic");
            save();
            return true;
        }

        /**
         * Returns the list of {@link org.jfrog.hudson.ArtifactoryServer} configured.
         *
         * @return can be empty but never null.
         */
        public List<ArtifactoryServer> getArtifactoryServers() {
            ArtifactoryBuilder.DescriptorImpl descriptor = (ArtifactoryBuilder.DescriptorImpl)
                    Hudson.getInstance().getDescriptor(ArtifactoryBuilder.class);
            return descriptor.getArtifactoryServers();
        }
    }
}


text:
<?php

namespace Fazland\ElasticaBundle\Highlights;

interface HighlighterInterface
{
    /**
     * Sets the highlights into the objects.
     *
     * @param array $objects
     * @param array $highlights
     */
    public function setHighlights(array $objects, array $highlights);
}


text:
 package com.amazonaws.services.dynamodbv2.xspec;

import com.amazonaws.annotation.Beta;

/**
 * Represents a plus binary operation in building expressions that involve
 * number attributes.
 *
 * <pre>
 * operand '+' operand
 * </pre>
 */
@Beta
public final class PlusOperation extends BinaryOperation {
    PlusOperation(Operand lhs, Operand rhs) {
        super(lhs, "+", rhs);
    }
}


text:
package io.youi.video

import scala.concurrent.{Future, Promise}

class Video(private[youi] val element: html.Video) extends Drawable {
  def isEmpty: Boolean = false
  def nonEmpty: Boolean = !isEmpty

  val width: Int = element.videoWidth
  val height: Int = element.videoHeight
  val duration: Double = element.duration

  val autoPlay: Var[Boolean] = Var(false)
  val loop: Var[Boolean] = Var(false)
  val muted: Var[Boolean] = Var(false)
  val position: Var[Double] = Var(0.0)
  val volume: Var[Double] = Var(1.0)

  private var updatingTime = false

  private def init(autoPlay: Boolean,
                   loop: Boolean,
                   muted: Boolean): Unit = if (!isEmpty) {
    this.autoPlay @= autoPlay
    this.loop @= loop
    this.muted @= muted

    this.autoPlay.attach(element.autoplay = _)
    this.loop.attach(element.loop = _)
    this.muted.attach(element.muted = _)

    position @= element.currentTime
    position.attach { p =>
      if (!updatingTime) element.currentTime = p
    }
    element.addEventListener("timeupdate", (_: Event) => {
      modified @= System.currentTimeMillis()
      updatingTime = true
      try {
        position @= element.currentTime
      } finally {
        updatingTime = false
      }
    })
    element.addEventListener("seeked", (_: Event) => {
      updatingTime = true
      try {
        position @= element.currentTime
      } finally {
        updatingTime = false
      }
    })

    var updatingVolume = false
    volume @= element.volume
    volume.attach { v =>
      if (!updatingVolume) element.volume = v
    }
    element.addEventListener("volumechange", (_: Event) => {
      updatingVolume = true
      try {
        volume @= element.volume
      } finally {
        updatingVolume = false
      }
    })
    modified @= System.currentTimeMillis()
  }

  def play(): Unit = element.play()
  def pause(): Unit = element.pause()
  def isPaused: Boolean = element.paused
  def isEnded: Boolean = element.ended

  def seek(position: Double): Future[Unit] = if (this.position() != position) {
    val promise = Promise[Unit]
    this.position.once(_ => {
      promise.success(())
    }, d => math.abs(position - d) <= 1.0)
    this.position @= position
    promise.future
  } else {
    Future.successful(())
  }

  def createImage(): Image = {
    val canvas = CanvasPool(width, height)
    val context = canvas.context
    context.drawImage(element, 0.0, 0.0)
    CanvasImage(canvas, ImageResizer.Pica)
  }

  override def draw(context: Context, x: Double, y: Double): Unit = if (!isEmpty) {
    context.drawVideo(element)(x, y, width, height)
    if (position() > 0.0 && !isPaused && !isEnded) {
      updatingTime = true
      try {
        position @= element.currentTime
      } finally {
        updatingTime = false
      }
      modified @= System.currentTimeMillis()
    }
  }

  def dispose(): Unit = pause()
}

object Video {
  object empty extends Video(dom.create[html.Video]("video")) {
    override def isEmpty: Boolean = true
  }

  def isVideo(file: File): Boolean = file.`type`.startsWith("video/")

  def apply(file: File, autoPlay: Boolean, loop: Boolean, muted: Boolean): Future[Video] = {
    val url = org.scalajs.dom.URL.createObjectURL(file)
    apply(url, autoPlay, loop, muted)
  }

  def apply(url: URL, autoPlay: Boolean, loop: Boolean, muted: Boolean): Future[Video] = {
    apply(url.toString, autoPlay, loop, muted)
  }

  def apply(url: String,
            autoPlay: Boolean,
            loop: Boolean,
            muted: Boolean): Future[Video] = {
    val element: html.Video = dom.create[html.Video]("video")
    element.autoplay = autoPlay
    element.loop = loop
    element.muted = muted
    val promise = Promise[Video]
    element.addEventListener("loadedmetadata", (_: Event) => {
      val v = new Video(element)
      v.init(autoPlay, loop, muted)
      promise.success(v)
    })
    element.src = url
    promise.future
  }
}


text:
use shared::minwindef::{PUCHAR, ULONG, USHORT};
use um::winnt::{BOOLEAN, CHAR, LARGE_INTEGER, LONG, PCHAR, PVOID, PWSTR};
STRUCT!{struct UNICODE_STRING {
    Length: USHORT,
    MaximumLength: USHORT,
    Buffer: PWSTR,
}}
pub type PUNICODE_STRING = *mut UNICODE_STRING;
STRUCT!{struct STRING {
    Length: USHORT,
    MaximumLength: USHORT,
    Buffer: PCHAR,
}}
pub type PSTRING = *mut STRING;
STRUCT!{struct OLD_LARGE_INTEGER {
    LowPart: ULONG,
    HighPart: LONG,
}}
pub type POLD_LARGE_INTEGER = *mut OLD_LARGE_INTEGER;
pub type SAM_HANDLE = PVOID;
pub type PSAM_HANDLE = *mut PVOID;
pub const USER_ACCOUNT_DISABLED: ULONG = 0x00000001;
pub const USER_HOME_DIRECTORY_REQUIRED: ULONG = 0x00000002;
pub const USER_PASSWORD_NOT_REQUIRED: ULONG = 0x00000004;
pub const USER_TEMP_DUPLICATE_ACCOUNT: ULONG = 0x00000008;
pub const USER_NORMAL_ACCOUNT: ULONG = 0x00000010;
pub const USER_MNS_LOGON_ACCOUNT: ULONG = 0x00000020;
pub const USER_INTERDOMAIN_TRUST_ACCOUNT: ULONG = 0x00000040;
pub const USER_WORKSTATION_TRUST_ACCOUNT: ULONG = 0x00000080;
pub const USER_SERVER_TRUST_ACCOUNT: ULONG = 0x00000100;
pub const USER_DONT_EXPIRE_PASSWORD: ULONG = 0x00000200;
pub const USER_ACCOUNT_AUTO_LOCKED: ULONG = 0x00000400;
pub const USER_ENCRYPTED_TEXT_PASSWORD_ALLOWED: ULONG = 0x00000800;
pub const USER_SMARTCARD_REQUIRED: ULONG = 0x00001000;
pub const USER_TRUSTED_FOR_DELEGATION: ULONG = 0x00002000;
pub const USER_NOT_DELEGATED: ULONG = 0x00004000;
pub const USER_USE_DES_KEY_ONLY: ULONG = 0x00008000;
pub const USER_DONT_REQUIRE_PREAUTH: ULONG = 0x00010000;
pub const USER_PASSWORD_EXPIRED: ULONG = 0x00020000;
pub const USER_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION: ULONG = 0x00040000;
pub const USER_NO_AUTH_DATA_REQUIRED: ULONG = 0x00080000;
pub const USER_PARTIAL_SECRETS_ACCOUNT: ULONG = 0x00100000;
pub const USER_USE_AES_KEYS: ULONG = 0x00200000;
pub const NEXT_FREE_ACCOUNT_CONTROL_BIT: ULONG = USER_USE_AES_KEYS << 1;
pub const USER_MACHINE_ACCOUNT_MASK: ULONG = USER_INTERDOMAIN_TRUST_ACCOUNT
    | USER_WORKSTATION_TRUST_ACCOUNT | USER_SERVER_TRUST_ACCOUNT;
pub const USER_ACCOUNT_TYPE_MASK: ULONG = USER_TEMP_DUPLICATE_ACCOUNT | USER_NORMAL_ACCOUNT
    | USER_MACHINE_ACCOUNT_MASK;
pub const USER_COMPUTED_ACCOUNT_CONTROL_BITS: ULONG = USER_ACCOUNT_AUTO_LOCKED
    | USER_PASSWORD_EXPIRED;
pub const SAM_DAYS_PER_WEEK: USHORT = 7;
pub const SAM_HOURS_PER_WEEK: USHORT = 24 * SAM_DAYS_PER_WEEK;
pub const SAM_MINUTES_PER_WEEK: USHORT = 60 * SAM_HOURS_PER_WEEK;
STRUCT!{struct LOGON_HOURS {
    UnitsPerWeek: USHORT,
    LogonHours: PUCHAR,
}}
pub type PLOGON_HOURS = *mut LOGON_HOURS;
STRUCT!{struct SR_SECURITY_DESCRIPTOR {
    Length: ULONG,
    SecurityDescriptor: PUCHAR,
}}
pub type PSR_SECURITY_DESCRIPTOR = *mut SR_SECURITY_DESCRIPTOR;
STRUCT!{struct USER_ALL_INFORMATION {
    LastLogon: LARGE_INTEGER,
    LastLogoff: LARGE_INTEGER,
    PasswordLastSet: LARGE_INTEGER,
    AccountExpires: LARGE_INTEGER,
    PasswordCanChange: LARGE_INTEGER,
    PasswordMustChange: LARGE_INTEGER,
    UserName: UNICODE_STRING,
    FullName: UNICODE_STRING,
    HomeDirectory: UNICODE_STRING,
    HomeDirectoryDrive: UNICODE_STRING,
    ScriptPath: UNICODE_STRING,
    ProfilePath: UNICODE_STRING,
    AdminComment: UNICODE_STRING,
    WorkStations: UNICODE_STRING,
    UserComment: UNICODE_STRING,
    Parameters: UNICODE_STRING,
    LmPassword: UNICODE_STRING,
    NtPassword: UNICODE_STRING,
    PrivateData: UNICODE_STRING,
    SecurityDescriptor: SR_SECURITY_DESCRIPTOR,
    UserId: ULONG,
    PrimaryGroupId: ULONG,
    UserAccountControl: ULONG,
    WhichFields: ULONG,
    LogonHours: LOGON_HOURS,
    BadPasswordCount: USHORT,
    LogonCount: USHORT,
    CountryCode: USHORT,
    CodePage: USHORT,
    LmPasswordPresent: BOOLEAN,
    NtPasswordPresent: BOOLEAN,
    PasswordExpired: BOOLEAN,
    PrivateDataSensitive: BOOLEAN,
}}
pub type PUSER_ALL_INFORMATION = *mut USER_ALL_INFORMATION;
pub const USER_ALL_PARAMETERS: ULONG = 0x00200000;
pub const CLEAR_BLOCK_LENGTH: usize = 8;
STRUCT!{struct CLEAR_BLOCK {
    data: [CHAR; CLEAR_BLOCK_LENGTH],
}}
pub type PCLEAR_BLOCK = *mut CLEAR_BLOCK;
pub const CYPHER_BLOCK_LENGTH: usize = 8;
STRUCT!{struct CYPHER_BLOCK {
    data: [CHAR; CYPHER_BLOCK_LENGTH],
}}
pub type PCYPHER_BLOCK = *mut CYPHER_BLOCK;
STRUCT!{struct LM_OWF_PASSWORD {
    data: [CYPHER_BLOCK; 2],
}}
pub type PLM_OWF_PASSWORD = *mut LM_OWF_PASSWORD;
pub type LM_CHALLENGE = CLEAR_BLOCK;
pub type PLM_CHALLENGE = *mut LM_CHALLENGE;
pub type NT_OWF_PASSWORD = LM_OWF_PASSWORD;
pub type PNT_OWF_PASSWORD = *mut NT_OWF_PASSWORD;
pub type NT_CHALLENGE = LM_CHALLENGE;
pub type PNT_CHALLENGE = *mut NT_CHALLENGE;
pub const USER_SESSION_KEY_LENGTH: usize = CYPHER_BLOCK_LENGTH * 2;
STRUCT!{struct USER_SESSION_KEY {
    data: [CYPHER_BLOCK; 2],
}}
pub type PUSER_SESSION_KEY = *mut USER_SESSION_KEY;
ENUM!{enum NETLOGON_LOGON_INFO_CLASS {
    NetlogonInteractiveInformation = 1,
    NetlogonNetworkInformation,
    NetlogonServiceInformation,
    NetlogonGenericInformation,
    NetlogonInteractiveTransitiveInformation,
    NetlogonNetworkTransitiveInformation,
    NetlogonServiceTransitiveInformation,
}}
STRUCT!{struct NETLOGON_LOGON_IDENTITY_INFO {
    LogonDomainName: UNICODE_STRING,
    ParameterControl: ULONG,
    LogonId: OLD_LARGE_INTEGER,
    UserName: UNICODE_STRING,
    Workstation: UNICODE_STRING,
}}
pub type PNETLOGON_LOGON_IDENTITY_INFO = *mut NETLOGON_LOGON_IDENTITY_INFO;
STRUCT!{struct NETLOGON_INTERACTIVE_INFO {
    Identity: NETLOGON_LOGON_IDENTITY_INFO,
    LmOwfPassword: LM_OWF_PASSWORD,
    NtOwfPassword: NT_OWF_PASSWORD,
}}
pub type PNETLOGON_INTERACTIVE_INFO = *mut NETLOGON_INTERACTIVE_INFO;
STRUCT!{struct NETLOGON_SERVICE_INFO {
    Identity: NETLOGON_LOGON_IDENTITY_INFO,
    LmOwfPassword: LM_OWF_PASSWORD,
    NtOwfPassword: NT_OWF_PASSWORD,
}}
pub type PNETLOGON_SERVICE_INFO = *mut NETLOGON_SERVICE_INFO;
STRUCT!{struct NETLOGON_NETWORK_INFO {
    Identity: NETLOGON_LOGON_IDENTITY_INFO,
    LmChallenge: LM_CHALLENGE,
    NtChallengeResponse: STRING,
    LmChallengeResponse: STRING,
}}
pub type PNETLOGON_NETWORK_INFO = *mut NETLOGON_NETWORK_INFO;
STRUCT!{struct NETLOGON_GENERIC_INFO {
    Identity: NETLOGON_LOGON_IDENTITY_INFO,
    PackageName: UNICODE_STRING,
    DataLength: ULONG,
    LogonData: PUCHAR,
}}
pub type PNETLOGON_GENERIC_INFO = *mut NETLOGON_GENERIC_INFO;
pub const MSV1_0_PASSTHRU: ULONG = 0x01;
pub const MSV1_0_GUEST_LOGON: ULONG = 0x02;
STRUCT!{struct MSV1_0_VALIDATION_INFO {
    LogoffTime: LARGE_INTEGER,
    KickoffTime: LARGE_INTEGER,
    LogonServer: UNICODE_STRING,
    LogonDomainName: UNICODE_STRING,
    SessionKey: USER_SESSION_KEY,
    Authoritative: BOOLEAN,
    UserFlags: ULONG,
    WhichFields: ULONG,
    UserId: ULONG,
}}
pub type PMSV1_0_VALIDATION_INFO = *mut MSV1_0_VALIDATION_INFO;
pub const MSV1_0_VALIDATION_LOGOFF_TIME: ULONG = 0x00000001;
pub const MSV1_0_VALIDATION_KICKOFF_TIME: ULONG = 0x00000002;
pub const MSV1_0_VALIDATION_LOGON_SERVER: ULONG = 0x00000004;
pub const MSV1_0_VALIDATION_LOGON_DOMAIN: ULONG = 0x00000008;
pub const MSV1_0_VALIDATION_SESSION_KEY: ULONG = 0x00000010;
pub const MSV1_0_VALIDATION_USER_FLAGS: ULONG = 0x00000020;
pub const MSV1_0_VALIDATION_USER_ID: ULONG = 0x00000040;
pub const MSV1_0_SUBAUTH_ACCOUNT_DISABLED: ULONG = 0x00000001;
pub const MSV1_0_SUBAUTH_PASSWORD: ULONG = 0x00000002;
pub const MSV1_0_SUBAUTH_WORKSTATIONS: ULONG = 0x00000004;
pub const MSV1_0_SUBAUTH_LOGON_HOURS: ULONG = 0x00000008;
pub const MSV1_0_SUBAUTH_ACCOUNT_EXPIRY: ULONG = 0x00000010;
pub const MSV1_0_SUBAUTH_PASSWORD_EXPIRY: ULONG = 0x00000020;
pub const MSV1_0_SUBAUTH_ACCOUNT_TYPE: ULONG = 0x00000040;
pub const MSV1_0_SUBAUTH_LOCKOUT: ULONG = 0x00000080;
// STATUS_*


text:
<!DOCTYPE html>

<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">

<meta charset="utf-8">

<title>            About      Cisco EPN @epndocs      </title>

<meta property="og:locale" content="en-US">
<meta property="og:site_name" content="Cisco EPN @epndocs">
<meta property="og:title" content="About">

  <link rel="canonical" href="http://localhost:4000/about/">
  <meta property="og:url" content="http://localhost:4000/about/">

  <meta property="og:description" content="Minimal Mistakes is a flexible two-column Jekyll theme.">

  <meta name="twitter:site" content="@epndocs">
  <meta name="twitter:title" content="About">
  <meta name="twitter:description" content="Minimal Mistakes is a flexible two-column Jekyll theme.">
  <meta name="twitter:url" content="http://localhost:4000/about/">

    <meta name="twitter:card" content="summary">

      <meta name="twitter:image" content="http://localhost:4000/images/xrdocs_twitter.png">

<link href="http://localhost:4000/feed.xml" type="application/atom+xml" rel="alternate" title="Cisco EPN @epndocs Feed">

<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="google-site-verification" content="jgRKKm6B9FwJJPXxpmc0-EP3D0Mh8JHXaJqoYIGj1ek">

<link rel="stylesheet" href="http://localhost:4000/assets/css/main.css">

<meta http-equiv="cleartype" content="on">

<link rel="apple-touch-icon-precomposed" sizes="57x57" href="http://localhost:4000/images/apple-touch-icon-57x57.png">
<link rel="apple-touch-icon-precomposed" sizes="114x114" href="http://localhost:4000/images/apple-touch-icon-114x114.png">
<link rel="apple-touch-icon-precomposed" sizes="72x72" href="http://localhost:4000/images/apple-touch-icon-72x72.png">
<link rel="apple-touch-icon-precomposed" sizes="144x144" href="http://localhost:4000/images/apple-touch-icon-144x144.png">
<link rel="apple-touch-icon-precomposed" sizes="60x60" href="http://localhost:4000/images/apple-touch-icon-60x60.png">
<link rel="apple-touch-icon-precomposed" sizes="120x120" href="http://localhost:4000/images/apple-touch-icon-120x120.png">
<link rel="apple-touch-icon-precomposed" sizes="76x76" href="http://localhost:4000/images/apple-touch-icon-76x76.png">
<link rel="apple-touch-icon-precomposed" sizes="152x152" href="http://localhost:4000/images/apple-touch-icon-152x152.png">
<link rel="icon" type="image/png" href="http://localhost:4000/images/favicon-196x196.png" sizes="196x196">
<link rel="icon" type="image/png" href="http://localhost:4000/images/favicon-96x96.png" sizes="96x96">
<link rel="icon" type="image/png" href="http://localhost:4000/images/favicon-32x32.png" sizes="32x32">
<link rel="icon" type="image/png" href="http://localhost:4000/images/favicon-16x16.png" sizes="16x16">
<link rel="icon" type="image/png" href="http://localhost:4000/images/favicon-128.png" sizes="128x128">
<link rel="shortcut icon" href="http://localhost:4000/images/favicon_cisco.ico">
<meta name="application-name" content=" ">
<meta name="msapplication-TileColor" content="#FFFFFF">
<meta name="msapplication-TileImage" content="http://localhost:4000/images/mstile-144x144.png">
<meta name="msapplication-square70x70logo" content="http://localhost:4000/images/mstile-70x70.png">
<meta name="msapplication-square150x150logo" content="http://localhost:4000/images/mstile-150x150.png">
<meta name="msapplication-wide310x150logo" content="http://localhost:4000/images/mstile-310x150.png">
<meta name="msapplication-square310x310logo" content="http://localhost:4000/images/mstile-310x310.png">

        <button>

</button>

@epndocs

Get Started

EPN 5.0

EPN 4.0

Cisco EPN Team

A Team of Network Architects and Software Engineers who have proven record of building innovative and world-class solutions

    <button class="btn btn--inverse">Follow</button>

 San jose, California

 Github

    <meta itemprop="headline" content="About">
    <meta itemprop="description" content="Minimal Mistakes is a flexible two-column Jekyll theme.">

    <meta itemprop="dateModified" content="April 18, 2016">

About

Minimal Mistakes is a flexible two-column Jekyll theme. Perfect for hosting your personal site, blog, or portfolio on GitHub or self-hosting on your own server. As the name implies — styling is purposely minimalistic to be enhanced and customized by you .

The theme includes responsive layouts (single, archive, and splash pages) that look great on mobile and desktop browsers.

Examples of included layouts splash, single, and archive.

Install the Theme

Notable Features

Compatible with Jekyll 3.x and GitHub Pages

Several layout options (single, archive, splash pages)

SEO optimized with support for Twitter Cards and Open Graph data

Optional header images, sidebars, table of contents, galleries, related posts, breadcrumb links, and more.

Optional comments (Disqus, Facebook, Google+, and custom)

Optional analytics (Google Analytics and custom)

Demo Pages

      Name
      Description

      [Post with Header Image][header-image-post]
      A post with a large header image.

      [HTML Tags and Formatting Post][html-tags-post]
      A variety of common markup showing how the theme styles them.

      [Syntax Highlighting Post][syntax-post]
      Post displaying highlighted code.

      [Post with a Gallery][gallery-post]
      A post showing several images wrapped in <figure> elements.

      [Sample Collection Page][sample-collection]
      Single page from a collection.

      [Categories Archive][categories-archive]
      Posts grouped by category.

      [Tags Archive][tags-archive]
      Posts grouped by tags.

For even more demo pages check the [posts archive][year-archive].

Credits

Icons + Demo Images:

The Noun Project – Garrett Knoll, Arthur Shlain, and tracy tam

Font Awesome

Unsplash

Other:

Jekyll

jQuery

Susy

Breakpoint

Magnific Popup

FitVids.JS

Greedy Navigation - lukejacksonn

jQuery Smooth Scroll

Stickyfill

Minimal Mistakes is designed, developed, and maintained by Michael Rose. Just another boring, tattooed, designer from Buffalo New York.

 Updated: <time datetime="2016-04-18">April 18, 2016</time>

Follow:

 Twitter

 GitHub

 Feed

© 2017 Cisco Systems Inc. Powered by Jekyll & Minimal Mistakes.


text:
package de.japkit.examples.simpledto;

import de.japkit.annotations.RuntimeMetadata;
import de.japkit.functions.SrcInterface;
import de.japkit.functions.SrcType;
import de.japkit.metaannotations.Clazz;
import de.japkit.metaannotations.Field;
import de.japkit.metaannotations.Getter;
import de.japkit.metaannotations.Method;
import de.japkit.metaannotations.Setter;

@Clazz(nameSuffixToAppend = "DTO")
@RuntimeMetadata
public class DTOTemplate implements SrcInterface {
	@Field(src = "#{properties}", getter = @Getter, setter = @Setter)
	private SrcType $name$;

	/**
	 *

	 *
japkit.bodyBeforeIteratorCode return "#{name} {"+
	 *
japkit.bodyCode "#{name}=" + #{name} +
	 *
japkit.bodySeparator ", " +
	 *
japkit.bodyAfterIteratorCode "}";
	 *

	 */
	@Method(bodyIterator = "#{properties}", bodyIndentAfterLinebreak = true)
	@Override
	public String toString() {
		return null;
	}

}


text:
using System;

using Microsoft.Extensions.DependencyInjection;
using Orleans.Configuration;
using Orleans.Runtime.ReminderService;

namespace Orleans.Hosting
{
    /// <summary>
    /// Silo host builder extensions.
    /// </summary>
    public static class SiloHostBuilderReminderExtensions
    {
        /// <summary>
        /// Adds reminder storage using ADO.NET.
        /// </summary>
        /// <param name="builder">
        /// The builder.
        /// </param>
        /// <param name="configure">
        /// The delegate used to configure the reminder store.
        /// </param>
        /// <returns>
        /// The provided <see cref="ISiloHostBuilder"/>, for chaining.
        /// </returns>
        public static ISiloHostBuilder UseAdoNetReminderService(
            this ISiloHostBuilder builder,
            Action<AdoNetReminderTableOptions> configureOptions)
        {
            return builder.UseAdoNetReminderService(ob => ob.Configure(configureOptions));
        }

        /// <summary>
        /// Adds reminder storage using ADO.NET.
        /// </summary>
        /// <param name="builder">
        /// The builder.
        /// </param>
        /// <param name="configure">
        /// The delegate used to configure the reminder store.
        /// </param>
        /// <returns>
        /// The provided <see cref="ISiloHostBuilder"/>, for chaining.
        /// </returns>
        public static ISiloHostBuilder UseAdoNetReminderService(
            this ISiloHostBuilder builder,
            Action<OptionsBuilder<AdoNetReminderTableOptions>> configureOptions)
        {
            return builder.ConfigureServices(services => services.UseAdoNetReminderService(configureOptions));
        }

        /// <summary>
        /// Adds reminder storage using ADO.NET.
        /// </summary>
        /// <param name="services">
        /// The service collection.
        /// </param>
        /// <param name="configure">
        /// The delegate used to configure the reminder store.
        /// </param>
        /// <returns>
        /// The provided <see cref="ISiloHostBuilder"/>, for chaining.
        /// </returns>
        public static IServiceCollection UseAdoNetReminderService(this IServiceCollection services, Action<OptionsBuilder<AdoNetReminderTableOptions>> configureOptions)
        {
            services.AddSingleton<IReminderTable, AdoNetReminderTable>();
            services.ConfigureFormatter<AdoNetReminderTableOptions>();
            services.AddSingleton<IConfigurationValidator, AdoNetReminderTableOptionsValidator>();
            services.Configure(configureOptions);
            return services;
        }
    }
}


text:
(function($){
	$.eventPlayer = {};

	$.eventPlayer.defaultOptions = {
		show: function(eventPlayer, event, direction) {
			$(event.segment.element).slideDown();
		},
		hide: function(eventPlayer, event, direction) {
			$(event.segment.element).slideUp();
		},

		// Return a jQuery array of subtitle elements.
		subtitles: function(videoElement) {
			return $(videoElement).next('.subtitles').children();
		},

		// Given one of the subtitle elements, return a segment.
		segment: function(videoElement, subtitleElement) {
			var segment = EventPlayer.Segments.getTimeFromElement(subtitleElement);

			return $.extend({
				show: this.show,
				hide: this.hide,
				element: subtitleElement,
			}, segment);
		}
	}

	var EventPlayerDataKey = 'eventPlayer';

	//	var eventPlayer = $('.video').eventPlayer();
	$.fn.eventPlayer = function(options) {
		options = $.extend({}, $.eventPlayer.defaultOptions, options);

		// Connect the video event to the audio/video timeupdate event.
		return this.each(function() {
			if (!$(this).data(EventPlayerDataKey)) {
				var eventPlayer = new EventPlayer(options);

				eventPlayer.connect(this);

				$(this).data(EventPlayerDataKey, eventPlayer);
			}
		});
	}

	$.fn.subtitles = function(options) {
		options = $.extend({}, $.eventPlayer.defaultOptions, options);

		return this.each(function() {
			var eventPlayer = $(this).data('eventPlayer'),
				subtitles = options.subtitles(this),
				videoElement = this,
				segments = new EventPlayer.Segments();

			subtitles.each(function() {
				segments.add(options.segment(videoElement, this));
			});

			eventPlayer.addEvents(segments.events);
		});
	}
})(jQuery);


text:
/*
 * Dawn Engine
 * Written by David Avedissian (c) 2012-2019 (git@dga.dev)
 */
#include "Base.h"
#include "renderer/SystemPosition.h"

namespace dw {
const SystemPosition SystemPosition::origin;

SystemPosition::SystemPosition() : x{0.0}, y{0.0}, z{0.0} {
}

SystemPosition::SystemPosition(double x, double y, double z) : x{x}, y{y}, z{z} {
}

SystemPosition::SystemPosition(const Vec3& vector)
    : x(static_cast<double>(vector.x)),
      y(static_cast<double>(vector.y)),
      z(static_cast<double>(vector.z)) {
}

SystemPosition::SystemPosition(const SystemPosition& other) : x{other.x}, y{other.y}, z{other.z} {
}

Vec3 SystemPosition::getRelativeTo(const SystemPosition& point) const {
    SystemPosition delta = *this - point;
    return Vec3(static_cast<float>(delta.x), static_cast<float>(delta.y),
                static_cast<float>(delta.z));
}

Vec3 SystemPosition::toCameraSpace(const SystemPosition& camera_position) const {
    return getRelativeTo(camera_position);
}

SystemPosition SystemPosition::fromCameraSpace(const SystemPosition& camera_position,
                                               const Vec3& point) {
    return camera_position + point;
}

bool SystemPosition::operator==(const SystemPosition& other) const {
    return floatEq(x, other.x) && floatEq(y, other.y) && floatEq(z, other.z);
}

bool SystemPosition::operator!=(const SystemPosition& other) const {
    return !(*this == other);
}

SystemPosition& SystemPosition::operator=(const SystemPosition& other) {
    x = other.x;
    y = other.y;
    z = other.z;
    return *this;
}

SystemPosition& SystemPosition::operator=(const Vec3& other) {
    *this = SystemPosition(other);
    return *this;
}

SystemPosition& SystemPosition::operator+=(const SystemPosition& other) {
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
}

SystemPosition& SystemPosition::operator+=(const Vec3& other) {
    return *this += SystemPosition(other);
}

SystemPosition& SystemPosition::operator-=(const SystemPosition& other) {
    x -= other.x;
    y -= other.y;
    z -= other.z;
    return *this;
}

SystemPosition& SystemPosition::operator-=(const Vec3& other) {
    return *this -= SystemPosition(other);
}

SystemPosition& SystemPosition::operator*=(float scalar) {
    x *= scalar;
    y *= scalar;
    z *= scalar;
    return *this;
}

SystemPosition& SystemPosition::operator/=(float scalar) {
    return *this *= (1.0f / scalar);
}

SystemPosition SystemPosition::operator-() const {
    return SystemPosition(-x, -y, -z);
}

SystemPosition SystemPosition::operator+(const SystemPosition& other) const {
    return SystemPosition(x + other.x, y + other.y, z + other.z);
}

SystemPosition SystemPosition::operator+(const Vec3& other) const {
    return *this + SystemPosition(other);
}

SystemPosition SystemPosition::operator-(const SystemPosition& other) const {
    return SystemPosition(x - other.x, y - other.y, z - other.z);
}

SystemPosition SystemPosition::operator-(const Vec3& other) const {
    return *this - SystemPosition(other);
}

SystemPosition SystemPosition::operator*(float scalar) const {
    return SystemPosition(x * scalar, y * scalar, z * scalar);
}

SystemPosition SystemPosition::operator/(float scalar) const {
    return *this * (1.0f / scalar);
}
}  // namespace dw


text:
package org.spongepowered.common.mixin.core.entity.projectile;

import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.item.EntityXPOrb;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntityFishHook;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.DamageSource;
import net.minecraft.util.MathHelper;
import org.spongepowered.api.data.Transaction;
import org.spongepowered.api.entity.Entity;
import org.spongepowered.api.entity.EntitySnapshot;
import org.spongepowered.api.entity.living.player.Player;
import org.spongepowered.api.entity.projectile.FishHook;
import org.spongepowered.api.entity.projectile.source.ProjectileSource;
import org.spongepowered.api.event.SpongeEventFactory;
import org.spongepowered.api.event.action.FishingEvent;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.cause.NamedCause;
import org.spongepowered.api.item.ItemTypes;
import org.spongepowered.api.item.inventory.ItemStack;
import org.spongepowered.api.item.inventory.ItemStackSnapshot;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.common.SpongeImpl;
import org.spongepowered.common.data.util.NbtDataUtil;
import org.spongepowered.common.entity.projectile.ProjectileSourceSerializer;
import org.spongepowered.common.interfaces.IMixinEntityFishHook;
import org.spongepowered.common.mixin.core.entity.MixinEntity;

import java.util.Optional;

import javax.annotation.Nullable;

@Mixin(EntityFishHook.class)
public abstract class MixinEntityFishHook extends MixinEntity implements FishHook, IMixinEntityFishHook {

    @Shadow private boolean inGround;
    @Shadow private EntityPlayer angler;
    @Shadow public net.minecraft.entity.Entity caughtEntity;
    @Shadow private int ticksCatchable;
    @Shadow public abstract net.minecraft.item.ItemStack getFishingResult();

    @Nullable
    public ProjectileSource projectileSource;
    private double damageAmount;
    private net.minecraft.item.ItemStack fishingRod;

    @Override
    public ProjectileSource getShooter() {
        if (this.projectileSource != null) {
            return this.projectileSource;
        } else if (this.angler != null && this.angler instanceof ProjectileSource) {
            return (ProjectileSource) this.angler;
        }
        return ProjectileSource.UNKNOWN;
    }

    @Override
    public void setShooter(ProjectileSource shooter) {
        if (shooter instanceof EntityPlayer) {
            // This allows things like Vanilla kill attribution to take place
            this.angler = (EntityPlayer) shooter;
        } else {
            this.angler = null;
        }
        this.projectileSource = shooter;
    }

    @Override
    public Optional<Entity> getHookedEntity() {
        return Optional.ofNullable((Entity) this.caughtEntity);
    }

    @Override
    public void setHookedEntity(@Nullable Entity entity) {
        this.caughtEntity = (net.minecraft.entity.Entity) entity;
    }

    @Redirect(method = "onUpdate()V", at =
            @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;attackEntityFrom(Lnet/minecraft/util/DamageSource;F)Z")
        )
    public boolean onAttackEntityFrom(net.minecraft.entity.Entity entity, DamageSource damageSource, float damage) {
        EntitySnapshot fishHookSnapshot = this.createSnapshot();
        FishingEvent.HookEntity event = SpongeEventFactory.createFishingEventHookEntity(
            Cause.of(NamedCause.source(this.angler)), this.createSnapshot(), this, (Entity) entity);
        if (!SpongeImpl.postEvent(event)) {
            if (this.getShooter() instanceof Entity) {
                DamageSource.causeThrownDamage((net.minecraft.entity.Entity) (Object) this, (net.minecraft.entity.Entity) this.getShooter());
            }
            return entity.attackEntityFrom(damageSource, (float) this.getDamage());
        }
        return false;
    }

    public double getDamage() {
        return this.damageAmount;
    }

    /**
     * @author Aaron1011 - February 6th, 2015
     * @reason This needs to handle for both cases where a fish and/or an entity is being caught.
     * There's no real good way to do this with an injection.
     */
    @Overwrite
    public int handleHookRetraction() {
        if (this.worldObj.isRemote) {
            return 0;
        }

        // Sponge start
        byte b0 = 0;

        net.minecraft.item.ItemStack itemStack = null;
        int exp = 0;
        if (this.ticksCatchable > 0) {
            itemStack = this.getFishingResult();
            exp = this.rand.nextInt(6) + 1;
        }

        EntitySnapshot fishHookSnapshot = this.createSnapshot();

        Transaction<ItemStackSnapshot> transaction = null;
        if (itemStack != null) {
            ItemStackSnapshot original = ((ItemStack) itemStack).createSnapshot();
            ItemStackSnapshot replacement = ((ItemStack) itemStack).createSnapshot();
            transaction = new Transaction<>(original, replacement);
        } else {
            transaction = new Transaction<>(ItemStackSnapshot.NONE, ItemStackSnapshot.NONE);
        }

        FishingEvent.Stop event = SpongeEventFactory.createFishingEventStop(Cause.of(NamedCause.source(this.angler)), exp, exp,
            fishHookSnapshot, this, transaction, (Player) this.angler);
        if (!SpongeImpl.postEvent(event)) {
            // Sponge end
            if (this.caughtEntity != null) {
                double d0 = this.angler.posX - this.posX;
                double d2 = this.angler.posY - this.posY;
                double d4 = this.angler.posZ - this.posZ;
                double d6 = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2 + d4 * d4);
                double d8 = 0.1D;
                this.caughtEntity.motionX += d0 * d8;
                this.caughtEntity.motionY += d2 * d8 + (double)MathHelper.sqrt_double(d6) * 0.08D;
                this.caughtEntity.motionZ += d4 * d8;
                b0 = 3;
            }

            // Sponge Start
            if (!event.getItemStackTransaction().getFinal().getType().equals(ItemTypes.NONE)) {
                ItemStackSnapshot itemSnapshot = event.getItemStackTransaction().getFinal();
                EntityItem entityitem1 = new EntityItem(this.worldObj, this.posX, this.posY, this.posZ, (net.minecraft.item.ItemStack) itemSnapshot.createStack());
                double d1 = this.angler.posX - this.posX;
                double d3 = this.angler.posY - this.posY;
                double d5 = this.angler.posZ - this.posZ;
                double d7 = MathHelper.sqrt_double(d1 * d1 + d3 * d3 + d5 * d5);
                double d9 = 0.1D;
                entityitem1.motionX = d1 * d9;
                entityitem1.motionY = d3 * d9 + MathHelper.sqrt_double(d7) * 0.08D;
                entityitem1.motionZ = d5 * d9;
                this.worldObj.spawnEntityInWorld(entityitem1);
                this.angler.worldObj.spawnEntityInWorld(
                        new EntityXPOrb(this.angler.worldObj, this.angler.posX, this.angler.posY + 0.5D, this.angler.posZ + 0.5D,
                                event.getExperience()));
                // Sponge End
                b0 = 1;
            }

            if (this.inGround) {
                b0 = 2;
            }

            this.setDead();
            this.angler.fishEntity = null;

            // Sponge Start
            if (this.fishingRod != null) {
                this.fishingRod.damageItem(b0, this.angler);
                this.angler.swingItem();
                this.fishingRod = null;
            }
            // Sponge End
        }
        return b0;
    }

    @Override
    public void setFishingRodItemStack(net.minecraft.item.ItemStack fishingRod) {
        this.fishingRod = fishingRod;
    }

    @Override
    public void readFromNbt(NBTTagCompound compound) {
        super.readFromNbt(compound);
        if (compound.hasKey(NbtDataUtil.PROJECTILE_DAMAGE_AMOUNT)) {
            this.damageAmount = compound.getDouble(NbtDataUtil.PROJECTILE_DAMAGE_AMOUNT);
        }
        ProjectileSourceSerializer.readSourceFromNbt(compound, this);
    }

    @Override
    public void writeToNbt(NBTTagCompound compound) {
        super.writeToNbt(compound);
        compound.setDouble(NbtDataUtil.PROJECTILE_DAMAGE_AMOUNT, this.damageAmount);
        ProjectileSourceSerializer.writeSourceToNbt(compound, this.projectileSource, this.angler);
    }
}


text:
#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace UniRx.Async.Internal
{
    public static class TaskTracker
    {
#if UNITY_EDITOR

        static int trackingId = 0;

        public const string EnableAutoReloadKey = "UniTaskTrackerWindow_EnableAutoReloadKey";
        public const string EnableTrackingKey = "UniTaskTrackerWindow_EnableTrackingKey";
        public const string EnableStackTraceKey = "UniTaskTrackerWindow_EnableStackTraceKey";

        public static class EditorEnableState
        {
            static bool enableAutoReload;
            public static bool EnableAutoReload
            {
                get { return enableAutoReload; }
                set
                {
                    enableAutoReload = value;
                    UnityEditor.EditorPrefs.SetBool(EnableAutoReloadKey, value);
                }
            }

            static bool enableTracking;
            public static bool EnableTracking
            {
                get { return enableTracking; }
                set
                {
                    enableTracking = value;
                    UnityEditor.EditorPrefs.SetBool(EnableTrackingKey, value);
                }
            }

            static bool enableStackTrace;
            public static bool EnableStackTrace
            {
                get { return enableStackTrace; }
                set
                {
                    enableStackTrace = value;
                    UnityEditor.EditorPrefs.SetBool(EnableStackTraceKey, value);
                }
            }
        }

#endif

        static List<KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>>();

        static readonly WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>();

        [Conditional("UNITY_EDITOR")]
        public static void TrackActiveTask(IAwaiter task, int skipFrame = 1)
        {
#if UNITY_EDITOR
            dirty = true;
            if (!EditorEnableState.EnableTracking) return;
            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, true).CleanupAsyncStackTrace() : "";
            tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
#endif
        }

        [Conditional("UNITY_EDITOR")]
        public static void TrackActiveTask(IAwaiter task, string stackTrace)
        {
#if UNITY_EDITOR
            dirty = true;
            if (!EditorEnableState.EnableTracking) return;
            var success = tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
#endif
        }

        public static string CaptureStackTrace(int skipFrame)
        {
#if UNITY_EDITOR
            if (!EditorEnableState.EnableTracking) return "";
            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame + 1, true).CleanupAsyncStackTrace() : "";
            return stackTrace;
#else
            return null;
#endif
        }

        [Conditional("UNITY_EDITOR")]
        public static void RemoveTracking(IAwaiter task)
        {
#if UNITY_EDITOR
            dirty = true;
            if (!EditorEnableState.EnableTracking) return;
            var success = tracking.TryRemove(task);
#endif
        }

        static bool dirty;

        public static bool CheckAndResetDirty()
        {
            var current = dirty;
            dirty = false;
            return current;
        }

        /// <summary>(trackingId, awaiterType, awaiterStatus, createdTime, stackTrace)</summary>
        public static void ForEachActiveTask(Action<int, string, AwaiterStatus, DateTime, string> action)
        {
            lock (listPool)
            {
                var count = tracking.ToList(ref listPool, clear: false);
                try
                {
                    for (int i = 0; i < count; i++)
                    {
                        string typeName = null;
                        var keyType = listPool[i].Key.GetType();
                        if (keyType.IsNested)
                        {
                            typeName = keyType.DeclaringType.Name + "." + keyType.Name;
                        }
                        else
                        {
                            typeName = keyType.Name;
                        }

                        action(listPool[i].Value.trackingId, typeName, listPool[i].Key.Status, listPool[i].Value.addTime, listPool[i].Value.stackTrace);
                        listPool[i] = new KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>(null, (0, default(DateTime), null)); // clear
                    }
                }
                catch
                {
                    listPool.Clear();
                    throw;
                }
            }
        }
    }
}

#endif


text:
var fs = require('fs');
var lineColumn = require("line-column");
var path = require('path');
var chai = require('chai');
var should = chai.should();
var _this = this;

var createUiDefFileName = "createuidefinition.json";
var mainTemplateFileName = "maintemplate.json";

// Get files in the root folder and in the nested folder if recursive is set true, otherwise only get files in the root folder
exports.getFiles = function getFiles(folder, fileType, filelist, recursive) {
    if (folder == './') {
        folder = __dirname + '/../';
    }
    if (folder.toLowerCase().endsWith('__macosx') || folder.toLowerCase().endsWith('source.temp')) { //skip Mac zip folder or temp folder for AMA
        return filelist;
    }
    var files = fs.readdirSync(folder);
    filelist = filelist || [];
    files.forEach(function(file) {
        if (fs.statSync(path.join(folder, file)).isDirectory() && recursive) {
            filelist = getFiles(path.join(folder, file), fileType, filelist, recursive);
        } else {
            if (file.toLowerCase().endsWith(fileType)) {
                filelist.push(path.join(folder, file));
            }
        }
    });
    return filelist;
};

// Get create ui def file
exports.getCreateUiDefFile = function getCreateUiDefFile(folder) {
    var createUiDefFiles = [];
    createUiDefFiles = _this.getFiles(folder, createUiDefFileName, createUiDefFiles, true);
    createUiDefFiles.length.should.equals(1, 'Only one createUiDefinition.json file should exist, but found ' + createUiDefFiles.length + ' file(s) in path ' + folder);
    var fileString = fs.readFileSync(path.resolve(createUiDefFiles[0]), {
        encoding: 'utf8'
    }).trim();
    return {
        file: path.resolve(createUiDefFiles[0]),
        jsonObject: JSON.parse(fileString)
    };
};

// Get main template file
exports.getMainTemplateFile = function getMainTemplateFile(folder) {
    var mainTemplateFiles = [];
    mainTemplateFiles = _this.getFiles(folder, mainTemplateFileName, mainTemplateFiles, true);
    var rootMainTemplateFiles = [];
    rootMainTemplateFiles = _this.getFiles(folder, mainTemplateFileName, rootMainTemplateFiles, false);
    /** There must be one mainTemplate.json in the root folder. */
    rootMainTemplateFiles.length.should.equals(1, 'Only one mainTemplate.json file should exist in the root folder, but found ' + mainTemplateFiles.length + ' file(s)');
    /** There cannot be more than one mainTemplate.json in the root folder and nested folders. */
    mainTemplateFiles.length.should.equals(1, 'Only one mainTemplate.json file should exist, but found ' + mainTemplateFiles.length + ' file(s) in path ' + path.resolve(folder));
    var fileString = fs.readFileSync(path.resolve(mainTemplateFiles[0]), {
        encoding: 'utf8'
    }).trim();
    return {
        file: path.resolve(mainTemplateFiles[0]),
        jsonObject: JSON.parse(fileString)
    };
};

// Get objects that matches a given key and value
exports.getObjects = function getObjects(obj, key, val) {
    var objects = [];
    for (var i in obj) {
        if (!obj.hasOwnProperty(i)) continue;
        if (typeof obj[i] == 'object') {
            objects = objects.concat(getObjects(obj[i], key, val));
        } else
        if (i.toLowerCase() == key && obj[i].toLowerCase() == val) { //
            objects.push(obj);
        }
    }
    return objects;
};

// Get template files
exports.getTemplateFiles = function getTemplateFiles(folder) {
    var templateFiles = [];
    templateFiles = _this.getFiles(folder, '.json', templateFiles, true);
    var files = [];
    var fileJSONObjects = [];
    templateFiles.forEach(f => {
        if (f.toLowerCase().indexOf(createUiDefFileName) == -1) {
            var fileString = fs.readFileSync(path.resolve(f), {
                encoding: 'utf8'
            }).trim().toLowerCase();
            var jsonObject = JSON.parse(fileString);
            if (jsonObject.$schema && jsonObject.$schema.match('schema.management.azure.com/schemas/(.*)/deploymenttemplate.json')) {
                files.push(path.resolve(f));
                fileJSONObjects.push({
                    filename: f,
                    value: jsonObject,
                    filepath: path.resolve(f)
                });
            }
        }
    });
    return {
        files: files,
        fileJSONObjects: fileJSONObjects
    };
};

// verify directory contains the file
exports.assertMainTemplateExists = function assertMainTemplateExists(folder) {
    _this.getMainTemplateFile(folder);
};

// verify directory contains the file
exports.assertCreateUiDefExists = function assertCreateUiDefExists(folder) {
    _this.getCreateUiDefFile(folder);
};

// for now, get position of name element in file, so better error message can be thrown
exports.getPosition = function getPosition(obj, file) {
    var fileString = fs.readFileSync(file, {
        encoding: 'utf8'
    }).trim();

    // get the object "name"
    var stringToSearch;
    for (var key in obj) {
        if (key.toLowerCase() == 'name') {
            stringToSearch = '"name": "' + obj[key] + '"';
        }
    }
    var ind = fileString.indexOf(stringToSearch);
    var lc = lineColumn(fileString).fromIndex(ind);
    if (lc) {
        return lc.line
    }
    return 'UNIDENTIFIED';
};


text:
package io.gatling.http.check.w2

import io.gatling.core.check.{ CheckProtocolProvider, Preparer, Specializer }
import io.gatling.core.check.extractor.jsonpath.JsonPathCheckType
import io.gatling.core.json.JsonParsers
import io.gatling.http.action.ws2.WsTextCheck

class WsJsonPathProvider(jsonParsers: JsonParsers) extends CheckProtocolProvider[JsonPathCheckType, WsTextCheck, String, Any] {

  override val specializer: Specializer[WsTextCheck, String] = WsTextCheck(_)

  override val preparer: Preparer[String, Any] = jsonParsers.safeParseBoon
}


text:
 pylint $1 | \
  grep -v "name doesn't conform" |  \
  grep -v "missing docstring" |  \
  grep -v "third party import" |  \
  grep -v "standard import" | \
  grep -v "doesn't conform to snake"  | \
  grep -v "issing class docstring" | \
  grep -v "Too many instance attributes" | \
  grep -v "Too many local variables" | \
  grep -v "Too few public methods" | \
  grep -v "Too many arguments" | \
  grep -v "Too many statements" | \
  grep -v "Too many branches" | \
  grep -v "Access to a protected member" | \
  grep -v "Missing function or method docstring" | \
  grep -v "Bad indentation" | \
  grep -v "(wrong-import-position)" | \
  grep -v "(useless-object-inheritance)" | \
  grep -v "Catching too general exception Exception"