text:
<!DOCTYPE html>

			ID PENGGUNA
			USERNAME
			PASSWORD
			NO TELP
			STATUS PENGGUNA
			ALAMAT
			LEVEL
			Edit/Hapus

		<?php
		//iclude file koneksi ke database
		include('db.php');

		//query ke database dg SELECT table siswa diurutkan berdasarkan NIS paling besar
		$query = mysql_query("SELECT * FROM pengguna ORDER BY id_pengguna DESC") or die(mysql_error());

		//cek, apakakah hasil query di atas mendapatkan hasil atau tidak (data kosong atau tidak)
		if(mysql_num_rows($query) == 0){	//ini artinya jika data hasil query di atas kosong

			//jika data kosong, maka akan menampilkan row kosong
			echo '
Tidak ada data!
';

		}else{	//else ini artinya jika data hasil query ada (data diu database tidak kosong)

			//jika data tidak kosong, maka akan melakukan perulangan while

			while($data = mysql_fetch_assoc($query)){	//perulangan while dg membuat variabel $data yang akan mengambil data di database

				//menampilkan row dengan data di database
				echo '
';

					echo ''.$data['id_pengguna'].'	';	//menampilkan data nis dari database
					echo ''.$data['username'].'	';	//menampilkan data nama lengkap dari database
					echo ''.$data['password'].'	';	//menampilkan data kelas dari database
					echo ''.$data['no_telp'].'	';	//menampilkan data jurusan dari database
					echo ''.$data['status_pengguna'].'	';	//menampilkan data nis dari database
					echo ''.$data['alamat'].'	';
					echo ''.$data['level'].'	';					//menampilkan data nama lengkap dari database

					echo 'Edit / Hapus	';	//menampilkan link edit dan hapus dimana tiap link terdapat GET id -> ?id=siswa_id
				echo '
';

			}

		}
		?>


text:
use CondorTest;

$cmd = 'job_core_perhold-true_van.cmd';
$testdesc =  'Condor submit with for periodic hold test - vanilla U';
$testname = "job_core_perhold_van";
$ENV{UNIVERSE} = "vanilla";
$ENV{UPREPEND} = "v_";

my $killedchosen = 0;

# truly const variables in perl
sub IDLE{1};
sub HELD{5};
sub RUNNING{2};

$abnormal = sub {
	my %info = @_;

	die "Want to see only execute, hold and abort events for periodic hold test\n";
};

$aborted = sub {
	my %info = @_;
	my $done;
	CondorTest::debug("Abort event expected from periodic remove after hold event seen\n",1);
};

$held = sub {
	my %info = @_;
	my $cluster = $info{"cluster"};

	CondorTest::debug("Held event expected, removing job.....\n",1);
	my @adarray;
	my $status = 1;
	my $cmd = "condor_rm $cluster";
	$status = CondorTest::runCondorTool($cmd,\@adarray,2);
	if(!$status)
	{
		CondorTest::debug("Test failure due to Condor Tool Failure<$cmd>\n",1);
		exit(1)
	}
};

$executed = sub
{
	my %args = @_;
	my $cluster = $args{"cluster"};

	CondorTest::debug("Periodic Hold should see and execute, followed by a hold and then we remove the job\n",1);
};

$submitted = sub
{
	my %args = @_;
	my $cluster = $args{"cluster"};

	CondorTest::debug("submitted: ok\n",1);
};

CondorTest::RegisterExecute($testname, $executed);
CondorTest::RegisterExitedAbnormal( $testname, $abnormal );
CondorTest::RegisterAbort( $testname, $aborted );
CondorTest::RegisterHold( $testname, $held );
CondorTest::RegisterSubmit( $testname, $submitted );

if( CondorTest::RunTest($testname, $cmd, 0) ) {
	CondorTest::debug("$testname: SUCCESS\n",1);
	exit(0);
} else {
	die "$testname: CondorTest::RunTest() failed\n";
}

redpajama_set_name: RedPajamaGithub


text:
<?php echo __('Dear Sir/Madam,')?>

<?php echo __('Our system is a virtual organizations manager software, this e-mail is sent by our robot.') ?>

<?php echo __('%lname%, %email% - the manager of service %service% kindly asks you to validate the service ownership', array("%lname%"=>$p->getUser()->getLastName(), "%email%"=>$p->getUser()->getEmailAddress(), "%service%"=>$s))?>

<?php echo __('For further information please contact him/her personally.')?>

<?php echo __('You can do the ownership validation - after authentication - by clicking ')?>
<?php echo  link_to(__("here."),url_for("service/validate?id=".$s->getId()."&token=".$s->getToken(),true)) ?>

<? if ($m!=""): ?>

<?php echo __('%lname%, %email% has also sent you a private message, which is the following: ',array("%lname%"=>$p->getUser()->getLastName(), "%email%"=>$p->getUser()->getEmailAddress()))?>

<?php echo  $m ?>

<?endif?>

<?php echo __('Best regards,')?>

VO

aai.sztaki.hu


text:
{% extends "editor/editor_base.html" %}

{% set form_id = "assed_form" %}
{% set formulaic_after = url_for("editor.journal_page", journal_id=obj.id) %}
{% set form_action = url_for("editor.journal_page", journal_id=obj.id) %}

{% set js_validation = True %}
{% set auto_save = 0 %}
{% set notabs = true %}
{% set diff_table = false %}
{% set quick_reject = false %}
{% set withdrawable = false %}

{% block page_title %}Journal: {{ obj.bibjson().title }}{% endblock %}

{% block editor_content scoped %}
<body id="apply">
    <main class="page-content">
        {% include "application_form/editorial_form_body.html" %}
    </main>
 </body>
{% endblock %}

{% block extra_js_bottom scoped %}
    {% set factory = "journal" %}
    {% include "application_form/js/_form_js.html" %}
{% endblock %}


text:
Additional Index Implementations
================================

GeoMesa supports additional index formats at runtime, using
`Java service providers <http://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html>`__. To add a new
index, implement ``org.locationtech.geomesa.index.api.GeoMesaFeatureIndexFactory`` and register your class under
``META-INF/services``, as described in the
`Java documentation <http://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html>`__.

Once an index is registered, it can be enabled through the ``SimpleFeatureType`` user data, as described in
:ref:`customizing_index_creation`.

Some additional indices are provided out-of-the-box:

S2/S3 Index
-----------

The S2 and S3 indices are based on the `S2 library <https://s2geometry.io/>`__:

.. pull-quote::

  The S2 library represents all data on a three-dimensional sphere (similar to a globe). This makes it
  possible to build a worldwide geographic database with no seams or singularities, using a single coordinate
  system, and with low distortion everywhere compared to the true shape of the Earth.

The S2 index is a spatial index, identified by the name ``s2``. The S3 index is a composite spatial and time index,
identified by the name ``s3``. The default time period for the S3 index can be configured through the user data
key ``geomesa.s3.interval`` (see :ref:`customizing_z_index` for reference).


text:
"""

Given a positive integer num, return the number of positive integers less than or equal to num whose digit sums are even.
The digit sum of a positive integer is the sum of all its digits.

Example 1:

Input: num = 4
Output: 2
Explanation:
The only integers less than or equal to 4 whose digit sums are even are 2 and 4.

Example 2:

Input: num = 30
Output: 14
Explanation:
The 14 integers less than or equal to 30 whose digit sums are even are
2, 4, 6, 8, 11, 13, 15, 17, 19, 20, 22, 24, 26, and 28.

Constraints:

1 <= num <= 1000

"""

