text:
package org.apache.geode.connectors.jdbc.internal;

import java.util.HashMap;
import java.util.Set;

public class TableMetaData implements TableMetaDataView {

  private final String tableName;
  private final String keyColumnName;
  private final HashMap<String, Integer> columnNameToTypeMap;
  private final String identifierQuoteString;

  public TableMetaData(String tableName, String keyColumnName, String quoteString) {
    this.tableName = tableName;
    this.keyColumnName = keyColumnName;
    this.columnNameToTypeMap = new HashMap<>();
    this.identifierQuoteString = quoteString;
  }

  @Override
  public String getTableName() {
    return tableName;
  }

  @Override
  public String getKeyColumnName() {
    return this.keyColumnName;
  }

  @Override
  public int getColumnDataType(String columnName) {
    Integer dataType = this.columnNameToTypeMap.get(columnName);
    if (dataType == null) {
      return 0;
    }
    return dataType;
  }

  @Override
  public Set<String> getColumnNames() {
    return columnNameToTypeMap.keySet();
  }

  public void addDataType(String columnName, int dataType) {
    this.columnNameToTypeMap.put(columnName, dataType);
  }

  @Override
  public String getIdentifierQuoteString() {
    return this.identifierQuoteString;
  }
}


text:
  // @file console.cc
  // @brief The console output.
  // @author Maoru Kaminaga
  // @date 2017-08-11 09:14:37
  // Copyright 2017 Maoru Kaminaga
#include <stdarg.h>
#include <stdio.h>
#include <wchar.h>
#include <windows.h>
#include "./console.h"
#define GAME_CONSOLE_TXT_MAX  (256)
bool InitConsole() {
  FILE* fp = nullptr;
  AllocConsole();
  freopen_s(&fp, "CON", "w", stdout);
  return true;
}
void FianlzieConsole() {
  FreeConsole();
}
bool PrintToConsole(const wchar_t* format, ...) {
  wchar_t buffer[GAME_CONSOLE_TXT_MAX] = {0};
  va_list args;
  va_start(args, format);
  vswprintf_s(buffer, GAME_CONSOLE_TXT_MAX, format, args);
  _putws(buffer);
  return true;
}

redpajama_set_name: RedPajamaGithub


text:
import * as av_utils from "./utils.js";

av_utils.load_css("/js/ad/map-draw/ace-view/201807/toolkit.css");

// ----------------------------------------------------------------------

export const sGREY = "#c0c0c0";
export const sLIGHTGREY = "#e0e0e0";
export const sAnaColors = ["#03569b", "#e72f27", "#ffc808", "#a2b324", "#a5b8c7", "#049457", "#f1b066", "#742f32", "#9e806e", "#75ada9", "#675b2c", "#a020f0", "#8b8989", "#e9a390", "#dde8cf", "#00939f"];

export function ana_colors(index) {
    if (index < 0 || index >= sAnaColors.length)
        return sGREY;
    return sAnaColors[index];
}

// ----------------------------------------------------------------------

export class Modal
{
    // args: {element:, z_index:, dismiss: function}
    constructor(args) {
        this.background_ = $("

").appendTo("body")
            .css({width: $(document).width(), height: $(document).height(), position: "absolute", left: 0, top: 0, "z-index": args.z_index || 900})
            .on("click", evt => av_utils.forward_event(evt, () => {
                if (args.dismiss)
                    args.dismiss();
                this.destroy();
            }))
            .show();
        if (args.element) {
            args.element.css("z-index", args.z_index ? args.z_index + 1 : 901);
        }
    }

    destroy() {
        if (this.background_) {
            this.background_.remove();
            delete this.background_;
        }
    }
}

// ----------------------------------------------------------------------

export function drag(evt, callback) {
    let mouse_pos = {left: evt.clientX, top: evt.clientY};
    document.onmouseup = () => {
        $("body").removeClass("av-unselectable");
        document.onmouseup = document.onmousemove = null;
    };
    document.onmousemove = evt2 => {
        $("body").addClass("av-unselectable");
        callback({left: evt2.clientX - mouse_pos.left, top: evt2.clientY - mouse_pos.top});
        mouse_pos = {left: evt2.clientX, top: evt2.clientY};
    };
}

// ----------------------------------------------------------------------

class Popup_Base {

    constructor(css_classes) {
        this.css_classes = css_classes;
    }

    destroy() {
        this.find_element().remove();
    }

    find_or_create() {
        let elt = this.find_element();
        if (elt.length === 0) {
            elt = this.create_element();
            if (this.css_classes)
                elt.addClass(this.css_classes);
        }
        return elt;
    }

    show(contents, parent, offsets_to_parent) {
        this.hide();
        const popup = this.find_or_create();
        popup.empty();
        if (typeof(contents) === "function")
            contents(popup);
        else
            popup.append(contents);
        popup.css({left: offsets_to_parent.left + parent.offset().left, top: offsets_to_parent.top + parent.offset().top}).show();
        return this;
    }

    // show_ul(text_rows, parent, offsets_to_parent) {
    //     this.show($("

").append(text_rows.map(text => "
" + text + "
").join("")), parent, offsets_to_parent);
    // }

    classes(classes) {
        if (classes)
            this.find_or_create().addClass(classes);
        return this;
    }

    hide() {
        this.find_element().hide();
    }
}

// ----------------------------------------------------------------------

const MousePopup_id = "amw201807-mouse-popup";

class MousePopup extends Popup_Base {

    find_element() {
        return $("#" + MousePopup_id);
    }

    create_element() {
        return $("

").appendTo($("body"));
    }
}

// returns popup div
export function mouse_popup_show(contents, parent, offsets_to_parent, classes="av201807-window-shadow") {
    return new MousePopup().classes(classes).show(contents, parent, offsets_to_parent).find_element();
}

export function mouse_popup_hide() {
    return $("#" + MousePopup_id).hide();
}

// ----------------------------------------------------------------------

export class BurgerMenu
{
    // {trigger: $("#trigger"), menu: $("#menu"), callback: item => console.log("burger-menu", item)}
    constructor(args) {
        this.menu_ = args.menu.addClass("av201807-burger-menu av201807-window-shadow");
        this.menu_.find("ul").addClass("av201807-window-shadow");
        this.menu_.find("li[menu]").on("click", evt => av_utils.forward_event(evt, () => this.clicked(evt.currentTarget)));
        this.menu_.find("li:has(>ul)").append("
&#9654
");
        this.callback_ = args.callback;
        this.trigger_ = args.trigger.addClass("av201807-burger-menu-trigger");
        this.trigger_.on("click", evt => av_utils.forward_event(evt, () => this.show()));
    }

    destroy() {
        this.trigger_.off("click");
        this.menu_.find("li[menu]").off("click");
    }

    show() {
        this.modal_support_ = new Modal({element: this.menu_, z_index: 1000, dismiss: () => this.hide()});
        const trigger_pos = this.trigger_.position();
        this.menu_.show().css({left: trigger_pos.left, top: trigger_pos.top + this.trigger_.height()});
        this.menu_.find("> li > ul").css("left", this.menu_.width());
    }

    hide() {
        this.menu_.hide();
        this.modal_support_.destroy();
        delete this.modal_support_;
    }

    clicked(target) {
        if (!target.matches(".av-menu-disabled") && target.matches("[menu]")) {
            this.hide();
            if (this.callback_)
                this.callback_(target.getAttribute("menu"));
        }
    }
}

// ----------------------------------------------------------------------

const MovableWindow_html = "\

\

\

×
\

\

×
\

\

\

\

\
";

export class MovableWindow {

    // {title, content, id, parent: "center", classes: "", content_css: {width:, height:}, on_destroy: function}
    constructor(args) {
        if (args.id)
            this.div_ = $("body").find("#" + args.id);
        if (!this.div_ || this.div_.length === 0) {
            this.div_ = $(MovableWindow_html).appendTo($("body"));
            if (args.id)
                this.div_.attr("id", args.id);
            this.div_.find(".av-close").on("click", () => this.destroy());
            this.div_.find(".av-window-title").on("mousedown", evt => this.drag(evt, pos_diff => this.drag_window(pos_diff)));
            this.div_.find(".av-window-resizer").on("mousedown", evt => this.drag(evt, pos_diff => this.resize_window(pos_diff)));
            if (args.classes)
                this.div_.addClass(args.classes);
        }
        if (args.title)
            this.div_.find(".av-title").empty().append(args.title);
        if (args.content)
            this.content().empty().append(args.content);
        if (args.content_css)
            this.content().css(args.content_css);
        this.position(args.parent);
        this.on_destroy = args.on_destroy;
    }

    destroy() {
        this.div_.remove();
        if (this.on_destroy)
            this.on_destroy();
    }

    classes(classes) {
        if (classes)
            this.div_.addClass(classes);
        return this;
    }

    content() {
        return this.div_.find(".av-content");
    }

    drag(evt, callback) {
        let mouse_pos = {left: evt.clientX, top: evt.clientY};
        document.onmouseup = () => {
            document.onmouseup = document.onmousemove = null;
            this.div_.find(".av-content").removeClass("av-unselectable");
            $("body").removeClass("av-unselectable");
        };
        document.onmousemove = evt2 => {
            this.div_.find(".av-content").addClass("av-unselectable");
            $("body").addClass("av-unselectable");
            callback({left: mouse_pos.left - evt2.clientX, top: mouse_pos.top - evt2.clientY});
            mouse_pos = {left: evt2.clientX, top: evt2.clientY};
        };
    }

    drag_window(pos_diff) {
        this.div_.css({left: this.div_.offset().left - pos_diff.left, top : this.div_.offset().top - pos_diff.top});
    }

    resize_window(pos_diff) {
        const element = this.div_.find(".av-content");
        element.css({width: element.width() - pos_diff.left, height : element.height() - pos_diff.top});
    }

