text:
var canvas;
var canvas_size = { width: 100, height: 100 };

// this updates the svg preview with the current text inside the 'import_text' textbox
function update_preview() {
	canvas.clear();
	var path = canvas.path($('#import_text').val());

	// scale
	var bbox = path.getBBox();
	// to prevent cut off on the canvas sides, subtract one pixel for each side
	var scale = Math.min((canvas_size.width-2) / bbox.width, (canvas_size.height-2) / bbox.height);
	path.scale(scale, scale, 0, 0);
	bbox = path.getBBox(); // new bbox after scaling
	path.translate(1-bbox.x, 1-bbox.y); // same here: offset by 1px
}

function update_categories() {
	// get categories and add them to the category combo box
	$('#import_category').text('');
	$.ajax({
		   data: { task: 'getCategories' },
		   dataType: 'json',
		   success: function(json) {
				for(var item in json) {
					$('<option value=\'' + json[item].id + '\'>' + json[item].name + '</option>').appendTo('#import_category');
				}
				$('#import_category').val(0);
		   }
	});
}

$(function() {
	$.ajaxSetup({type: 'post'});

	// init raphael
	canvas = Raphael(document.getElementById('preview'), canvas_size.width, canvas_size.height);

	// update categories
	update_categories();

	// handle svg file import
	$('#import_file').change(function(event) {
		var reader = new FileReader();
		reader.onload = function() {
			if(reader.result.length == 0) {
				alert('Sorry, but you can\'t add an empty file!');
				return;
			}

			var svg = $($.parseXML(reader.result));
			var paths = svg.find('path');
			if(paths.length == 0) {
				alert('Sorry, but your SVG image doesn\'t contain any paths!');
				return;
			}

			// clear old data
			$('#import_text').text('');
			$('#import_text').val('');

			// new data:
			var data = '';
			paths.each(function (index, path) {
				var path = $(path).attr('d');
				if(path) {
					// replace first 'm' by 'M' if it exists and isn't preceded by an 'M'
					var first_m = path.indexOf('m');
					var first_M = path.indexOf('M');
					if(first_m >= 0 && (first_M < 0 || first_M > first_m)) {
						path = path.substring(0, first_m)+'M'+path.substring(first_m+1, path.length);
					}

					data += path + '\n';
				}
			});
			$('#import_text').val(data);

			update_preview();
		}
		reader.readAsBinaryString($('#import_file')[0].files[0]);
	});

	// update the svg preview when the textbox changes (key input)
	$('#import_text').bind('keyup', function(event) {
		update_preview();
	});

	// handle form submit
	$('#import_form').submit(function(event) {
		event.preventDefault();

		var import_name = $('#import_name').val();
		var import_text = $('#import_text').val();
		var import_category = $('#import_category').val();

		$.ajax({
		   data: { task: 'import', import_name: import_name, import_text: import_text, import_category: import_category },
		   dataType: 'text',
		   success: function(text) {
				if(text == 'success') {
					alert('Import successful!');

					// clear form
					$('#import_name').val('');
					$('#import_file').val('');
					$('#import_text').val('');
					$('#import_category').val(0);
					update_preview();

					return;
				}

				alert('Import failed: '+text);
		   }
		});
	});

	// handle 'add category'
	$('#import_add_category').click(function(event) {
		var category_name = prompt('Category Name:', '');
		if(category_name == '' || category_name.length == 0) {
			alert('Category name is empty!');
			return;
		}
		else if(category_name.length > 32) {
			alert('Category name is too long! (max: 32 characters)');
			return;
		}

		//
		$.ajax({
		   data: { task: 'addCategory', category_name: category_name },
		   dataType: 'text',
		   success: function(text) {
				if(text == 'success') {
					alert('Category \''+category_name+'\' added successfully!');
					update_categories();
					return;
				}

				alert('Failed to add category: '+text);
		   }
		});
	});
});


text:
<!DOCTYPE html>

    <meta http-equiv="refresh" content="0;URL=fn.from_u32_unchecked.html">

Redirecting to fn.from_u32_unchecked.html...

redpajama_set_name: RedPajamaGithub


text:
var browser = require("./browser.js");
var buster = require("buster");
var assert = buster.referee.assert;
var tc;

var nvc = browser.evalFiles(
    ['../lib/db.js', '../lib/highlight.js', '../lib/noteList.js']);
nvc.document = browser.document();
var db = nvc.db;
var highlight = nvc.highlight;
var noteList = nvc.noteList;

tc = {
  "simple note with highlight": function() {
    var note = {
      id: 99,
      title: 'Title test',
      text: 'Title test\nBody test\n'
    };
    var terms = ["test"];
    var regexp = highlight.regexpForHighlight(terms);
    var expected = '
Title <q>test</q>Body <q>test</q>\n
';
    assert.equals(noteList.test_noteHtml(regexp, note), expected);
  },
};
buster.testCase("single note with highlighting", tc);

tc = {
  "selection": function() {
    var observer = this.spy();
    var ul = nvc.document.createElement('ul');
    noteList.init(ul, observer);

    var notes = [
      {id: 33, title: 'Title', text: 'Title\nFoo\n'},
      {id: 99, title: 'Title test', text: 'Title test\nBody test\n'},
    ];
    var terms = [];
    noteList.display(terms, notes);
    var expected = '
TitleFoo\n
\n' +
                   '
Title testBody test\n
';
    assert.equals(ul.innerHTML, expected);

    // No previous selection -> select first.
    noteList.selectNext();
    assert.match(ul.children, [{className: 'selected'}, {}]);
    // Check the selection observer.
    assert.calledWithMatch(observer, {id: 33});

    noteList.selectNext();
    assert.match(ul.children, [{}, {className: 'selected'}]);
    // Check the selection observer.
    assert.calledWithMatch(observer, {id: 99});

    // Can't move past end.
    noteList.selectNext();
    assert.match(ul.children, [{}, {className: 'selected'}]);

    // And back.
    noteList.selectPrev();
    assert.match(ul.children, [{className: 'selected'}, {}]);

    // Can't move past beginning.
    noteList.selectPrev();
    assert.match(ul.children, [{className: 'selected'}, {}]);
  },
};
buster.testCase("noteList", tc);


text:
.syntaxhighlighter,
.syntaxhighlighter div,
.syntaxhighlighter code,
.syntaxhighlighter table,
.syntaxhighlighter table td,
.syntaxhighlighter table tr,
.syntaxhighlighter table tbody
{
	margin: 0 !important;
	padding: 0 !important;
	border: 0 !important;
	outline: 0 !important;
	background: none !important;
	text-align: left !important;
	float: none !important;
	vertical-align: baseline !important;
	position: static !important;
	left: auto !important;
	top: auto !important;
	right: auto !important;
	bottom: auto !important;
	height: auto !important;
	width: auto !important;
	font-family: "Consolas", "Bitstream Vera Sans Mono", "Courier New", Courier, monospace !important;
	font-weight: normal !important;
	font-style: normal !important;
	min-height: inherit !important; /* For IE8, FF & WebKit */
	min-height: auto !important; /* For IE7 */

/*
	line-height: 1.1em !important;
	font-size: 1em !important;
*/

	font-size:12px !important;
	line-height:18px !important;

}

.syntaxhighlighter
{
	width: 99.9% !important; /* 99% fixes IE8 horizontal scrollbar */
	margin: 1em 0 1em 0 !important;
	padding: 1px !important; /* adds a little border on top and bottom */
	position: relative !important;
}

.syntaxhighlighter .bold
{
	font-weight: bold !important;
}

.syntaxhighlighter .italic
{
	font-style: italic !important;
}

.syntaxhighlighter .line
{
}

.syntaxhighlighter .no-wrap .line .content
{
	white-space: pre !important;
}

.syntaxhighlighter .line table
{
	border-collapse: collapse !important;
}

.syntaxhighlighter .line td
{
	vertical-align: top !important;
}

.syntaxhighlighter .line .number
{
	width: 3em !important;
}

.syntaxhighlighter .line .number code
{
	width: 2.7em !important;
	padding-right: .3em !important;
	text-align: right !important;
	display: block !important;
}

.syntaxhighlighter .line .content
{
	padding-left: .5em !important;
}

.syntaxhighlighter .line .spaces
{
}

/* Disable border and margin on the lines when no gutter option is set */
.syntaxhighlighter.nogutter .line .content
{
	border-left: none !important;
}

.syntaxhighlighter .bar
{
	display: none !important;
}

.syntaxhighlighter .bar.show
{
	display: block !important;
}

.syntaxhighlighter.collapsed .bar
{
	display: block !important;
}

/* Adjust some properties when collapsed */

.syntaxhighlighter.collapsed .lines
{
	display: none !important;
}

.syntaxhighlighter .lines.no-wrap
{
	overflow: auto !important;
	overflow-y: hidden !important;
}

/* Styles for the toolbar */

.syntaxhighlighter .toolbar
{
	position: absolute !important;
	right: 0px !important;
	top: 0px !important;
	font-size: 1px !important;
	padding: 8px 8px 8px 0 !important; /* in px because images don't scale with ems */
}

.syntaxhighlighter.collapsed .toolbar
{
	font-size: 80% !important;
	padding: .2em 0 .5em .5em !important;
	position: static !important;
}