class Solution:
    def countEven(self, num: int) -> int:
        def sum_digits(n):
            s = 0
            while n > 0:
                n, r = divmod(n, 10)
                s += r
            return s

        r = 0
        for n in range(1, num + 1):
            if sum_digits(n) % 2 == 0:
                r += 1
        return r


text:
DEVICEGROUP.type = "generator_energy_solar"

--[[
	You can also use skin = number here to define a skin to make the Module spawn with
	You can also use material = "path/to/material" to set a material to make it spawn with
]]

DEVICEGROUP.devices = {
    add_one = {
        Name = "CE Small Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_small.mdl",
        skin = 0
    },
    add_two = {
        Name = "CE Medium Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_medium.mdl",
        skin = 0
    },
    add_three = {
        Name = "CE Large Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_large.mdl",
        skin = 0
    },
    add_4 = {
        Name = "CE Huge Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_huge.mdl",
        skin = 0
    },
    add_5 = {
        Name = "CE Small Circle Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_c_small.mdl",
        skin = 0
    },
    add_6 = {
        Name = "CE Medium Circle Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_c_medium.mdl",
        skin = 0
    },
    add_7 = {
        Name = "CE Large Circle Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_c_large.mdl",
        skin = 0
    },
    add_8 = {
        Name = "CE Huge Circle Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_c_huge.mdl",
        skin = 0
    },
    add_9 = {
        Name = "CE Giant Solar Panel",
        model = "models/ce_ls3additional/solar_generator/solar_generator_giant.mdl",
        skin = 0
    },
}


text:
FactoryGirl.define do
  factory :vote, :class => 'Votes' do
    user_id 1
    proposed_location_id 1
  end
end


text:
@interface UIColor (ESGenerate)
+ (UIColor *)es_random;
+ (UIColor *)es_r:(CGFloat)r g:(CGFloat)g b:(CGFloat)b a:(CGFloat)a;
+ (UIColor *)es_hex:(NSString *)hexStr;
@end


text:
/** \file stlsoft/algorithms/debug.hpp
 *
 * \brief [C++ only] Debug algorithms
 *   (\ref group__library__algorithms "Algorithms" Library).
 */

#ifndef STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_DEBUG
#define STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_DEBUG

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_DEBUG_MAJOR     3
# define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_DEBUG_MINOR     1
# define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_DEBUG_REVISION  1
# define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_DEBUG_EDIT      68
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Compatibility
 */

/* /////////////////////////////////////////////////////////////////////////
 * Includes
 */

#ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
# include <stlsoft/stlsoft.h>
#endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 */

#ifndef _STLSOFT_NO_NAMESPACE
namespace stlsoft
{
#endif /* _STLSOFT_NO_NAMESPACE */

/* /////////////////////////////////////////////////////////////////////////
 * Algorithms
 */

template<   ss_typename_param_k I
        ,   ss_typename_param_k O
        >
// [[synesis:function:algorithm: copy_preinc(T<I> first, T<I> last, T<O> o)]]
inline O copy_preinc(
    I   first
,   I   last
,   O   o
)
{
    for(; first != last; ++o, ++first)
    {
        *o = *first;
    }

    return o;
}

// [[synesis:function:algorithm: copy_postinc(T<I> first, T<I> last, T<O> o)]]
template<   ss_typename_param_k I
        ,   ss_typename_param_k O
        >
inline O copy_postinc(
    I   first
,   I   last
,   O   o
)
{
    for(; first != last; o++, first++)
    {
        *o = *first;
    }

    return o;
}

/** \brief Carries out for_each on the range, using pre-increment on the iterator
 *
 * \ingroup group__library__algorithms
 *
 * \param first The start of the sequence
 * \param last The end of the sequence
 * \param func The function
 */
// [[synesis:function:algorithm: for_each_preinc(T<I> first, T<I> last, T<UF> func)]]
template<   ss_typename_param_k I
        ,   ss_typename_param_k UF
        >
inline UF for_each_preinc(I first, I last, UF func)
{
    for(; first != last; ++first)
    {
        func(*first);
    }

    return func;
}

/** \brief Carries out for_each on the range, using post-increment on the iterator
 *
 * \ingroup group__library__algorithms
 *
 * \param first The start of the sequence
 * \param last The end of the sequence
 * \param func The function
 */
// [[synesis:function:algorithm: for_each_postinc(T<I> first, T<I> last, T<UF> func)]]
template<   ss_typename_param_k I
        ,   ss_typename_param_k UF
        >
inline UF for_each_postinc(I first, I last, UF func)
{
    for(; first != last; first++)
    {
        func(*first);
    }

    return func;
}

////////////////////////////////////////////////////////////////////////////
// Unit-testing

#ifdef STLSOFT_UNITTEST
# include "./unittest/debug_unittest_.h"
#endif /* STLSOFT_UNITTEST */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _STLSOFT_NO_NAMESPACE
} // namespace stlsoft
#endif /* _STLSOFT_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_DEBUG */

/* ///////////////////////////// end of file //////////////////////////// */


text:
/**
 *
 * THIS CLASS IS NOT YET COMPLETE
 *
 * This class defines matrices in the linear algebra sense.  Matrices are treated
 * as a collection (a Java List) of vectors.  A matrix is
 * a mathematical object of M rows and N columns.  So matrix can be thought of
 * as collection of m vectors of dimension n.
 * @author Accribus
 */

import java.util.ArrayList;

public class MatrixLinAlg extends VectorLinAlg {

    private ArrayList<VectorLinAlg> vectors = new ArrayList<VectorLinAlg>();
    private int columns = 0;
    private int rows = 0;

    /**
     * A basic constructor that creates a vector of M rows
     * @param mRows
     */
    public MatrixLinAlg(int mRows) {
        this.rows = mRows;
        vectors.ensureCapacity(this.rows);
    }
    /**
     * A basic constructor that creates an M x N matrix
     * @param mRows
     * @param nCols
     */
    public MatrixLinAlg(int mRows, int nCols){

        this.rows = mRows;
        this.columns = nCols;
        vectors.ensureCapacity(mRows);
    }

    /**
     * This method affects only the first row of the matrix
     * @param i
     * @return value at i
     */
    @Override
    public double getIndexAtVector(int i){
        return 0;
    }

    /**
     * This method affects only the first row of the matrix
     * @param i
     * @param val
     */
    @Override
    public void setIndexAtVector(int i, double val){

    }

    /**
     * The N in an MxN matrix is the dimension of any
     * component vector.
     *
     * @return the dimension of the component vectors
     */
    @Override
    public int getDimension(){

        return 0;
    }

}


text:
package org.openrtb4j.v21.data.refs;

/**
 * The following table lists the various options for the content context; what
 * type of content is it.
 *
 * <i>Note to the reader:</i> This OpenRTB table has values derived from the IAB
 * Quality Assurance Guidelines (QAG). Users of OpenRTB should keep in synch
 * with updates to the QAG values as published on IAB.net.
 *
 * Specification Table 6.13
 *
 * @author Andrey Karayvansky
 *
 */
public interface ContentContext {

    /**
     * Video (a video file or stream that is being watched by the user,
     * including (Internet) television broadcasts)
     */
    int VIDEO = 1;

    /**
     * Game (an interactive software game that is being played by the user)
     */
    int GAME = 2;

    /**
     * Music (an audio file or stream that is being listened to by the user,
     * including (Internet) radio broadcasts)
     */
    int MUSIC = 3;

    /**
     * Application (an interactive software application that is being used by
     * the user)
     */
    int APPLICATION = 4;

    /**
     * Text (a document that is primarily textual in nature that is being read
     * or viewed by the user, including web page, ebook, or news article)
     */
    int TEXT = 5;

