text:
<!--

/* ~~~~~~~~~
 * build.xml
 * ~~~~~~~~~
 * (C) Copyright 2003-2010, by Barak Naveh and Contributors.
 *
 * Original Author:  Barak Naveh
 * Contributor(s):   John V. Sichi
 *
 * $Id: build.xml 756 2012-01-19 23:21:17Z perfecthash $
 *
 * Changes
 * ~~~~~~~
 * 24-Jul-2003 : Initial revision (BN);
 * 15-Aug-2003 : Used wildcards instead of enumerating files(JVS);
 * 15-Aug-2003 : Added checkstyle task (JVS);
 * 15-Aug-2003 : Used JUnit batch test feature (JVS);
 * 15-Aug-2003 : Added jalopy task (JVS);
 * 03-Sep-2003 : Added etags support (JVS);
 * 24-Feb-2004 : Removed duplicates and cleaned code (BN);
 * 06-Mar-2004 : Added tasks for building a release by CVS tag (BN);
 * 13-Oct-2004 : Added task for building experimental package (MB);
 * 31-Jul-2005 : Added support for retroweaver (JVS);
 * 23-Apr-2006 : Renamed package to org.jgrapht (JVS);
 * 25-Jun-2006 : Fold experimental into main build (JVS);
 * 01-Jul-2006 : Remove checkstyle, switch from CVS to SVN (JVS);
 * 29-Sep-2007 : Dropped support for retroweaver in 0.7.2 release (JVS);
 * 28-Sep-2008 : Moved to JDK 1.6 for 0.8.0 release (JVS);
 *
 */
-->

<!--
/**
 * An ant build file for JGraphT (use Ant 1.6.0 and above).
 * Before running this script, make sure that the libraries used by JGraphT are
 * found under ./lib directory. This script will create directories ./build
 * and ./testbuild for generated classfiles. These can be removed at any time
 * via the 'clean' target.  A temporary ./distribution directory is created
 * when building a distribution. A ./javadoc directory is created for the
 * Javadoc HTML pages.
 *
 * This script was originally based on a nice script written by David Gilbert.
 *
 * @author Barak Naveh
 * @author John V. Sichi
 *
 * @since 24-Jul-2003
 */
-->