.syntaxhighlighter .toolbar a.item,
.syntaxhighlighter .toolbar .item
{
	display: block !important;
	float: left !important;
	margin-left: 8px !important;
	background-repeat: no-repeat !important;
	overflow: hidden !important;
	text-indent: -5000px !important;
}

.syntaxhighlighter.collapsed .toolbar .item
{
	display: none !important;
}

.syntaxhighlighter.collapsed .toolbar .item.expandSource
{
	background-image: url(magnifier.png) !important;
	display: inline !important;
	text-indent: 0 !important;
	width: auto !important;
	float: none !important;
	height: 16px !important;
	padding-left: 20px !important;
}

.syntaxhighlighter .toolbar .item.viewSource
{
	background-image: url(page_white_code.png) !important;
}

.syntaxhighlighter .toolbar .item.printSource
{
	background-image: url(printer.png) !important;
}

.syntaxhighlighter .toolbar .item.copyToClipboard
{
	text-indent: 0 !important;
	background: none !important;
	overflow: visible !important;
}

.syntaxhighlighter .toolbar .item.about
{
	background-image: url(help.png) !important;
}

/**
 * Print view.
 * Colors are based on the default theme without background.
 */

.syntaxhighlighter.printing,
.syntaxhighlighter.printing .line.alt1 .content,
.syntaxhighlighter.printing .line.alt2 .content,
.syntaxhighlighter.printing .line.highlighted .number,
.syntaxhighlighter.printing .line.highlighted.alt1 .content,
.syntaxhighlighter.printing .line.highlighted.alt2 .content,
{
	background: none !important;
}

/* Gutter line numbers */
.syntaxhighlighter.printing .line .number
{
	color: #bbb !important;
}

/* Add border to the lines */
.syntaxhighlighter.printing .line .content
{
	color: #000 !important;
}

/* Toolbar when visible */
.syntaxhighlighter.printing .toolbar
{
	display: none !important;
}

.syntaxhighlighter.printing a
{
	text-decoration: none !important;
}

.syntaxhighlighter.printing .plain,
.syntaxhighlighter.printing .plain a
{
	color: #000 !important;
}

.syntaxhighlighter.printing .comments,
.syntaxhighlighter.printing .comments a
{
	color: #008200 !important;
}

.syntaxhighlighter.printing .string,
.syntaxhighlighter.printing .string a
{
	color: blue !important;
}

.syntaxhighlighter.printing .keyword
{
	color: #069 !important;
	font-weight: bold !important;
}

.syntaxhighlighter.printing .preprocessor
{
	color: gray !important;
}

.syntaxhighlighter.printing .variable
{
	color: #a70 !important;
}

.syntaxhighlighter.printing .value
{
	color: #090 !important;
}

.syntaxhighlighter.printing .functions
{
	color: #ff1493 !important;
}

.syntaxhighlighter.printing .constants
{
	color: #0066CC !important;
}

.syntaxhighlighter.printing .script
{
	font-weight: bold !important;
}

.syntaxhighlighter.printing .color1,
.syntaxhighlighter.printing .color1 a
{
	color: #808080 !important;
}

.syntaxhighlighter.printing .color2,
.syntaxhighlighter.printing .color2 a
{
	color: #ff1493 !important;
}

.syntaxhighlighter.printing .color3,
.syntaxhighlighter.printing .color3 a
{
	color: red !important;
}
/**
 * SyntaxHighlighter
 * http://alexgorbatchev.com/
 *
 * SyntaxHighlighter is donationware. If you are using it, please donate.
 * http://alexgorbatchev.com/wiki/SyntaxHighlighter:Donate
 *
 * @version
 * 2.1.364 (October 15 2009)
 *
 * @copyright
 * Copyright (C) 2004-2009 Alex Gorbatchev.
 *
 * @license
 * This file is part of SyntaxHighlighter.
 *
 * SyntaxHighlighter is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SyntaxHighlighter is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with SyntaxHighlighter.  If not, see <http://www.gnu.org/copyleft/lesser.html>.
 */
/************************************
 * Default Syntax Highlighter theme.
 *
 * Interface elements.
 ************************************/

.syntaxhighlighter
{
	background-color: #fff !important;
}

/* Highlighed line number */
.syntaxhighlighter .line.highlighted .number
{
	color: black !important;
}

/* Highlighed line */
.syntaxhighlighter .line.highlighted.alt1,
.syntaxhighlighter .line.highlighted.alt2
{
	background-color: #e0e0e0 !important;
}

/* Gutter line numbers */
.syntaxhighlighter .line .number
{
	color: #afafaf !important;
}

/* Add border to the lines */
.syntaxhighlighter .line .content
{
	border-left: 1px solid gray !important;
	color: #000 !important;
}

.syntaxhighlighter.printing .line .content
{
	border: 0 !important;
}

/* First line */
.syntaxhighlighter .line.alt1
{
	background-color: #fff !important;
}

/* Second line */
.syntaxhighlighter .line.alt2
{
	background-color: #F8F8F8 !important;
}

.syntaxhighlighter .toolbar
{
	background-color: #F8F8F8 !important;
	border: #E7E5DC solid 1px !important;
}

.syntaxhighlighter .toolbar a
{
	color: #a0a0a0 !important;
}

.syntaxhighlighter .toolbar a:hover
{
	color: red !important;
}

/************************************
 * Actual syntax highlighter colors.
 ************************************/
.syntaxhighlighter .plain,
.syntaxhighlighter .plain a
{
	color: #000 !important;
}

.syntaxhighlighter .comments,
.syntaxhighlighter .comments a
{
	color: #008200 !important;
}

.syntaxhighlighter .string,
.syntaxhighlighter .string a
{
	color: blue !important;
}

.syntaxhighlighter .keyword
{
	color: #069 !important;
	font-weight: bold !important;
}

.syntaxhighlighter .preprocessor
{
	color: gray !important;
}

.syntaxhighlighter .variable
{
	color: #a70 !important;
}

.syntaxhighlighter .value
{
	color: #090 !important;
}

.syntaxhighlighter .functions
{
	color: #ff1493 !important;
}

.syntaxhighlighter .constants
{
	color: #0066CC !important;
}

.syntaxhighlighter .script
{
	background-color: yellow !important;
}

.syntaxhighlighter .color1,
.syntaxhighlighter .color1 a
{
	color: #808080 !important;
}

.syntaxhighlighter .color2,
.syntaxhighlighter .color2 a
{
	color: #ff1493 !important;
}

.syntaxhighlighter .color3,
.syntaxhighlighter .color3 a
{
	color: red !important;
}


text:
# Events listeners / subscribers

## Events

The bundle is throwing some events during an elFinder command execution :
- `FM\ElfinderBundle\Event\ElFinderEvents::PRE_EXECUTION` : `fm_elfinder.event.pre_execution`
- `FM\ElfinderBundle\Event\ElFinderEvents::POST_EXECUTION` : `fm_elfinder.event.post_execution`

The pre execution event has its own class (`FM\ElfinderBundle\Event\ElFinderPreExecutionEvent`) which contains
the http request object, the elFinder instance name and the home folder.

The post execution event (`FM\ElfinderBundle\Event\ElFinderPostExecutionEvent`) has the same attributes
than the pre execution events, plus the command result and a `hasErrors()` function indicating if
errors has been encountered during command execution.
The result to return to the elFinder.js client can be modified with the post execution event
using the `setResult` function on this event.

You can register event listeners with the `fm_elfinder.event_listener` tag
and event subscribers with the `fm_elfinder.event_subscriber` tag.