    /**
     * Other (content type unknown or the user is consuming content which does
     * not fit into one of the categories above)
     */
    int OTHER = 6;

    /**
     * Unknown
     */
    int UNKNOWN = 7;

}


text:
'''
Created on May 1, 2011

@author: Mark V Systems Limited
(c) Copyright 2011 Mark V Systems Limited, All rights reserved.
'''
from tkinter import Toplevel, N, S, E, W, messagebox
try:
    from tkinter.ttk import Frame, Button
except ImportError:
    from ttk import Frame, Button
try:
    import regex as re
except ImportError:
    import re
from arelle.UiUtil import gridHdr, gridCell, gridCombobox, label, checkbox, radiobutton
from arelle.CntlrWinTooltip import ToolTip
from arelle import ModelDocument, XPathContext, XPathParser, XmlUtil
from arelle.ModelDtsObject import ModelConcept
from arelle.ModelInstanceObject import ModelFact
from arelle.ModelRssItem import ModelRssItem
from arelle.ModelFormulaObject import Trace

'''
caller checks accepted, if True, caller retrieves url
'''

reMetaChars = '[]\\^$.|?*+(){}'

newFindOptions = {
    "direction": "down",
    "exprType": "text",
    "all": False,
    "conceptLabel": False,
    "conceptName": False,
    "conceptSubs": False,
    "conceptPer": False,
    "conceptBal": False,
    "factLabel": False,
    "factName": False,
    "factValue": False,
    "factCntx": False,
    "factUnit": False,
    "messagesLog": False,
    "priorExpressions": [],
    "geometry": None
}

def find(mainWin):
    dialog = DialogFind(mainWin, mainWin.config.setdefault("findOptions", newFindOptions))