<project name="jgrapht" default="all" basedir=".">

  <!-- import local property overrides; these take precedence over
  later definitions in this file -->
  <property file="etc/build.properties"/>

  <property name="latest.version.name"
    value="0.8.3" />

  <!-- SVN tags and their respective version names -->
  <property name="ver_0_8_3.name"
    value="0.8.3" />
  <property name="ver_0_8_2.name"
    value="0.8.2" />
  <property name="ver_0_8_1.name"
    value="0.8.1" />
  <property name="ver_0_8_0.name"
    value="0.8.0" />
  <property name="ver_0_7_3.name"
    value="0.7.3" />
  <property name="ver_0_7_2.name"
    value="0.7.2" />
  <property name="ver_0_7_1.name"
    value="0.7.1" />
  <property name="ver_0_7_0.name"
    value="0.7.0" />
  <property name="ver_0_6_0.name"
    value="0.6.0" />
  <property name="ver_0_5_3.name"
    value="0.5.3" />
  <property name="ver_0_5_2.name"
    value="0.5.2" />

  <!-- Initialization. -->
  <target name="init.local" unless="svntag">
    <property name="checkout.dir"     value="checkout" />
    <property name="project.version"  value="${latest.version.name}-local" />
  </target>

  <target name="init.svn" if="svntag">
    <property name="checkout.dir"
      value="${svntag}" />
    <!-- A dereferencing hack to set project.version=${${svntag}.name} -->
    <!-- To be simplified if future Ant versions will support it directly -->
    <echo file="project.version.tmp">project.version=$${${svntag}.name}</echo>
    <property file="project.version.tmp" />
    <delete file="project.version.tmp" />
    <!-- project.version now has the dereferenced value of ${${svntag}.name} -->
  </target>

  <target name="init" depends="init.local,init.svn">
    <echo level="info">JAVA_HOME=${java.home}</echo>
    <property name="project.name"
      value="jgrapht" />
    <property name="project.prefix"
      value="${project.name}-${project.version}" />

    <!-- Directories -->
    <property name="build.dir"
      value="${basedir}/build" />
    <property name="testbuild.dir"
      value="${basedir}/testbuild" />
    <property name="distrib.dir"
      value="${basedir}/distribution"/>
    <property name="src.dir"
      value="${basedir}/src"/>
    <property name="testsrc.dir"
      value="${basedir}/testsrc"/>
    <property name="lib.dir"
      value="${basedir}/lib"/>
    <property name="etc.dir"
      value="${basedir}/etc"/>
    <property name="javadoc.dir"
      value="${basedir}/javadoc"/>

    <!-- File names -->
    <property name="project.jar.name"
      value="${project.name}-jdk1.6.jar" />
    <property name="project.tar.name"
      value="${project.prefix}.tar" />
    <property name="project.tar.gz.name"
      value="${project.prefix}.tar.gz" />
    <property name="project.zip.name"
      value="${project.prefix}.zip" />
    <property name="build.file.name"
      value="build.xml" />
    <property name="license.file.name"
      value="license-LGPL.txt" />
    <property name="junit.jar.name"
      value="junit.jar" />
    <property name="xmlunit.jar.name"
      value="xmlunit1.0.jar" />
    <property name="jgraph.jar.name"
      value="jgraph.jar" />
    <property name="touchgraph.jar.name"
      value="TGGraphLayout.jar" />

    <!-- Files -->
    <property name="project.jar"
      value="${basedir}/${project.jar.name}" />
    <property name="project.tar"
      value="${basedir}/${project.tar.name}" />
    <property name="project.tar.gz"
      value="${basedir}/${project.tar.gz.name}" />
    <property name="project.zip"
      value="${basedir}/${project.zip.name}" />
    <property name="junit.jar"
      value="${lib.dir}/${junit.jar.name}"/>
    <property name="xmlunit.jar"
      value="${lib.dir}/${xmlunit.jar.name}"/>
    <property name="jgraph.jar"
      value="${lib.dir}/${jgraph.jar.name}"/>
    <property name="touchgraph.jar"
      value="${lib.dir}/${touchgraph.jar.name}"/>
    <property name="build.file"
      value="${basedir}/${build.file.name}"/>
    <property name="jalopy.settings"
      value="${etc.dir}/triemax-jalopy-settings.xml"/>

  <!-- NOTE jvs 18-Mar-2007:  junit.jar and xmlunit.jar should really be on
       testbuild.classpath only, but this way makes Eclipse setup easier -->

    <!-- Classpath for building functional sources. -->
    <path id="build.classpath">
      <pathelement location="${junit.jar}"/>
      <pathelement location="${xmlunit.jar}"/>
      <pathelement location="${jgraph.jar}"/>
      <pathelement location="${touchgraph.jar}"/>
    </path>
    <property name="build.classpath" refid="build.classpath"/>

    <!-- Classpath for building tests. -->
    <path id="testbuild.classpath">
      <pathelement path="${build.classpath}"/>
      <pathelement location="${build.dir}"/>
    </path>
    <property name="testbuild.classpath" refid="testbuild.classpath"/>

    <!-- Classpath for running svn task. -->
    <path id="svn.classpath">
      <pathelement location="${lib.dir}/svnant.jar"/>
      <pathelement location="${lib.dir}/svnClientAdapter.jar"/>
    </path>
    <property name="svn.classpath" refid="svn.classpath"/>

    <!-- Classpath for running tests. -->
    <path id="test.classpath">
      <pathelement path="${testbuild.classpath}"/>
      <pathelement location="${testbuild.dir}"/>
    </path>
    <property name="test.classpath" refid="test.classpath"/>
  </target>

  <!-- NOTE jvs 18-Mar-2007:  If you change the javac's below, update
       the Eclipse setup instructions in
       http://jgrapht.wikispaces.com/ContributorGuidelines -->

  <!-- Compile the classes -->
  <target name="compile" depends="init"
    description="Compiles the JGraphT source code.">

    <!-- create a build directory -->
    <mkdir dir="${build.dir}" />

    <!-- compile the source -->
    <javac srcdir="${src.dir}" destdir="${build.dir}" source="1.6">
      <classpath refid="build.classpath" />
      <include name="org/jgrapht/util/TypeUtil.java"/>
    </javac>
    <javac srcdir="${src.dir}" destdir="${build.dir}" source="1.6">
      <compilerarg line="-Xlint:all" />
      <classpath refid="build.classpath" />
      <include name="**/*.java"/>
      <exclude name="org/jgrapht/experimental/**/*.java"/>
      <exclude name="org/jgrapht/util/TypeUtil.java"/>
      <exclude name="org/jgrapht/ext/JGraphModelAdapter.java"/>
      <exclude name="org/jgrapht/demo/JGraphAdapterDemo.java"/>
    </javac>
    <javac srcdir="${src.dir}" destdir="${build.dir}" source="1.6">
      <classpath refid="build.classpath" />
      <include name="**/*.java"/>
    </javac>
  </target>

  <!-- Run the experimental touchgraph demo -->
  <target name="touchgraph.demo" depends="compile"
    description="Runs the experimental Touchgraph demo.">
    <java
      classname="org.jgrapht.experimental.touchgraph.SimpleTouchgraphApplet">
      <classpath refid="test.classpath" />
    </java>
  </target>

  <!-- Generate the runtime jar -->
  <target name="jar" depends="compile">
    <jar jarfile="${project.jar}" basedir="${build.dir}">
      <manifest>
        <attribute name="Main-Class"
          value="org.jgrapht.demo.JGraphAdapterDemo"/>
        <attribute name="Class-Path"
          value="lib/${jgraph.jar.name}"/>
        <attribute name="Specification-Title"
          value="${project.name}"/>
        <attribute name="Specification-Version"
          value="${project.version}"/>
        <attribute name="Implementation-Version"
          value="${project.version}-jdk1.6"/>
      </manifest>
    </jar>
  </target>

  <!-- Build all JUnit tests -->
  <target name="test.compile" depends="compile"
    description="Builds all JUnit tests.">
    <!-- create a test build directory -->
    <mkdir dir="${testbuild.dir}" />

    <javac srcdir="${testsrc.dir}" destdir="${testbuild.dir}" source="1.6"
      debug="on">
      <classpath refid="testbuild.classpath" />
      <include name="org/jgrapht/**"/>
    </javac>
  </target>

  <!-- Macro for running all JUnit tests -->
  <macrodef name="runTests">
    <attribute name="jvm" default="java"/>
    <attribute name="classpath.refid" default="test.classpath"/>
    <sequential>
      <echo level="info">
        If you get a junit task lookup failure, you need to add the junit.jar to
        the classpath, possibly by copying it into the ANT_HOME/lib folder.
        See http://ant.apache.org/manual/OptionalTasks/junit.html for more.
      </echo>
      <junit printsummary="no" fork="yes" jvm="@{jvm}"
        haltonerror="true" haltonfailure="true">
        <classpath refid="@{classpath.refid}"/>
        <jvmarg line="-ea -esa" />
        <formatter type="brief" usefile="no" />
        <batchtest>
          <fileset dir="${testsrc.dir}">
            <include name="**/*Test.java"/>
            <exclude name="**/Abstract*Test.java"/>
            <exclude name="**/DefaultEdgeTest.java"/>
          </fileset>
        </batchtest>
      </junit>
    </sequential>
  </macrodef>

  <!-- Run all JUnit tests -->
  <target name="test" depends="test.compile"
    description="Builds and runs all JUnit tests.">
    <runTests/>
  </target>

  <!-- Run jalopy on source code                                         -->
  <!-- NOTE:  requires manual installation of .jars in lib/jalopy        -->
  <target name="jalopy" depends="test.compile"
    description="Runs jalopy on all source code.">
    <taskdef name="jalopy"
      classname="com.triemax.JalopyTask">
      <classpath>
        <fileset dir="${basedir}/lib/jalopy">
          <include name="*.jar"/>
        </fileset>
      </classpath>
    </taskdef>
    <jalopy force="true" backup="true" convention="${jalopy.settings}"
      classpathref="test.classpath" history="CRC32" threads="2">
      <fileset dir="${basedir}">
        <include name="src/**/*.java"/>
        <include name="testsrc/**/*.java"/>
      </fileset>
    </jalopy>
  </target>

  <!-- Generate the JGraphT JavaDoc HTML pages -->
  <target name="javadoc" depends="init" description="Creates the Javadocs.">
    <delete dir="${javadoc.dir}" />
    <mkdir dir="${javadoc.dir}" />
    <javadoc destdir="${javadoc.dir}" source="1.6" failonerror="true"
      access="protected"
      windowtitle="JGraphT : a free Java graph library"
      overview="${src.dir}/overview.html">
      <classpath refid="build.classpath" />
      <packageset dir="${src.dir}" defaultexcludes="yes">
        <include name="**"/>
        <exclude name="org/jgrapht/experimental/**"/>
      </packageset>
    </javadoc>
  </target>

  <!-- Prepares a distribution directory of JGraphT -->
  <target name="prepare.distribution" depends="jar,javadoc">

    <!-- make a temporary distribution directory -->
    <mkdir dir="${distrib.dir}" />

    <!-- add README -->
    <copy file="${basedir}/README.html" tofile="${distrib.dir}/README.html" />

    <!-- add license -->
    <copy file="${basedir}/${license.file.name}"
      tofile="${distrib.dir}/${license.file.name}" />

    <!-- add runtime jar file -->
    <copy file="${project.jar}" tofile="${distrib.dir}/${project.jar.name}" />

    <!-- add source files -->
    <copy todir="${distrib.dir}/src">
      <fileset dir="${src.dir}">
        <include name="overview.html"/>
        <include name="**/*.java"/>
        <include name="**/package.html"/>
      </fileset>
    </copy>

    <!-- add source files of unit tests -->
    <copy todir="${distrib.dir}/testsrc">
      <fileset dir="${testsrc.dir}">
        <include name="**"/>
      </fileset>
    </copy>

    <!-- add lib files -->
    <copy todir="${distrib.dir}/lib">
      <fileset dir="${lib.dir}">
        <include name="*.jar"/>
        <include name="lib-readme.txt"/>
      </fileset>
    </copy>

    <!-- add ant build file (this file) -->
    <copy file="${build.file}" tofile="${distrib.dir}/${build.file.name}" />

    <!-- add etc files -->
    <copy todir="${distrib.dir}/etc">
      <fileset dir="${etc.dir}">
        <include name="jalopy-settings.xml"/>
        <include name="build.properties.template"/>
      </fileset>
    </copy>

    <!-- add etc/build.properties -->
    <copy file="${etc.dir}/build.properties.template"
      tofile="${distrib.dir}/etc/build.properties">
    </copy>

    <!-- add Javadoc files -->
    <copy todir="${distrib.dir}/javadoc">
      <fileset dir="${javadoc.dir}"/>
    </copy>
  </target>

  <!-- Packages a .zip distribution for JGraphT -->
  <target name="zip" depends="prepare.distribution">

    <!-- convert end-of-line characters in text files to PC style -->
    <fixcrlf srcdir="${distrib.dir}/src"     eol="crlf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}/testsrc" eol="crlf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}/etc"     eol="crlf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}"         eol="crlf" eof="remove"
      includes="${build.file.name},${license.file.name}"/>

    <!-- make the zip file -->
    <zip zipfile="${project.zip}">
      <zipfileset dir="${distrib.dir}" prefix="${project.prefix}" />
    </zip>
  </target>

  <!-- Packages a .tar.gz distribution for JGraphT -->
  <target name="targz" depends="prepare.distribution">

    <!-- convert end-of-line characters in text files to Unix style -->
    <fixcrlf srcdir="${distrib.dir}/src"     eol="lf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}/testsrc" eol="lf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}/etc"     eol="lf" eof="remove" />
    <fixcrlf srcdir="${distrib.dir}"         eol="lf" eof="remove"
      includes="${build.file.name},${license.file.name}"/>

    <!-- make the tar.gz file -->
    <tar tarfile="${project.tar}" longfile="gnu">
      <tarfileset dir="${distrib.dir}" prefix="${project.prefix}" />
    </tar>
    <gzip zipfile="${project.tar.gz}" src="${project.tar}" />
    <delete file="${project.tar}" />
  </target>

  <!-- Clean outputs from previous build -->
  <target name="clean" depends="init"
    description="Cleans all outputs from previous builds">
    <delete dir="${distrib.dir}" />
    <delete dir="${build.dir}" />
    <delete dir="${testbuild.dir}" />
    <delete dir="${javadoc.dir}" />
    <delete file="${project.jar}" />
    <delete file="${project.zip}" />
    <delete file="${project.tar.gz}" />
  </target>

  <!-- ALL -->
  <target name="all" depends="clean,compile,test,zip,targz"
    description="Cleans, compiles, tests and creates distribution files (.zip and .tar.gz).">

    <!-- Clean unnecessary outputs from this build -->
    <delete dir="${distrib.dir}" />
    <delete dir="${javadoc.dir}" />
    <delete file="${project.jar}" />
  </target>

  <!-- generate Emacs tags -->
  <fileset dir="${basedir}" id="fileset.taggable">
    <include name="src/**/*.java"/>
    <include name="testsrc/**/*.java"/>
  </fileset>
  <target name="etags"
    depends="init"
    description="Generates TAGS file for Emacs">
    <property name="file.taggable.tmp"
      location="${basedir}/taggedfiles"/>
    <antcall target="etags.find_taggable_files"/>
    <exec dir="${basedir}" executable="ctags">
      <arg line="-e"/>
      <arg line="-L taggedfiles"/>
    </exec>
    <delete file="${file.taggable.tmp}" quiet="true"/>
  </target>

  <!-- Internal helper for etags target -->
  <target name="etags.find_taggable_files">
    <concat destfile="${file.taggable.tmp}">replaceme</concat>
    <pathconvert property="files.taggable"
      pathsep="${line.separator}"
      dirsep="/" refid="fileset.taggable" >
      <map from="${basedir}" to="." />
    </pathconvert>
    <replace file="${file.taggable.tmp}"
      token="replaceme" value="${files.taggable}" />
    <fixcrlf srcDir="${basedir}" includes="taggedfiles"
      eol="lf" eof="remove" />
  </target>

  <!-- Creates a release according to a user-defined SVN tag -->
  <target name="release" depends="init,svntag.missing" if="svntag"
    description="Checks out and builds a release according to a SVN tag">

    <echo>Starting release build at ${checkout.dir}/${build.file.name}</echo>

    <antcall target="checkout"/>
    <ant dir="${checkout.dir}" antfile="${build.file.name}"
      target="all" inheritall="false" inheritrefs="false">
      <property name="svntag" value="${svntag}"/>
    </ant>
  </target>

  <!-- Checks out a snapshot according to a user-defined SVN tag -->
  <target name="checkout" depends="init,svntag.missing" if="svntag"
    description="Checks out a snapshot from SVN according to a tag">
    <taskdef resource="svntask.properties" classpathref="svn.classpath"/>
    <echo level="info">Checking out files of SVN tag: ${svntag}</echo>

    <property name="project.svnroot"
      value="https://jgrapht.svn.sourceforge.net/svnroot/jgrapht" />
    <delete dir="${checkout.dir}" />
    <mkdir  dir="${checkout.dir}" />
    <svn username="guest" password="" javahl="false">
      <checkout url="${project.svnroot}/tags/${svntag}"
        destPath="${checkout.dir}"/>
    </svn>
  </target>

  <!-- Outputs an error message if SVN tag is unspecified -->
  <target name="svntag.missing" unless="svntag">
    <echo level="error">Variable $${svntag} must be specified for selected target.</echo>
  </target>

  <target name="maven.pom" depends="init">
    <copy file="etc/pom.xml.template" tofile="pom.xml" overwrite="true">
      <filterchain>
        <tokenfilter>
          <replacestring from="@VERSION@" to="${latest.version.name}"/>
        </tokenfilter>
      </filterchain>
    </copy>
  </target>

</project>


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Sitecore.Courier.WebRunner {

    public partial class PackageGenerationWizard {

        /// <summary>
        /// form1 control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.HtmlControls.HtmlForm form1;

        /// <summary>
        /// SourcePath control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.TextBox SourcePath;

        /// <summary>
        /// TargetPath control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.TextBox TargetPath;

        /// <summary>
        /// Analyze control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button Analyze;

        /// <summary>
        /// Generate control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button Generate;

        /// <summary>
        /// DownloadLink control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.HyperLink DownloadLink;

        /// <summary>
        /// AnalyzeResults control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Panel AnalyzeResults;

        /// <summary>
        /// AddedCount control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Literal AddedCount;

        /// <summary>
        /// DeletedCount control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Literal DeletedCount;

        /// <summary>
        /// ChangedCount control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Literal ChangedCount;

        /// <summary>
        /// Added control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.CheckBoxList Added;

        /// <summary>
        /// Deleted control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.CheckBoxList Deleted;

        /// <summary>
        /// Changed control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.CheckBoxList Changed;
    }
}