**Note:** you must set the [`cors_support`](https://github.com/helios-ag/FMElfinderBundle/blob/master/docs/cors-support.md "CORS Support documentation") option to `true` to use events.
If you don't, the symfony life cycle won't end properly and the post execution event won't be dispatched.
Only use the NelmioCORSBundle if your elFinder client is on an other domain.

You can access to all commands names [here](https://github.com/helios-ag/ElFinderPHP/blob/master/src/ElFinder.php#L61 "elFinder commands").

## Sub requests

Events allows you to perform sub requests (only for commands used with HTTP GET method, i.e. not to upload a file).
These subrequests are working the same way than `forward` function on symfony controllers,
and are also hookable.

**Note:** You will have to set a `volume_id` to your instance's root to be sure the volume
is mounted with the same ID between each requests.

Here is an exemple of event listener on the post execution event, making a sub request :

```xml
<!-- src/AppBundle/Resources/config/services.xml -->
<service id="app_bundle.listener.elfinder_post_execution" class="AppBundle\EventListener\ElFinder\PostExecutionListener">
    <tag name="fm_elfinder.event_listener" event="fm_elfinder.event.post_execution" method="onPostExecute" />
</service>
```

```php
// src/AppBundle/EventListener/ElFinder/PostExecutionListener.php
namespace AppBundle\EventListener\ElFinder;

use FM\ElfinderBundle\Event\ElFinderPostExecutionEvent;

class PostExecutionListener
{
    /**
     * @param  ElFinderPostExecutionEvent $event
     */
    public function onPostExecute(ElFinderPostExecutionEvent $event)
    {
        if (!$event->hasErrors() && $event->getCommand() == 'tmb') { // 'tmb', 'mkdir', 'open', etc...
            // do your stuff here
            // ...
            // you can perform a sub request
            $queryParameters = $event->getRequest()->query->all(); // getting original request parameters
            $queryParameters['cmd'] = 'info'; // changing the command to execute in sub request

            $jsonResponse = $event->subRequest(array(
                'instance' => $event->getInstance(),    // you can also make a subrequest on an other instance
                'homeFolder' => $event->getHomeFolder() // and an other homeFolder
            ), $queryParameters);

            $data = json_decode($jsonResponse->getContent());
            // work with sub request data
            // ...
        }
    }
}
```


text:
package org.ovirt.engine.ui.common.widget.uicommon.storage;

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

import com.google.gwt.dom.client.Style;
import org.ovirt.engine.ui.common.widget.UiCommandButton;
import org.ovirt.engine.ui.common.widget.editor.EntityModelCellTable;
import org.ovirt.engine.ui.common.widget.label.TextBoxLabel;
import org.ovirt.engine.ui.common.widget.table.column.LunSelectionColumn;
import org.ovirt.engine.ui.common.widget.table.column.LunTextColumn;
import org.ovirt.engine.ui.common.widget.table.column.ScrollableTextColumn;
import org.ovirt.engine.ui.uicommonweb.models.EntityModel;
import org.ovirt.engine.ui.uicommonweb.models.ListModel;
import org.ovirt.engine.ui.uicommonweb.models.storage.LunModel;
import org.ovirt.engine.ui.uicommonweb.models.storage.SanStorageModelBase;
import org.ovirt.engine.ui.uicommonweb.models.storage.SanTargetModel;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.Scheduler;
import com.google.gwt.core.client.Scheduler.ScheduledCommand;
import com.google.gwt.dom.client.Style.Float;
import com.google.gwt.dom.client.Style.TableLayout;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.cellview.client.CellTable.Resources;
import com.google.gwt.user.cellview.client.TextColumn;
import com.google.gwt.user.client.ui.HasVerticalAlignment;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.ScrollPanel;
import com.google.gwt.user.client.ui.TreeItem;
import com.google.gwt.user.client.ui.ValueBoxBase.TextAlignment;
import com.google.gwt.view.client.SelectionChangeEvent;
import com.google.gwt.view.client.SelectionChangeEvent.Handler;
import com.google.gwt.view.client.SingleSelectionModel;

public class SanStorageTargetToLunList extends AbstractSanStorageList<SanTargetModel, ListModel> {

    protected int treeScrollPosition;

    public SanStorageTargetToLunList(SanStorageModelBase model) {
        super(model);
    }

    public SanStorageTargetToLunList(SanStorageModelBase model, boolean hideLeaf) {
        super(model, hideLeaf, false);
    }

    public SanStorageTargetToLunList(SanStorageModelBase model, boolean hideLeaf, boolean multiSelection) {
        super(model, hideLeaf, multiSelection);
    }

    @Override
    protected void createSanStorageListWidget() {
        super.createSanStorageListWidget();

    }

    @Override
    protected ListModel getLeafModel(SanTargetModel rootModel) {
        return rootModel.getLunsList();
    }

    @Override
    protected void createHeaderWidget() {
        EntityModelCellTable<ListModel> table = new EntityModelCellTable<ListModel>(false,
                (Resources) GWT.create(SanStorageListHeaderResources.class),
                true);

        // Add first blank column
        table.addColumn(new TextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return ""; //$NON-NLS-1$
            }
        }, constants.empty(), "20px"); //$NON-NLS-1$

        table.addColumn(new ScrollableTextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return model.getName();
            }
        }, constants.targetNameSanStorage(), ""); //$NON-NLS-1$

        table.addColumn(new ScrollableTextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return model.getAddress();
            }
        }, constants.addressSanStorage(), "95px"); //$NON-NLS-1$

        table.addColumn(new ScrollableTextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return model.getPort();
            }
        }, constants.portSanStorage(), "65px"); //$NON-NLS-1$

        table.setWidth("100%", true); //$NON-NLS-1$

        // Add last blank columns
        table.addColumn(new TextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return ""; //$NON-NLS-1$
            }
        }, constants.empty(), "30px"); //$NON-NLS-1$
        table.addColumn(new TextColumn<SanTargetModel>() {
            @Override
            public String getValue(SanTargetModel model) {
                return ""; //$NON-NLS-1$
            }
        }, constants.empty(), "17px"); //$NON-NLS-1$

        // Add blank item list
        table.setRowData(new ArrayList<EntityModel>());
        table.setWidth("100%", true); //$NON-NLS-1$

        // Add table as header widget
        treeHeader.add(table);
    }

    private void addLoginButton(HorizontalPanel panel, SanTargetModel rootModel) {
        final UiCommandButton loginButton = new UiCommandButton();
        loginButton.setCommand(rootModel.getLoginCommand());
        loginButton.setTitle(constants.storageIscsiPopupLoginButtonLabel());
        loginButton.setImage(rootModel.getLoginCommand().getIsExecutionAllowed() ?
                resources.loginIcon() : resources.loginDisabledIcon());
        loginButton.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                treeScrollPosition = treeContainer.getVerticalScrollPosition();
                loginButton.getCommand().execute();
            }
        });
        loginButton.getElement().getStyle().setFloat(Float.RIGHT);
        loginButton.getElement().getStyle().setMarginRight(6, Unit.PX);
        Style spanStyle = loginButton.getElement().getElementsByTagName("span").getItem(0).getStyle(); //$NON-NLS-1$
        spanStyle.setPosition(Style.Position.RELATIVE);
        spanStyle.setTop(-3, Unit.PX);

        panel.add(loginButton);
        panel.setCellVerticalAlignment(loginButton, HasVerticalAlignment.ALIGN_MIDDLE);
        panel.setCellWidth(loginButton, "35px"); //$NON-NLS-1$
    }

    private void additemToRootNodePanel(HorizontalPanel panel,
            TextBoxLabel item,
            String text,
            String width,
            TextAlignment align) {
        item.getElement().getStyle().setBackgroundColor("transparent"); //$NON-NLS-1$
        item.getElement().getStyle().setColor("black"); //$NON-NLS-1$
        item.setAlignment(align);
        item.setText(text);

        panel.add(item);
        panel.setCellWidth(item, width);
    }

    @Override
    protected TreeItem createRootNode(SanTargetModel rootModel) {
        HorizontalPanel panel = new HorizontalPanel();

        additemToRootNodePanel(panel, new TextBoxLabel(), rootModel.getName(), "", TextAlignment.LEFT); //$NON-NLS-1$
        additemToRootNodePanel(panel, new TextBoxLabel(), rootModel.getAddress(), "95px", TextAlignment.LEFT); //$NON-NLS-1$
        additemToRootNodePanel(panel, new TextBoxLabel(), rootModel.getPort(), "60px", TextAlignment.LEFT); //$NON-NLS-1$
        addLoginButton(panel, rootModel);

        panel.setSpacing(1);
        panel.setWidth("100%"); //$NON-NLS-1$
        panel.getElement().getStyle().setTableLayout(TableLayout.FIXED);

        return new TreeItem(panel);
    }

    @SuppressWarnings("unchecked")
    @Override
    protected TreeItem createLeafNode(ListModel leafModel) {
        TreeItem item = new TreeItem();
        List<LunModel> items = (List<LunModel>) leafModel.getItems();

        if (hideLeaf || items.isEmpty()) {
            item.setUserObject(Boolean.TRUE);
            return item;
        }

        final EntityModelCellTable<ListModel> table =
                new EntityModelCellTable<ListModel>(multiSelection,
                        (Resources) GWT.create(SanStorageListLunTableResources.class));

        LunSelectionColumn lunSelectionColumn = new LunSelectionColumn(multiSelection) {
            @Override
            public LunModel getValue(LunModel object) {
                return object;
            }
        };

        table.setCustomSelectionColumn(lunSelectionColumn, "30px"); //$NON-NLS-1$

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return model.getLunId();
            }
        }, constants.lunIdSanStorage());

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return String.valueOf(model.getSize()) + "GB"; //$NON-NLS-1$
            }
        }, constants.devSizeSanStorage(), "70px"); //$NON-NLS-1$

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return String.valueOf(model.getMultipathing());
            }
        }, constants.pathSanStorage(), "55px"); //$NON-NLS-1$

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return model.getVendorId();
            }
        }, constants.vendorIdSanStorage(), "100px"); //$NON-NLS-1$

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return model.getProductId();
            }
        }, constants.productIdSanStorage(), "100px"); //$NON-NLS-1$

        table.addColumn(new LunTextColumn() {
            @Override
            public String getRawValue(LunModel model) {
                return model.getSerial();
            }
        }, constants.serialSanStorage(), "120px"); //$NON-NLS-1$

        table.setRowData(items);
        table.asEditor().edit(leafModel);
        table.setWidth("100%", true); //$NON-NLS-1$

        if (!multiSelection) {
            for (LunModel lunModel : items) {
                if (lunModel.getIsSelected()) {
                    table.getSelectionModel().setSelected(lunModel, true);
                }
            }

            table.getSelectionModel().addSelectionChangeHandler(new Handler() {
                @Override
                public void onSelectionChange(SelectionChangeEvent event) {
                    SingleSelectionModel SingleSelectionModel = (SingleSelectionModel) event.getSource();
                    LunModel selectedLunModel = (LunModel) SingleSelectionModel.getSelectedObject();

                    if (selectedLunModel != null) {
                        updateSelectedLunWarning(selectedLunModel);
                    }
                }
            });
        }
        else {
            for (LunModel lunModel : items) {
                table.getSelectionModel().setSelected(lunModel, lunModel.getIsSelected());
            }
        }

        ScrollPanel panel = new ScrollPanel();
        panel.add(table);
        item.setWidget(panel);

        // Display LUNs as grayed-out if needed
        for (LunModel lunModel : items) {
            if (lunModel.getIsGrayedOut()) {
                grayOutItem(lunModel.getGrayedOutReasons(), lunModel, table);
            }
        }

        return item;
    }

    @Override
    protected void updateItems() {
        super.updateItems();

        Scheduler.get().scheduleDeferred(new ScheduledCommand() {
            @Override
            public void execute() {
                treeContainer.setVerticalScrollPosition(treeScrollPosition);
            }
        });
    }
}