class DialogFind(Toplevel):
    def __init__(self, mainWin, options):
        parent = mainWin.parent
        super(DialogFind, self).__init__(parent)
        self.parent = parent
        self.modelManager = mainWin.modelManager
        self.modelXbrl = None   # set when Find pressed, this blocks next prematurely
        if options is None: options = newFindOptions
        self.options = options
        parentGeometry = re.match("(\d+)x(\d+)[+]?([-]?\d+)[+]?([-]?\d+)", parent.geometry())
        dialogW = int(parentGeometry.group(1))
        dialogH = int(parentGeometry.group(2))
        dialogX = int(parentGeometry.group(3))
        dialogY = int(parentGeometry.group(4))
        self.accepted = False

        self.transient(self.parent)
        self.title(_("Find"))

        self.objsList = [] # next may be tried before anything is found

        frame = Frame(self)

        # load grid
        findLabel = gridHdr(frame, 1, 0, "Find:", anchor="w")
        findLabel.grid(padx=8)
        self.cbExpr = gridCombobox(frame, 1, 1, values=options["priorExpressions"])
        self.cbExpr.grid(columnspan=3, padx=8)
        ToolTip(self.cbExpr, text=_("Enter expression to find, or select from combo box drop down history list."), wraplength=240)

        y = 2

        # checkbox entries
        label(frame, 1, y, "Direction:")
        label(frame, 1, y + 3, "Match:")
        scopeLabel = label(frame, 2, y, "Scope:")
        ToolTip(scopeLabel, text=_("Scope for an XBRL document (instance or DTS).  "
                                   "For an RSS Feed, all properties are matched.  "), wraplength=240)
        rbUp = radiobutton(frame, 1, y+1, "Up", "up", "direction")
        ToolTip(rbUp, text=_("Find/Next up (on screen) from last to first match."), wraplength=240)
        rbDn = radiobutton(frame, 1, y+2, "Down", "down", "direction", rbUp.valueVar)
        ToolTip(rbDn, text=_("Find/Next down (on screen) from first to last match."), wraplength=240)
        rbText = radiobutton(frame, 1, y+4, "Text (ignore case)", "text", "exprType")
        ToolTip(rbText, text=_("Expression is a set of characters to match, ignoring case.  "
                               "The match may occur anywhere within the scope. "), wraplength=360)
        rbRegex = radiobutton(frame, 1, y+5, "Regular expression", "regex", "exprType", rbText.valueVar)
        ToolTip(rbRegex, text=_('A regular expression to match, anywhere in the scope, ignoring case.  '
                                'For example, "cash" would match cash anywhere in a string (like cash on hand), '
                                'whereas "^cash$" would match a full string to only contain cash. '
                                'Use regular expression metacharacters, e.g., "." for any single character, '
                                '".*" for any number of wild characters, .{3} for exactly 3 wild characters. '), wraplength=360)
        rbXPath = radiobutton(frame, 1, y+6, "XPath 2 expression", "xpath", "exprType", rbText.valueVar)
        ToolTip(rbXPath, text=_('An XPath 2 expression, where the context element, ".", is a candidate concept QName, if any concept scope is checked, '
                                'and a candidate fact item, if any fact scope is checked.  The XPath 2 functions do not need an "fn:" prefix (but it is defined).  '
                                'The XBRL Functions Registry functions do require an "xfi:" prefix.  Constructors require an "xs:" prefix.  '
                                'The expression is considered "matched" for the candidate concept QNames or fact items where the effective boolean value of the expression is "true()".  '), wraplength=360)
        self.optionControls = (
           rbUp,
           rbDn,
           rbText,
           rbRegex,
           rbXPath,
           #checkbox(frame, 2, y + 1, "All", "all"),
           checkbox(frame, 2, y + 1, "Concept label", "conceptLabel"),
           checkbox(frame, 2, y + 2, "   name", "conceptName"),
           checkbox(frame, 2, y + 3, "   type", "conceptType"),
           checkbox(frame, 2, y + 4, "   subs group", "conceptSubs"),
           checkbox(frame, 2, y + 5, "   period type", "conceptPer"),
           checkbox(frame, 2, y + 6, "   balance", "conceptBal"),
           checkbox(frame, 3, y + 1, "Fact label", "factLabel"),
           checkbox(frame, 3, y + 2, "   name", "factName"),
           checkbox(frame, 3, y + 3, "   value", "factValue"),
           checkbox(frame, 3, y + 4, "   context", "factCntx"),
           checkbox(frame, 3, y + 5, "   unit", "factUnit"),
           checkbox(frame, 3, y + 6, "Messages", "messagesLog"),

           # Note: if adding to this list keep Finder.FindOptions in sync

           )
        y += 7
        resultLabel = gridHdr(frame, 1, y, "Result:", anchor="w")
        resultLabel.grid(padx=8)
        self.resultText = gridCell(frame, 1, y + 1)
        self.resultText.grid(columnspan=3, padx=8)
        self.resultText.config(state="readonly")
        y += 2

        mainWin.showStatus(None)

        buttonFrame = Frame(frame)
        buttonFrame.grid(columnspan=4, sticky=E, padx=8)
        findButton = Button(buttonFrame, text=_("Find"), width=12, command=self.find)
        ToolTip(findButton, text=_('Compile (if regular expression or XPath 2), and find first match (if down direction) or last match (if up direction).  '), wraplength=240)
        nextButton = Button(buttonFrame, text=_("Next"), width=12, command=self.next)
        ToolTip(nextButton, text=_('Advance to the next matched object (in selected direction).  '), wraplength=240)
        closeButton = Button(buttonFrame, text=_("Close"), width=12, command=self.close)
        ToolTip(closeButton, text=_('Close the find dialog.  '), wraplength=240)
        findButton.grid(row=1, column=1, pady=3)
        nextButton.grid(row=1, column=2, pady=3)
        closeButton.grid(row=1, column=3, padx=3)

        frame.grid(row=0, column=0, sticky=(N,S,E,W))
        frame.columnconfigure(1, weight=1)
        frame.columnconfigure(2, weight=1)
        frame.columnconfigure(3, weight=1)
        window = self.winfo_toplevel()
        window.columnconfigure(0, weight=1)
        if self.options["geometry"]:
            self.geometry(self.options["geometry"])
        else:
            self.geometry("+{0}+{1}".format(dialogX+50,dialogY+100))

        #self.bind("<Return>", self.ok)
        #self.bind("<Escape>", self.close)

        self.protocol("WM_DELETE_WINDOW", self.close)

        # make this dialog non-modal
        self.focus_set()
        #self.grab_set()
        #self.wait_window(self)

    def setOptions(self):
        # set formula options
        for optionControl in self.optionControls:
            self.options[optionControl.attr] = optionControl.value

    def find(self, event=None):
        self.setOptions()
        self.accepted = True
        # self.close()

        docType = self.modelManager.modelXbrl.modelDocument.type if self.modelManager.modelXbrl else None
        if self.options["messagesLog"]:
            if docType == ModelDocument.Type.RSSFEED and self.options["exprType"] == "xpath":
                messagebox.showerror(_("Find cannot be completed"),
                         _("XPath matching is not available for searching messages, please choose text or regular expression.  "), parent=self)
                return
        else:
            if not self.modelManager.modelXbrl or not docType in (
                 ModelDocument.Type.SCHEMA, ModelDocument.Type.LINKBASE, ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL,
                 ModelDocument.Type.RSSFEED):
                messagebox.showerror(_("Find cannot be completed"),
                         _("Find requires an opened DTS or RSS Feed"), parent=self.parent)
                return

            if docType == ModelDocument.Type.RSSFEED and self.options["exprType"] == "xpath":
                messagebox.showerror(_("Find cannot be completed"),
                         _("XPath matching is not available for an RSS Feed, please choose text or regular expression.  "), parent=self)
                return

        self.modelXbrl = self.modelManager.modelXbrl
        expr = self.cbExpr.value
        # update find expressions history
        if expr in self.options["priorExpressions"]:
            self.options["priorExpressions"].remove(expr)
        elif len(self.options["priorExpressions"]) > 10:
            self.options["priorExpressions"] = self.options["priorExpressions"][0:10]
        self.options["priorExpressions"].insert(0, expr)
        self.cbExpr.config(values=self.options["priorExpressions"])
        self.saveConfig()

        import threading
        thread = threading.Thread(target=lambda
                                  expr=self.cbExpr.value,
                                  logViewLines=self.modelManager.cntlr.logView.lines() if self.options["messagesLog"] else None
                                  : self.backgroundFind(expr, logViewLines))
        thread.daemon = True
        thread.start()

    def backgroundFind(self, expr, logViewLines):
        exprType = self.options["exprType"]
        inConceptLabel = self.options["conceptLabel"]
        inConceptName = self.options["conceptName"]
        inConceptType = self.options["conceptType"]
        inConceptSubs = self.options["conceptSubs"]
        inConceptPer = self.options["conceptPer"]
        inConceptBal = self.options["conceptBal"]
        inFactLabel = self.options["factLabel"]
        inFactName = self.options["factName"]
        inFactValue = self.options["factValue"]
        inFactCntx = self.options["factCntx"]
        inFactUnit = self.options["factUnit"]
        inMessagesLog = self.options["messagesLog"]
        nextIsDown = self.options["direction"] == "down"

        objsFound = set()

        try:
            if exprType == "text":
                # escape regex metacharacters
                pattern = re.compile(''.join(
                         [(('\\' + c) if c in reMetaChars else c) for c in expr]),
                         re.IGNORECASE)
                isRE = True
                isXP = False
            elif exprType == "regex":
                pattern = re.compile(expr, re.IGNORECASE)
                isRE = True
                isXP = False
            elif exprType == "xpath":
                isRE = False
                isXP = True
                self.resultText.setValue(_("Compiling xpath expression..."))
                XPathParser.initializeParser(self.modelManager)
                self.modelManager.showStatus(_("Compiling xpath expression..."))
                xpProg= XPathParser.parse(self,
                                          expr,
                                          XPathParser.staticExpressionFunctionContext(),
                                          "find expression",
                                          Trace.CALL)
                xpCtx = XPathContext.create(self.modelXbrl, sourceElement=None)

            else:
                return  # nothing to do

            if inMessagesLog:
                for lineNumber, line in enumerate(logViewLines):
                    if pattern.search(line):
                        objsFound.add(lineNumber)
            elif self.modelXbrl.modelDocument.type == ModelDocument.Type.RSSFEED:
                for rssItem in self.modelXbrl.modelDocument.items:
                    if any(pattern.search(str(value)) for name, value in rssItem.propertyView):
                        objsFound.add(rssItem)
            else: # DTS search
                if inConceptLabel or inConceptName or inConceptType or inConceptSubs or inConceptPer or inConceptBal:
                    self.modelManager.cntlr.uiThreadQueue.put((self.resultText.setValue, [_("Matching concepts...")]))
                    self.modelManager.showStatus(_("Matching concepts..."))
                    for conceptName, concepts in self.modelXbrl.nameConcepts.items():
                        for concept in concepts:
                            if ((isXP and xpCtx.evaluateBooleanValue(xpProg, contextItem=concept.qname)) or
                                (isRE and
                                 (inConceptLabel and pattern.search(concept.label())) or
                                 (inConceptName and pattern.search(conceptName)) or
                                 (inConceptType and pattern.search(str(concept.typeQname))) or
                                 (inConceptSubs and pattern.search(str(concept.substitutionGroupQname))) or
                                 (inConceptPer and concept.periodType and pattern.search(concept.periodType)) or
                                 (inConceptBal and concept.balance and pattern.search(concept.balance))
                                 )
                                ):
                                objsFound.add(concept)
                if inFactLabel or inFactName or inFactValue or inFactCntx or inFactUnit:
                    self.modelManager.cntlr.uiThreadQueue.put((self.resultText.setValue, [_("Matching facts...")]))
                    self.modelManager.showStatus(_("Matching facts..."))
                    for fact in self.modelXbrl.facts:
                        if ((isXP and xpCtx.evaluateBooleanValue(xpProg, contextItem=fact)) or
                            (isRE and
                             (inFactName and pattern.search(fact.concept.name) or
                             (inFactLabel and pattern.search(fact.concept.label())) or
                             (inFactValue and pattern.search(fact.value)) or
                             (inFactCntx and pattern.search(XmlUtil.innerText(fact.context.element))) or
                             (inFactUnit and pattern.search(XmlUtil.innerText(fact.unit.element))))
                             )
                            ):
                            objsFound.add(fact)
        except XPathContext.XPathException as err:
            err = _("Find expression error: {0} \n{1}").format(err.message, err.sourceErrorIndication)
            self.modelManager.addToLog(err)
            self.modelManager.cntlr.uiThreadQueue.put((self.resultText.setValue, [err]))
            self.modelManager.showStatus(_("Completed with errors"), 5000)

        numConcepts = 0
        numFacts = 0
        numRssItems = 0
        numMessages = 0
        self.objsList = []
        for obj in objsFound:
            if inMessagesLog:
                numMessages += 1
                self.objsList.append( ('m', "{0:06}".format(obj), obj) )
            elif isinstance(obj,ModelConcept):
                numConcepts += 1
                self.objsList.append( ('c', obj.localName, obj.objectId()) )
            elif isinstance(obj,ModelFact):
                numFacts += 1
                self.objsList.append( ('f', obj.__hash__(), obj.objectId()) )
            elif isinstance(obj,ModelRssItem):
                numRssItems += 1
                self.objsList.append( ('r', obj.__hash__(), obj.objectId()) )
        self.objsList.sort()
        self.result = "Found "
        if numConcepts:
            self.result += "{0} concepts".format(numConcepts)
            if numFacts: self.result += ", "
        if numFacts:
            self.result += "{0} facts".format(numFacts)
        if numRssItems:
            self.result += "{0} RSS items".format(numRssItems)
        if numMessages:
            self.result += "{0} Messages".format(numMessages)
        if numConcepts + numFacts + numRssItems + numMessages == 0:
            self.result += "no matches"
            self.foundIndex = -1
            self.modelManager.cntlr.uiThreadQueue.put((self.resultText.setValue, [self.result]))
        else:
            self.foundIndex = 0 if nextIsDown else (len(self.objsList) - 1)
            self.modelManager.cntlr.uiThreadQueue.put((self.next, []))
        self.modelManager.showStatus(_("Ready..."), 2000)

    def next(self):
        self.setOptions() # refresh options
        nextIsDown = self.options["direction"] == "down"
        # check that asme instance applies
        if not self.options["messagesLog"]:
            if self.modelXbrl is None:
                return
            if self.modelManager.modelXbrl != self.modelXbrl:
                messagebox.showerror(_("Next cannot be completed"),
                                _("A different DTS is active, than find was initiated with.  Please press 'find' to re-search with the current DTS"), parent=self)
                return
        lenObjsList = len(self.objsList)
        if lenObjsList == 0:
            messagebox.showwarning(_("Next cannot be completed"),
                            _("No matches were found.  Please try a different search."), parent=self)
            return

        if self.foundIndex < 0 and nextIsDown:
            self.foundIndex += 1
        elif self.foundIndex >= lenObjsList and not nextIsDown:
            self.foundIndex -= 1
        if 0 <= self.foundIndex < lenObjsList:
            objectFound = self.objsList[self.foundIndex][2]
            if self.options["messagesLog"]:
                self.modelManager.cntlr.logView.selectLine(objectFound)
            else:
                self.modelManager.modelXbrl.viewModelObject(objectFound)
            self.resultText.setValue("{0}, selection {1} of {2}".format(self.result, self.foundIndex + 1, len(self.objsList) ) )
            self.foundIndex += 1 if nextIsDown else -1
        elif nextIsDown:
            self.resultText.setValue("{0}, selection at end".format(self.result) )
        else:
            self.resultText.setValue("{0}, selection at start".format(self.result) )

    def close(self, event=None):
        self.options["geometry"] = self.geometry()
        self.saveConfig()
        self.parent.focus_set()
        self.destroy()

    def saveConfig(self):
        self.modelManager.cntlr.config["findOptions"] = self.options
        self.modelManager.cntlr.saveConfig()