redpajama_set_name: RedPajamaGithub


text:
<?php
/**
 * User: Ivan Pirus
 * Group: B14
 * Date: January 2016
 */
include'con_main_search.php';
include 'controller_main_language.php';
include'models/select_articles.php';
include 'views/search.php';
include 'views/pagination.php';
include 'con_cookie.php';

if(isset($_GET['key']))
{
    $words = $_GET['key'];
}
else{ die("Nothing is found");}
if($words === "")
{
    ShowEmpty();
    return;
}
$select_search = SearchSelect($words, 0, 1000);         // get select with db
$array_result = SearchResult($select_search); //controller get select with db
if($array_result != false)
{
    SaveCookieWord($words, 'word'); // Save word search in cookie
    UpdateCookieWord('search', 'language_search'); // Update result look
    //PrepareUpdate($array_result); // update reviews article
    $result = count($array_result); // get numbers result search
    DeleteCookieWord('searched');
    SaveCookieWord($result, 'searched');
    ShowNumbers($result); // show numbers searched result
   // ShowResult($array_result); // show searched content
    ShowPagination();

}
else{
    ShowNumbers(0);
    ShowNoSearch($words);
}
echo"
    <script type='text/javascript' src='template/js/jquery-1.12.0.js'></script>
    <script type='text/javascript' src='content/controllers/views/views_js/pagination.js'></script>
    ";

?>