text:
<?php

namespace Spec\Dumplie\SharedKernel\Infrastructure\Tactician\Middleware;

use Dumplie\Customer\Application\Command\AddToCart;
use Dumplie\SharedKernel\Application\Command\Extension;
use Dumplie\SharedKernel\Application\Command\ExtensionRegistry;
use Dumplie\SharedKernel\Application\ServiceLocator;
use Dumplie\Customer\Domain\CartId;
use PhpSpec\ObjectBehavior;
use Prophecy\Argument;

class ExtensionMiddlewareSpec extends ObjectBehavior
{
    /**
     * @var ExtensionRegistry
     */
    private $registry;

    function let(ServiceLocator $serviceLocator)
    {
        $this->registry = new ExtensionRegistry($serviceLocator->getWrappedObject());
        $this->beConstructedWith($this->registry);
    }

    function it_execute_extension_points(Extension $extension)
    {
        $command = new AddToCart("SKU", 1, (string) CartId::generate());

        $extension->pre($command, Argument::type(ServiceLocator::class))->shouldBeCalled();
        $extension->post($command, Argument::type(ServiceLocator::class))->shouldBeCalled();
        $extension->expands($command)->willReturn(true);

        $this->registry->register($extension->getWrappedObject());

        $this->execute($command, function() {});
    }
}


text:
import datetime
from typing import Dict, List, Optional, TYPE_CHECKING, Union

from .. import _serialization

if TYPE_CHECKING:
    # pylint: disable=unused-import,ungrouped-imports
    from .. import models as _models

class AADBasedSecurityPrincipal(_serialization.Model):
    """AAD based security principal with associated Ledger RoleName.

    :ivar principal_id: UUID/GUID based Principal Id of the Security Principal.
    :vartype principal_id: str
    :ivar tenant_id: UUID/GUID based Tenant Id of the Security Principal.
    :vartype tenant_id: str
    :ivar ledger_role_name: LedgerRole associated with the Security Principal of Ledger. Known
     values are: "Reader", "Contributor", and "Administrator".
    :vartype ledger_role_name: str or ~azure.mgmt.confidentialledger.models.LedgerRoleName
    """

    _attribute_map = {
        "principal_id": {"key": "principalId", "type": "str"},
        "tenant_id": {"key": "tenantId", "type": "str"},
        "ledger_role_name": {"key": "ledgerRoleName", "type": "str"},
    }

    def __init__(
        self,
        *,
        principal_id: Optional[str] = None,
        tenant_id: Optional[str] = None,
        ledger_role_name: Optional[Union[str, "_models.LedgerRoleName"]] = None,
        **kwargs
    ):
        """
        :keyword principal_id: UUID/GUID based Principal Id of the Security Principal.
        :paramtype principal_id: str
        :keyword tenant_id: UUID/GUID based Tenant Id of the Security Principal.
        :paramtype tenant_id: str
        :keyword ledger_role_name: LedgerRole associated with the Security Principal of Ledger. Known
         values are: "Reader", "Contributor", and "Administrator".
        :paramtype ledger_role_name: str or ~azure.mgmt.confidentialledger.models.LedgerRoleName
        """
        super().__init__(**kwargs)
        self.principal_id = principal_id
        self.tenant_id = tenant_id
        self.ledger_role_name = ledger_role_name

class CertBasedSecurityPrincipal(_serialization.Model):
    """Cert based security principal with Ledger RoleName.

    :ivar cert: Public key of the user cert (.pem or .cer).
    :vartype cert: str
    :ivar ledger_role_name: LedgerRole associated with the Security Principal of Ledger. Known
     values are: "Reader", "Contributor", and "Administrator".
    :vartype ledger_role_name: str or ~azure.mgmt.confidentialledger.models.LedgerRoleName
    """

    _attribute_map = {
        "cert": {"key": "cert", "type": "str"},
        "ledger_role_name": {"key": "ledgerRoleName", "type": "str"},
    }

    def __init__(
        self,
        *,
        cert: Optional[str] = None,
        ledger_role_name: Optional[Union[str, "_models.LedgerRoleName"]] = None,
        **kwargs
    ):
        """
        :keyword cert: Public key of the user cert (.pem or .cer).
        :paramtype cert: str
        :keyword ledger_role_name: LedgerRole associated with the Security Principal of Ledger. Known
         values are: "Reader", "Contributor", and "Administrator".
        :paramtype ledger_role_name: str or ~azure.mgmt.confidentialledger.models.LedgerRoleName
        """
        super().__init__(**kwargs)
        self.cert = cert
        self.ledger_role_name = ledger_role_name

class Tags(_serialization.Model):
    """Tags for Confidential Ledger Resource.

    :ivar tags: Additional tags for Confidential Ledger.
    :vartype tags: dict[str, str]
    """

    _attribute_map = {
        "tags": {"key": "tags", "type": "{str}"},
    }

    def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs):
        """
        :keyword tags: Additional tags for Confidential Ledger.
        :paramtype tags: dict[str, str]
        """
        super().__init__(**kwargs)
        self.tags = tags

class Location(_serialization.Model):
    """Location of the ARM Resource.

    :ivar location: The Azure location where the Confidential Ledger is running.
    :vartype location: str
    """

    _attribute_map = {
        "location": {"key": "location", "type": "str"},
    }

    def __init__(self, *, location: Optional[str] = None, **kwargs):
        """
        :keyword location: The Azure location where the Confidential Ledger is running.
        :paramtype location: str
        """
        super().__init__(**kwargs)
        self.location = location

class Resource(_serialization.Model):
    """An Azure resource.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar name: Name of the Resource.
    :vartype name: str
    :ivar id: Fully qualified resource Id for the resource.
    :vartype id: str
    :ivar type: The type of the resource.
    :vartype type: str
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~azure.mgmt.confidentialledger.models.SystemData
    """

    _validation = {
        "name": {"readonly": True},
        "id": {"readonly": True},
        "type": {"readonly": True},
        "system_data": {"readonly": True},
    }

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "id": {"key": "id", "type": "str"},
        "type": {"key": "type", "type": "str"},
        "system_data": {"key": "systemData", "type": "SystemData"},
    }

    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)
        self.name = None
        self.id = None
        self.type = None
        self.system_data = None