text:
<?php
// WARNING, this is a read only file created by import scripts
// WARNING
// WARNING,  Changes made to this file will be clobbered
// WARNING
// WARNING,  Please make changes on poeditor instead of here
//
//
?>
subject: Dnevni pregled

{alternative:plain}

Poštovani,

U nastavku pogledajte pregled preuzimanja za vaš transfer {transfer.id} (uploaded {date:transfer.created}) :

{if:events}
{each:events as event}
  - Primalac {event.who} preuzeo {if:event.what == "archive"}arhivu{else}fajl {event.what_name}{endif} dana {datetime:event.when}
{endeach}
{else}
Nema preuzimanja
{endif}

Dodatne pojedinosti možete naći na  {transfer.link}

Lep pozdrav,
{cfg:site_name}

{alternative:html}

    Poštovani,

    U nastavku pogledajte pregled preuzimanja za vaš transfer {transfer.id} (uploaded {date:transfer.created}) :

{if:events}

{each:events as event}

Primalac {event.who} preuzeo {if:event.what == "archive"}arhivu{else}fajl {event.what_name}{endif} dana {datetime:event.when}

{endeach}

{else}

    Nema preuzimanja

{endif}

    Dodatne pojedinosti možete naći na {transfer.link}

    Lep pozdrav,

    {cfg:site_name}


text:
goog.provide('shaka.media.StallDetector');
goog.provide('shaka.media.StallDetector.Implementation');
goog.provide('shaka.media.StallDetector.MediaElementImplementation');

goog.require('shaka.media.TimeRangesUtils');
goog.require('shaka.util.FakeEvent');
goog.require('shaka.util.IReleasable');

/**
 * Some platforms/browsers can get stuck in the middle of a buffered range (e.g.
 * when seeking in a background tab). Detect when we get stuck so that the
 * player can respond.
 *
 * @implements {shaka.util.IReleasable}
 * @final
 */
shaka.media.StallDetector = class {
  /**
   * @param {shaka.media.StallDetector.Implementation} implementation
   * @param {number} stallThresholdSeconds
   * @param {function(!Event)} onEvent
   *     Called when an event is raised to be sent to the application.
   */
  constructor(implementation, stallThresholdSeconds, onEvent) {
    /** @private {?function(!Event)} */
    this.onEvent_ = onEvent;
    /** @private {shaka.media.StallDetector.Implementation} */
    this.implementation_ = implementation;
    /** @private {boolean} */
    this.wasMakingProgress_ = implementation.shouldBeMakingProgress();
    /** @private {number} */
    this.value_ = implementation.getPresentationSeconds();
    /** @private {number} */
    this.lastUpdateSeconds_ = implementation.getWallSeconds();
    /** @private {boolean} */
    this.didJump_ = false;
    /** @private {number} */
    this.stallsDetected_ = 0;

    /**
     * The amount of time in seconds that we must have the same value of
     * |value_| before we declare it as a stall.
     *
     * @private {number}
     */
    this.stallThresholdSeconds_ = stallThresholdSeconds;

    /** @private {function(number, number)} */
    this.onStall_ = () => {};
  }

  /** @override */
  release() {
    // Drop external references to make things easier on the GC.
    this.implementation_ = null;
    this.onEvent_ = null;
    this.onStall_ = () => {};
  }

  /**
   * Set the callback that should be called when a stall is detected. Calling
   * this will override any previous calls to |onStall|.
   *
   * @param {function(number, number)} doThis
   */
  onStall(doThis) {
    this.onStall_ = doThis;
  }

  /**
   * Returns the number of playback stalls detected.
   */
  getStallsDetected() {
    return this.stallsDetected_;
  }

  /**
   * Have the detector update itself and fire the "on stall" callback if a stall
   * was detected.
   *
   * @return {boolean} True if action was taken.
   */
  poll() {
    const impl = this.implementation_;

    const shouldBeMakingProgress = impl.shouldBeMakingProgress();
    const value = impl.getPresentationSeconds();
    const wallTimeSeconds = impl.getWallSeconds();

    const acceptUpdate = this.value_ != value ||
                         this.wasMakingProgress_ != shouldBeMakingProgress;

    if (acceptUpdate) {
      this.lastUpdateSeconds_ = wallTimeSeconds;
      this.value_ = value;
      this.wasMakingProgress_ = shouldBeMakingProgress;
      this.didJump_ = false;
    }

    const stallSeconds = wallTimeSeconds - this.lastUpdateSeconds_;

    const triggerCallback = stallSeconds >= this.stallThresholdSeconds_ &&
                            shouldBeMakingProgress && !this.didJump_;

    if (triggerCallback) {
      this.onStall_(this.value_, stallSeconds);
      this.didJump_ = true;
      // If the onStall_ method updated the current time, update our stored
      // value so we don't think that was an update.
      this.value_ = impl.getPresentationSeconds();
      this.stallsDetected_++;
      this.onEvent_(new shaka.util.FakeEvent(
          shaka.util.FakeEvent.EventName.StallDetected));
    }

    return triggerCallback;
  }
};