text:
Here is a list of the standard virtual audio node factories exported by virtual-audio-graph and the params you can provide them with ([the virtual-audio-graph guide is here](https://virtual-audio-graph.netlify.com/)).

## [analyser](https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode)

```javascript
analyser(output, {
  fftSize,
  minDecibels,
  maxDecibels,
  smoothingTimeConstant,
}]
```
___

## [bufferSource](https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode)

```javascript
const {audioContext, audioContext: {sampleRate}} = virtualAudioGraph
const buffer = audioContext.createBuffer(2, sampleRate * 2, sampleRate)
bufferSource(output, {
  buffer,
  loop,
  loopEnd,
  loopStart,
  // The offset parameter, which defaults to 0
  // and defines where the playback will start
  offsetTime,
  onended,
  playbackRate,
  // time in seconds since virtualAudioGraph.currentTime
  // was 0, if not provided then node starts immediately
  startTime,
  // if not provided then stop is not called on node
  // until it is disconnected
  stopTime
})
```
___

## [biquadFilter](https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode)

```javascript
biquadFilter(output, {type, frequency, detune, Q})
```
___
## [channelMerger](https://developer.mozilla.org/en-US/docs/Web/API/ChannelMergerNode)

```javascript
channelMerger(output, {numberOfOutputs})
```
___
## [channelSplitter](https://developer.mozilla.org/en-US/docs/Web/API/ChannelSplitterNode)

NB ChannelSplitter has it's own syntax for the output parameter. Because the channel is split it means each node can have multiple outputs. Each output is indexed and the outputs property should be an array of these indices. Then the inputs property should be an array of indices corresponding to the inputs of the destination node. Check out the spec and the link above for more info.

```javascript
channelSplitter({key, outputs, inputs}, {numberOfOutputs})
```
___
## [convolver](https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode)

```javascript
convolver(output, {buffer, normalize})
```
___

## [delay](https://developer.mozilla.org/en-US/docs/Web/API/DelayNode)
NB maxDelayTime must be set when node is first created but cannot be updated. A new node will have to be inserted if a different maxDelayTime is required.

```javascript
delay(output, {delayTime, maxDelayTime})
```
___

## [dynamicsCompressor](https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode)

```javascript
dynamicsCompressor(output, {
  attack,
  knee,
  ratio,
  release,
  threshold,
}]
```
___

## [gain](https://developer.mozilla.org/en-US/docs/Web/API/GainNode)

```javascript
gain(output, {gain})
```
___
## [mediaElementSource](https://developer.mozilla.org/en-US/docs/Web/API/MediaElementAudioSourceNode)
NB params can only be set once
```javascript
mediaElementSource(output, {mediaElement})
```
___
## [mediaStreamDestination](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode)

This node has no output as it is a destination. It also takes no parameters. Use virtualAudioGraph.getAudioNodeById method to access the node's stream property

```javascript
mediaStreamDestination()
```
___
## [mediaStreamSource](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode)
NB params can only be set once
```javascript
mediaStreamSource(output, {mediaStream})
```
___

## [oscillator](https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode)

```javascript
oscillator(output, {
  type,
  frequency,
  detune,
  // time in seconds since virtualAudioGraph.currentTime
  // was 0, if not provided then node starts immediately
  startTime,
  // if not provided then stop is not called on node until it is disconnected
  stopTime,
})
```
___

## [panner](https://developer.mozilla.org/en-US/docs/Web/API/PannerNode)

```javascript
panner(output, {
  coneInnerAngle,
  coneOuterAngle,
  coneOuterGain,
  distanceModel,
  // applies an array of arguments with the corresponding AudioNode setter:
  orientation,
  panningModel,
  // applies an array of arguments with the corresponding AudioNode setter:
  position,
  maxDistance,
  refDistance,
  rolloffFactor,
})
```
___

## [stereoPanner](https://developer.mozilla.org/en-US/docs/Web/API/StereoPannerNode)

```javascript
stereoPanner(output, {pan})
```
___

## [waveShaper](https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode)

```javascript
waveShaper(output, {curve, oversample})
```


text:
var searchData=
[
  ['allocatestorage',['allocateStorage',['../class_storage_manager.html#a0b3049042f6237c8f876517432b71c1d',1,'StorageManager']]],
  ['allocatestoragearray',['allocateStorageArray',['../class_storage_manager.html#affd4c4b9593af7b4aaa2bfc34b7aeb4b',1,'StorageManager']]]
];


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="ican.ytx.com.mediacodectest.MainActivity">

    <ican.ytx.com.mediacodectest.view.VideoGlSurfaceView
        android:id="@+id/surfaceView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</LinearLayout>


text:
ROOT = ../../../../../..
DIR = Pegasus/Server/ProviderRegistrationManager/tests/createInstances
include $(ROOT)/mak/config.mak
include ../libraries.mak

EXTRA_INCLUDES = $(SYS_INCLUDES)

LOCAL_DEFINES = -DPEGASUS_INTERNALONLY

PROGRAM = createInstances

SOURCES = createInstances.cpp

include $(ROOT)/mak/program.mak

tests:
	@$(MAKE) -f../load/Makefile localrep
	@$(PROGRAM)
	$(RMREPOSITORY) $(TMP_DIR)/repository

poststarttests:


text:
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.execution.target;

import com.intellij.execution.ExecutionException;
import com.intellij.execution.ExecutionManager;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.process.ProcessOutputType;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProcessCanceledException;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.NlsContexts;
import com.intellij.openapi.util.ThrowableComputable;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.concurrency.AppExecutorUtil;
import org.jetbrains.annotations.*;
import org.jetbrains.concurrency.AsyncPromise;
import org.jetbrains.concurrency.Promise;
import org.jetbrains.concurrency.Promises;

@ApiStatus.Experimental
public interface TargetEnvironmentAwareRunProfileState extends RunProfileState {
  void prepareTargetEnvironmentRequest(@NotNull TargetEnvironmentRequest request,
                                       @Nullable TargetEnvironmentConfiguration configuration,
                                       @NotNull TargetProgressIndicator targetProgressIndicator) throws ExecutionException;

  /**
   * @throws ExecutionException to notify that preparation failed, and execution should not be proceeded. Should be localised.
   */
  void handleCreatedTargetEnvironment(@NotNull TargetEnvironment targetEnvironment,
                                      @NotNull TargetProgressIndicator targetProgressIndicator)
    throws ExecutionException;

  default <T> Promise<T> prepareTargetToCommandExecution(@NotNull ExecutionEnvironment env,
                                                         @NotNull Logger logger,
                                                         @NonNls String logFailureMessage,
                                                         @NotNull ThrowableComputable<? extends T, ? extends Throwable> afterPreparation) throws ExecutionException {
    Promise<Object> preparationTasks;
    if (((TargetEnvironmentAwareRunProfile)env.getRunProfile()).needPrepareTarget()) {
      preparationTasks = ExecutionManager.getInstance(env.getProject()).executePreparationTasks(env, this);
    }
    else {
      preparationTasks = Promises.resolvedPromise();
    }

    return preparationTasks.thenAsync((Object o) -> {
      AsyncPromise<@Nullable T> promise = new AsyncPromise<>();
      AppExecutorUtil.getAppExecutorService().execute(() -> {
        try {
          promise.setResult(afterPreparation.compute());
        }
        catch (ProcessCanceledException e) {
          promise.setError(StringUtil.notNullize(e.getLocalizedMessage()));
        }
        catch (Throwable t) {
          logger.warn(logFailureMessage, t);
          promise.setError(StringUtil.notNullize(t.getLocalizedMessage()));
        }
      });
      return promise;
    });
  }

  default TargetEnvironmentFactory createCustomTargetEnvironmentFactory() {
    return null;
  }

  interface TargetProgressIndicator {
    TargetProgressIndicator EMPTY = new TargetProgressIndicator() {
      @Override
      public void addText(@Nls @NotNull String text, @NotNull Key<?> key) { }

      @Override
      public boolean isCanceled() {
        return false;
      }

      @Override
      public void stop() { }

      @Override
      public boolean isStopped() {
        return false;
      }
    };

    void addText(@Nls @NotNull String text, @NotNull Key<?> key);

    default void addSystemLine(@Nls @NotNull String message) {
      addText(message + "\n", ProcessOutputType.SYSTEM);
    }

    boolean isCanceled();

    void stop();

    boolean isStopped();

    default void stopWithErrorMessage(@NlsContexts.DialogMessage @NotNull String text) {
      addText(text + "\n", ProcessOutputType.STDERR);
      stop();
    }
  }
}


text:
#ifndef METRIC_FILTER_FILTER_LOCAL_H
#define METRIC_FILTER_FILTER_LOCAL_H

#define FILTER_DEFAULT_FLUSH		1000		// msec
#define FILTER_DEFAULT_DELAY		10000		// msec

#include "metric_filter.h"

#define lock_filters( )				pthread_mutex_lock(   &(ctl->filt->genlock) )
#define unlock_filters( )			pthread_mutex_unlock( &(ctl->filt->genlock) )

extern const char *filter_mode_name[];
extern FLT_CTL *_filt;

int filter_load( void );
void filter_unlock( void );

#endif


text:
.class public final enum Lcom/sec/ims/options/CapabilityRefreshType;
.super Ljava/lang/Enum;
.source "CapabilityRefreshType.java"

# annotations
.annotation system Ldalvik/annotation/Signature;
    value = {
        "Ljava/lang/Enum",
        "<",
        "Lcom/sec/ims/options/CapabilityRefreshType;",
        ">;"
    }
.end annotation

# static fields
.field private static final synthetic $VALUES:[Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum ALWAYS_FORCE_REFRESH:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum DISABLED:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum FORCE_REFRESH_SYNC:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum FORCE_REFRESH_UCE:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum ONLY_IF_EXPIRED:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum ONLY_IF_NOT_FRESH:Lcom/sec/ims/options/CapabilityRefreshType;

.field public static final enum ONLY_IF_NOT_FRESH_IN_MSG_CTX:Lcom/sec/ims/options/CapabilityRefreshType;

# direct methods
.method static constructor <clinit>()V
    .locals 8

    const/4 v7, 0x4

    const/4 v6, 0x3

    const/4 v5, 0x2

    const/4 v4, 0x1

    const/4 v3, 0x0

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "ONLY_IF_NOT_FRESH"

    invoke-direct {v0, v1, v3}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_NOT_FRESH:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "ONLY_IF_EXPIRED"

    invoke-direct {v0, v1, v4}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_EXPIRED:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "ALWAYS_FORCE_REFRESH"

    invoke-direct {v0, v1, v5}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->ALWAYS_FORCE_REFRESH:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "ONLY_IF_NOT_FRESH_IN_MSG_CTX"

    invoke-direct {v0, v1, v6}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_NOT_FRESH_IN_MSG_CTX:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "DISABLED"

    invoke-direct {v0, v1, v7}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->DISABLED:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "FORCE_REFRESH_UCE"

    const/4 v2, 0x5

    invoke-direct {v0, v1, v2}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->FORCE_REFRESH_UCE:Lcom/sec/ims/options/CapabilityRefreshType;

    new-instance v0, Lcom/sec/ims/options/CapabilityRefreshType;

    const-string/jumbo v1, "FORCE_REFRESH_SYNC"

    const/4 v2, 0x6

    invoke-direct {v0, v1, v2}, Lcom/sec/ims/options/CapabilityRefreshType;-><init>(Ljava/lang/String;I)V

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->FORCE_REFRESH_SYNC:Lcom/sec/ims/options/CapabilityRefreshType;

    const/4 v0, 0x7

    new-array v0, v0, [Lcom/sec/ims/options/CapabilityRefreshType;

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_NOT_FRESH:Lcom/sec/ims/options/CapabilityRefreshType;

    aput-object v1, v0, v3

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_EXPIRED:Lcom/sec/ims/options/CapabilityRefreshType;

    aput-object v1, v0, v4

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->ALWAYS_FORCE_REFRESH:Lcom/sec/ims/options/CapabilityRefreshType;

    aput-object v1, v0, v5

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->ONLY_IF_NOT_FRESH_IN_MSG_CTX:Lcom/sec/ims/options/CapabilityRefreshType;

    aput-object v1, v0, v6

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->DISABLED:Lcom/sec/ims/options/CapabilityRefreshType;

    aput-object v1, v0, v7

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->FORCE_REFRESH_UCE:Lcom/sec/ims/options/CapabilityRefreshType;

    const/4 v2, 0x5

    aput-object v1, v0, v2

    sget-object v1, Lcom/sec/ims/options/CapabilityRefreshType;->FORCE_REFRESH_SYNC:Lcom/sec/ims/options/CapabilityRefreshType;

    const/4 v2, 0x6

    aput-object v1, v0, v2

    sput-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->$VALUES:[Lcom/sec/ims/options/CapabilityRefreshType;

    return-void
.end method

.method private constructor <init>(Ljava/lang/String;I)V
    .locals 0

    invoke-direct {p0, p1, p2}, Ljava/lang/Enum;-><init>(Ljava/lang/String;I)V

    return-void
.end method

.method public static valueOf(Ljava/lang/String;)Lcom/sec/ims/options/CapabilityRefreshType;
    .locals 1

    const-class v0, Lcom/sec/ims/options/CapabilityRefreshType;

    invoke-static {v0, p0}, Ljava/lang/Enum;->valueOf(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;

    move-result-object v0

    check-cast v0, Lcom/sec/ims/options/CapabilityRefreshType;

    return-object v0
.end method

.method public static values()[Lcom/sec/ims/options/CapabilityRefreshType;
    .locals 1

    sget-object v0, Lcom/sec/ims/options/CapabilityRefreshType;->$VALUES:[Lcom/sec/ims/options/CapabilityRefreshType;

    return-object v0
.end method


text:
MCTransceiver
=============

iOS library providing an abstracted interface to the Multipeer Connectivity API

##### Features:
* Quickly add ability for two iOS devices to seamlessly pair and communicate via the [Multipeer Connectivity Framework](https://developer.apple.com/library/ios/documentation/MultipeerConnectivity/Reference/MultipeerConnectivityFramework/_index.html#//apple_ref/doc/uid/TP40013328).

##### Using
* Clone repo (or download ZIP file)
* Drag & drop ABTools.xcodeproj into your workspace
* Follow [Apple's documentation](https://developer.apple.com/library/ios/technotes/iOSStaticLibraries/Articles/configuration.html) on how to use static libraries in iOS

The library uses ARC. It has been developed using Xcode 5 & tested against iOS 7.x.

##### Documentation
The Xcode project includes a `Documentation` target which can be used to generate documentation for the API. It requires the use of [appledoc](http://gentlebytes.com/appledoc/). Once you've built the documentation it will be available through Xcode's Documentation window.

The latest [HTML documentation](http://keithermel.github.io/MCTransceiver/docs/Classes/MCTransceiver.html) is also available.

##### Examples
The [Examples](https://github.com/KeithErmel/MCTransceiver/tree/master/Examples) folder includes a the [MCTransceiverExample](https://github.com/KeithErmel/MCTransceiver/tree/master/Examples/MCTransceiverExample) project that demonstrates communication between two iOS devices: one acting as the advertiser (host) the other as the browser (join).

###### Advertising, Browsing and Sending Data
* While this API is presented through a single interface -- [MCTransceiver](https://github.com/KeithErmel/MCTransceiver/blob/master/MCTransceiver/MCTransceiver/MCTransceiver.h) -- the tasks of advertising and browsing are provided separately, through the startAdvertising: and startBrowsing: methods.

* Currently the only way to send data from one device to another is through the sendUnreliableData:toPeers:completion method. From the documentation, sending data unreliably means:
> Messages to peers should be sent immediately without socket-level queueing. If a message cannot be sent immediately, it should be dropped. The order of messages is not guaranteed.

* Future additions to this API will provide the ability to:
    * Send reliable data (guaranteed, in-order delivery, retransmitted as needed)
    * Send a resource based on URL to a peer
    * Stream data to a peer


text:
define(["require", "exports"], function (require, exports) {
    exports.waiting = undefined;
    exports.unresolved = "unresolved";
    exports.resolved = "has-resolution";
    exports.rejected = "has-rejection";
});


text:
package eu.bcvsolutions.idm.rpt.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import eu.bcvsolutions.idm.core.api.config.swagger.AbstractSwaggerConfig;
import eu.bcvsolutions.idm.core.api.domain.ModuleDescriptor;
import eu.bcvsolutions.idm.rpt.RptModuleDescriptor;
import springfox.documentation.spring.web.plugins.Docket;

/**
 * Report module swagger configuration
 *
 * @author Radek Tomiška
 *
 */
@Configuration
@ConditionalOnProperty(prefix = "springfox.documentation.swagger", name = "enabled", matchIfMissing = true)
public class RptSwaggerConfig extends AbstractSwaggerConfig {

	@Autowired private RptModuleDescriptor moduleDescriptor;

	@Override
	protected ModuleDescriptor getModuleDescriptor() {
		return moduleDescriptor;
	}

	@Bean
	public Docket rptApi() {
		return api("eu.bcvsolutions.idm.rpt.rest");
	}
}


text:
module.exports = (() => {

  'use strict';

  const Command = require('../command.js');

  let interfaceCommands = require('../interface/generate/new.js');

  return new Command(
    null,
    'new',
    {definition: 'Initialize the current directory as a new Nodal project', order: 1},
    (args, flags, callback) => interfaceCommands.new(args, flags, callback)
  );

})();


text:
package com.mohiva.play.silhouette.impl.authenticators

import com.mohiva.play.silhouette.api.Authenticator.Implicits._
import com.mohiva.play.silhouette.api.crypto.AuthenticatorEncoder
import com.mohiva.play.silhouette.api.exceptions._
import com.mohiva.play.silhouette.api.services.AuthenticatorService._
import com.mohiva.play.silhouette.api.services.{ AuthenticatorResult, AuthenticatorService }
import com.mohiva.play.silhouette.api.util.{ Clock, ExtractableRequest, FingerprintGenerator }
import com.mohiva.play.silhouette.api.{ Authenticator, ExpirableAuthenticator, Logger, LoginInfo }
import com.mohiva.play.silhouette.impl.authenticators.SessionAuthenticatorService._
import org.joda.time.DateTime
import play.api.libs.json.Json
import play.api.mvc._
import play.api.mvc.request.{ Cell, RequestAttrKey }

import scala.concurrent.duration._
import scala.concurrent.{ ExecutionContext, Future }
import scala.util.{ Failure, Success, Try }

/**
 * An authenticator that uses a stateless, session based approach. It works by storing a
 * serialized authenticator instance in the Play Framework session cookie.
 *
 * The authenticator can use sliding window expiration. This means that the authenticator times
 * out after a certain time if it wasn't used. This can be controlled with the [[idleTimeout]]
 * property.
 *
 * @param loginInfo          The linked login info for an identity.
 * @param lastUsedDateTime   The last used date/time.
 * @param expirationDateTime The expiration date/time.
 * @param idleTimeout        The duration an authenticator can be idle before it timed out.
 * @param fingerprint        Maybe a fingerprint of the user.
 */
case class SessionAuthenticator(
  loginInfo: LoginInfo,
  lastUsedDateTime: DateTime,
  expirationDateTime: DateTime,
  idleTimeout: Option[FiniteDuration],
  fingerprint: Option[String])
  extends Authenticator with ExpirableAuthenticator {

  /**
   * The Type of the generated value an authenticator will be serialized to.
   */
  override type Value = Session
}

/**
 * The companion object of the authenticator.
 */
object SessionAuthenticator extends Logger {
  import com.mohiva.play.silhouette.api.util.JsonFormats._
  import play.api.libs.json.JodaReads._
  import play.api.libs.json.JodaWrites._

  /**
   * Converts the SessionAuthenticator to Json and vice versa.
   */
  implicit val jsonFormat = Json.format[SessionAuthenticator]

  /**
   * Serializes the authenticator.
   *
   * @param authenticator        The authenticator to serialize.
   * @param authenticatorEncoder The authenticator encoder.
   * @return The serialized authenticator.
   */
  def serialize(authenticator: SessionAuthenticator, authenticatorEncoder: AuthenticatorEncoder) = {
    authenticatorEncoder.encode(Json.toJson(authenticator).toString())
  }

  /**
   * Unserializes the authenticator.
   *
   * @param str                  The string representation of the authenticator.
   * @param authenticatorEncoder The authenticator encoder.
   * @return Some authenticator on success, otherwise None.
   */
  def unserialize(str: String, authenticatorEncoder: AuthenticatorEncoder): Try[SessionAuthenticator] = {
    buildAuthenticator(authenticatorEncoder.decode(str))
  }

  /**
   * Builds the authenticator from Json.
   *
   * @param str The string representation of the authenticator.
   * @return Some authenticator on success, otherwise None.
   */
  private def buildAuthenticator(str: String): Try[SessionAuthenticator] = {
    Try(Json.parse(str)) match {
      case Success(json) => json.validate[SessionAuthenticator].asEither match {
        case Left(error)          => Failure(new AuthenticatorException(InvalidJsonFormat.format(ID, error)))
        case Right(authenticator) => Success(authenticator)
      }
      case Failure(error) => Failure(new AuthenticatorException(JsonParseError.format(ID, str), error))
    }
  }
}

/**
 * The service that handles the session authenticator.
 *
 * @param settings             The authenticator settings.
 * @param fingerprintGenerator The fingerprint generator implementation.
 * @param authenticatorEncoder The authenticator encoder.
 * @param sessionCookieBaker   The session cookie baker.
 * @param clock                The clock implementation.
 * @param executionContext     The execution context to handle the asynchronous operations.
 */
class SessionAuthenticatorService(
  settings: SessionAuthenticatorSettings,
  fingerprintGenerator: FingerprintGenerator,
  authenticatorEncoder: AuthenticatorEncoder,
  sessionCookieBaker: SessionCookieBaker,
  clock: Clock)(implicit val executionContext: ExecutionContext)
  extends AuthenticatorService[SessionAuthenticator]
  with Logger {

  import SessionAuthenticator._

  /**
   * Creates a new authenticator for the specified login info.
   *
   * @param loginInfo The login info for which the authenticator should be created.
   * @param request   The request header.
   * @return An authenticator.
   */
  override def create(loginInfo: LoginInfo)(implicit request: RequestHeader): Future[SessionAuthenticator] = {
    Future.fromTry(Try {
      val now = clock.now
      SessionAuthenticator(
        loginInfo = loginInfo,
        lastUsedDateTime = now,
        expirationDateTime = now + settings.authenticatorExpiry,
        idleTimeout = settings.authenticatorIdleTimeout,
        fingerprint = if (settings.useFingerprinting) Some(fingerprintGenerator.generate) else None
      )
    }).recover {
      case e => throw new AuthenticatorCreationException(CreateError.format(ID, loginInfo), e)
    }
  }

  /**
   * Retrieves the authenticator from request.
   *
   * @param request The request to retrieve the authenticator from.
   * @tparam B The type of the request body.
   * @return Some authenticator or None if no authenticator could be found in request.
   */
  override def retrieve[B](implicit request: ExtractableRequest[B]): Future[Option[SessionAuthenticator]] = {
    Future.fromTry(Try {
      if (settings.useFingerprinting) Some(fingerprintGenerator.generate) else None
    }).map { fingerprint =>
      request.session.get(settings.sessionKey).flatMap { value =>
        unserialize(value, authenticatorEncoder) match {
          case Success(authenticator) if fingerprint.isDefined && authenticator.fingerprint != fingerprint =>
            logger.info(InvalidFingerprint.format(ID, fingerprint, authenticator))
            None
          case Success(authenticator) => Some(authenticator)
          case Failure(error) =>
            logger.info(error.getMessage, error)
            None
        }
      }
    }.recover {
      case e => throw new AuthenticatorRetrievalException(RetrieveError.format(ID), e)
    }
  }

  /**
   * Returns a new user session containing the authenticator.
   *
   * @param authenticator The authenticator instance.
   * @param request       The request header.
   * @return The serialized authenticator value.
   */
  override def init(authenticator: SessionAuthenticator)(implicit request: RequestHeader): Future[Session] = {
    Future.successful(request.session + (settings.sessionKey -> serialize(authenticator, authenticatorEncoder)))
  }

  /**
   * Embeds the user session into the result.
   *
   * @param session The session to embed.
   * @param result  The result to manipulate.
   * @return The manipulated result.
   */
  override def embed(session: Session, result: Result)(implicit request: RequestHeader): Future[AuthenticatorResult] = {
    Future.successful(AuthenticatorResult(result.addingToSession(session.data.toSeq: _*)))
  }

  /**
   * Overrides the user session in request.
   *
   * @param session The session to embed.
   * @param request The request header.
   * @return The manipulated request header.
   */
  override def embed(session: Session, request: RequestHeader): RequestHeader = {
    val s = request.attrs.get(RequestAttrKey.Session) match {
      case Some(existing) => sessionCookieBaker.deserialize(existing.value.data ++ session.data)
      case None           => session
    }

    request.withAttrs(request.attrs + RequestAttrKey.Session.bindValue(Cell(s)))
  }

  /**
   * @inheritdoc
   *
   * @param authenticator The authenticator to touch.
   * @return The touched authenticator on the left or the untouched authenticator on the right.
   */
  override def touch(authenticator: SessionAuthenticator): Either[SessionAuthenticator, SessionAuthenticator] = {
    if (authenticator.idleTimeout.isDefined) {
      Left(authenticator.copy(lastUsedDateTime = clock.now))
    } else {
      Right(authenticator)
    }
  }

  /**
   * Updates the authenticator and store it in the user session.
   *
   * Because of the fact that we store the authenticator client side in the user session, we must update
   * the authenticator in the session on every subsequent request to keep the last used date in sync.
   *
   * @param authenticator The authenticator to update.
   * @param result        The result to manipulate.
   * @param request       The request header.
   * @return The original or a manipulated result.
   */
  override def update(authenticator: SessionAuthenticator, result: Result)(
    implicit
    request: RequestHeader): Future[AuthenticatorResult] = {

    Future.fromTry(Try {
      AuthenticatorResult(result.addingToSession(settings.sessionKey -> serialize(authenticator, authenticatorEncoder)))
    }.recover {
      case e => throw new AuthenticatorUpdateException(UpdateError.format(ID, authenticator), e)
    })
  }

  /**
   * Renews an authenticator.
   *
   * The old authenticator needn't be revoked because we use a stateless approach here. So only
   * one authenticator can be bound to a user session. This method doesn't embed the the authenticator
   * into the result. This must be done manually if needed or use the other renew method otherwise.
   *
   * @param authenticator The authenticator to renew.
   * @param request       The request header.
   * @return The serialized expression of the authenticator.
   */
  override def renew(authenticator: SessionAuthenticator)(
    implicit
    request: RequestHeader): Future[Session] = {

    create(authenticator.loginInfo).flatMap(init).recover {
      case e => throw new AuthenticatorRenewalException(RenewError.format(ID, authenticator), e)
    }
  }

  /**
   * Renews an authenticator and replaces the authenticator in session with a new one.
   *
   * The old authenticator needn't be revoked because we use a stateless approach here. So only
   * one authenticator can be bound to a user session.
   *
   * @param authenticator The authenticator to update.
   * @param result        The result to manipulate.
   * @param request       The request header.
   * @return The original or a manipulated result.
   */
  override def renew(authenticator: SessionAuthenticator, result: Result)(
    implicit
    request: RequestHeader): Future[AuthenticatorResult] = {

    renew(authenticator).flatMap(v => embed(v, result)).recover {
      case e => throw new AuthenticatorRenewalException(RenewError.format(ID, authenticator), e)
    }
  }

  /**
   * Removes the authenticator from session.
   *
   * @param result  The result to manipulate.
   * @param request The request header.
   * @return The manipulated result.
   */
  override def discard(authenticator: SessionAuthenticator, result: Result)(
    implicit
    request: RequestHeader): Future[AuthenticatorResult] = {

    Future.fromTry(Try {
      AuthenticatorResult(result.removingFromSession(settings.sessionKey))
    }.recover {
      case e => throw new AuthenticatorDiscardingException(DiscardError.format(ID, authenticator), e)
    })
  }
}

/**
 * The companion object of the authenticator service.
 */
object SessionAuthenticatorService {

  /**
   * The ID of the authenticator.
   */
  val ID = "session-authenticator"

  /**
   * The error messages.
   */
  val JsonParseError = "[Silhouette][%s] Cannot parse Json: %s"
  val InvalidJsonFormat = "[Silhouette][%s] Invalid Json format: %s"
  val InvalidFingerprint = "[Silhouette][%s] Fingerprint %s doesn't match authenticator: %s"
}

/**
 * The settings for the session authenticator.
 *
 * @param sessionKey               The key of the authenticator in the session.
 * @param useFingerprinting        Indicates if a fingerprint of the user should be stored in the authenticator.
 * @param authenticatorIdleTimeout The duration an authenticator can be idle before it timed out.
 * @param authenticatorExpiry      The duration an authenticator expires after it was created.
 */
case class SessionAuthenticatorSettings(
  sessionKey: String = "authenticator",
  useFingerprinting: Boolean = true,
  authenticatorIdleTimeout: Option[FiniteDuration] = None,
  authenticatorExpiry: FiniteDuration = 12 hours)


text:
package com.lee.engine.animation;

import android.opengl.Matrix;
import android.os.SystemClock;
import android.util.Log;

import com.lee.engine.model.AnimatedModel;
import com.lee.engine.model.Object3DData;
import com.lee.engine.services.collada.entities.Joint;

import java.util.HashMap;
import java.util.Map;

/**
 *
 * This class contains all the functionality to apply an animation to an
 * animated entity. An Animator instance is associated with just one
 * {@link AnimatedModel}. It also keeps track of the running time (in seconds)
 * of the current animation, along with a reference to the currently playing
 * animation for the corresponding entity.
 *
 * An Animator instance needs to be updated every frame, in order for it to keep
 * updating the animation pose of the associated entity. The currently playing
 * animation can be changed at any time using the doAnimation() method. The
 * Animator will keep looping the current animation until a new animation is
 * chosen.
 *
 * The Animator calculates the desired current animation pose by interpolating
 * between the previous and next keyframes of the animation (based on the
 * current animation time). The Animator then updates the transforms all of the
 * joints each frame to match the current desired animation pose.
 *
 * @author Karl
 *
 */
public class Animator {

	private float animationTime = 0;

    private final float IDENTITY_MATRIX[] = new float[16];

    // TODO: implement slower/faster speed
    private float speed = 1f;

    private final Map<String,float[]> cache = new HashMap<>();

    public Animator() {
        Matrix.setIdentityM(IDENTITY_MATRIX,0);
	}

	/**
	 * This method should be called each frame to update the animation currently
	 * being played. This increases the animation time (and loops it back to
	 * zero if necessary), finds the pose that the entity should be in at that
	 * time of the animation, and then applies that pose to all the model's
	 * joints by setting the joint transforms.
	 */
	public void update(Object3DData obj) {
		if (!(obj instanceof AnimatedModel)) {
			return;
		}
		// if (true) return;
		AnimatedModel animatedModel = (AnimatedModel)obj;
		if (animatedModel.getAnimation() == null) return;

		// add missing key transformations
		initAnimation(animatedModel);

		// increase time to progress animation
		increaseAnimationTime((AnimatedModel)obj);

		Map<String, float[]> currentPose = calculateCurrentAnimationPose(animatedModel);

		applyPoseToJoints(currentPose, (animatedModel).getRootJoint(), IDENTITY_MATRIX, 0);
	}

	private void initAnimation(AnimatedModel animatedModel) {
		if (animatedModel.getAnimation().isInitialized()) {
			return;
		}
		KeyFrame[] keyFrames = animatedModel.getAnimation().getKeyFrames();
		Log.i("Animator", "Initializing " + animatedModel.getId() + ". " + keyFrames.length + " key frames...");
		for (int i = 0; i < keyFrames.length; i++) {
			int j = (i + 1) % keyFrames.length;
			KeyFrame keyFramePrevious = keyFrames[i];
			KeyFrame keyFrameNext = keyFrames[j];
			Map<String, JointTransform> jointTransforms = keyFramePrevious.getJointKeyFrames();
			for (Map.Entry<String, JointTransform> transform : jointTransforms.entrySet()) {
				String jointId = transform.getKey();
				if (keyFrameNext.getJointKeyFrames().containsKey(jointId)) {
					continue;
				}
				JointTransform keyFramePreviousTransform = keyFramePrevious.getJointKeyFrames().get(jointId);
				JointTransform keyFrameNextTransform;
				KeyFrame keyFrameNextNext;
				int k = (j + 1) % keyFrames.length;
				do {
					keyFrameNextNext = keyFrames[k];
					keyFrameNextTransform = keyFrameNextNext.getJointKeyFrames().get(jointId);
					k = (k + 1) % keyFrames.length;
				} while (keyFrameNextTransform == null);
				this.animationTime = keyFrameNext.getTimeStamp();
				float progression = calculateProgression(keyFramePrevious, keyFrameNextNext);
				JointTransform missingFrameTransform = JointTransform.interpolate(keyFramePreviousTransform, keyFrameNextTransform, progression);
				keyFrameNext.getJointKeyFrames().put(jointId, missingFrameTransform);
				Log.i("Animator","Added missing key transform for "+jointId);
			}
		}
		animatedModel.getAnimation().setInitialized(true);
		Log.i("Animator", "Initialized " + animatedModel.getId() + ". " + keyFrames.length + " key frames");
	}

	/**
	 * Increases the current animation time which allows the animation to
	 * progress. If the current animation has reached the end then the timer is
	 * reset, causing the animation to loop.
	 */
	private void increaseAnimationTime(AnimatedModel obj) {
		this.animationTime = SystemClock.uptimeMillis() / 1000f * speed;
		this.animationTime %= obj.getAnimation().getLength();
	}

	/**
	 * This method returns the current animation pose of the entity. It returns
	 * the desired local-space transforms for all the joints in a map, indexed
	 * by the name of the joint that they correspond to.
	 *
	 * The pose is calculated based on the previous and next keyframes in the
	 * current animation. Each keyframe provides the desired pose at a certain
	 * time in the animation, so the animated pose for the current time can be
	 * calculated by interpolating between the previous and next keyframe.
	 *
	 * This method first finds the preious and next keyframe, calculates how far
	 * between the two the current animation is, and then calculated the pose
	 * for the current animation time by interpolating between the transforms at
	 * those keyframes.
	 *
	 * @return The current pose as a map of the desired local-space transforms
	 *         for all the joints. The transforms are indexed by the name ID of
	 *         the joint that they should be applied to.
	 */
	private Map<String, float[]> calculateCurrentAnimationPose(AnimatedModel obj) {
		KeyFrame[] frames = getPreviousAndNextFrames(obj);
		float progression = calculateProgression(frames[0], frames[1]);
		return interpolatePoses(frames[0], frames[1], progression);
	}

	/**
	 * This is the method where the animator calculates and sets those all-
	 * important "joint transforms" that I talked about so much in the tutorial.
	 *
	 * This method applies the current pose to a given joint, and all of its
	 * descendants. It does this by getting the desired local-transform for the
	 * current joint, before applying it to the joint. Before applying the
	 * transformations it needs to be converted from local-space to model-space
	 * (so that they are relative to the model's origin, rather than relative to
	 * the parent joint). This can be done by multiplying the local-transform of
	 * the joint with the model-space transform of the parent joint.
	 *
	 * The same thing is then done to all the child joints.
	 *
	 * Finally the inverse of the joint's bind transform is multiplied with the
	 * model-space transform of the joint. This basically "subtracts" the
	 * joint's original bind (no animation applied) transform from the desired
	 * pose transform. The result of this is then the transform required to move
	 * the joint from its original model-space transform to it's desired
	 * model-space posed transform. This is the transform that needs to be
	 * loaded up to the vertex shader and used to transform the vertices into
	 * the current pose.
	 *
	 * @param currentPose
	 *            - a map of the local-space transforms for all the joints for
	 *            the desired pose. The map is indexed by the name of the joint
	 *            which the transform corresponds to.
	 * @param joint
	 *            - the current joint which the pose should be applied to.
	 * @param parentTransform
	 *            - the desired model-space transform of the parent joint for
	 *            the pose.
	 */
	private void applyPoseToJoints(Map<String, float[]> currentPose, Joint joint, float[] parentTransform, int limit) {

	    float[] currentTransform = cache.get(joint.getName());
	    if (currentTransform == null){
	        currentTransform = new float[16];
	        cache.put(joint.getName(), currentTransform);
        }

        // TODO: implement bind pose
        if (limit <= 0){
			if (currentPose.get(joint.getName()) != null) {
				Matrix.multiplyMM(currentTransform, 0, parentTransform, 0, currentPose.get(joint.getName()), 0);
			} else {
				Matrix.multiplyMM(currentTransform, 0, parentTransform, 0, joint.getBindLocalTransform(), 0);
			}
        } else{
            Matrix.multiplyMM(currentTransform, 0, parentTransform, 0, joint.getBindLocalTransform(), 0);
        }

        // calculate animation only if its used by vertices
        //joint.calcInverseBindTransform2(parentTransform);
        if (joint.getIndex() >= 0) {
            Matrix.multiplyMM(joint.getAnimatedTransform(), 0, currentTransform, 0,
                    joint.getInverseBindTransform(), 0);
        }

		// transform children
		for (int i=0; i<joint.getChildren().size(); i++) {
            Joint childJoint = joint.getChildren().get(i);
			applyPoseToJoints(currentPose, childJoint, currentTransform, limit-1);
		}
	}

	/**
	 * Finds the previous keyframe in the animation and the next keyframe in the
	 * animation, and returns them in an array of length 2. If there is no
	 * previous frame (perhaps current animation time is 0.5 and the first
	 * keyframe is at time 1.5) then the first keyframe is used as both the
	 * previous and next keyframe. The last keyframe is used for both next and
	 * previous if there is no next keyframe.
	 *
	 * @return The previous and next keyframes, in an array which therefore will
	 *         always have a length of 2.
	 */
	private KeyFrame[] getPreviousAndNextFrames(AnimatedModel obj) {
		KeyFrame[] allFrames = obj.getAnimation().getKeyFrames();
		KeyFrame previousFrame = allFrames[0];
		KeyFrame nextFrame = allFrames[0];
		for (int i = 1; i < allFrames.length; i++) {
			nextFrame = allFrames[i];
			if (nextFrame.getTimeStamp() > animationTime) {
				break;
			}
			previousFrame = allFrames[i];
		}
		return new KeyFrame[] { previousFrame, nextFrame };
	}

	/**
	 * Calculates how far between the previous and next keyframe the current
	 * animation time is, and returns it as a value between 0 and 1.
	 *
	 * @param previousFrame
	 *            - the previous keyframe in the animation.
	 * @param nextFrame
	 *            - the next keyframe in the animation.
	 * @return A number between 0 and 1 indicating how far between the two
	 *         keyframes the current animation time is.
	 */
	private float calculateProgression(KeyFrame previousFrame, KeyFrame nextFrame) {
		float totalTime = nextFrame.getTimeStamp() - previousFrame.getTimeStamp();
		float currentTime = animationTime - previousFrame.getTimeStamp();
        // TODO: implement key frame display
        //return 0;
		return currentTime / totalTime;
	}

	/**
	 * Calculates all the local-space joint transforms for the desired current
	 * pose by interpolating between the transforms at the previous and next
	 * keyframes.
	 *
	 * @param previousFrame
	 *            - the previous keyframe in the animation.
	 * @param nextFrame
	 *            - the next keyframe in the animation.
	 * @param progression
	 *            - a number between 0 and 1 indicating how far between the
	 *            previous and next keyframes the current animation time is.
	 * @return The local-space transforms for all the joints for the desired
	 *         current pose. They are returned in a map, indexed by the name of
	 *         the joint to which they should be applied.
	 */
	private Map<String, float[]> interpolatePoses(KeyFrame previousFrame, KeyFrame nextFrame, float progression) {
	    // TODO: optimize this (memory allocation)
		Map<String, float[]> currentPose = new HashMap<>();
		for (String jointName : previousFrame.getJointKeyFrames().keySet()) {
			JointTransform previousTransform = previousFrame.getJointKeyFrames().get(jointName);
			if (Math.signum(progression) == 0){
                currentPose.put(jointName, previousTransform.getLocalTransform());
            } else {
			    // memory optimization
                float[] jointPose = cache.get(jointName);
                if (jointPose == null){
                    jointPose = new float[16];
                    cache.put(jointName, jointPose);
                }
                float[] jointPoseRot = cache.get("___rotation___interpolation___");
                if (jointPoseRot == null){
                    jointPoseRot = new float[16];
                    cache.put("___rotation___interpolation___", jointPoseRot);
                }
                // calculate interpolation
                JointTransform nextTransform = nextFrame.getJointKeyFrames().get(jointName);
                JointTransform.interpolate(previousTransform, nextTransform, progression, jointPose, jointPoseRot);
                currentPose.put(jointName, jointPose);
            }
		}
		return currentPose;
	}

}


text:
import json
import os
import sys
sys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))


text:
package com.yammer.backups.healthchecks;

import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.health.HealthCheck;
import com.google.common.base.Supplier;
import com.yammer.backups.processor.scheduled.AbstractScheduledProcessor;
import io.dropwizard.lifecycle.Managed;
import io.dropwizard.util.Duration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicReference;

public final class ScheduledHealthCheck extends HealthCheck implements Managed {

    private static final Duration INITIAL_DELAY = Duration.seconds(0);
    private static final Logger LOG = LoggerFactory.getLogger(ScheduledHealthCheck.class);

    public static ScheduledHealthCheck wrap(HealthCheck delegate, String name, ScheduledExecutorService executorService, Duration frequency, MetricRegistry metricRegistry) {
        return new ScheduledHealthCheck(delegate, name, executorService, frequency, metricRegistry);
    }

    private final AtomicReference<Result> result;
    private final Supplier<Result> supplier;
    private final AbstractScheduledProcessor processor;

    private ScheduledHealthCheck(final HealthCheck delegate, final String name, final ScheduledExecutorService executor, final Duration frequency, final MetricRegistry metricRegistry) {
        result = new AtomicReference<>(Result.unhealthy("Scheduled health check not yet checked."));
        supplier = new Supplier<Result>() {
            @Override
            public Result get() {
                LOG.trace("Running scheduled health check: {}", name);
                return delegate.execute();
            }
        };

        processor = new AbstractScheduledProcessor(executor, frequency, INITIAL_DELAY, name, metricRegistry) {
            @Override
            public void execute() {
                result.set(supplier.get());
            }
        };
    }

    @Override
    public void start() {
        processor.start();
    }

    @Override
    public void stop() {
        processor.stop();
    }

    @Override
    protected Result check() {
        return result.get();
    }
}


text:
Проект для создания и эксплуатации серверных приложений с помощью контейнеров [Docker](https://www.docker.com/)

## Особенности

* Все контейнеры docker публикуются как [автоматические билды](https://registry.hub.docker.com/u/lekovr/), вся приватная информация размещается в каталоге, являющимся текущим при запуске контейнера
* Каждый контейнер представляет собой логический сервис, который может состоять из нескольких процессов. Например, сервис [postgresql](Dockerfiles/postgres/README.ru.md), кроме СУБД, содержит сервер [dbcc](https://github.com/LeKovr/dbcc) для автоматического создания БД и пользователей. Эти процессы управляются [supervisor](http://supervisord.org/)
* Взаимодействие между контейнерами осуществляется с помощью [consul](https://www.consul.io/) (каждый контейнер линкуется с контейнером consul и содержит в своем составе consul agent, который дополнительно выполняет функции Health check сервисов контейнера)
* Совместно используемые контейнеры описываются как зависимости. Например, единственный запущенный контейнер postgres может использоваться несколькими другими контейнерами. При старте контейнера его зависимости запускаются автоматически.
* Конфигурация контейнеров задается в yml-файлах, трансляция которых в аргументы docker производится bash-скриптом [fidm](https://github.com/LeKovr/fidm)

## Зависимости

* linux 64bit
* [docker](https://www.docker.com/)
* [fidm](https://github.com/LeKovr/fidm)

## Поддерживаемые сервисы

Системные
* [consul](Dockerfiles/consul/README.ru.md) - сервис регистрации, мониторинга контейнеров и key-value хранилище конфигураций
* [nginx](Dockerfiles/nginx/README.ru.md) - фронтенд http-сервисов, автогенерация сертификатов [Let's Encrypt](https://letsencrypt.org/), сервис статических сайтов
* [postgresql](Dockerfiles/postgres/README.ru.md) - СУБД Postgresql

Прикладные
* [consul-ui](Dockerfiles/consul/skel/README.ru.md) - Web-интерфейс с consul
* [webhook](Dockerfiles/webhook/skel/README.ru.md) - сервис Continuous integration
* gitbook - генерация статического сайта документации по файлам Markdown
* [gogs](Dockerfiles/gogs/skel/README.ru.md) - управление Git
* mattermost - платформа обмена сообщениями
* pdns - DNS-сервер

См. также: [Dockerfiles/*/](Dockerfiles/)

## Схема инфраструктуры consup

![Container structure](doc/consup.png)

## Установка

Установка производится на хост с 64bit linux (64bit - это требование docker).

### Установка **make** и **wget**

Ниже описывается вариант для apt-based ОС (Debian, Ubuntu), в других дистрибутивах установка make и wget производится аналогично.

При установке пакета потребуется пароль для sudo.

```
which make > /dev/null || sudo apt-get install make
```

Если в системе не установлен wget, он ставится аналогично:

```
which wget > /dev/null || sudo apt-get install wget
```

### Установка **docker**, **fidm**, **consup**

Загрузка Makefile и конфигураций fidm:

```
cd /opt
wget -qO- https://raw.githubusercontent.com/LeKovr/consup/master/install.sh | sh
```

Установка **docker** и **fidm** (потребуется пароль для sudo)

docker будет установлен согласно [инструкции](http://docs.docker.com/linux/step_one/). Если такой вариант не подходит, надо предварительно поставить docker вручную.

```
cd /opt/consup
make deps
```

Для того, чтобы текущий пользователь мог работать с docker, его надо добавить в группу docker:
```
sudo usermod -a -G docker $USER
```

## Лицензия

The MIT License (MIT), see [LICENSE](LICENSE).

Copyright (c) 2014 - 2017 Alexey Kovrizhkin lekovr@gmail.com


text:
package org.apache.druid.server.emitter;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Supplier;
import com.google.inject.Binder;
import com.google.inject.Module;
import com.google.inject.Provides;
import com.google.inject.name.Named;
import com.google.inject.util.Providers;
import io.netty.handler.ssl.ClientAuth;
import io.netty.handler.ssl.JdkSslContext;
import io.netty.util.HashedWheelTimer;
import org.apache.druid.guice.JsonConfigProvider;
import org.apache.druid.guice.LazySingleton;
import org.apache.druid.guice.ManageLifecycle;
import org.apache.druid.java.util.common.concurrent.Execs;
import org.apache.druid.java.util.common.lifecycle.Lifecycle;
import org.apache.druid.java.util.common.logger.Logger;
import org.apache.druid.java.util.emitter.core.Emitter;
import org.apache.druid.java.util.emitter.core.HttpEmitterConfig;
import org.apache.druid.java.util.emitter.core.HttpPostEmitter;
import org.apache.druid.server.security.TLSUtils;
import org.asynchttpclient.AsyncHttpClient;
import org.asynchttpclient.DefaultAsyncHttpClient;
import org.asynchttpclient.DefaultAsyncHttpClientConfig;

import javax.annotation.Nullable;
import javax.net.ssl.SSLContext;
import java.security.NoSuchAlgorithmException;

/**
 */
public class HttpEmitterModule implements Module
{
  private static final Logger log = new Logger(HttpEmitterModule.class);

  @Override
  public void configure(Binder binder)
  {
    JsonConfigProvider.bind(binder, "druid.emitter.http", HttpEmitterConfig.class);
    JsonConfigProvider.bind(binder, "druid.emitter.http.ssl", HttpEmitterSSLClientConfig.class);

    configureSsl(binder);
  }

  static void configureSsl(Binder binder)
  {
    final SSLContext context;
    try {
      context = SSLContext.getDefault();
    }
    catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    }

    binder.bind(SSLContext.class).toProvider(Providers.of(context)).in(LazySingleton.class);
  }

  static AsyncHttpClient createAsyncHttpClient(
      String nameFormat,
      String timerThreadNameFormat,
      @Nullable SSLContext sslContext
  )
  {
    final DefaultAsyncHttpClientConfig.Builder builder = new DefaultAsyncHttpClientConfig.Builder()
        .setThreadFactory(Execs.makeThreadFactory(nameFormat))
        .setNettyTimer(new HashedWheelTimer(Execs.makeThreadFactory(timerThreadNameFormat)));
    if (sslContext != null) {
      builder.setSslContext(new JdkSslContext(sslContext, true, ClientAuth.NONE));
    }
    return new DefaultAsyncHttpClient(builder.build());
  }

  @Provides
  @ManageLifecycle
  @Named("http")
  public Emitter getEmitter(
      Supplier<HttpEmitterConfig> config,
      Supplier<HttpEmitterSSLClientConfig> sslConfig,
      @Nullable SSLContext sslContext,
      Lifecycle lifecycle,
      ObjectMapper jsonMapper
  )
  {
    return new HttpPostEmitter(
        config.get(),
        lifecycle.addCloseableInstance(
            createAsyncHttpClient(
                "HttpPostEmitter-AsyncHttpClient-%d",
                "HttpPostEmitter-AsyncHttpClient-Timer-%d",
                getEffectiveSSLContext(sslConfig.get(), sslContext)
            )
        ),
        jsonMapper
    );
  }

  public static SSLContext getEffectiveSSLContext(HttpEmitterSSLClientConfig sslConfig, SSLContext sslContext)
  {
    SSLContext effectiveSSLContext;
    if (sslConfig.isUseDefaultJavaContext()) {
      try {
        effectiveSSLContext = SSLContext.getDefault();
      }
      catch (NoSuchAlgorithmException nsae) {
        throw new RuntimeException(nsae);
      }
    } else if (sslConfig.getTrustStorePath() != null) {
      log.info("Creating SSLContext for HttpEmitter client using config [%s]", sslConfig);
      effectiveSSLContext = new TLSUtils.ClientSSLContextBuilder()
          .setProtocol(sslConfig.getProtocol())
          .setTrustStoreType(sslConfig.getTrustStoreType())
          .setTrustStorePath(sslConfig.getTrustStorePath())
          .setTrustStoreAlgorithm(sslConfig.getTrustStoreAlgorithm())
          .setTrustStorePasswordProvider(sslConfig.getTrustStorePasswordProvider())
          .build();
    } else {
      effectiveSSLContext = sslContext;
    }
    return effectiveSSLContext;
  }
}


text:
import * as TSESTree from './ast-spec';
declare module './ast-spec' {
    interface BaseNode {
        parent?: TSESTree.Node;
    }
}
export * as TSESTree from './ast-spec';
//# sourceMappingURL=ts-estree.d.ts.map


text:
theme :
  name : hooligan
layout: default
---
{% include JB/setup %}
{% include themes/hooligan/page.html %}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">

<title>DLynam Blog | My personal Tech blog</title>
<meta name="generator" content="Jekyll v3.9.0" />
<meta property="og:title" content="DLynam Blog" />
<meta name="author" content="David Lynam" />
<meta property="og:locale" content="en" />
<meta name="description" content="My personal Tech blog" />
<meta property="og:description" content="My personal Tech blog" />
<meta property="og:site_name" content="DLynam Blog" />
<meta name="twitter:card" content="summary" />
<meta property="twitter:title" content="DLynam Blog" />
<meta name="twitter:site" content="@t00cool" />
<meta name="twitter:creator" content="@David Lynam" />
<meta name="google-site-verification" content="u4WXQl0Eu66rsQo2kRdCNx" />

<link type="application/atom+xml" rel="alternate" href="/feed.xml" title="DLynam Blog" />

<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Open%20Sans|Roboto|Roboto%20Slab|Inconsolata|Dancing%20Script|Noto%20Sans%20SC|Noto%20Sans%20TC|Noto%20Serif%20SC|Noto%20Serif%20TC|Ma%20Shan%20Zheng">

<link rel="stylesheet" href="/assets/css/main.css">
<link rel="stylesheet" href="/assets/css/skin.css">

  DLynam Blog

        David Lynam

        davidlynam1@hotmail.co.uk

            Internal APIs with Fargate

          <time class="dt-published" datetime="2021-11-19T00:00:00+00:00" itemprop="datePublished">
            Nov 19, 2021
          </time>•

A walk through on building an internal API using Fargate

            Halloween horror with AWS Savings Plans

          <time class="dt-published" datetime="2021-10-30T00:00:00+01:00" itemprop="datePublished">
            Oct 30, 2021
          </time>•

A story about how purchasing savings plans can go badly wrong

            Welcome to my blog

          <time class="dt-published" datetime="2021-10-06T00:00:00+01:00" itemprop="datePublished">
            Oct 6, 2021
          </time>•

What I plan on blogging about

•

1

•

Copyright © 2021 David Lynam; All rights reserved.

      Powered by Jekyll & Hamilton

My personal Tech blog


text:
package jhc.redsniff.internal.matchers;

import jhc.redsniff.internal.core.CollectionOf;

import org.hamcrest.Description;

public class NoFilterPossibleFilterResult<E> extends FilterResult<E> {

	public NoFilterPossibleFilterResult() {
		super(CollectionOf.<E>empty());
		// TODO Auto-generated constructor stub
	}

	@Override
	public void describeTo(Description description) {
		description.appendText("Could not filter");
	}

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

}


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

<beans default-lazy-init="true" xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="sldParser" class="org.mapfish.print.map.style.SLDParserPlugin" />
    <bean id="mapfishJsonParser" class="org.mapfish.print.map.style.json.MapfishJsonStyleParserPlugin" />
</beans>


text:
Python ctypes-based bindings for libvlc
=======================================

The bindings use ctypes to directly call the libvlc dynamic lib, and
the code is generated from the include files defining the public
API. The same module is compatible with various versions of libvlc
2.*.

License
-------

The generated module is licensed, like libvlc, under the GNU Lesser
General Public License 2.1 or later. The module generator itself is
licensed under the GNU General Public License version 2 or later.

Building from source
--------------------

You can get the latest version of the code generator from
<https://github.com/oaubert/python-vlc/> or
<http://git.videolan.org/?p=vlc/bindings/python.git>.

To generate the vlc.py module and its documentation, use

    make

To install it for development purposes (add a symlink to your Python
library) simply do

    python setup.py develop

preferably inside a virtualenv. You can uninstall it later with

    python setup.py develop --uninstall

Documentation building needs epydoc. An online build is available at
<http://olivieraubert.net/vlc/python-ctypes/>

Layout
------

The module offers two ways of accessing the API - a raw access to all
exported methods, and more convenient wrapper classes :

- Raw access: methods are available as attributes of the vlc
  module. Use their docstring (any introspective shell like ipython is
  your friends) to explore them.

- Wrapper classes: most major structures of the libvlc API (Instance,
  Media, MediaPlayer, etc) are wrapped as classes, with shorter method
  names.

Using the module
----------------

On win32, the simplest way is to put the ``vlc.py`` file in the same
directory as the libvlc.dll file (standard location:
``c:\Program Files\VideoLAN\VLC``).

- Using raw access:

    >>> import vlc
    >>> vlc.libvlc_get_version()
    '1.0.0 Goldeneye'
    >>> e=vlc.VLCException()
    >>> i=vlc.libvlc_new(0, [], e)
    >>> i
    <vlc.Instance object at 0x8384a4c>
    >>> vlc.libvlc_audio_get_volume(i,e)
    50

- Using wrapper classes:

   >>> import vlc
   >>> i=vlc.Instance('--no-audio', '--fullscreen')
   >>> i.audio_get_volume()
   50
   >>> p=i.media_player_new()
   >>> m=i.media_new('file:///tmp/foo.avi')
   >>> m.get_mrl()
   'file:///tmp/foo.avi'
   >>> p.set_media(m)
   >>> p.play()

or shorter:

   >>> import vlc
   >>> p=vlc.MediaPlayer('file:///tmp/foo.avi')
   >>> p.play()

In this latter case, a default ``vlc.Instance`` will be instanciated and
stored in ``vlc._default_instance``. It will be used to instanciate the
various classes (``Media``, ``MediaList``, ``MediaPlayer``, etc).


text:
<TITLE>Review for Girl, Interrupted (1999)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Girl, Interrupted (1999)

reviewed by
Ross Anthony

"You and Me Amplified"
Girl, Interrupted

By Ross Anthony

"Some advice ... never stick your finger out at a crazy person," a wild cat,
dangerously honest, less than stable Angelina Jolie warns an older
acquaintance of Winona Ryder at a local ice cream parlor during a rare field
trip from the institution.

Essentially, this is the story of one woman's sabbatical from sanity. We
begin the film with an assortment of flashbacks as Ryder admits herself to
Clayman Mental Center in hopes of getting a little rest from all the
headaches, hallucinations, etc. After the first half-hour, we're up to speed
on the history, and spend most of the rest of the film in the institution,
making friends and getting used to the awkward routine. "Don't drop anchor,
here," Whoopi Goldberg (nurse) cautions the confused Ryder.

Ryder is very good. Jolie is awesome. The direction, script and editing are
also supreme until the climax, where the script dumps a preciously delicate,
off-balance momentum for a rather cliché resolution. It was an "A" before
that.

Girl, Interrupted. Copyright © 2000. Rated R.
Starring Winona Ryder, Angelina Jolie, Clea Duvall, Brittany Murphy, Vanessa
Redgrave, Whoopi Goldberg.
Directed by James Mangold.
Written by James Mangold, Lisa Loomer and Anna Hamilton Phelan.
Based on the book by Susanna Kaysen.
Produced by Douglas Wick, Cathy Konrad at Sony.

Grade..........................B+

--
Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted
and shot documentaries, music videos, and shorts in 35 countries across
North America, Europe, Africa and Asia. For more reviews visit:
http://RossAnthony.com

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
def find_minimum_coins(total_change, coins):
    if total_change < 0:
        raise ValueError("cannot find negative change values")
    min_coins_required = [1e9] * (total_change + 1)
    last_coin = [0]*(total_change + 1)
    min_coins_required[0] = 0
    last_coin[0] = -1
    for change in range(1, total_change + 1):
        final_result = min_coins_required[change]
        for coin in coins:
            if coin <= change:
                result = min_coins_required[change - coin] + 1
                if result < final_result:
                    final_result = result
                    last_coin[change] = change - coin
        min_coins_required[change] = final_result
    if min_coins_required[total_change] == 1e9:
        raise ValueError("no combination can add up to target")
    else:
        last_coin_value = total_change
        array = []
        while(last_coin[last_coin_value] != -1):
            array.append(last_coin_value-last_coin[last_coin_value])
            last_coin_value = last_coin[last_coin_value]
        return array


text:
    Tokyo Restaurants

    Copyright 2016


text:
<?php namespace ZN\Remote\Exception;
/**
 * ZN PHP Web Framework
 *
 * "Simplicity is the ultimate sophistication." ~ Da Vinci
 *
 * @package ZN
 * @license MIT [http://opensource.org/licenses/MIT]
 * @author  Ozan UYKUN [ozan@znframework.com]
 */

use ZN\Exception;

class FileRemoteUploadException extends Exception
{
    const lang =
    [
        'en' => '`%` file is not uploaded from the server!',
        'tr' => '`%` dosyası sunucuya yüklenemiyor!'
    ];
}