class ConfidentialLedger(Resource, Location, Tags):
    """Confidential Ledger. Contains the properties of Confidential Ledger Resource.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar tags: Additional tags for Confidential Ledger.
    :vartype tags: dict[str, str]
    :ivar location: The Azure location where the Confidential Ledger is running.
    :vartype location: str
    :ivar name: Name of the Resource.
    :vartype name: str
    :ivar id: Fully qualified resource Id for the resource.
    :vartype id: str
    :ivar type: The type of the resource.
    :vartype type: str
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~azure.mgmt.confidentialledger.models.SystemData
    :ivar properties: Properties of Confidential Ledger Resource.
    :vartype properties: ~azure.mgmt.confidentialledger.models.LedgerProperties
    """

    _validation = {
        "name": {"readonly": True},
        "id": {"readonly": True},
        "type": {"readonly": True},
        "system_data": {"readonly": True},
    }

    _attribute_map = {
        "tags": {"key": "tags", "type": "{str}"},
        "location": {"key": "location", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "id": {"key": "id", "type": "str"},
        "type": {"key": "type", "type": "str"},
        "system_data": {"key": "systemData", "type": "SystemData"},
        "properties": {"key": "properties", "type": "LedgerProperties"},
    }

    def __init__(
        self,
        *,
        tags: Optional[Dict[str, str]] = None,
        location: Optional[str] = None,
        properties: Optional["_models.LedgerProperties"] = None,
        **kwargs
    ):
        """
        :keyword tags: Additional tags for Confidential Ledger.
        :paramtype tags: dict[str, str]
        :keyword location: The Azure location where the Confidential Ledger is running.
        :paramtype location: str
        :keyword properties: Properties of Confidential Ledger Resource.
        :paramtype properties: ~azure.mgmt.confidentialledger.models.LedgerProperties
        """
        super().__init__(location=location, tags=tags, **kwargs)
        self.tags = tags
        self.location = location
        self.properties = properties
        self.name = None
        self.id = None
        self.type = None
        self.system_data = None

class ConfidentialLedgerList(_serialization.Model):
    """Object that includes an array of Confidential Ledgers and a possible link for next set.

    :ivar value: List of Confidential Ledgers.
    :vartype value: list[~azure.mgmt.confidentialledger.models.ConfidentialLedger]
    :ivar next_link: The URL the client should use to fetch the next page (per server side paging).
    :vartype next_link: str
    """

    _attribute_map = {
        "value": {"key": "value", "type": "[ConfidentialLedger]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self, *, value: Optional[List["_models.ConfidentialLedger"]] = None, next_link: Optional[str] = None, **kwargs
    ):
        """
        :keyword value: List of Confidential Ledgers.
        :paramtype value: list[~azure.mgmt.confidentialledger.models.ConfidentialLedger]
        :keyword next_link: The URL the client should use to fetch the next page (per server side
         paging).
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link

class ErrorAdditionalInfo(_serialization.Model):
    """The resource management error additional info.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar type: The additional info type.
    :vartype type: str
    :ivar info: The additional info.
    :vartype info: JSON
    """

    _validation = {
        "type": {"readonly": True},
        "info": {"readonly": True},
    }

    _attribute_map = {
        "type": {"key": "type", "type": "str"},
        "info": {"key": "info", "type": "object"},
    }

    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)
        self.type = None
        self.info = None

class ErrorDetail(_serialization.Model):
    """The error detail.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar code: The error code.
    :vartype code: str
    :ivar message: The error message.
    :vartype message: str
    :ivar target: The error target.
    :vartype target: str
    :ivar details: The error details.
    :vartype details: list[~azure.mgmt.confidentialledger.models.ErrorDetail]
    :ivar additional_info: The error additional info.
    :vartype additional_info: list[~azure.mgmt.confidentialledger.models.ErrorAdditionalInfo]
    """

    _validation = {
        "code": {"readonly": True},
        "message": {"readonly": True},
        "target": {"readonly": True},
        "details": {"readonly": True},
        "additional_info": {"readonly": True},
    }

    _attribute_map = {
        "code": {"key": "code", "type": "str"},
        "message": {"key": "message", "type": "str"},
        "target": {"key": "target", "type": "str"},
        "details": {"key": "details", "type": "[ErrorDetail]"},
        "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"},
    }

    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)
        self.code = None
        self.message = None
        self.target = None
        self.details = None
        self.additional_info = None

class ErrorResponse(_serialization.Model):
    """Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

    :ivar error: The error object.
    :vartype error: ~azure.mgmt.confidentialledger.models.ErrorDetail
    """

    _attribute_map = {
        "error": {"key": "error", "type": "ErrorDetail"},
    }

    def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs):
        """
        :keyword error: The error object.
        :paramtype error: ~azure.mgmt.confidentialledger.models.ErrorDetail
        """
        super().__init__(**kwargs)
        self.error = error

class LedgerProperties(_serialization.Model):
    """Additional Confidential Ledger properties.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar ledger_name: Unique name for the Confidential Ledger.
    :vartype ledger_name: str
    :ivar ledger_uri: Endpoint for calling Ledger Service.
    :vartype ledger_uri: str
    :ivar identity_service_uri: Endpoint for accessing network identity.
    :vartype identity_service_uri: str
    :ivar ledger_internal_namespace: Internal namespace for the Ledger.
    :vartype ledger_internal_namespace: str
    :ivar ledger_storage_account: Name of the Blob Storage Account for saving ledger files.
    :vartype ledger_storage_account: str
    :ivar ledger_type: Type of Confidential Ledger. Known values are: "Unknown", "Public", and
     "Private".
    :vartype ledger_type: str or ~azure.mgmt.confidentialledger.models.LedgerType
    :ivar provisioning_state: Provisioning state of Ledger Resource. Known values are: "Unknown",
     "Succeeded", "Failed", "Canceled", "Creating", "Deleting", and "Updating".
    :vartype provisioning_state: str or ~azure.mgmt.confidentialledger.models.ProvisioningState
    :ivar aad_based_security_principals: Array of all AAD based Security Principals.
    :vartype aad_based_security_principals:
     list[~azure.mgmt.confidentialledger.models.AADBasedSecurityPrincipal]
    :ivar cert_based_security_principals: Array of all cert based Security Principals.
    :vartype cert_based_security_principals:
     list[~azure.mgmt.confidentialledger.models.CertBasedSecurityPrincipal]
    """

    _validation = {
        "ledger_name": {"readonly": True},
        "ledger_uri": {"readonly": True},
        "identity_service_uri": {"readonly": True},
        "ledger_internal_namespace": {"readonly": True},
        "provisioning_state": {"readonly": True},
    }

    _attribute_map = {
        "ledger_name": {"key": "ledgerName", "type": "str"},
        "ledger_uri": {"key": "ledgerUri", "type": "str"},
        "identity_service_uri": {"key": "identityServiceUri", "type": "str"},
        "ledger_internal_namespace": {"key": "ledgerInternalNamespace", "type": "str"},
        "ledger_storage_account": {"key": "ledgerStorageAccount", "type": "str"},
        "ledger_type": {"key": "ledgerType", "type": "str"},
        "provisioning_state": {"key": "provisioningState", "type": "str"},
        "aad_based_security_principals": {"key": "aadBasedSecurityPrincipals", "type": "[AADBasedSecurityPrincipal]"},
        "cert_based_security_principals": {
            "key": "certBasedSecurityPrincipals",
            "type": "[CertBasedSecurityPrincipal]",
        },
    }

    def __init__(
        self,
        *,
        ledger_storage_account: Optional[str] = None,
        ledger_type: Optional[Union[str, "_models.LedgerType"]] = None,
        aad_based_security_principals: Optional[List["_models.AADBasedSecurityPrincipal"]] = None,
        cert_based_security_principals: Optional[List["_models.CertBasedSecurityPrincipal"]] = None,
        **kwargs
    ):
        """
        :keyword ledger_storage_account: Name of the Blob Storage Account for saving ledger files.
        :paramtype ledger_storage_account: str
        :keyword ledger_type: Type of Confidential Ledger. Known values are: "Unknown", "Public", and
         "Private".
        :paramtype ledger_type: str or ~azure.mgmt.confidentialledger.models.LedgerType
        :keyword aad_based_security_principals: Array of all AAD based Security Principals.
        :paramtype aad_based_security_principals:
         list[~azure.mgmt.confidentialledger.models.AADBasedSecurityPrincipal]
        :keyword cert_based_security_principals: Array of all cert based Security Principals.
        :paramtype cert_based_security_principals:
         list[~azure.mgmt.confidentialledger.models.CertBasedSecurityPrincipal]
        """
        super().__init__(**kwargs)
        self.ledger_name = None
        self.ledger_uri = None
        self.identity_service_uri = None
        self.ledger_internal_namespace = None
        self.ledger_storage_account = ledger_storage_account
        self.ledger_type = ledger_type
        self.provisioning_state = None
        self.aad_based_security_principals = aad_based_security_principals
        self.cert_based_security_principals = cert_based_security_principals

class ResourceProviderOperationDefinition(_serialization.Model):
    """Describes the Resource Provider Operation.

    :ivar name: Resource provider operation name.
    :vartype name: str
    :ivar is_data_action: Indicates whether the operation is data action or not.
    :vartype is_data_action: bool
    :ivar display: Details about the operations.
    :vartype display: ~azure.mgmt.confidentialledger.models.ResourceProviderOperationDisplay
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "is_data_action": {"key": "isDataAction", "type": "bool"},
        "display": {"key": "display", "type": "ResourceProviderOperationDisplay"},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        is_data_action: Optional[bool] = None,
        display: Optional["_models.ResourceProviderOperationDisplay"] = None,
        **kwargs
    ):
        """
        :keyword name: Resource provider operation name.
        :paramtype name: str
        :keyword is_data_action: Indicates whether the operation is data action or not.
        :paramtype is_data_action: bool
        :keyword display: Details about the operations.
        :paramtype display: ~azure.mgmt.confidentialledger.models.ResourceProviderOperationDisplay
        """
        super().__init__(**kwargs)
        self.name = name
        self.is_data_action = is_data_action
        self.display = display

class ResourceProviderOperationDisplay(_serialization.Model):
    """Describes the properties of the Operation.

    :ivar provider: Name of the resource provider.
    :vartype provider: str
    :ivar resource: Name of the resource type.
    :vartype resource: str
    :ivar operation: Name of the resource provider operation.
    :vartype operation: str
    :ivar description: Description of the resource provider operation.
    :vartype description: str
    """

    _attribute_map = {
        "provider": {"key": "provider", "type": "str"},
        "resource": {"key": "resource", "type": "str"},
        "operation": {"key": "operation", "type": "str"},
        "description": {"key": "description", "type": "str"},
    }

    def __init__(
        self,
        *,
        provider: Optional[str] = None,
        resource: Optional[str] = None,
        operation: Optional[str] = None,
        description: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword provider: Name of the resource provider.
        :paramtype provider: str
        :keyword resource: Name of the resource type.
        :paramtype resource: str
        :keyword operation: Name of the resource provider operation.
        :paramtype operation: str
        :keyword description: Description of the resource provider operation.
        :paramtype description: str
        """
        super().__init__(**kwargs)
        self.provider = provider
        self.resource = resource
        self.operation = operation
        self.description = description

class ResourceProviderOperationList(_serialization.Model):
    """List containing this Resource Provider's available operations.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar value: Resource provider operations list.
    :vartype value: list[~azure.mgmt.confidentialledger.models.ResourceProviderOperationDefinition]
    :ivar next_link: The URI that can be used to request the next page for list of Azure
     operations.
    :vartype next_link: str
    """

    _validation = {
        "value": {"readonly": True},
        "next_link": {"readonly": True},
    }

    _attribute_map = {
        "value": {"key": "value", "type": "[ResourceProviderOperationDefinition]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)
        self.value = None
        self.next_link = None

class SystemData(_serialization.Model):
    """Metadata pertaining to creation and last modification of the resource.

    :ivar created_by: The identity that created the resource.
    :vartype created_by: str
    :ivar created_by_type: The type of identity that created the resource. Known values are:
     "User", "Application", "ManagedIdentity", and "Key".
    :vartype created_by_type: str or ~azure.mgmt.confidentialledger.models.CreatedByType
    :ivar created_at: The timestamp of resource creation (UTC).
    :vartype created_at: ~datetime.datetime
    :ivar last_modified_by: The identity that last modified the resource.
    :vartype last_modified_by: str
    :ivar last_modified_by_type: The type of identity that last modified the resource. Known values
     are: "User", "Application", "ManagedIdentity", and "Key".
    :vartype last_modified_by_type: str or ~azure.mgmt.confidentialledger.models.CreatedByType
    :ivar last_modified_at: The timestamp of resource last modification (UTC).
    :vartype last_modified_at: ~datetime.datetime
    """

    _attribute_map = {
        "created_by": {"key": "createdBy", "type": "str"},
        "created_by_type": {"key": "createdByType", "type": "str"},
        "created_at": {"key": "createdAt", "type": "iso-8601"},
        "last_modified_by": {"key": "lastModifiedBy", "type": "str"},
        "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"},
        "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"},
    }

    def __init__(
        self,
        *,
        created_by: Optional[str] = None,
        created_by_type: Optional[Union[str, "_models.CreatedByType"]] = None,
        created_at: Optional[datetime.datetime] = None,
        last_modified_by: Optional[str] = None,
        last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None,
        last_modified_at: Optional[datetime.datetime] = None,
        **kwargs
    ):
        """
        :keyword created_by: The identity that created the resource.
        :paramtype created_by: str
        :keyword created_by_type: The type of identity that created the resource. Known values are:
         "User", "Application", "ManagedIdentity", and "Key".
        :paramtype created_by_type: str or ~azure.mgmt.confidentialledger.models.CreatedByType
        :keyword created_at: The timestamp of resource creation (UTC).
        :paramtype created_at: ~datetime.datetime
        :keyword last_modified_by: The identity that last modified the resource.
        :paramtype last_modified_by: str
        :keyword last_modified_by_type: The type of identity that last modified the resource. Known
         values are: "User", "Application", "ManagedIdentity", and "Key".
        :paramtype last_modified_by_type: str or ~azure.mgmt.confidentialledger.models.CreatedByType
        :keyword last_modified_at: The timestamp of resource last modification (UTC).
        :paramtype last_modified_at: ~datetime.datetime
        """
        super().__init__(**kwargs)
        self.created_by = created_by
        self.created_by_type = created_by_type
        self.created_at = created_at
        self.last_modified_by = last_modified_by
        self.last_modified_by_type = last_modified_by_type
        self.last_modified_at = last_modified_at


text:
module Noodle
  class MinLengthValidator < ActiveModel::Validator
    def validate(record)
      if record.node_class_property.properties.key?('validators') && record.node_class_property.properties['validators'].key?('min_length')
        record.errors.add(:empty_value, 'Valu is to short', strict: true) if record.value.length < record.node_class_property.properties['validators']['min_length']
      end
    end
  end
end


text:
using System;
using System.Collections.Generic;
using Umbraco.Core.Models;

namespace Umbraco.Core.Services
{
    public interface IMemberTypeService : IService
    {
        /// <summary>
        /// Gets a list of all available <see cref="IContentType"/> objects
        /// </summary>
        /// <param name="ids">Optional list of ids</param>
        /// <returns>An Enumerable list of <see cref="IContentType"/> objects</returns>
        IEnumerable<IMemberType> GetAll(params int[] ids);

        /// <summary>
        /// Gets an <see cref="IMemberType"/> object by its Id
        /// </summary>
        /// <param name="id">Id of the <see cref="IMemberType"/> to retrieve</param>
        /// <returns><see cref="IMemberType"/></returns>
        IMemberType Get(int id);

        /// <summary>
        /// Gets an <see cref="IMemberType"/> object by its Key
        /// </summary>
        /// <param name="key">Key of the <see cref="IMemberType"/> to retrieve</param>
        /// <returns><see cref="IMemberType"/></returns>
        IMemberType Get(Guid key);

        /// <summary>
        /// Gets an <see cref="IMemberType"/> object by its Alias
        /// </summary>
        /// <param name="alias">Alias of the <see cref="IMemberType"/> to retrieve</param>
        /// <returns><see cref="IMemberType"/></returns>
        IMemberType Get(string alias);

        /// <summary>
        /// Saves a single <see cref="IMemberType"/> object
        /// </summary>
        /// <param name="memberType"><see cref="IMemberType"/> to save</param>
        /// <param name="userId">Optional Id of the User saving the ContentType</param>
        void Save(IMemberType memberType, int userId = 0);

        /// <summary>
        /// Saves a collection of <see cref="IMemberType"/> objects
        /// </summary>
        /// <param name="memberTypes">Collection of <see cref="IMemberType"/> to save</param>
        /// <param name="userId">Optional Id of the User saving the ContentTypes</param>
        void Save(IEnumerable<IMemberType> memberTypes, int userId = 0);

        /// <summary>
        /// Deletes a single <see cref="IMemberType"/> object
        /// </summary>
        /// <param name="memberType"><see cref="IMemberType"/> to delete</param>
        /// <remarks>Deleting a <see cref="IMemberType"/> will delete all the <see cref="IContent"/> objects based on this <see cref="IMemberType"/></remarks>
        /// <param name="userId">Optional Id of the User deleting the ContentType</param>
        void Delete(IMemberType memberType, int userId = 0);

        /// <summary>
        /// Deletes a collection of <see cref="IMemberType"/> objects
        /// </summary>
        /// <param name="memberTypes">Collection of <see cref="IMemberType"/> to delete</param>
        /// <remarks>Deleting a <see cref="IMemberType"/> will delete all the <see cref="IContent"/> objects based on this <see cref="IMemberType"/></remarks>
        /// <param name="userId">Optional Id of the User deleting the ContentTypes</param>
        void Delete(IEnumerable<IMemberType> memberTypes, int userId = 0);
    }
}


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Xunit;
using Xunit.Extensions;

namespace NuGet.Test.Integration.NuGetCommandLine
{
    public static class Util
    {
        /// <summary>
        /// Creates a test package.
        /// </summary>
        /// <param name="packageId">The id of the created package.</param>
        /// <param name="version">The version of the created package.</param>
        /// <param name="path">The directory where the package is created.</param>
        /// <returns>The full path of the created package file.</returns>
        public static string CreateTestPackage(string packageId, string version, string path)
        {
            var packageBuilder = new PackageBuilder
            {
                Id = packageId,
                Version = new SemanticVersion(version),
                Description = "Test desc"
            };

            var dependencies = new PackageDependency("Dummy");
            packageBuilder.DependencySets.Add(new PackageDependencySet(null, new[] { dependencies }));
            packageBuilder.Authors.Add("test author");

            var packageFileName = string.Format("{0}.{1}.nupkg", packageId, version);
            var packageFileFullPath = Path.Combine(path, packageFileName);
            using (var fileStream = File.Create(packageFileFullPath))
            {
                packageBuilder.Save(fileStream);
            }

            return packageFileFullPath;
        }

        /// <summary>
        /// Creates the specified directory. If it exists, it's first deleted before
        /// it's created. Thus, the directory is guaranteed to be empty.
        /// </summary>
        /// <param name="directory">The directory to be created.</param>
        public static void CreateDirectory(string directory)
        {
            Util.DeleteDirectory(directory);
            Directory.CreateDirectory(directory);
        }

        /// <summary>
        /// Deletes the specified directory.
        /// </summary>
        /// <param name="packageDirectory">The directory to be deleted.</param>
        public static void DeleteDirectory(string directory)
        {
            if (Directory.Exists(directory))
            {
                Directory.Delete(directory, true);
            }
        }

        /// <summary>
        /// Creates a file with the specified content.
        /// </summary>
        /// <param name="directory">The directory of the created file.</param>
        /// <param name="fileName">The name of the created file.</param>
        /// <param name="fileContent">The content of the created file.</param>
        public static void CreateFile(string directory, string fileName, string fileContent)
        {
            var fileFullName = Path.Combine(directory, fileName);
            using (var writer = new StreamWriter(fileFullName))
            {
                writer.Write(fileContent);
            }
        }
    }
}


text:
package net.nemerosa.ontrack.common;

public class TaskNotScheduledException extends BaseException {

    public TaskNotScheduledException(String message) {
        super("Task was not launched in the background: %s", message);
    }

}


text:
/* jshint expr: true */
'use strict';

var _ = require('lodash');
var express = require('express');
var fs = require('fs');
var mailin = require('../lib/mailin');
var multiparty = require('multiparty');
var simplesmtp = require('simplesmtp');
var shell = require('shelljs');

var should = null;
should = require('should');

before(function (done) {
    mailin.start({
        verbose: true,
    }, function (err) {
        should.not.exist(err);
        done();
    });
});

beforeEach(function () {
    mailin.removeAllListeners();
});

describe('Mailin', function () {
    it('should post a json to a webhook after receiving an email and trigger some events', function (done) {
        this.timeout(10000);

        var doing = 2; // Number of async operations we need to wait for before calling done

        var expectedSpamScore = 3.3;
        if (!shell.which('spamassassin') || !shell.which('spamc')) {
            console.warn('Spamassassin is not installed. Skipping spam score test.');
            expectedSpamScore = 0;
        }

        /* Add listeners to the events. */
        var connData = null;
        mailin.on('startMessage', function (connection) {
            console.log("Event 'startMessage' triggered.");
            connData = _.pick(connection, ['from', 'to', 'remoteAddress', 'authentication', 'id']);
            console.log(connData);
        });

        mailin.on('message', function (connection, data) {
            console.log("Event 'message' triggered.");
            // console.log(data);

            data.attachments[0].content.toString().should.eql('my dummy attachment contents');

            /* Delete the headers that include a timestamp. */
            delete data.headers.received;

            data.should.eql({
                html: 'Hello world!',
                text: 'Hello world!',
                headers: {
                    'x-mailer': 'Nodemailer 1.0',
                    from: '"Me" <me@jokund.com>',
                    to: '"First Receiver" <first@jokund.com>, second@jokund.com',
                    'content-type': 'multipart/mixed; boundary="----mailcomposer-?=_1-1402581589619"',
                    'mime-version': '1.0'
                },
                priority: 'normal',
                from: [{
                    address: 'me@jokund.com',
                    name: 'Me'
                }],
                to: [{
                    address: 'first@jokund.com',
                    name: 'First Receiver'
                }, {
                    address: 'second@jokund.com',
                    name: ''
                }],
                attachments: [{
                    contentType: 'text/plain',
                    fileName: 'dummyFile.txt',
                    contentDisposition: 'attachment',
                    transferEncoding: 'base64',
                    generatedFileName: 'dummyFile.txt',
                    contentId: '6e4a9c577e603de61e554abab84f6297@mailparser',
                    checksum: 'e9fa6319356c536b962650eda9399a44',
                    length: 28,
                    content: new Buffer('my dummy attachment contents'),
                    // contents: [
                    // 109,
                    // 121,
                    // 32,
                    // 100,
                    // 117,
                    // 109,
                    // 109,
                    // 121,
                    // 32,
                    // 97,
                    // 116,
                    // 116,
                    // 97,
                    // 99,
                    // 104,
                    // 109,
                    // 101,
                    // 110,
                    // 116,
                    // 32,
                    // 99,
                    // 111,
                    // 110,
                    // 116,
                    // 101,
                    // 110,
                    // 116,
                    // 115
                    // ]
                }],
                dkim: 'failed',
                envelopeFrom: [{
                    address: "envelopefrom@jokund.com",
                    name: ""
                }],
                envelopeTo: [{
                    address: "envelopeto@jokund.com",
                    name: ""
                }],
                spf: 'failed',
                spamScore: expectedSpamScore,
                language: 'pidgin',
                cc: [],
                connection: connData
            });

            doing--;
        });

        /* Make an http server to receive the webhook. */
        var server = express(),
            conn;
        server.use(server.router);
        server.head('/webhook', function (req, res) {
            res.send(200);
        });
        server.post('/webhook', function (req, res) {
            console.log('Receiving webhook.');

            var form = new multiparty.Form();
            form.parse(req, function (err, fields, files) {
                if (err) console.log(err.stack);
                should.not.exist(err);

                should.exist(files);
                Object.keys(files).length.should.eql(0);

                should.exist(fields);
                should.exist(fields.mailinMsg);
                should.exist(fields['dummyFile.txt']);

                var mailinMsg = JSON.parse(fields.mailinMsg);

                /* Delete the headers that include a timestamp. */
                delete mailinMsg.headers.received;

                /* And the connection id, which is random. */
                delete mailinMsg.data;

                mailinMsg.should.eql({
                    html: 'Hello world!',
                    text: 'Hello world!',
                    headers: {
                        'x-mailer': 'Nodemailer 1.0',
                        from: '"Me" <me@jokund.com>',
                        to: '"First Receiver" <first@jokund.com>, second@jokund.com',
                        'content-type': 'multipart/mixed; boundary="----mailcomposer-?=_1-1402581589619"',
                        'mime-version': '1.0'
                    },
                    priority: 'normal',
                    from: [{
                        address: 'me@jokund.com',
                        name: 'Me'
                    }],
                    to: [{
                        address: 'first@jokund.com',
                        name: 'First Receiver'
                    }, {
                        address: 'second@jokund.com',
                        name: ''
                    }],
                    attachments: [{
                        contentType: 'text/plain',
                        fileName: 'dummyFile.txt',
                        contentDisposition: 'attachment',
                        transferEncoding: 'base64',
                        generatedFileName: 'dummyFile.txt',
                        contentId: '6e4a9c577e603de61e554abab84f6297@mailparser',
                        checksum: 'e9fa6319356c536b962650eda9399a44',
                        length: '28'
                    }],
                    dkim: 'failed',
                    envelopeFrom: [{
                        address: 'envelopefrom@jokund.com',
                        name: ''
                    }],
                    envelopeTo: [{
                        address: 'envelopeto@jokund.com',
                        name: ''
                    }],
                    spf: 'failed',
                    spamScore: expectedSpamScore,
                    language: 'pidgin',
                    cc: [],
                    connection: connData
                });

                res.send(200);

                doing--;
            });

            var waiting = setInterval(function () {
                if (!doing) {
                    clearInterval(waiting);
                    conn.close();
                    done();
                }
            }, 1000);
        });
        conn = server.listen(3000, function (err) {
            if (err) console.log(err);
            should.not.exist(err);

            console.log('Http server listening on port 3000');

            /* Make an smtp client to send an email. */
            var client = simplesmtp.connect(2500);

            /* Run only once as 'idle' is emitted again after message delivery. */
            client.once('idle', function () {
                client.useEnvelope({
                    from: 'envelopefrom@jokund.com',
                    to: 'envelopeto@jokund.com'
                });
            });

            client.on('message', function () {
                fs.createReadStream('./test/fixtures/test.eml').pipe(client);
            });
        });
    });

    it('should convert an HTML-only message to text', function (done) {
        this.timeout(10000);

        mailin.on('message', function (connection, data) {
            // console.log(data);
            data.text.should.eql('HELLO WORLD\nThis is a line that needs to be at least a little longer than 80 characters so\nthat we can check the character wrapping functionality.\n\nThis is a test of a link [https://github.com/Flolagale/mailin] .');
            done();
        });

        /* Make an smtp client to send an email. */
        var client = simplesmtp.connect(2500);

        /* Run only once as 'idle' is emitted again after message delivery. */
        client.once('idle', function () {
            client.useEnvelope({
                from: 'envelopefrom@jokund.com',
                to: 'envelopeto@jokund.com'
            });
        });

        client.on('message', function () {
            fs.createReadStream('./test/fixtures/test-html-only.eml').pipe(client);
        });
    });

    it('should not validate sender domain DNS by default', function (done) {
        this.timeout(10000);

        mailin.on('message', function (connection, data) {
            data.html.should.eql('Hello world!');
            done();
        });

        /* Make an smtp client to send an email. */
        var client = simplesmtp.connect(2500);

        /* Run only once as 'idle' is emitted again after message delivery. */
        client.once('idle', function () {
            client.useEnvelope({
                from: 'envelopefrom@foo.fifoo',
                to: 'envelopeto@foo.fifoo'
            });
        });

        client.on('message', function () {
            fs.createReadStream('./test/fixtures/test.eml').pipe(client);
        });
    });

    /* This test should run as the last test since it restarts mailin with
     * different options. */
    it('should validate sender domain DNS if requested', function (done) {
        this.timeout(10000);

        mailin.stop(function (err) {
            if (err) console.log(err);
            should.not.exist(err);

            mailin.start({
                smtpOptions: {
                    disableDNSValidation: false
                }
            }, function (err) {
                if (err) console.log(err);
                should.not.exist(err);

                var doneEvents = [];
                var registerDoneEvent = function (eventName) {
                    doneEvents.push(eventName);

                    /* Call done if all the events of the test have been called. */
                    var shouldCallDone = ['senderValidationFailed', 'error'].every(function (eventName) {
                        return _.contains(doneEvents, eventName);
                    });

                    if (shouldCallDone) return done();
                };

                mailin.on('senderValidationFailed', function (err) {
                    should.exist(err);
                    err.should.equal('envelopefrom@foo.fifoo');
                    registerDoneEvent('senderValidationFailed');
                });

                /* Make an smtp client to send an email. */
                var client = simplesmtp.connect(2500);

                /* Run only once as 'idle' is emitted again after message delivery. */
                client.once('idle', function () {
                    client.useEnvelope({
                        from: 'envelopefrom@foo.fifoo',
                        to: 'envelopeto@foo.fifoo'
                    });
                });

                client.on('error', function (err) {
                    should.exist(err);
                    console.log(err);
                    err.data.indexOf('Sender address rejected: Domain not found').should.not.equal(-1);
                    registerDoneEvent('error');
                });

                client.on('message', function () {
                    fs.createReadStream('./test/fixtures/test.eml').pipe(client);
                });
            });
        });
    });
});


text:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:rsb="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/bandUpBlack"
    tools:context="com.melodies.bandup.main_screen_activity.SettingsFragment">

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <include layout="@layout/ads" />

        <ScrollView
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="vertical" >
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />

                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_title_filter"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:text="Radius 20 km"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:id="@+id/txtRadius"
                    android:textSize="18sp"
                    android:textColor="@color/colorWhite"
                    android:layout_marginTop="10dp"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp" />

                <SeekBar
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:id="@+id/seekBarRadius"
                    android:layout_marginTop="10dp"
                    android:layout_marginStart="10dp"
                    android:layout_marginEnd="10dp"
                    android:layout_marginBottom="20dp"
                    />
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#40FFFFFF" />
                <TextView
                    android:text="@string/settings_filter_ages"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:id="@+id/txtAges"
                    android:textSize="18sp"
                    android:paddingTop="5dp"
                    android:textColor="@color/colorWhite"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp" />

                <org.florescu.android.rangeseekbar.RangeSeekBar
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:id="@+id/seekBarAges"
                    android:layout_marginBottom="15dp"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp"
                    android:layout_marginTop="-10dp"
                    android:scrollbarAlwaysDrawHorizontalTrack="true"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_title_push_notifications"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                android:layout_width="fill_parent"
                android:layout_height="1dp"
                android:background="#50FFFFFF" />

                <Switch
                    android:text="@string/settings_new_matches"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/switchMatches"
                    android:checked="true"
                    android:textSize="18sp"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp"/>

                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#40FFFFFF" />

                <Switch
                    android:text="@string/settings_inactive_alert"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/switchAlert"
                    android:textSize="18sp"
                    android:checked="true"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp" />

                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#40FFFFFF" />

                <Switch
                    android:text="@string/settings_messages"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/switchMessages"
                    android:checked="true"
                    android:textSize="18sp"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp" />
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_title_measurement"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />

                <Switch
                    android:text="@string/settings_use_imperial_system"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/switchUnit"
                    android:textSize="18sp"
                    android:checked="false"
                    android:textAllCaps="false"
                    android:layout_marginStart="20dp"
                    android:layout_marginEnd="20dp" />
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_support"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:text="@string/settings_email_support"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:gravity="center_vertical"
                    android:id="@+id/txtContact"
                    android:onClick="onClickContact"
                    android:textSize="18sp"
                    android:textColor="@color/colorWhite"
                    android:paddingStart="20dp"
                    android:paddingEnd="20dp"
                    android:background="?android:attr/selectableItemBackground"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_title_legal"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:text="@string/settings_privacy_policy"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/txtLicenses"
                    android:onClick="onClickPrivacyPolicy"
                    android:textSize="18sp"
                    android:textColor="@color/colorWhite"
                    android:paddingStart="20dp"
                    android:paddingEnd="20dp"
                    android:gravity="center_vertical"
                    android:background="?android:attr/selectableItemBackground"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#40FFFFFF" />
                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:text="@string/settings_title_manage_account"
                    android:paddingStart="20dp"
                    android:textSize="20sp"
                    android:paddingTop="5dp"
                    android:paddingBottom="5dp"
                    android:background="@color/colorGray"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:text="@string/settings_delete_account"
                    android:layout_width="match_parent"
                    android:layout_height="60dp"
                    android:id="@+id/txtDeleteAccount"
                    android:onClick="onClickDeleteAccount"
                    android:textSize="18sp"
                    android:textColor="@color/bandUpRed"
                    android:paddingStart="20dp"
                    android:paddingEnd="20dp"
                    android:gravity="center_vertical"
                    android:background="?android:attr/selectableItemBackground"/>
                <View
                    android:layout_width="fill_parent"
                    android:layout_height="1dp"
                    android:background="#50FFFFFF" />
                <TextView
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:id="@+id/band_up_version_number"
                    android:paddingStart="20dp"
                    android:paddingTop="10dp"
                    android:paddingBottom="10dp"
                    android:paddingEnd="20dp"/>

            </LinearLayout>
        </ScrollView>

    </LinearLayout>

</FrameLayout>


text:
<app-navbar></app-navbar>
<div class="container">
  <flash-messages></flash-messages>
  <router-outlet></router-outlet>
</div>


text:
/* config.h.  Generated from config.h.in by configure.  */
/* config.h.in.  Generated from configure.ac by autoheader.  */

/* Define to 1 if you have the <attr/xattr.h> header file. */
/* #undef HAVE_ATTR_XATTR_H */

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <linux/capability.h> header file. */
#define HAVE_LINUX_CAPABILITY_H 1

/* Define to 1 if you have the <linux/securebits.h> header file. */
/* #undef HAVE_LINUX_SECUREBITS_H */

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have <sys/syscall.h>. */
#define HAVE_SYSCALL_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to the sub-directory in which libtool stores uninstalled libraries.
   */
#define LT_OBJDIR ".libs/"

/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* Name of package */
#define PACKAGE "libcap-ng"

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT ""

/* Define to the full name of this package. */
#define PACKAGE_NAME "libcap-ng"

/* Define to the full name and version of this package. */
#define PACKAGE_STRING "libcap-ng 0.7"

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "libcap-ng"

/* Define to the home page for this package. */
#define PACKAGE_URL ""

/* Define to the version of this package. */
#define PACKAGE_VERSION "0.7"

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* Version number of package */
#define VERSION "0.7"

/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */

/* Define to `__inline__' or `__inline' if that's what the C compiler
   calls it, or to nothing if 'inline' is not supported under any name.  */
#ifndef __cplusplus
/* #undef inline */
#endif


text:
class CWeaponSVD :
	public CWeaponCustomPistol
{
	typedef CWeaponCustomPistol inherited;
protected:
	virtual void switch2_Fire	();
	virtual void OnAnimationEnd (u32 state);
public:
	CWeaponSVD(void);
	virtual ~CWeaponSVD(void);

	DECLARE_SCRIPT_REGISTER_FUNCTION
};
add_to_type_list(CWeaponSVD)
#undef script_type_list
#define script_type_list save_type_list(CWeaponSVD)


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Nova Hedwigia 14: 256 (1968)

#### Original name
Ramalina cactacearum Follmann

### Remarks
null


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.github.ljtfreitas</groupId>
		<artifactId>java-restify-group</artifactId>
		<version>2.1.1-SNAPSHOT</version>
	</parent>
	<artifactId>java-restify-netflix-kubernetes-service-discovery</artifactId>

	<properties>
		<kubernetes.client.version>4.2.2</kubernetes.client.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>io.fabric8</groupId>
			<artifactId>kubernetes-client</artifactId>
			<version>${kubernetes.client.version}</version>
		</dependency>
		<dependency>
           <groupId>com.github.ljtfreitas</groupId>
           <artifactId>java-restify-netflix-service-discovery</artifactId>
           <version>${project.version}</version>
        </dependency>
        <dependency>
           <groupId>com.github.ljtfreitas</groupId>
           <artifactId>java-restify-util</artifactId>
           <version>${project.version}</version>
           <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>io.fabric8</groupId>
            <artifactId>kubernetes-server-mock</artifactId>
            <version>${kubernetes.client.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>java-restify-json-jackson-converter</artifactId>
			<version>${project.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>java-restify-http-message</artifactId>
			<version>${project.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>java-restify-http-client</artifactId>
			<version>${project.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>${project.groupId}</groupId>
			<artifactId>java-restify-reflection</artifactId>
			<version>${project.version}</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
</project>


text:
using SimpleMinecraft.Library.PlayerElements;
using SimpleMinecraft.Library.SceneElements;
using SimpleMinecraft.Unity.Scripts.SceneElementScripts;
using SimpleMinecraft.Unity.Scripts.SystemScripts;
using UnityEngine;

namespace SimpleMinecraft.Unity.Scripts.PlayerScripts
{
    public class PlayerCollectItemEntityController : MonoBehaviour
    {
        void OnTriggerEnter(Collider other)
        {
            if (other.tag == "ItemEntity" && other.GetComponent<ItemEntityController>() != null)
            {
                Debug.Log("col");
                ItemEntity itemEntity = other.GetComponent<ItemEntityController>().ItemEntity;
                SceneManager.Instance.DestroyItemEntity(itemEntity);
                InventoryItemInfo info;
                PlayerManager.Instance.Inventory.AddItem(itemEntity.Item, 1, out info);
            }
        }
    }
}