/**
 * @interface
 */
shaka.media.StallDetector.Implementation = class {
  /**
   * Check if the presentation time should be changing. This will return |true|
   * when we expect the presentation time to change.
   *
   * @return {boolean}
   */
  shouldBeMakingProgress() {}

  /**
   * Get the presentation time in seconds.
   *
   * @return {number}
   */
  getPresentationSeconds() {}

  /**
   * Get the time wall time in seconds.
   *
   * @return {number}
   */
  getWallSeconds() {}
};

/**
 * Some platforms/browsers can get stuck in the middle of a buffered range (e.g.
 * when seeking in a background tab). Force a seek to help get it going again.
 *
 * @implements {shaka.media.StallDetector.Implementation}
 * @final
 */
shaka.media.StallDetector.MediaElementImplementation = class {
  /**
   * @param {!HTMLMediaElement} mediaElement
   */
  constructor(mediaElement) {
    /** @private {!HTMLMediaElement} */
    this.mediaElement_ = mediaElement;
  }

  /** @override */
  shouldBeMakingProgress() {
    // If we are not trying to play, the lack of change could be misidentified
    // as a stall.
    if (this.mediaElement_.paused) {
      return false;
    }
    if (this.mediaElement_.playbackRate == 0) {
      return false;
    }

    // If we have don't have enough content, we are not stalled, we are
    // buffering.
    if (this.mediaElement_.buffered.length == 0) {
      return false;
    }

    return shaka.media.StallDetector.MediaElementImplementation.hasContentFor_(
        this.mediaElement_.buffered,
        /* timeInSeconds= */ this.mediaElement_.currentTime);
  }

  /** @override */
  getPresentationSeconds() {
    return this.mediaElement_.currentTime;
  }

  /** @override */
  getWallSeconds() {
    return Date.now() / 1000;
  }

  /**
   * Check if we have buffered enough content to play at |timeInSeconds|. Ignore
   * the end of the buffered range since it may not play any more on all
   * platforms.
   *
   * @param {!TimeRanges} buffered
   * @param {number} timeInSeconds
   * @return {boolean}
   * @private
   */
  static hasContentFor_(buffered, timeInSeconds) {
    const TimeRangesUtils = shaka.media.TimeRangesUtils;
    for (const {start, end} of TimeRangesUtils.getBufferedInfo(buffered)) {
      // Can be as much as 100ms before the range
      if (timeInSeconds < start - 0.1) {
        continue;
      }
      // Must be at least 500ms inside the range
      if (timeInSeconds > end - 0.5) {
        continue;
      }

      return true;
    }

    return false;
  }
};


text:
package com.arges.sepan.argmusicplayer.Notification;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

import com.arges.sepan.argmusicplayer.ArgMusicPlayer;

public class ArgNotificationReceiver extends BroadcastReceiver {
    public ArgNotificationReceiver() {

    }

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        ArgMusicPlayer player = ArgMusicPlayer.getInstance();
        if (player == null) {
            ArgNotification.close(context);
            return;
        }

        switch (action) {
            case "com.arges.intent.PLAYPAUSE":
                if (player.isPlaying())
                    player.pause();
                else
                    player.continuePlaying();
                break;

            case "com.arges.intent.CLOSE":
                ArgNotification.close(context);
                player.stop();
                break;

            case "com.arges.intent.NEXT":
                player.playNextAudio();
                break;

            case "com.arges.intent.PREV":
                player.playPreviousAudio();
                break;
        }
    }
}


text:
using System;

namespace YAF.Lucene.Net.Search
{

    using BytesRef = YAF.Lucene.Net.Util.BytesRef;

    /// <summary>
    /// A <see cref="Filter"/> that restricts search results to a range of term
    /// values in a given field.
    ///
    /// <para/>This filter matches the documents looking for terms that fall into the
    /// supplied range according to
    /// <see cref="byte.CompareTo(byte)"/>,  It is not intended
    /// for numerical ranges; use <see cref="NumericRangeFilter"/> instead.
    ///
    /// <para/>If you construct a large number of range filters with different ranges but on the
    /// same field, <see cref="FieldCacheRangeFilter"/> may have significantly better performance.
    /// <para/>
    /// @since 2.9
    /// </summary>
    public class TermRangeFilter : MultiTermQueryWrapperFilter<TermRangeQuery>
    {
        /// <param name="fieldName"> The field this range applies to </param>
        /// <param name="lowerTerm"> The lower bound on this range </param>
        /// <param name="upperTerm"> The upper bound on this range </param>
        /// <param name="includeLower"> Does this range include the lower bound? </param>
        /// <param name="includeUpper"> Does this range include the upper bound? </param>
        /// <exception cref="ArgumentException"> if both terms are <c>null</c> or if
        ///  lowerTerm is <c>null</c> and includeLower is <c>true</c> (similar for upperTerm
        ///  and includeUpper) </exception>
        public TermRangeFilter(string fieldName, BytesRef lowerTerm, BytesRef upperTerm, bool includeLower, bool includeUpper)
            : base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper))
        {
        }

        /// <summary>
        /// Factory that creates a new <see cref="TermRangeFilter"/> using <see cref="string"/>s for term text.
        /// </summary>
        public static TermRangeFilter NewStringRange(string field, string lowerTerm, string upperTerm, bool includeLower, bool includeUpper)
        {
            BytesRef lower = lowerTerm is null ? null : new BytesRef(lowerTerm);
            BytesRef upper = upperTerm is null ? null : new BytesRef(upperTerm);
            return new TermRangeFilter(field, lower, upper, includeLower, includeUpper);
        }

        /// <summary>
        /// Constructs a filter for field <paramref name="fieldName"/> matching
        /// less than or equal to <paramref name="upperTerm"/>.
        /// </summary>
        public static TermRangeFilter Less(string fieldName, BytesRef upperTerm)
        {
            return new TermRangeFilter(fieldName, null, upperTerm, false, true);
        }

        /// <summary>
        /// Constructs a filter for field <paramref name="fieldName"/> matching
        /// greater than or equal to <paramref name="lowerTerm"/>.
        /// </summary>
        public static TermRangeFilter More(string fieldName, BytesRef lowerTerm)
        {
            return new TermRangeFilter(fieldName, lowerTerm, null, true, false);
        }

        /// <summary>
        /// Returns the lower value of this range filter </summary>
        public virtual BytesRef LowerTerm => m_query.LowerTerm;

        /// <summary>
        /// Returns the upper value of this range filter </summary>
        public virtual BytesRef UpperTerm => m_query.UpperTerm;

        /// <summary>
        /// Returns <c>true</c> if the lower endpoint is inclusive </summary>
        public virtual bool IncludesLower => m_query.IncludesLower;

        /// <summary>
        /// Returns <c>true</c> if the upper endpoint is inclusive </summary>
        public virtual bool IncludesUpper => m_query.IncludesUpper;
    }
}


text:
<?php

namespace prbdias\mbway;

class FinancialOperationInquiryRes
{
    /**
     * @var string
     */
    protected $merchantOprId;

    /**
     * @var dateTime
     * @var \DateTime $merchantOprTimestamp
     */
    protected $merchantOprTimestamp;

    /**
     * @var int
     */
    protected $merchantOprSttCde;

    /**
     * @var dateTime
     * @var \DateTime $merchantOprSttCdeTimestamp
     */
    protected $merchantOprSttCdeTimestamp;