    position(parent) {
        if (!parent || parent === "center") {
            const wind = $(window);
            this.div_.css({left: (wind.scrollLeft() + wind.width() - this.div_.width()) / 2, top: (wind.scrollTop() + wind.height() - this.div_.height()) / 2});
        }
        else {
            let offset = $(parent).offset();
            offset.left += $(parent).outerWidth();
            this.div_.css(offset);
        }
    }
}

// ----------------------------------------------------------------------

export function movable_window_with_json(data, invoking_node, title) {
    const wind = new MovableWindow({title: title || data.name || data.description || data._id, content: `<pre class='json-highlight'>${av_utils.json_syntax_highlight(JSON.stringify(data, undefined, 2))}</pre>`, parent: invoking_node});
    wind.classes("av-json-data");
}

// ----------------------------------------------------------------------

export function movable_window_with_error(data, invoking_node) {
    if (typeof(data) === "object")
        data = `<pre class='json-highlight'>${av_utils.json_syntax_highlight(JSON.stringify(data, undefined, 2))}</pre>`;
    else
        data = `<p>${data}</p>`;
    new MovableWindow({title: "ERROR", content: data, parent: invoking_node}).classes("av-error");
}

// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:


text:
RVO.ObstacleTreeNode = function() {
}


text:
export const BattleStatuses: {[k: string]: ModdedPureEffectData} = {
	slp: {
		inherit: true,
		onSwitchIn(target) {
			this.effectData.time = this.effectData.startTime;
		},
	},
	partiallytrapped: {
		inherit: true,
		onStart(pokemon, source) {
			this.add('-activate', pokemon, 'move: ' + this.effectData.sourceEffect, '[of] ' + source);
			this.effectData.boundDivisor = source.hasItem('bindingband') ? 8 : 16;
		},
		onResidual(pokemon) {
			const trapper = this.effectData.source;
			if (trapper && (!trapper.isActive || trapper.hp <= 0 || !trapper.activeTurns)) {
				delete pokemon.volatiles['partiallytrapped'];
				return;
			}
			this.damage(pokemon.baseMaxhp / this.effectData.boundDivisor);
		},
	},
	stall: {
		// Protect, Detect, Endure counter
		duration: 2,
		counterMax: 256,
		onStart() {
			this.effectData.counter = 2;
		},
		onStallMove() {
			// this.effectData.counter should never be undefined here.
			// However, just in case, use 1 if it is undefined.
			const counter = this.effectData.counter || 1;
			if (counter >= 256) {
				// 2^32 - special-cased because Battle.random(n) can't handle n > 2^16 - 1
				return (this.random() * 4294967296 < 1);
			}
			this.debug("Success chance: " + Math.round(100 / counter) + "%");
			return this.randomChance(1, counter);
		},
		onRestart() {
			// @ts-ignore
			if (this.effectData.counter < this.effect.counterMax) {
				this.effectData.counter *= 2;
			}
			this.effectData.duration = 2;
		},
	},
	gem: {
		duration: 1,
		affectsFainted: true,
		onBasePower(basePower, user, target, move) {
			this.debug('Gem Boost');
			return this.chainModify(1.5);
		},
	},
};


text:
<?php
	$dbhost ='localhost';
	$dbuser ='root';
	$dbpassword ='';
	$dbdatabase ='trouw';

	$link = mysqli_Connect($dbhost , $dbuser , $dbpassword , $dbdatabase);

	/*Verbinding controleren*/
	if(mysqli_connect_error())
	{
		echo("connection failed!, ". mysqli_connect_error());
		exit();
	}
?>


text:
#ifndef SFIDLESCREENTRACKER_H_
#define SFIDLESCREENTRACKER_H_

#include <QObject>
#include <bb/AbstractBpsEventHandler>
#include <bps/bps.h>
#include <bps/screen.h>

class QTimer;

namespace sf {
using namespace bb;

/*!
 * @class SFIdleScreenTracker
 * @headerfile SFIdleScreenTracker.h <core/SFIdleScreenTracker.h>
 *
 * @brief @c SFIdleScreenTracker monitors user activity and emits a singal when the user has been idle for the
 * specified amount of time. This class is meant to be used by the SDK classes.
 */
class SFIdleScreenTracker : public QObject, public bb::AbstractBpsEventHandler {
	Q_OBJECT

signals:
	/*!
	 * Singal emitted when the screen idle timer times out.
	 */
	void screenIdleTimeout();
public slots:
	/*!
	 * starts tracking
	 */
	void startTracking(const int & timeoutSeconds = 0);
	/*!
	 * stops tracking
	 */
	void stopTracking();
	/*!
	 * handles the screen idle signal from BPS service.
	 */
	void onTimerTimeout();
public:
	enum ScreenIdleState {
		ScreenNotIdle = 0,
		ScreenIdle = 1
	};
	SFIdleScreenTracker(QObject * parent = NULL);
	virtual ~SFIdleScreenTracker();

	virtual void event(bps_event_t *event);

	/* accessors */
	bool isActive() const {return mActive;};
	int timeoutSeconds() const {return mTimeoutSeconds;};
	void setTimeoutSeconds(const int & timeoutSeconds);

protected:
	bool mActive;
	int mTimeoutSeconds;
	QTimer *mIdleNotificationTimer;
	screen_context_t mScreenContext;

	ScreenIdleState currentScreenIdleState();
};

} /* namespace sf */
#endif /* SFIDLESCREENTRACKER_H_ */


text:
<!DOCTYPE html>

<meta charset="UTF-8">
<title>Ldap Configuration</title>

<Link rel="stylesheet" href="../css/animate.min.css"/>

			<form class="form-horizontal" role="form">

									<input type="checkbox">

						<input type="text"  id="connectionURL" name="connectionURL" class="col-sm-5">

						<input type="text" id="connectionName" name="connectionName" class="col-sm-5">

						<input type="password"id="connectionPassword" name="connectionPassword" class="col-sm-5">

						UserBase
						<input type="text"  id="userBase" name="userBase" class="col-sm-5">

						<button id="submit" name="submitth" class="btn btn-primary btn-label-left col-sm-offset-7 col-sm-2" style="margin-left: 58.3333%;"></button>

			</form>


text:
// Copyright 2007 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.opengse.configuration.impl;

import com.google.opengse.configuration.WebAppTagLib;

/**
 * A mutable implementation of WebAppTagLib.
*
* @author Mike Jennings
*/
public final class MutableWebAppTagLib implements WebAppTagLib {
  private String taglibUri;
  private String taglibLocation;

  private MutableWebAppTagLib() {
  }

  public static MutableWebAppTagLib create() {
    return new MutableWebAppTagLib();
  }

  public String getTaglibUri() {
    return taglibUri;
  }

  public void setTaglibUri(String taglibUri) {
    this.taglibUri = taglibUri;
  }

  public String getTaglibLocation() {
    return taglibLocation;
  }