    /**
     * @return string
     */
    public function getMerchantOprId()
    {
        return $this->merchantOprId;
    }

    /**
     * @param string $merchantOprId
     *
     * @return FinancialOperationInquiryRes
     */
    public function setMerchantOprId($merchantOprId)
    {
        $this->merchantOprId = $merchantOprId;

        return $this;
    }

    /**
     * @return \DateTime
     */
    public function getMerchantOprTimestamp()
    {
        if ($this->merchantOprTimestamp == null) {
            return;
        } else {
            return new \DateTime($this->merchantOprTimestamp);
        }
    }

    /**
     * @param \DateTime $merchantOprTimestamp
     *
     * @return FinancialOperationInquiryRes
     */
    public function setTimestamp(\DateTime $merchantOprTimestamp)
    {
        $this->merchantOprTimestamp = $merchantOprTimestamp->format(\DateTime::ATOM);

        return $this;
    }

    /**
     * @return int
     */
    public function getMerchantOprSttCde()
    {
        return $this->merchantOprSttCde;
    }

    /**
     * @param int $merchantOprSttCde
     *
     * @return FinancialOperationInquiryRes
     */
    public function setMerchantOprSttCde($merchantOprSttCde)
    {
        $this->merchantOprSttCde = $merchantOprSttCde;

        return $this;
    }

    /**
     * @return \DateTime
     */
    public function getMerchantOprSttCdeTimestamp()
    {
        if ($this->merchantOprSttCdeTimestamp == null) {
            return;
        } else {
            return new \DateTime($this->merchantOprSttCdeTimestamp);
        }
    }

    /**
     * @param \DateTime $merchantOprSttCdeTimestamp
     *
     * @return FinancialOperationInquiryRes
     */
    public function setMerchantOprSttCdeTimestamp(\DateTime $merchantOprSttCdeTimestamp)
    {
        $this->merchantOprSttCdeTimestamp = $merchantOprSttCdeTimestamp->format(\DateTime::ATOM);

        return $this;
    }
}


text:
namespace Microsoft.Azure.Management.DataFactory.Models
{
    using Microsoft.Rest;
    using Microsoft.Rest.Serialization;
    using Newtonsoft.Json;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;

    /// <summary>
    /// Linked service for Sybase data source.
    /// </summary>
    [Newtonsoft.Json.JsonObject("Sybase")]
    [Rest.Serialization.JsonTransformation]
    public partial class SybaseLinkedService : LinkedService
    {
        /// <summary>
        /// Initializes a new instance of the SybaseLinkedService class.
        /// </summary>
        public SybaseLinkedService()
        {
            CustomInit();
        }

        /// <summary>
        /// Initializes a new instance of the SybaseLinkedService class.
        /// </summary>
        /// <param name="server">Server name for connection. Type: string (or
        /// Expression with resultType string).</param>
        /// <param name="database">Database name for connection. Type: string
        /// (or Expression with resultType string).</param>
        /// <param name="additionalProperties">Unmatched properties from the
        /// message are deserialized this collection</param>
        /// <param name="connectVia">The integration runtime reference.</param>
        /// <param name="description">Linked service description.</param>
        /// <param name="schema">Schema name for connection. Type: string (or
        /// Expression with resultType string).</param>
        /// <param name="authenticationType">AuthenticationType to be used for
        /// connection. Possible values include: 'Basic', 'Windows'</param>
        /// <param name="username">Username for authentication. Type: string
        /// (or Expression with resultType string).</param>
        /// <param name="password">Password for authentication.</param>
        /// <param name="encryptedCredential">The encrypted credential used for
        /// authentication. Credentials are encrypted using the integration
        /// runtime credential manager. Type: string (or Expression with
        /// resultType string).</param>
        public SybaseLinkedService(object server, object database, IDictionary<string, object> additionalProperties = default(IDictionary<string, object>), IntegrationRuntimeReference connectVia = default(IntegrationRuntimeReference), string description = default(string), object schema = default(object), string authenticationType = default(string), object username = default(object), SecureString password = default(SecureString), object encryptedCredential = default(object))
            : base(additionalProperties, connectVia, description)
        {
            Server = server;
            Database = database;
            Schema = schema;
            AuthenticationType = authenticationType;
            Username = username;
            Password = password;
            EncryptedCredential = encryptedCredential;
            CustomInit();
        }

        /// <summary>
        /// An initialization method that performs custom operations like setting defaults
        /// </summary>
        partial void CustomInit();

        /// <summary>
        /// Gets or sets server name for connection. Type: string (or
        /// Expression with resultType string).
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.server")]
        public object Server { get; set; }

        /// <summary>
        /// Gets or sets database name for connection. Type: string (or
        /// Expression with resultType string).
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.database")]
        public object Database { get; set; }

        /// <summary>
        /// Gets or sets schema name for connection. Type: string (or
        /// Expression with resultType string).
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.schema")]
        public object Schema { get; set; }

        /// <summary>
        /// Gets or sets authenticationType to be used for connection. Possible
        /// values include: 'Basic', 'Windows'
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.authenticationType")]
        public string AuthenticationType { get; set; }

        /// <summary>
        /// Gets or sets username for authentication. Type: string (or
        /// Expression with resultType string).
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.username")]
        public object Username { get; set; }

        /// <summary>
        /// Gets or sets password for authentication.
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.password")]
        public SecureString Password { get; set; }

        /// <summary>
        /// Gets or sets the encrypted credential used for authentication.
        /// Credentials are encrypted using the integration runtime credential
        /// manager. Type: string (or Expression with resultType string).
        /// </summary>
        [JsonProperty(PropertyName = "typeProperties.encryptedCredential")]
        public object EncryptedCredential { get; set; }

        /// <summary>
        /// Validate the object.
        /// </summary>
        /// <exception cref="ValidationException">
        /// Thrown if validation fails
        /// </exception>
        public override void Validate()
        {
            base.Validate();
            if (Server == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "Server");
            }
            if (Database == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "Database");
            }
            if (Password != null)
            {
                Password.Validate();
            }
        }
    }
}


text:
    <link rel="stylesheet" href="example.css" />

    <button onclick="document.querySelector('#gameDiv').children[0].webkitRequestFullScreen()">FullScreen</button>
    <button onclick="stage.swapChildren(leftSquare, leftStick)">Swap leftSquare and leftStick</button>
    <button onclick="stage.swapChildren(rightSquare, rightStick)">Swap rightSquare and rightStick</button>


text:
package com.github.amsemy.warby.controller;

import static com.github.amsemy.warby.controller.WarbyException.*;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

/**
 * Параметр действия. Если простого типа, то маппится на параметр запроса.
 * Если POJO-типа, то содержит в себе другие парметры действия.
 */
class WarbyActionParam {

    final Constructor<?> constr;
    final Field field;
    final boolean isPrimitive;
    final boolean isRequired;
    final String name;
    final WarbyParamKind paramKind;
    final List<WarbyActionParam> params;
    final Method setter;
    final Class<?> type;
    final WarbyTypeKind typeKind;

    /**
     * Создаёт параметр действия по минимальному набору параметров.
     *
     * @param  obj
     *         Объект, который содержит действие.
     * @param  name
     *         Имя парметра действия.
     * @param  type
     *         Тип данных параметра действия.
     * @param  isRequired
     *         Признак обязательности передачи параметра действию.
     * @param  paramKind
     *         Способ отображения парметра запроса на параметр действия.
     * @param  field
     *         Ссылка на поле POJO-параметра.
     * @param  setter
     *         Ссылка на setter-метод POJO-параметра.
     * @param  isPojo
     *         Признак того, что параметр является POJO.
     * @throws  WarbyException
     *          Если тип параметра не удовлетворяет
     *          {@link com.github.amsemy.warby.annotation.WrbParam допустимым
     *          требованиям}.
     */
    private WarbyActionParam(
            Object obj,
            String name,
            Class<?> type,
            boolean isRequired,
            WarbyParamKind paramKind,
            Field field,
            Method setter,
            boolean isPojo) throws WarbyException {
        this.name = name;
        this.type = type;
        this.isRequired = isRequired;
        this.paramKind = paramKind;
        this.field = field;
        this.setter = setter;
        try {
            if (isPojo) {
                if (type.isArray()) {
                    throw new WarbyException(MSG_POJO_ARRAY,
                            obj.getClass(), "%2$s", name, type);
                }
                if (type.isMemberClass()) {
                    if (Modifier.isStatic(type.getModifiers())) {
                        constr = type.getDeclaredConstructor();
                        typeKind = WarbyTypeKind.NESTED_POJO;
                    } else {
                        constr = type.getDeclaredConstructor(obj.getClass());
                        typeKind = WarbyTypeKind.INNER_POJO;
                    }
                } else {
                    constr = type.getDeclaredConstructor();
                    typeKind = WarbyTypeKind.POJO;
                }
                isPrimitive = false;
                params = new ArrayList<>();
            } else {
                Class<?> cl = (type.isArray()) ? type.getComponentType() : type;
                if (cl.isPrimitive() && cl != char.class) {
                    if (cl == boolean.class) {
                        constr = Boolean.class.getConstructor(String.class);
                    } else if (cl == byte.class) {
                        constr = Byte.class.getConstructor(String.class);
                    } else if (cl == double.class) {
                        constr = Double.class.getConstructor(String.class);
                    } else if (cl == float.class) {
                        constr = Float.class.getConstructor(String.class);
                    } else if (cl == int.class) {
                        constr = Integer.class.getConstructor(String.class);
                    } else if (cl == long.class) {
                        constr = Long.class.getConstructor(String.class);
                    } else if (cl == short.class) {
                        constr = Short.class.getConstructor(String.class);
                    } else {
                        throw new WarbyException(MSG_UNSUPPORTED_PARAM_TYPE,
                                obj.getClass(), "%2$s", name, type);
                    }
                    if (type.isArray()) {
                        typeKind = WarbyTypeKind.PRIMITIVE_ARRAY;
                    } else {
                        typeKind = WarbyTypeKind.PRIMITIVE;
                    }
                } else if (cl == Boolean.class
                        || cl == Byte.class
                        || cl == Double.class
                        || cl == Float.class
                        || cl == Integer.class
                        || cl == Long.class
                        || cl == Short.class) {
                    constr = cl.getDeclaredConstructor(String.class);
                    if (type.isArray()) {
                        typeKind = WarbyTypeKind.WRAP_ARRAY;
                    } else {
                        typeKind = WarbyTypeKind.WRAP;
                    }
                } else if (cl == String.class) {
                    constr = null;
                    if (type.isArray()) {
                        typeKind = WarbyTypeKind.STRING_ARRY;
                    } else {
                        typeKind = WarbyTypeKind.STRING;
                    }
                } else if (cl == char.class || cl == Character.class) {
                    constr = null;
                    if (type.isArray()) {
                        typeKind = WarbyTypeKind.CHAR_ARRAY;
                    } else {
                        typeKind = WarbyTypeKind.CHAR;
                    }
                } else {
                    throw new WarbyException(MSG_UNSUPPORTED_PARAM_TYPE,
                            obj.getClass(), "%2$s", name, type);
                }
                isPrimitive = cl.isPrimitive();
                params = null;
            }
        } catch (NoSuchMethodException ex) {
            throw new WarbyException(MSG_WITHOUT_CONSTR,
                    obj.getClass(), "%2$s", name);
        }
    }

    /**
     * Создаёт параметр действия со способом отображения {@code ARGUMENT}.
     *
     * @param  obj
     *         Объект, который содержит действие.
     * @param  name
     *         Имя парметра действия.
     * @param  type
     *         Тип данных параметра действия.
     * @param  isRequired
     *         Признак обязательности передачи параметра действию.
     * @param  isPojo
     *         Признак того, что параметр является POJO.
     * @return  Параметр действия.
     * @throws  WarbyException
     *          Если тип параметра не удовлетворяет
     *          {@link com.github.amsemy.warby.annotation.WrbParam допустимым
     *          требованиям}.
     */
    static WarbyActionParam newArgument(Object obj, String name, Class<?> type,
            boolean isRequired, boolean isPojo) throws WarbyException {
        return new WarbyActionParam(
                obj,
                name,
                type,
                isRequired,
                WarbyParamKind.ARGUMENT,
                null,
                null,
                isPojo);
    }

    /**
     * Создаёт параметр действия со способом отображения {@code FIELD}.
     *
     * @param  obj
     *         Объект, который содержит действие.
     * @param  name
     *         Имя парметра действия.
     * @param  type
     *         Тип данных параметра действия.
     * @param  isRequired
     *         Признак обязательности передачи параметра действию.
     * @param  isPojo
     *         Признак того, что параметр является POJO.
     * @param  field
     *         Ссылка на поле POJO-параметра.
     * @return  Параметр действия.
     * @throws  WarbyException
     *          Если тип параметра не удовлетворяет
     *          {@link com.github.amsemy.warby.annotation.WrbParam допустимым
     *          требованиям}.
     */
    static WarbyActionParam newField(Object obj, String name, Class<?> type,
            boolean isRequired, boolean isPojo, Field field) throws WarbyException {
        return new WarbyActionParam(
                obj,
                name,
                type,
                isRequired,
                WarbyParamKind.FIELD,
                field,
                null,
                isPojo);
    }

    /**
     * Создаёт параметр действия со способом отображения {@code SETTER}.
     *
     * @param  obj
     *         Объект, который содержит действие.
     * @param  name
     *         Имя парметра действия.
     * @param  type
     *         Тип данных параметра действия.
     * @param  isRequired
     *         Признак обязательности передачи параметра действию.
     * @param  isPojo
     *         Признак того, что параметр является POJO.
     * @param  setter
     *         Ссылка на setter-метод POJO-параметра.
     * @return  Параметр действия.
     * @throws  WarbyException
     *          Если тип параметра не удовлетворяет
     *          {@link com.github.amsemy.warby.annotation.WrbParam допустимым
     *          требованиям}.
     */
    static WarbyActionParam newSetter(Object obj, String name, Class<?> type,
            boolean isRequired, boolean isPojo, Method setter) throws WarbyException {
        return new WarbyActionParam(
                obj,
                name,
                type,
                isRequired,
                WarbyParamKind.SETTER,
                null,
                setter,
                isPojo);
    }

}


text:
define(
   ({
    instruction: "Définissez le contenu qui s\'affiche à l\'écran de présentation de votre application. L\'écran de présentation apparaît avant le chargement de l\'application. ",
    defaultContent: "Ajoutez du texte, des liens et des petits graphiques ici.",
    requireConfirm: "Demander confirmation avant de poursuivre",
    noRequireConfirm: "Ne pas demander confirmation avant de poursuivre",
    optionText: "Fournissez l\'option permettant de réafficher ou non l\'écran de démarrage.",
    confirmLabel: "Textes de confirmation : ",
    defaultConfirmText: "J'accepte les conditions d'utilisation ci-dessus",
    confirmOption: "Toujours afficher cet écran de présentation à chaque lancement de l\'application",
    backgroundColor: "Couleur d\'arrière-plan"
  })
);