  public void setTaglibLocation(String taglibLocation) {
    this.taglibLocation = taglibLocation;
  }
}


text:
\DeclareMathOperator{\sign}{sign}
\DeclareMathOperator{\prox}{prox}

\DeclareMathOperator*{\argmax}{\arg\!\max}
\DeclareMathOperator*{\argmin}{\arg\!\min}

\newcommand{\indep}{\rotatebox[origin=c]{90}{$\models$}}

\newcommand{\mybold}[1]{\ensuremath{\operatorname{\boldsymbol{#1}}}}
\newcommand{\mydef}{\triangleq}
\newcommand{\mytrans}{\intercal}
\newcommand{\mypseudo}{\dagger}
\newcommand{\myhat}[1]{\ensuremath{\operatorname{\hat{#1}}}}
\newcommand{\myexp}[1]{\ensuremath{\operatorname{\exp{ \left(#1\right)}}}}
\newcommand{\mysign}[1]{\ensuremath{\operatorname{\sign{\left(#1\right)}}}}
\newcommand{\mydot}{\cdot}

\newcommand{\R}{{\rm I\!R}}
\newcommand{\subjectto}{\:\:\:\:\:\: s.t. \:\:\:\:\:\:}
\newcommand{\Df}{D_f}
\newcommand{\dimsh}{P}
\newcommand{\dimsl}{Q}
\newcommand{\dimth}{N}
\newcommand{\dimtl}{M}
\newcommand{\dimpsh}{p}
\newcommand{\dimpsl}{q}
\newcommand{\dimpth}{n}
\newcommand{\dimptl}{m}
\newcommand{\dimdict}{K}
\newcommand{\dimtrunc}{L}

\newcommand{\dimpacc}{r} % accumulative patch size
\newcommand{\dimpsr}{s} % searching region size
\newcommand{\nlmfilparam}{\sigma} % accumulative patch size \tau

\newcommand{\neighbor}{\mathcal{N}}
\newcommand{\mymapto}{\longmapsto}
\newcommand{\mymapfrom}{\mathrel{\reflectbox{\ensuremath{\mymapto}}}}

\newcommand{\z}{\mybold{z}}
\newcommand{\y}{\mybold{y}}
\newcommand{\x}{\mybold{x}}
\newcommand{\Z}{\mathbf{Z}}
\newcommand{\Y}{\mathbf{Y}}
\newcommand{\X}{\mathbf{X}}
\newcommand{\B}{\mathbf{B}}
\newcommand{\I}{\mathbf{I}}
\newcommand{\Diag}{\mathbf{D}}
\newcommand{\Umat}{\mathbf{U}}
\newcommand{\Vmat}{\mathbf{V}}

\newcommand{\LR}{\y}
\newcommand{\HR}{\z}
\newcommand{\LF}{\z_{lf}}
\newcommand{\HF}{\z_{hf}}
\newcommand{\HFest}{\hat{\z }_{hf}}

\newcommand{\h}{\mybold{h}}
\newcommand{\n}{\mybold{n}}
\newcommand{\boundHF}{\mybold{b}}

\newcommand{\knot}{{\circ}}
\newcommand{\ext}{{e}} % denote the generalization data for prediction

\newcommand{\Interp}{\varmathbb{I}}
\newcommand{\Sub}{\varmathbb{S}}
\newcommand{\LPF}{\varmathbb{L}}

\newcommand{\distr}{\mathscr{N}}
\newcommand{\loss}{\mathcal{L}}

\newcommand{\normtwo}[1]{\ensuremath{\operatorname{\Arrowvert  \mathit{#1} \Arrowvert^2_2 }}}
\newcommand{\Mdist}[2]{\ensuremath{\operatorname{\Arrowvert \mathit{#1} \Arrowvert^2_{\mathit{#2}} }}}
\newcommand{\normone}[1]{\ensuremath{\operatorname{\Arrowvert \mathit{#1} \Arrowvert_1 }}}
\newcommand{\normzero}[1]{\ensuremath{\operatorname{\Arrowvert  \mathit{#1} \Arrowvert_0 }}}
\newcommand{\normp}[1]{\ensuremath{\operatorname{\Arrowvert  \mathit{#1} \Arrowvert_p }}}

\newcommand{\detmat}[1]{\ensuremath{\operatorname{\left|  \mathit{#1} \right| }}}
\newcommand{\cov}[1]{\ensuremath{\operatorname{cov \left\lbrace  \mathit{#1} \right\rbrace }}}
\newcommand{\E}[1]{\ensuremath{\operatorname{E \left[  \mathit{#1} \right] }}}
\newcommand{\tr}[1]{\ensuremath{\operatorname{tr \left\lbrace  \mathit{#1} \right\rbrace }}}
\newcommand{\Conv}{\mathop{\scalebox{1.5}{\raisebox{-0.2ex}{$\ast$}}}}

\newcommand{\pinv}[1]{\ensuremath{\operatorname{  \mathit{#1} ^\dagger}}}
%\newcommand{\featmap}[1]{\ensuremath{\operatorname{  \mathcal{F} \left(#1\right)}}}
\newcommand{\featmap}[1]{\ensuremath{\operatorname{ \varphi \left(\mathit{#1}\right)}}}

%\newcommand{\dict}{\mathds{D}}
%\newcommand{\dictco}{\mathds{A}}
\newcommand{\dict}{\mathbf{D}}
\newcommand{\dictco}{\mathbf{A}}
\newcommand{\adict}{\boldsymbol{d}}
\newcommand{\adictco}{\boldsymbol{a}}

\newcommand{\patchlow}[1]{\ensuremath{\operatorname{\mathit{\mybold{p}_{\ell}^{#1}}}}}
\newcommand{\patchhigh}[1]{\ensuremath{\operatorname{\mathit{\mybold{p}_h^{#1}}}}}
\newcommand{\dictlow}{\dict_\ell}
\newcommand{\dicthigh}{\dict_h}
\newcommand{\adictcolow}[1]{\ensuremath{\operatorname{\boldsymbol{a}_\ell^{\mathit{#1}}}}}
\newcommand{\adictcohigh}[1]{\ensuremath{\operatorname{\mathit{\boldsymbol{a}_h^{#1}}}}}
\newcommand{\adictlow}[1]{\ensuremath{\operatorname{\boldsymbol{d}_\ell^{\mathit{#1}}}}}
\newcommand{\adicthigh}[1]{\ensuremath{\operatorname{\mathit{\boldsymbol{d}_h^{#1}}}}}

\newcommand{\extractlow}[1]{\ensuremath{\operatorname{\mathcal{R}_{\ell}^{\mathit{#1}}}}}
\newcommand{\extracthigh}[1]{\ensuremath{\operatorname{\mathit{\mathcal{R}_h^{#1}}}}}
\newcommand{\extract}[1]{\ensuremath{\operatorname{\mathcal{R}^{\mathit{#1}}}}}

\newcommand{\mytrace}[1]{\ensuremath{\operatorname{\text{Tr} \left( #1 \right)}}}


text:
/* eslint-disable @typescript-eslint/no-unused-vars */
import { ThinEngine } from "../../Engines/thinEngine";

declare module "../../Engines/thinEngine" {
    export interface ThinEngine {
        /** @internal */
        _debugPushGroup(groupName: string, targetObject?: number): void;

        /** @internal */
        _debugPopGroup(targetObject?: number): void;

        /** @internal */
        _debugInsertMarker(text: string, targetObject?: number): void;

        /** @internal */
        _debugFlushPendingCommands(): void;
    }
}

ThinEngine.prototype._debugPushGroup = function (groupName: string, targetObject?: number): void {};

ThinEngine.prototype._debugPopGroup = function (targetObject?: number): void {};

ThinEngine.prototype._debugInsertMarker = function (text: string, targetObject?: number): void {};

ThinEngine.prototype._debugFlushPendingCommands = function (): void {};


text: <!DOCTYPE html>


text:
<?php namespace BackupManager\ShellProcessing;

use Symfony\Component\Process\Process;

/**
 * Class CommandProcessor
 * @package BackupManager
 */
class ShellProcessor {

    /** @var Process */
    private $process;

    /**
     * @param Process $process
     */
    public function __construct(Process $process) {
        $this->process = $process;
    }

    /**
     * @param $command
     * @throws ShellProcessFailed
     * @throws \Symfony\Component\Process\Exception\LogicException
     */
    public function process($command) {
        if (empty($command)) {
            return;
        }

        $this->process->setCommandLine($command);
        $this->process->setTimeout(null);
        $this->process->run();
        if ( ! $this->process->isSuccessful()) {
            throw new ShellProcessFailed($this->process->getErrorOutput());
        }
    }
}


text:
%--------------------------------------------------------------------------------------------------------
% The system is created based on the principles described in the following paper
% Jimmy SJ. Ren and Li Xu, "On Vectorization of Deep Convolutional Neural Networks for Vision Tasks",
% The 29th AAAI Conference on Artificial Intelligence (AAAI-15). Austin, Texas, USA, January 25-30, 2015
% email: jimmy.sj.ren@gmail.com
%--------------------------------------------------------------------------------------------------------
addpath applications/image_denoise/
addpath applications/image_denoise/utility/
addpath utils/
addpath cuda/
addpath mem/
addpath layers/
addpath layers_adapters/
addpath optimization/
addpath pipeline/
addpath data/

clearvars -global config;
clearvars -global mem;
clear;
global config mem;
denoise_configure();
init(0);

load('data/denoise/val/val_1');
perm = randperm(size(test_samples, 4));
test_samples = test_samples(:,:,:,perm);
test_labels = test_labels(:,:,:,perm);
test_samples = config.NEW_MEM(test_samples(:,:,:,1:1000));
test_labels = config.NEW_MEM(test_labels(:,:,:,1:1000));

count = 0;
cost_avg = 0;
epoc = 0;
points_seen = 0;
display_points = 1000;
save_points = 10000;
max_grad = 1;
fprintf('%s\n', datestr(now, 'dd-mm-yyyy HH:MM:SS FFF'));
for pass = 1:10
    for p = 1:11
        load(strcat('data/denoise/train/patches_', num2str(p), '.mat'));
        perm = randperm(10000);
        samples = samples(:,:,:,perm);
        labels = labels(:,:,:,perm);
        train_imgs = config.NEW_MEM(samples);
        train_labels = config.NEW_MEM(labels);

        for i = 1:size(train_labels, 4) / config.batch_size
            points_seen = points_seen + config.batch_size;
            in = train_imgs(:,:,:,(i-1)*config.batch_size+1:i*config.batch_size);
            out = train_labels(:,:,:,(i-1)*config.batch_size+1:i*config.batch_size);
            out = out((size(in, 1) - config.output_size(1)) / 2 + 1:(size(in, 1) - config.output_size(1)) / 2 + config.output_size(1), ...
                      (size(in, 2) - config.output_size(2)) / 2 + 1:(size(in, 2) - config.output_size(2)) / 2 + config.output_size(2), :, :);

            % operate the training pipeline
            op_train_pipe(in, out);
            % update the weights
            config.UPDATE_WEIGHTS();

            if(cost_avg == 0)
                cost_avg = config.cost;
            else
                cost_avg = (cost_avg + config.cost) / 2;
            end

            % display point
            if(mod(points_seen, display_points) == 0)
                count = count + 1;
                fprintf('%d ', count);
            end
            % save point
            if(mod(points_seen, save_points) == 0)
                fprintf('\n%s', datestr(now, 'dd-mm-yyyy HH:MM:SS FFF'));
                epoc = epoc + 1;
                test_cost = 0;
                for t = 1:size(test_samples, 4) / config.batch_size
                    t_label = test_labels(:,:,:,(t-1)*config.batch_size+1:t*config.batch_size);
                    t_label = config.NEW_MEM(t_label((size(in, 1) - config.output_size(1)) / 2 + 1:(size(in, 1) - config.output_size(1)) / 2 + config.output_size(1), ...
                                            (size(in, 2) - config.output_size(2)) / 2 + 1:(size(in, 2) - config.output_size(2)) / 2 + config.output_size(2), :));

                    op_test_pipe(test_samples(:,:,:,(t-1)*config.batch_size+1:t*config.batch_size), t_label);
                    test_out = gather(mem.output);
                    test_cost = test_cost + config.cost;
                end
                test_cost = test_cost / size(test_samples, 4);
                fprintf('\nepoc %d, training avg cost: %f, test avg cost: %f\n', epoc, cost_avg, test_cost);

                save_weights(strcat('applications/image_denoise/results/epoc', num2str(epoc), '.mat'));
                cost_avg = 0;
            end
        end
    end
end


text:
require 'rufus-scheduler'

# Let's use the rufus-scheduler singleton
#
s = Rufus::Scheduler.singleton
if ENV['SCHEDULE_VALIDATION_TASKS']

  Rails.logger.info "Activate time tracking validation jobs"

  s.cron '30 1 * * *' do
    Rails.logger.info "Running working day validation at #{Time.now}"
    WorkingDayValidationController.validate_previous_working_day
  end

  s.cron '30 3 * * 1' do
    Rails.logger.info "Running working week validation at #{Time.now}"
    WorkingDayValidationController.validate_previous_week
  end

  s.cron '30 1 1 * *' do
    Rails.logger.info "Running working month validation at #{Time.now}"
    WorkingDayValidationController.validate_previous_month
  end
else
  Rails.logger.info "Do not activate time tracking validation jobs"
end


text:
goog.provide('__crWeb.findInPageEventListeners');

window.addEventListener('pagehide', __gCrWeb.findInPage.stop);


text:
[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/jsonreference/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/jsonreference?status.svg)](http://godoc.org/github.com/go-openapi/jsonreference)
An implementation of JSON Reference - Go language

## Status
Work in progress ( 90% done )

## Dependencies
https://github.com/go-openapi/jsonpointer

## References
http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07

http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03


text:
import Ember from 'ember';

export default function initActivePanes(currentPane, paneNames) {
  return Ember.on('init', function() {
    paneNames.forEach(function(paneName) {
      var split = paneName.split('/');
      var name = split[split.length - 1];

      var propName = Ember.String.camelize(name + 'Active');

      Ember.defineProperty(this, propName,
                          Ember.computed.equal(currentPane, paneName));
    }, this);
  });
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.10"/>
<title>SdFat: Class Members</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

SdFat

Main Page

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Hierarchy

Class Members

All

Functions

Variables

Typedefs

Enumerations

Enumerator

a

b

c

d

e

f

g

h

i

j

l

m

n

o

p

r

s

t

u

v

w

y

Here is a list of all documented class members with links to the class documentation for each member:

- l -

lastAccessDate
: directoryEntry

lastWriteDate
: directoryEntry

lastWriteTime
: directoryEntry

lbn()
: FatCache

leadSignature
: fat32_fsinfo

left
: ios_base

legal83Char()
: FatFile

len
: fname_t

length()
: obufstream

lfn
: fname_t

ls()
: FatFile
, FatFileSystem

<address class="footer">
Generated on Mon Sep 5 2016 10:18:53 for SdFat by

 1.8.10
</address>


text:
package org.locationtech.geogig.geotools.data.stresstest;

import static com.google.common.collect.ImmutableList.copyOf;
import static org.junit.Assert.assertEquals;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.geotools.data.DataUtilities;
import org.geotools.data.DefaultTransaction;
import org.geotools.data.Transaction;
import org.geotools.data.simple.SimpleFeatureCollection;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.data.simple.SimpleFeatureSource;
import org.geotools.data.simple.SimpleFeatureStore;
import org.geotools.feature.SchemaException;
import org.geotools.feature.simple.SimpleFeatureBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.locationtech.geogig.geotools.data.GeoGigDataStore;
import org.locationtech.geogig.model.RevCommit;
import org.locationtech.geogig.porcelain.ConfigOp;
import org.locationtech.geogig.porcelain.ConfigOp.ConfigAction;
import org.locationtech.geogig.porcelain.InitOp;
import org.locationtech.geogig.porcelain.LogOp;
import org.locationtech.geogig.repository.Context;
import org.locationtech.geogig.repository.Hints;
import org.locationtech.geogig.repository.impl.GeoGIG;
import org.locationtech.geogig.repository.impl.GlobalContextBuilder;
import org.locationtech.geogig.test.TestPlatform;
import org.locationtech.geogig.test.integration.TestContextBuilder;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;

import com.google.common.base.Throwables;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;

public class DataStoreConcurrencyTest {

    private GeoGigDataStore store;

    private static final SimpleFeatureType pointType;
    static {
        final String pointsTypeSpec = "sp:String,ip:Integer,pp:Point:srid=4326";
        try {
            pointType = DataUtilities.createType("point", pointsTypeSpec);
        } catch (SchemaException e) {
            throw Throwables.propagate(e);
        }
    }

    private ExecutorService editThreads;

    private ExecutorService readThreads;

    private final int writeThreadCount = 4, readThreadCount = 4;

    @Rule
    public TemporaryFolder tmp = new TemporaryFolder();

    private int initialCommitCount;

    @Before
    public void beforeTest() throws Exception {

        File workingDirectory = tmp.newFolder("repo");
        File userHomeDirectory = tmp.newFolder("home");
        TestPlatform platform = new TestPlatform(workingDirectory);
        platform.setUserHome(userHomeDirectory);

        GlobalContextBuilder.builder(new TestContextBuilder(platform));
        Context context = GlobalContextBuilder.builder().build(new Hints().platform(platform));

        GeoGIG repo = new GeoGIG(context);
        repo.command(InitOp.class).call();
        repo.command(ConfigOp.class).setAction(ConfigAction.CONFIG_SET).setName("user.name")
                .setValue("gabriel").call();
        repo.command(ConfigOp.class).setAction(ConfigAction.CONFIG_SET).setName("user.email")
                .setValue("gabriel@roldan.example.com").call();

        store = new GeoGigDataStore(repo.getRepository());

        store.createSchema(pointType);

        editThreads = Executors.newFixedThreadPool(writeThreadCount,
                new ThreadFactoryBuilder().setNameFormat("edit-thread-%d").build());

        readThreads = Executors.newFixedThreadPool(readThreadCount,
                new ThreadFactoryBuilder().setNameFormat("read-thread-%d").build());
        initialCommitCount = copyOf(store.getGeogig().command(LogOp.class).call()).size();
    }

    @After
    public void afterTest() throws Exception {
        if (store != null) {
            store.dispose();
        }
        if (editThreads != null) {
            editThreads.shutdownNow();
        }
        if (readThreads != null) {
            readThreads.shutdownNow();
        }
    }

    @Test
    public void testConcurrentEdits() throws Exception {
        final int insertsPerTask = 20;
        List<Future<Integer>> insertResults = runInserts(writeThreadCount, insertsPerTask);
        for (Future<Integer> f : insertResults) {
            assertEquals(insertsPerTask, f.get().intValue());
        }

        List<RevCommit> commits = copyOf(store.getGeogig().command(LogOp.class).call());
        final int expectedCommitCount = initialCommitCount + insertsPerTask * writeThreadCount;
        assertEquals(expectedCommitCount, commits.size());
    }

    @Test
    public void testConcurrentReads() throws Exception {

        final int insertsPerTask = 20;
        assertEquals(insertsPerTask, runInserts(1, insertsPerTask).get(0).get().intValue());

        final int readsPerTask = 20;
        List<Future<Integer>> readResults = runReads(readThreadCount, readsPerTask);

        for (Future<Integer> f : readResults) {
            assertEquals(readsPerTask, f.get().intValue());
        }
    }

    @Test
    public void testConcurrentEditsAndReads() throws Exception {

        final int insertsPerTask = 40;
        final int readsPerTask = 200;

        // have something to read
        runInserts(1, insertsPerTask).get(0).get();

        List<Future<Integer>> insertResults = runInserts(writeThreadCount, insertsPerTask);
        Thread.sleep(3000);
        List<Future<Integer>> readResults = runReads(readThreadCount, readsPerTask);

        for (Future<Integer> f : insertResults) {
            assertEquals(insertsPerTask, f.get().intValue());
        }
        for (Future<Integer> f : readResults) {
            assertEquals(readsPerTask, f.get().intValue());
        }

        List<RevCommit> commits = copyOf(store.getGeogig().command(LogOp.class).call());
        final int expectedCommitCount = insertsPerTask + initialCommitCount
                + insertsPerTask * writeThreadCount;
        assertEquals(expectedCommitCount, commits.size());
    }

    private List<Future<Integer>> runInserts(final int writeThreadCount, final int insertsPerTask) {
        List<Future<Integer>> insertResults = Lists.newArrayList();
        for (int i = 0; i < writeThreadCount; i++) {
            insertResults.add(editThreads.submit(new InsertTask(store, insertsPerTask)));
        }
        return insertResults;
    }

    private List<Future<Integer>> runReads(final int readThreadCount, final int readsPerTask) {
        List<Future<Integer>> readResults = Lists.newArrayList();
        for (int i = 0; i < readThreadCount; i++) {
            readResults.add(readThreads.submit(new ReadTask(store, readsPerTask)));
        }
        return readResults;
    }

    public static class InsertTask implements Callable<Integer> {

        private static final Random rnd = new Random(1000);

        private final GeoGigDataStore dataStore;

        private final SimpleFeatureBuilder builder;

        private int numInserts;

        public InsertTask(GeoGigDataStore store, int numInserts) {
            this.dataStore = store;
            this.numInserts = numInserts;
            this.builder = new SimpleFeatureBuilder(pointType);
        }

        @Override
        public Integer call() {
            int random;
            synchronized (rnd) {
                random = rnd.nextInt();
            }
            final String typeName = pointType.getTypeName();
            SimpleFeatureStore featureSource;
            int insertCount = 0;
            try {
                for (int i = 0; i < numInserts; i++) {
                    builder.reset();
                    builder.set("sp", String.valueOf(random));
                    builder.set("ip", Integer.valueOf(random));
                    SimpleFeature feature = builder.buildFeature(String.valueOf(random));

                    featureSource = (SimpleFeatureStore) dataStore.getFeatureSource(typeName);
                    Transaction tx = new DefaultTransaction();
                    featureSource.setTransaction(tx);
                    try {
                        featureSource.addFeatures(DataUtilities.collection(feature));
                        tx.commit();
                        insertCount++;
                    } finally {
                        tx.close();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw Throwables.propagate(e);
            }
            // System.err.printf("Thread %s finished\n", Thread.currentThread().getName());
            return insertCount;
        }
    }

    public static class ReadTask implements Callable<Integer> {

        private final GeoGigDataStore dataStore;

        private final int numReads;

        public ReadTask(GeoGigDataStore store, final int numReads) {
            this.dataStore = store;
            this.numReads = numReads;
        }

        @Override
        public Integer call() {
            int readCount = 0;
            try {
                for (int i = 0; i < numReads; i++) {
                    doRead();
                    readCount++;
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw Throwables.propagate(e);
            }
            System.err.printf("Thread %s finished\n", Thread.currentThread().getName());
            return readCount;
        }

        private void doRead() throws IOException {
            final String typeName = pointType.getTypeName();
            SimpleFeatureSource featureSource;
            featureSource = dataStore.getFeatureSource(typeName);
            SimpleFeatureCollection fc = featureSource.getFeatures();
            SimpleFeatureIterator features = fc.features();
            while (features.hasNext()) {
                SimpleFeature next = features.next();
            }
            features.close();
        }
    }

    public static void main(String args[]) {
        DataStoreConcurrencyTest test = new DataStoreConcurrencyTest();
        try {
            test.tmp.create();
            test.beforeTest();
            test.testConcurrentEditsAndReads();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                test.afterTest();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


text:
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using Dot.Net.DevFast.Extensions;
using Dot.Net.DevFast.Extensions.JsonExt;
using Newtonsoft.Json;

namespace Dot.Net.DevFast.Sample.JsonSample.FromExt
{
    public static class JsonConvertStreamDeLatency
    {
        public static void Run()
        {
            Console.Out.WriteLine("-------SmallObj File Deserialization-------");
            //Small Object serialization in 10M loops
            Run(1024 * 32, new SmallObj
            {
                Address = "123, Json street",
                Age = 20,
                Name = "Json Born"
            });
            Console.Out.WriteLine("-------LargeObj File Deserialization-------");
            //Large Object serialization in 1M loops
            Run(1024 * 32, LargeObj);

            Console.Out.WriteLine("-------LargeObj Array File Deserialization-------");
            //creating array of 1K LargeObj
            var objArr = new LargeObj[1024];
            for (var i = 0; i < 1024; i++)
            {
                objArr[i] = LargeObj;
            }
            //Large Object Array serialization in 1K loops
            Run(128, objArr);
        }

        private static void Run<T>(int iteration, T data)
        {
            Console.Out.WriteLine("Iterations: " + iteration);
            var convertFile = new FileInfo(@"C:\Temp\jsonTest.json");
            var dfFile = new FileInfo(@"C:\Temp\jsonTestDf.json");

            File.WriteAllText(convertFile.FullName, JsonConvert.SerializeObject(data));
            convertFile.Refresh();
            Console.Out.WriteLine("Con-SerializedLen: " + convertFile.Length);

            data.ToJson(dfFile.CreateStream(FileMode.Create), new JsonSerializer(), enc: new UTF8Encoding(false));
            dfFile.Refresh();
            Console.Out.WriteLine("Df-SerializedLen: " + dfFile.Length);

            //warm up
            convertFile.MeasureJsonConvert<T>(2, false);
            var jsonTime = convertFile.MeasureJsonConvert<T>(iteration);

            GC.Collect();
            GC.WaitForFullGCApproach();
            GC.WaitForFullGCComplete();
            GC.WaitForPendingFinalizers();

            GC.Collect();
            GC.WaitForFullGCApproach();
            GC.WaitForFullGCComplete();
            GC.WaitForPendingFinalizers();

            //warm up
            dfFile.MeasureDevFast<T>(2, false);
            var devfastTime = dfFile.MeasureDevFast<T>(iteration);
            var dfFastness = ((int)((100 - (devfastTime / jsonTime * 100)) * 100)) / 100.0;
            Console.Out.WriteLine("DevFast " + Math.Abs(dfFastness) + (dfFastness < 0 ? " % Slower" : " % Faster"));
            Console.Out.WriteLine();
        }

        private static double MeasureJsonConvert<T>(this FileInfo data, int iteration, bool print = true)
        {
            var sw = Stopwatch.StartNew();
            for (var i = 0; i < iteration; i++)
            {
                var desrialJson = JsonConvert.DeserializeObject<T>(File.ReadAllText(data.FullName));
            }
            sw.Stop();

            if (print)
            {
                Console.Out.WriteLine("JsonConvert Total Time: " + sw.Elapsed.TotalMilliseconds);
            }
            return sw.Elapsed.TotalMilliseconds;
        }

        private static double MeasureDevFast<T>(this FileInfo data, int iteration, bool print = true)
        {
            var sw = Stopwatch.StartNew();
            for (var i = 0; i < iteration; i++)
            {
                var desrialJson = data.CreateStream(FileMode.Open, options: FileOptions.SequentialScan)
                    .FromJson<T>(new JsonSerializer());
            }
            sw.Stop();

            if (print)
            {
                Console.Out.WriteLine("DevFast Total Time: " + sw.Elapsed.TotalMilliseconds);
            }
            return sw.Elapsed.TotalMilliseconds;
        }

        private static readonly LargeObj LargeObj = new LargeObj
        {
            Address = "123, Json street",
            Age = 20,
            Name = "Json Born",
            City = "Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch",
            Country = "The Former Yugoslav Republic of Macedonia",
            AboutMe =
                @"Do play they miss give so up. Words to up style of since world. We leaf to snug on no need. Way own uncommonly travelling now acceptance bed compliment solicitude. Dissimilar admiration so terminated no in contrasted it. Advantages entreaties mr he apartments do. Limits far yet turned highly repair parish talked six. Draw fond rank form nor the day eat.
Her extensive perceived may any sincerity extremity. Indeed add rather may pretty see. Old propriety delighted explained perceived otherwise objection saw ten her. Doubt merit sir the right these alone keeps. By sometimes intention smallness he northward. Consisted we otherwise arranging commanded discovery it explained. Does cold even song like two yet been. Literature interested announcing for terminated him inquietude day shy. Himself he fertile chicken perhaps waiting if highest no it. Continued promotion has consulted fat improving not way.
Excited him now natural saw passage offices you minuter. At by asked being court hopes. Farther so friends am to detract. Forbade concern do private be. Offending residence but men engrossed shy. Pretend am earnest offered arrived company so on. Felicity informed yet had admitted strictly how you.
Your it to gave life whom as. Favourable dissimilar resolution led for and had. At play much to time four many. Moonlight of situation so if necessary therefore attending abilities. Calling looking enquire up me to in removal. Park fat she nor does play deal our. Procured sex material his offering humanity laughing moderate can. Unreserved had she nay dissimilar admiration interested. Departure performed exquisite rapturous so ye me resources.
Manor we shall merit by chief wound no or would. Oh towards between subject passage sending mention or it. Sight happy do burst fruit to woody begin at. Assurance perpetual he in oh determine as. The year paid met him does eyes same. Own marianne improved sociable not out. Thing do sight blush mr an. Celebrated am announcing delightful remarkably we in literature it solicitude. Design use say piqued any gay supply. Front sex match vexed her those great.
Unfeeling so rapturous discovery he exquisite. Reasonably so middletons or impression by terminated. Old pleasure required removing elegance him had. Down she bore sing saw calm high. Of an or game gate west face shed. no great but music too old found arose.
Kindness to he horrible reserved ye. Effect twenty indeed beyond for not had county. The use him without greatly can private. Increasing it unpleasant no of contrasted no continuing. Nothing colonel my no removed in weather. It dissimilar in up devonshire inhabiting.
He unaffected sympathize discovered at no am conviction principles. Girl ham very how yet hill four show. Meet lain on he only size. Branched learning so subjects mistress do appetite jennings be in. Esteems up lasting no village morning do offices. Settled wishing ability musical may another set age. Diminution my apartments he attachment is entreaties announcing estimating. And total least her two whose great has which. Neat pain form eat sent sex good week. Led instrument sentiments she simplicity.
Old there any widow law rooms. Agreed but expect repair she nay sir silent person. Direction can dependent one bed situation attempted. His she are man their spite avoid. Her pretended fulfilled extremely education yet. Satisfied did one admitting incommode tolerably how are.
He difficult contented we determine ourselves me am earnestly. Hour no find it park. Eat welcomed any husbands moderate. Led was misery played waited almost cousin living. Of intention contained is by middleton am. Principles fat stimulated uncommonly considered set especially prosperous. Sons at park mr meet as fact like."
        };
    }
}


text:
<?php
namespace Forms\Form\Validation;

use Forms\Form\Common\Params;
use Forms\Form\Validation\Abstractions\Validator;
use Forms\Form\Validation\Result\ValidationResultMessage;

class BooleanCallbackValidator implements Validator {
	/** @var callable */
	private $fn;
	/** @var callable */
	private $argsFn;
	/** @var string */
	private string $message;

	/**
	 * @param callable $fn
	 * @param callable $argsFn
	 * @param string $message
	 */
	public function __construct($fn, string $message, $argsFn) {
		$this->fn = $fn;
		$this->argsFn = $argsFn;
		$this->message = $message;
	}

	/**
	 * @inheritDoc
	 */
	public function render(array $data): array {
		return $data;
	}

	/**
	 * @param array $data
	 * @param string[] $path
	 * @return ValidationResultMessage[]
	 */
	public function __invoke(array $data, array $path): array {
		$params = new Params($data, $path);
		if(!call_user_func($this->fn, $params)) {
			return [new ValidationResultMessage($this->message)];
		}
		return [];
	}
}


text:
(* ::Package:: *)

(* Mathematica Package *)
BeginPackage["NounouM2`", {"JLink`"}]

(* ::Section:: *)
(*Declarations*)

(* Exported symbols added here with SymbolName::usage *)
General::invalidArgs="Function called with invalid arguments `1`.";
General::invalidOptionValue="Option argument `2` -> `1` is invalid.";

$PackageDirectory = ParentDirectory[DirectoryName[FindFile["NounouM2`"]]];
$PackageNewestFileDate = DateString[Max @@ AbsoluteTime /@ FileDate /@ FileNames[ "*",$PackageDirectory,Infinity] ];
$GitCurrentHead = Block[{tempret},
	SetDirectory[ ParentDirectory[DirectoryName[ FindFile["NounouM2`"] ]] ];
	Run["git rev-parse HEAD > GitCurrentHEADHash.txt"];
	tempret = Import["GitCurrentHEADHash.txt"];
	ResetDirectory[];
	tempret
];

Print["Welcome to NounouM2, the Mathematica interface to nounou!"];
Print["      ( last updated:  "<> $PackageNewestFileDate <>" )"];
Print["      ( current Git HEAD:  "<> $GitCurrentHead <>" )"];
Print["      ( http://github.org/ktakagaki/nounoum )"];

(* ::Subsection:: *)
(*Common Option Declarations*)

NNStackLists::usage=" ";
(*NNAxes::usage=" ";
NNBaselineCorrection::usage="";*)

(* ::Subsubsection:: *)
(*TracePlot*)

NNTimeUnitMS::usage="True (plot in ms) or False.";
NNMasking::usage=" ";
NNAbsoluteValue::usage="Whether to plot traces in an absolute unit";

(* ::Subsection::Closed:: *)
(*Global Utility Functions*)

NNPadZeros::usage =
"PadZeros[n] gives the numeral n string padded to 3 digits with zeros. " <>
"PadZeros[n,m] gives the numeral n string padded to m digits with zeros.";

NNNextPower::usage=" ";

NNFunctionQ::usage=
"returns whether a given symbol is a pure function, or a function rule.";

(* ::Subsection::Closed:: *)
(*Rule List and Option Handling*)

NNRuleListQ::usage=
	"RuleListQ[ruleList_List]... returns whether the argument ruleList is a list of rules.";
NNRuleQ::usage=
	"RuleQ[rule_]... returns whether the argument ruleList is a list of Rule or RuleDelayed objects.";

NNJoinOptionLists::usage=
"JoinOptionLists[x_/;RuleQ[x], y_/;RuleQ[y]]...   joins the two option lists, "<>
"and if an option specified in x is repeated in y, the specification in y is dropped.

JoinOptionLists[x_/;RuleQ[x], y_/;RuleQ[y], z_/;RuleQ[z]]...    joins the three option lists, "<>
"and if an option specified in x is repeated in y, the specification in y is dropped, etc.

JoinOptionLists[symbol_Symbol, x_/;RuleQ[x], y_/;RuleQ[y],... ]...    Does the "<>
"same as above, but filters the rules for Option[Symbol] before returning.";

NNAddOptions::usage=
"AddOptions[object, opts]...     returns the original object (e.g. NNMData[<<>>, opts]), "<>
"but with the specified option(s) appended or replaced. opts can be specified either as a Sequence "<>
"or a List of rules (i.e., brackets {opts} are optional).";

NNExtractRules::usage=
"Extracts options from an object, e.g. NNMData[<<>>,  opt->1] ==> {opt->1}";

(* ::Subsection:: *)
(*DataReader Java Object Handling*)

NNDataReaderJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.DataReader";

NNFrameRangeJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.FrameRange";

NNXDataJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.data.XData";
NNXMaskJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.data.XMask";
NNXLayoutJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.data.XLayout";
NNXLayoutNullJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.data.XLayoutNull";
NNXLayoutSquareJavaObjectQ::usage="Checks whether something is a Java object and an instance of nounou.data.XLayoutSquare";

(* ::Subsection::Closed:: *)
(*ReloadPackage*)

NNReloadPackage::usage=
"ReloadPackage[string_String].... unloads and reloads any package which \
contains the specified string within its name. \
This function is convenient during package developemnt--the package under development can \
be reloaded to test functionality, without losing any precalculated results in the kernel.";

(* ::Section:: *)
(*Private*)

Begin["`Private`"];

(* ::Subsection:: *)
(*NNPadZeros*)

NNPadZeros[n_]:=NNPadZeros[n,3];
NNPadZeros[n_,m_]:=Apply[StringJoin,Map[ToString,IntegerDigits[n, 10, m] ]];

NNPadZeros[args___]:=Message[NNPadZeros::invalidArgs,{args}];

(* ::Subsection:: *)
(*NextPower/NextMultiple*)

NNNextPower[base_, n_]:= Ceiling[Log[base, n]];

NNNextPower[args___]:=Message[NNNextPower::invalidArgs,{args}];

(* ::Subsection::Closed:: *)
(*NNFunctionQ*)

(*Tests whether the symbol is a function or not*)
(*FunctionQ[x_String]:=FunctionQ[ToExpression[x]];*)
NNFunctionQ[x_Function]:=True;
NNFunctionQ[x_Symbol]:=MemberQ[Attributes[x],NumericFunction] || (Length[Flatten[#[x]&/@{DownValues,UpValues}]]>0);
NNFunctionQ[x_, sampleArgs_]:=NNFunctionQ[x, sampleArgs, NumericQ];
NNFunctionQ[x_, sampleArgs_, questionFunc_]:=Quiet[Check[questionFunc[  x @@ sampleArgs],False]];
NNFunctionQ[_]:=False;

NNFunctionQ[args___]:=Message[NNFunctionQ::invalidArgs, {args}];

(* ::Subsection::Closed:: *)
(*Rule List/Option Handling*)

(* ::Subsubsection::Closed:: *)
(*NNRuleListQ/NNRuleQ*)

NNRuleListQ[ruleList_List] := And @@ (NNRuleListQ /@ ruleList);
NNRuleListQ[rule_Rule] := True;
NNRuleListQ[rule_RuleDelayed] := True;
NNRuleListQ[rules__] := NNRuleListQ[{rules}];
NNRuleListQ[] := True;
NNRuleListQ[{}] := True;
NNRuleListQ[_] := False;
NNRuleListQ[args___]:=Message[NNRuleListQ::invalidArgs,{args}];

NNRuleQ[rule_Rule] := True;
NNRuleQ[rule_RuleDelayed] := True;
NNRuleQ[_] := False;
NNRuleQ[args___]:=Message[NNRuleQ::invalidArgs,{args}];

(* ::Subsubsection::Closed:: *)
(*NNJoinOptionLists*)

NNJoinOptionLists[x_/;NNRuleListQ[x], y_/;NNRuleListQ[y]]:=
	Module[{tempret},
		tempret=Join[Flatten[x], FilterRules[Flatten[y], Except[x]]];
		Return[tempret]
	];

NNJoinOptionLists[x_/;NNRuleListQ[x], y__/;(And@@(NNRuleListQ /@ {y}))]:=
	Module[{tempret},
		tempret=x;
		Do[tempret=NNJoinOptionLists[tempret, zz],{zz,{y}}];
		Return[tempret]
	];

NNJoinOptionLists[symbol_Symbol, x_/;NNRuleListQ[x]]:=
	Module[{},
		Return[FilterRules[x, Options[symbol]]]
	];

NNJoinOptionLists[symbol_Symbol, x_/;NNRuleListQ[x], y__/;(And@@(NNRuleListQ /@ {y}))]:=
	Module[{tempret},
		tempret = NNJoinOptionLists[x, y];
		Return[FilterRules[tempret, Options[symbol]]]
	];

NNJoinOptionLists[symbol_[contents_], x_/;NNRuleListQ[x], y__/;(And@@(NNRuleListQ /@ {y}))]:=
	Module[{tempret},
		tempret = NNJoinOptionLists[x, y];
		Return[FilterRules[tempret, Options[symbol]]]
	];

NNJoinOptionLists[args___]:=Message[NNJoinOptionLists::invalidArgs,{args}];

(* ::Subsubsection::Closed:: *)
(*AddOptions*)

NNAddOptions[symbol_[contents___], opts___]:=NNAddOptions[symbol[contents], {opts}];
NNAddOptions[symbol_[contents___], {opts___}]:=
	Module[{tempRet(*,oldRules*)},
		(*The following will strip off rules from the end.*)
		tempRet = Select[{contents}, !NNRuleQ[#]&];
		(*Append old rules which are not given in opts.*)

		tempRet = Append[tempRet, Hold[Sequence@@NNJoinOptionLists[symbol, {opts}, Select[{contents}, RuleQ]]] ];
		Return[ReleaseHold[ symbol[Sequence@@tempRet] ]]
		(*oldRules=FilterRules[Options[x], Except[opts]];
			If[Length[oldRules]>0, tempRet= Append[tempRet, Hold[Sequence@@oldRules]]];
		(*Append new rules given in opts*)
		tempRet= Append[tempRet, Hold[opts]];
		Return[ReleaseHold[tempRet]]*)
	];

NNAddOptions[args___]:=Message[NNAddOptions::invalidArgs,{args}];

(* ::Subsubsection::Closed:: *)
(*ExtractRules*)

NNExtractRules[x_[arg___]]:=Flatten[If[NNRuleQ[#],#,{}]& /@ {arg}];

NNExtractRules[args___]:=Message[NNExtractRules::invalidArgs,{args}];

(* ::Subsection:: *)
(*DataReader Java Object Handling*)

NNDataReaderJavaObjectQ[
	dataReaderJavaObj_/;(JavaObjectQ[dataReaderJavaObj]
					&& InstanceOf[dataReaderJavaObj, "nounou.DataReader"])
						]:= True ;
NNDataReaderJavaObjectQ[args___]:= False ;

NNFrameRangeJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.FrameRange"])] := True;
NNFrameRangeJavaObjectQ[args___] := False;

NNXDataJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.data.XData"])]:= True;
NNXDataJavaObjectQ[args___]:= False;

NNXMaskJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.data.XMask"])]:= True;
NNXMaskJavaObjectQ[args___]:= False;

NNXLayoutJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.data.XLayout"])]:= True;
NNXLayoutJavaObjectQ[args___]:= False;

NNXLayoutNullJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.data.XLayoutNull"])]:= True;
NNXLayoutNullJavaObjectQ[args___]:= False;

NNXLayoutSquareJavaObjectQ[x_/;(JavaObjectQ[x] && InstanceOf[x, "nounou.data.XLayoutSquare"])]:= True;
NNXLayoutSquareJavaObjectQ[args___]:= False;

(* ::Subsection::Closed:: *)
(*ReloadPackage*)

NNReloadPackage[string_String]:=
	Module[{tempPackages},
		tempPackages=Select[ $Packages, StringMatchQ[#, (___ ~~ string ~~ ___)]& ];
		If[Length[tempPackages]>0,
			Unprotect[$Packages];
			($ContextPath=DeleteCases[$ContextPath, #])& /@ tempPackages;
			($Packages=DeleteCases[$Packages, # ])& /@ tempPackages;
			(Remove[Evaluate[#<>"*"]])& /@ tempPackages;
			Needs /@ tempPackages;
			Print["Reloaded: " <> # ]& /@ tempPackages;
		];
		(*Protect[$ContextPath];--$ContextPath is not Protected*)
		Protect[$Packages];
	];

NNReloadPackage[strings_List/;(And @@ StringQ /@ strings)]:=
	Module[{},
		NNReloadPackage /@ strings;
	];

NNReloadPackage[args___]:=Message[NNReloadPackage::invalidArgs,{args}];

(* ::Section:: *)
(*Ending*)

End[]

EndPackage[]


text:
<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE part PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
<part xmlns:xi="http://www.w3.org/2001/XInclude" id="boostbook"
     last-revision="$Date$">
  <partinfo>
    <author>
      <firstname>Douglas</firstname>
      <surname>Gregor</surname>
    </author>

    <copyright>
      <year>2003</year>
      <year>2004</year>
      <year>2005</year>
      <holder>Douglas Gregor</holder>
    </copyright>

    <legalnotice>
      <para>Distributed under the Boost Software License, Version 1.0.
      (See accompanying file LICENSE_1_0.txt or copy at
      <ulink url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>).
      </para>
    </legalnotice>
  </partinfo>

  <title>The BoostBook Documentation Format</title>

  <chapter id="boostbook.introduction">
    <title>Introduction</title>

    <para>The BoostBook documentation format is an extension of <ulink
    url="http://www.docbook.org">DocBook</ulink>, an SGML- or
    XML-based format for describing documentation. BoostBook augments
    DocBook with semantic markup that aids in the documentation of C++
    libraries, specifically the <ulink
    url="http://www.boost.org">Boost C++ libraries</ulink>, by
    providing the ability to express and refer to C++ constructs such
    as namespaces, classes, overloaded functions, templates, and
    specializations.</para>

    <para>
    BoostBook offers additional features more specific to its use for
    documenting the <ulink url="http://www.boost.org">Boost C++
    libraries</ulink>. These features are intended to eliminate or
    reduce the need for duplication of information and to aid in
    documenting portions of Boost that might otherwise not be
    documented. Examples of Boost-centric features include:
      <itemizedlist>
        <listitem>
          <para><emphasis role="bold">Testsuites</emphasis>:
          Testsuites in Boost are created by writing an appropriate
          Jamfile and including that Jamfile in
          <filename>status/Jamfile</filename>. If the testsuites are
          documented (<ulink
          url="http://www.boost.org/libs/multi_array/doc/test_cases.html">as
          in the MultiArray library</ulink>), the documentation is
          maintained separately from the testcase Jamfile, leading to
          duplication of information and the possibility of having the
          documentation out of sync with the Jamfile. BoostBook
          contains elements that describe a testsuite for both
          purposes: the BoostBook stylesheets can generate
          documentation for the testcases and also generate an
          appropriate Jamfile to integrate the testcases with the
          regression testing system.</para>
        </listitem>
        <listitem>
          <para><emphasis role="bold">Example programs</emphasis>:
          Example programs in documentation need to be duplicated in
          testcases to ensure that the examples compile and execute
          correctly. Keeping the two copies in sync is a tedious and
          error-prone task. For instance, the following code snippet
          persisted for six months:</para>
<programlisting>
std::cout << f(5, 3) >> std::endl;
</programlisting>
          <para>The BoostBook format allows testcases to be generated
          by weaving together program fragments from example programs
          in the documentation. This capability is integrated with
          testsuite generation so that example programs are normal
          tests in BoostBook.</para>
        </listitem>
      </itemizedlist>
    </para>
  </chapter>

  <chapter id="boostbook.getting.started">
    <title>Getting Started</title>

    <para>To use the Boost documentation tools, you will need several tools:</para>
    <itemizedlist>
      <listitem><simpara><command>xsltproc</command>:</simpara>
        <itemizedlist>
          <listitem>Windows with <ulink
                       url="http://www.cygwin.com/">Cygwin</ulink>: select the libxml2 and libxslt packages.</listitem>
          <listitem>Windows without Cygwin: Download the <ulink url="http://www.zlatkovic.com/pub/libxml/">binary packages</ulink>
            from Igor Zlatkovic. At the very least, you'll need iconv, zlib, libxml2 and libxslt.</listitem>
          <listitem>Mac OS X with Fink: Get the libxslt package.</listitem>
          <listitem>Mac OS X without Fink: <ulink url="http://www.zveno.com/open_source/libxml2xslt.html">Download the libxslt binaries</ulink></listitem>
          <listitem>Any platform: <ulink
                                     url="http://xmlsoft.org/XSLT/">libxslt source</ulink>.</listitem>
        </itemizedlist>
      </listitem>
        <listitem><simpara><command>doxygen</command>:</simpara> Available from <ulink url="http://www.doxygen.org">http://www.doxygen.org</ulink></listitem>
    </itemizedlist>

      <title>Automatic setup for Unix-like systems</title>

      <para>BoostBook provides a nearly-automatic setup script. Once
      you have downloaded and
      installed <command>xsltproc</command>, <command>doxygen</command>,
      and (optionally) <command>java</command>, the setup script can
      download the required DocBook stylesheets, DocBook DTD, and
      (when Java is enabled) Apache FOP for PDF output. It will then
      configure Boost.Build version 2 to build BoostBook
      documentation.</para>

      <para>The script requires: <command>sh</command>,
      <command>curl</command> and <command>gunzip</command>.
      To perform the installation, execute the
      script <command>tools/boostbook/setup_boostbook.sh</command>
      from a directory where you would like the resulting XSL, DTD,
      and Apache FOP installations to occur. </para>

      <title>Manual setup for all systems</title>

      <para>This section describes how to manually configure Boost
      Boost version 2 (BBv@) for BoostBook. If you can use the
      automatic setup script, you should. All configuration will
      happen in the BBv2 user configuration file,
      <filename>user-config.jam</filename>. If you do not have a copy
      of this file in your home directory, you should copy the one
      that resides in tools/build/ to your home
      directory. Alternatively, you can edit
      <filename>tools/build/user-config.jam</filename> directly or
      a site-wide <filename>site-config.jam</filename> file.</para>

        <title>Configuring <command>xsltproc</command></title>

        <para>To configure <command>xsltproc</command> manually, you
        will need to add a directive to
        <filename>user-config.jam</filename> telling it where to find
        <command>xsltproc</command>. If the program is in your path,
        just add the following line to
        <filename>user-config.jam</filename>:</para>

<programlisting>using xsltproc ;</programlisting>

        <para>If <command>xsltproc</command> is somewhere else, use
        this directive, where XSLTPROC is the full
        pathname to <command>xsltproc</command> (including
        <command>xsltproc</command>):</para>

<programlisting>using xsltproc : XSLTPROC ;</programlisting>

        <title>Configuring local DocBook XSL and DTD distributions</title>

        <para>This section describes how to configure Boost.Build to
        use local copies of the DocBook DTD and XSL stylesheets to
        improve processing time. You will first need to download two
        packages:

        <itemizedlist>
          <listitem><para>Norman Walsh's DocBook XSL stylesheets,
          available at the <ulink
          url="http://docbook.sourceforge.net">DocBook sourceforge
          site</ulink>. Extract the DocBook XSL stylesheets to a
          directory on your hard disk (which we'll refer to as the
          DOCBOOK_XSL_DIR).</para>
          </listitem>

          <listitem><para>The DocBook DTD, available as a ZIP archive
          at the <ulink
          url="http://www.oasis-open.org/docbook/xml/4.2/">OASIS
          DocBook site</ulink>. The package is called "DocBook XML
          4.2". Extract the DocBook DTD to a directory on your hard
          disk (which we'll refer to as the
          DOCBOOK_DTD_DIR). You will want to extract this
          archive in a subdirectory!</para></listitem>
        </itemizedlist>
        </para>

        <para>Add the following directive telling BBv2 where to find
        the DocBook DTD and XSL stylesheets:</para>

        <programlisting>#  BoostBook configuration
using boostbook
  : DOCBOOK_XSL_DIR
  : DOCBOOK_DTD_DIR
  ;</programlisting>

        <para>Whenever you change this directive, you will need to
        remove the bin.v2 directory that BBv2 generates.
        This is due to longstanding bug we are trying to fix.</para>

        <para>At this point, you should be able to build HTML
        documentation for libraries that do not require Doxygen. To
        test this, change into the directory <filename
        class="directory">$BOOST_ROOT/libs/function/doc</filename> and
        run the command bjam: it should produce HTML
        documentation for the Boost.Function library in the
        html subdirectory.</para>

        <title>Configuring Doxygen for Documentation Extraction</title>

        <para>Doxygen is required to build the documentation for
        several Boost libraries. You will need a recent version of
        <ulink url="http://www.doxygen.org">Doxygen</ulink> (most of
        the 1.3.x and 1.4.x versions will suffice). BBv2 by adding the
        following directive to
        <filename>user-config.jam</filename>:</para>

        <programlisting>using doxygen : DOXYGEN ;</programlisting>

        <para><filename>DOXYGEN</filename> should be replaced with the
        name of the <command>doxygen</command> executable (with full
        path name). If the right <command>doxygen</command> executable
        can be found via the path, this parameter can be
        omitted, e.g.</para>

        <programlisting>using doxygen ;</programlisting>

        <important>
          <para>The relative order of declarations in
          <filename>user-config.jam</filename> /
          <filename>site-config.jam</filename> files is
          significant. In particular, the <literal>using
          doxygen</literal> line should come
          <emphasis>after</emphasis> the <literal>using
          boostbook</literal> declaration.
          </para>
        </important>

      <title>Configuring Apache FOP</title>

      <para>In order to generate PDF and PostScript output using
      Apache FOP, you will need a <ulink
      url="http://java.sun.com">Java interpreter</ulink> and <ulink
      url="http://xml.apache.org/fop/download.html">Apache FOP</ulink>
      (version 0.20.5 is best). Unpack Apache FOP to some
      directory. The top level directory of the FOP tool should
      contain a main script called <filename>fop.sh</filename> on Unix
      and <filename>fop.bat</filename> on Windows. You need to specify
      the location of that script and Java location to
      Boost.Build. Add the following to your
      <filename>user-config.jam</filename> or
      <filename>site-config.jam</filename>:
<programlisting>
using fop : FOP_COMMAND
          : JAVA_HOME
          ;
</programlisting> replacing
      FOP_COMMAND with the full path to the FOP main script, and
      replacing JAVA_HOME with the directory where Java is
      installed. If the <envar>JAVA_HOME</envar> environment variable is
      already set, you don't need to specify it above.
      </para>

      <para>
        Proper generation of images in PDFs depends on the <ulink
        url="http://java.sun.com/products/jimi/#">Jimi Image
        Library</ulink>.  To get FOP to use Jimi, extract the
        <filename>JimiProClasses.zip</filename> file from the Jimi SDK
        and rename it—if on Windows, to
        <filename>jimi-1.0.jar</filename>, or if on *nix, to
        <filename>JimiProClasses.jar</filename>—and place it in the
        <filename>lib/</filename> subdirectory of your FOP
        installation.
      </para>

      <para>To test PDF generation, switch to the directory <filename
      class="directory">$BOOST_ROOT/libs/function/doc</filename> and
      execute the command <command>bjam pdf</command>. In the
      absence of any errors, Apache FOP will be executed to transform
      the XSL:FO output of DocBook into a PDF file.</para>

    <title>Running BoostBook</title>

    <para>Once BoostBook has been configured, we can build some
    documentation. First, change to the directory
    $BOOST_ROOT/doc and remove (or make writable) the
    .html files in
    $BOOST_ROOT/doc/html. Then, run bjam
    to build HTML documentation. You should see several
    warnings like these while DocBook documentation is being built
    from BoostBook documentation:</para>

    <programlisting>Cannot find function named 'checked_delete'
Cannot find function named 'checked_array_delete'
Cannot find function named 'next'</programlisting>

    <para>These warnings are emitted when the Boost documentation
    tools cannot find documentation for functions, methods, or classes
    that are referenced in the source, and are not harmful in any
    way. Once Boost.Jam has completed its execution, HTML
    documentation for Boost will be available in
    $BOOST_ROOT/doc/html. You can also create HTML
    documentation in a single (large!) HTML file with the command line
    bjam onehtml, or Unix man pages with the command
    line bjam man. The complete list of output
    formats is listed in <xref
    linkend="boostbook.output.formats"/>. Several output formats can
    be passed to a single invocation of bjam, e.g.,
    bjam html man docbook would generate HTML
    (multiple files), man pages, and DocBook documentation.</para>

      <title>BoostBook Output Formats</title>
      <tgroup cols="2">

          <row><entry>Format</entry><entry>Description</entry></row>

          <row>
            <entry>html</entry>
            <entry><simpara>HTML output (multiple files). This is the default</simpara></entry>
          </row>
          <row>
            <entry>onehtml</entry>
            <entry><simpara>HTML output in a single HTML file.</simpara></entry>
          </row>
          <row>
            <entry>man</entry>
            <entry><simpara>Unix man pages.</simpara></entry>
          </row>
          <row>
            <entry>pdf</entry>
            <entry><simpara>PDF. Requires <ulink url="http://xml.apache.org/fop/index.html">Apache FOP</ulink>.</simpara></entry>
          </row>
          <row>
            <entry>ps</entry>
            <entry><simpara>Postscript. Requires <ulink url="http://xml.apache.org/fop/index.html">Apache FOP</ulink>.</simpara></entry>
          </row>
          <row>
            <entry>docbook</entry>
            <entry><ulink url="http://www.docbook.org/">DocBook</ulink>.</entry>
          </row>
          <row>
            <entry>fo</entry>
            <entry><ulink url="http://www.w3.org/TR/xsl/">XSL Formatting Objects</ulink></entry>
          </row>

      </tgroup>

      <title>Troubleshooting</title>

      <para>The Boost documentation tools are still in their early phase of
      development, and some things don't work as seamlessly as we would like
      them to, yet. In particular, error messages can be somewhat
      uninformative at times. If you find yourself in the situation when
      you have double checked everything, and yet things still don't work as
      expected, consider helping the tools by deleting
      <literal>bin.v2</literal> build directory.
      </para>

  </chapter>

  <xi:include href="documenting.xml"/>
  <xi:include href="together.xml"/>
  <xi:include href="reference.xml"/>
</part>


text:
package com.amazonaws.services.ec2.model.transform;

import java.util.Map;
import java.util.Map.Entry;

import javax.xml.stream.events.XMLEvent;

import com.amazonaws.services.ec2.model.*;
import com.amazonaws.transform.Unmarshaller;
import com.amazonaws.transform.MapEntry;
import com.amazonaws.transform.StaxUnmarshallerContext;
import com.amazonaws.transform.SimpleTypeStaxUnmarshallers.*;

/**
 * CreateVolumePermissionModifications StAX Unmarshaller
 */
public class CreateVolumePermissionModificationsStaxUnmarshaller
        implements
        Unmarshaller<CreateVolumePermissionModifications, StaxUnmarshallerContext> {

    public CreateVolumePermissionModifications unmarshall(
            StaxUnmarshallerContext context) throws Exception {
        CreateVolumePermissionModifications createVolumePermissionModifications = new CreateVolumePermissionModifications();
        int originalDepth = context.getCurrentDepth();
        int targetDepth = originalDepth + 1;

        if (context.isStartOfDocument())
            targetDepth += 1;

        while (true) {
            XMLEvent xmlEvent = context.nextEvent();
            if (xmlEvent.isEndDocument())
                return createVolumePermissionModifications;

            if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

                if (context.testExpression("Add/item", targetDepth)) {
                    createVolumePermissionModifications.getAdd().add(
                            CreateVolumePermissionStaxUnmarshaller
                                    .getInstance().unmarshall(context));
                    continue;
                }

                if (context.testExpression("Remove/item", targetDepth)) {
                    createVolumePermissionModifications.getRemove().add(
                            CreateVolumePermissionStaxUnmarshaller
                                    .getInstance().unmarshall(context));
                    continue;
                }

            } else if (xmlEvent.isEndElement()) {
                if (context.getCurrentDepth() < originalDepth) {
                    return createVolumePermissionModifications;
                }
            }
        }
    }

    private static CreateVolumePermissionModificationsStaxUnmarshaller instance;

    public static CreateVolumePermissionModificationsStaxUnmarshaller getInstance() {
        if (instance == null)
            instance = new CreateVolumePermissionModificationsStaxUnmarshaller();
        return instance;
    }
}


text:
copyright:
  years: 2015, 2017
lastupdated: "2017-03-31"

---

{:new_window: target="_blank"}
{:shortdesc: .shortdesc}

# About the IBM Watson Visual Recognition Dedicated service
{: #about}
The {{site.data.keyword.visualrecognitionfull}} Dedicated service uses deep learning algorithms to analyze images for scenes, objects, and other content. The response includes keywords that provide information about the content.
{: shortdesc}

A set of built-in classes provides highly accurate results without training. You can train custom classifiers to create specialized classes.

## How to use the service
{: notoc}
The following image shows the process of creating and using the classifier:
![Describes the flow of the {{site.data.keyword.visualrecognitionshort}} service, from preparing, training, and classifying images to viewing results](images/vr-process2.png)

## What to use the service for
{: #use-cases}
The {{site.data.keyword.visualrecognitionshort}} Dedicated service can be used for diverse applications and industries, such as:

- **Manufacturing:** Use images from a manufacturing setting to make sure products are being positioned correctly on an assembly line

- **Visual Auditing:** Look for visual compliance or deterioration in a fleet of trucks, planes, or windmills out in the field, train custom classifiers to understand what defects look like

- **Insurance:** Rapidly process claims by using images to classify claims into different categories.

- **Social listening:** Use images from your product line or your logo to track buzz about your company on social media

- **Social commerce:** Use an image of a plated dish to find out which restaurant serves it and find reviews, use a travel photo to find vacation suggestions based on similar experiences, use a house image to find similar homes that are for sale

- **Retail:** Take a photo of a favorite outfit to find stores with those clothes in stock or on sale, use a travel image to find retail suggestions in that area

- **Education:** Create image-based applications to educate about taxonomies, use pictures to find educational material on similar subjects

## Supported languages
{: #supported-languages}
The **Classify an image** method supports English (en), Spanish (es), Arabic (ar), and Japanese (ja) for default classes. Custom classifiers returned with this method support only English.

All other methods support English only.

# Related Links
{: #rellinks notoc}

## Tutorials and Samples
{: #samples}

* [View a video introduction ![External link icon](../../icons/launch-glyph.svg "External link icon")](https://www.youtube.com/watch?v=vnWblT50w1Y){:new_window} about training and retraining classifiers.

* [Get started with the service](getting-started.html).

* [Try out the demo ![External link icon](../../icons/launch-glyph.svg "External link icon")](http://visual-recognition-demo.mybluemix.net){:new_window}.


text:
import { Type } from '../type';
/**
 * Configures the `Injector` to return a value for a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ValueSansProvider'}
 *
 * @experimental
 */
export interface ValueSansProvider {
    /**
     * The value to inject.
     */
    useValue: any;
}
/**
 * Configures the `Injector` to return a value for a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface ValueProvider extends ValueSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Configures the `Injector` to return an instance of `useClass` for a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='StaticClassSansProvider'}
 *
 * @experimental
 */
export interface StaticClassSansProvider {
    /**
     * An optional class to instantiate for the `token`. (If not provided `provide` is assumed to be a
     * class to instantiate)
     */
    useClass: Type<any>;
    /**
     * A list of `token`s which need to be resolved by the injector. The list of values is then
     * used as arguments to the `useClass` constructor.
     */
    deps: any[];
}
/**
 * Configures the `Injector` to return an instance of `useClass` for a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}
 *
 * Note that following two providers are not equal:
 *
 * {@example core/di/ts/provider_spec.ts region='StaticClassProviderDifference'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface StaticClassProvider extends StaticClassSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Configures the `Injector` to return an instance of a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * ```
 * @Injectable(SomeModule, {deps: []})
 * class MyService {}
 * ```
 *
 * @experimental
 */
export interface ConstructorSansProvider {
    /**
     * A list of `token`s which need to be resolved by the injector. The list of values is then
     * used as arguments to the `useClass` constructor.
     */
    deps?: any[];
}
/**
 * Configures the `Injector` to return an instance of a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface ConstructorProvider extends ConstructorSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: Type<any>;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Configures the `Injector` to return a value of another `useExisting` token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ExistingSansProvider'}
 */
export interface ExistingSansProvider {
    /**
     * Existing `token` to return. (equivalent to `injector.get(useExisting)`)
     */
    useExisting: any;
}
/**
 * Configures the `Injector` to return a value of another `useExisting` token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ExistingProvider'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface ExistingProvider extends ExistingSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Configures the `Injector` to return a value by invoking a `useFactory` function.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='FactorySansProvider'}
 *
 * @experimental
 */
export interface FactorySansProvider {
    /**
     * A function to invoke to create a value for this `token`. The function is invoked with
     * resolved values of `token`s in the `deps` field.
     */
    useFactory: Function;
    /**
     * A list of `token`s which need to be resolved by the injector. The list of values is then
     * used as arguments to the `useFactory` function.
     */
    deps?: any[];
}
/**
 * Configures the `Injector` to return a value by invoking a `useFactory` function.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='FactoryProvider'}
 *
 * Dependencies can also be marked as optional:
 *
 * {@example core/di/ts/provider_spec.ts region='FactoryProviderOptionalDeps'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface FactoryProvider extends FactorySansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Describes how the `Injector` should be configured in a static way (Without reflection).
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @see `ValueProvider`
 * @see `ExistingProvider`
 * @see `FactoryProvider`
 */
export declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
/**
 * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.
 *
 * Create an instance by invoking the `new` operator and supplying additional arguments.
 * This form is a short form of `TypeProvider`;
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
 */
export interface TypeProvider extends Type<any> {
}
/**
 * Configures the `Injector` to return a value by invoking a `useClass` function.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ClassSansProvider'}
 *
 * @experimental
 */
export interface ClassSansProvider {
    /**
     * Class to instantiate for the `token`.
     */
    useClass: Type<any>;
}
/**
 * Configures the `Injector` to return an instance of `useClass` for a token.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @usageNotes
 * ### Example
 *
 * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
 *
 * Note that following two providers are not equal:
 *
 * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
 *
 * ### Multi-value example
 *
 * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
 */
export interface ClassProvider extends ClassSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     */
    multi?: boolean;
}
/**
 * Describes how the `Injector` should be configured.
 *
 * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
 *
 * @see `TypeProvider`
 * @see `ClassProvider`
 * @see `StaticProvider`
 */
export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];


text:
package hrisey.javac.lang;

import java.util.Arrays;

public class ExpressionCreator {

	public static Literal createLiteral(String stringValue) {
		return new Literal(stringValue);
	}

	public static Call createCall(Expression method, Expression... arguments) {
		return new Call(method, Arrays.asList(arguments));
	}

	public static Call createCall(String method) {
		return createCall(new DottedExpression(method));
	}

	public static Call createCall(String method, String argument) {
		return createCall(new DottedExpression(method), new DottedExpression(argument));
	}

	public static Call createCall(String method, Expression argument1) {
		return createCall(new DottedExpression(method), argument1);
	}

	public static Call createCall(String method, String argument1, String argument2) {
		return createCall(new DottedExpression(method), new DottedExpression(argument1), new DottedExpression(argument2));
	}

	public static Call createCall(String method, String argument1, Expression argument2) {
		return createCall(new DottedExpression(method), new DottedExpression(argument1), argument2);
	}

	public static Call createCall(String method, Expression argument1, String argument2) {
		return createCall(new DottedExpression(method), argument1, new DottedExpression(argument2));
	}

	public static Call createCall(String method, Expression argument1, Expression argument2) {
		return createCall(new DottedExpression(method), argument1, argument2);
	}

	public static Call createCall(Expression method, Expression argument1, String argument2) {
		return createCall(method, argument1, new DottedExpression(argument2));
	}

	public static Expression createIdent(String ident) {
		return new DottedExpression(ident);
	}

	public static Select createSelect(Expression expression, String selector) {
		return new Select(expression, selector);
	}

	public static Type createType(com.sun.tools.javac.code.Type type) {
		return new Type(type);
	}

	public static GenericType createType(String genericType, com.sun.tools.javac.code.Type paramType) {
		return new GenericType(new DottedExpression(genericType), new Type(paramType));
	}

	public static Equals createEquals(String left, Expression right) {
		return new Equals(new DottedExpression(left), right);
	}

	public static NotEquals createNotEquals(String left, Expression right) {
		return new NotEquals(new DottedExpression(left), right);
	}

	public static Literal createNull() {
		return new Literal();
	}

	public static NewInstance createNewInstance(TypeExpression type) {
		return new NewInstance(type, true);
	}
}


text:
package version

var Version string


text:
RenderedMemberStatement = mondelefant.new_class()
RenderedMemberStatement.table = 'rendered_member_statement'
RenderedMemberStatement.primary_key = { "member_id", "format" }

RenderedMemberStatement:add_reference{
  mode          = 'm1',
  to            = "Member",
  this_key      = 'member_id',
  that_key      = 'id',
  ref           = 'member',
}


text:
package test

type RequesterReturnElided interface {
	Get(path string) (a, b, c int, err error)
}


text:
package org.semagrow.evaluation.file;

import org.eclipse.rdf4j.common.iteration.CloseableIteration;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.query.BindingSet;
import org.eclipse.rdf4j.query.QueryEvaluationException;

/**
 * Created by angel on 10/20/14.
 */
public interface MaterializationManager {

    CloseableIteration<BindingSet,QueryEvaluationException>
        getResult(IRI handle) throws QueryEvaluationException;

    MaterializationHandle saveResult() throws QueryEvaluationException;

}


text:
import static org.junit.jupiter.api.Assertions.assertEquals;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import lombok.extern.slf4j.Slf4j;
import org.dotwebstack.framework.test.TestApplication;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.testcontainers.containers.BindMode;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;

@Slf4j
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = TestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
@Testcontainers
class OpenapiPostgresIntegrationTest {

  @Autowired
  private WebTestClient client;

  private final ObjectMapper mapper = new ObjectMapper();

  @Container
  static final TestPostgreSqlContainer postgreSqlContainer = new TestPostgreSqlContainer()
      .withClasspathResourceMapping("config/model", "/docker-entrypoint-initdb.d", BindMode.READ_ONLY);

  private static class TestPostgreSqlContainer extends PostgreSQLContainer<TestPostgreSqlContainer> {
    public TestPostgreSqlContainer() {
      super(DockerImageName.parse("postgis/postgis:11-3.1")
          .asCompatibleSubstituteFor("postgres"));
    }
  }

  @DynamicPropertySource
  static void registerDynamicProperties(DynamicPropertyRegistry registry) {
    registry.add("dotwebstack.postgres.host", postgreSqlContainer::getHost);
    registry.add("dotwebstack.postgres.port", postgreSqlContainer::getFirstMappedPort);
    registry.add("dotwebstack.postgres.username", postgreSqlContainer::getUsername);
    registry.add("dotwebstack.postgres.password", postgreSqlContainer::getPassword);
    registry.add("dotwebstack.postgres.database", postgreSqlContainer::getDatabaseName);
  }

  @Test
  void breweries_returnsExpectedResult() throws IOException {
    String result = client.get()
        .uri("/breweries")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries.json");
  }

  @Test
  void breweries_returnsExpectedResult_withContext() throws IOException {
    String result = client.get()
        .uri("/breweriesInContext")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries_context.json");
  }

  @Test
  void breweries_returnsExpectedResult_withSortAscending() throws IOException {
    String result = client.get()
        .uri("/breweries?sort=name")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries_sortAscending.json");
  }

  @Test
  void breweries_returnsExpectedResult_withSortDescending() throws IOException {
    String result = client.get()
        .uri("/breweries?sort=-name")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries_sortDescending.json");
  }

  @Test
  void breweries_returnsExpectedResult_withExpanded() throws IOException {
    String result = client.get()
        .uri("/breweries?expand=postalAddress")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries_postalAddress.json");
  }

  @Test
  @Disabled
  void breweries_returnsExpectedResult_withFilter() throws IOException {
    String result = client.get()
        .uri("/breweries?name=Brewery X")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "breweries_filtered.json");
  }

  @Test
  void breweries_returnsExpectedResult_withKey() throws IOException {
    String result = client.get()
        .uri("/brewery/d3654375-95fa-46b4-8529-08b0f777bd6b")
        .exchange()
        .expectBody(String.class)
        .returnResult()
        .getResponseBody();

    assertResult(result, "brewery_X.json");
  }

  private void assertResult(String result, String jsonResult) throws IOException {
    JsonNode expectedObj = mapper.readTree(getClass().getResourceAsStream("/results/" + jsonResult));
    JsonNode actualObj = mapper.readTree(result);

    assertEquals(expectedObj, actualObj);
  }
}