text:
var _cloneRegExp = /*#__PURE__*/require('./internal/_cloneRegExp');

var _curry2 = /*#__PURE__*/require('./internal/_curry2');

var _isRegExp = /*#__PURE__*/require('./internal/_isRegExp');

var toString = /*#__PURE__*/require('./toString');

/**
 * Determines whether a given string matches a given regular expression.
 *
 * @func
 * @memberOf R
 * @since v0.12.0
 * @category String
 * @sig RegExp -> String -> Boolean
 * @param {RegExp} pattern
 * @param {String} str
 * @return {Boolean}
 * @see R.match
 * @example
 *
 *      R.test(/^x/, 'xyz'); //=> true
 *      R.test(/^y/, 'xyz'); //=> false
 */

var test = /*#__PURE__*/_curry2(function test(pattern, str) {
  if (!_isRegExp(pattern)) {
    throw new TypeError(''test' requires a value of type RegExp as its first argument; received ' + toString(pattern));
  }
  return _cloneRegExp(pattern).test(str);
});
module.exports = test;


text:
using Helium::Chemist::Molecule;
using namespace boost::python;

bool Smarts_init_1(Helium::Smarts &self, const std::string &smarts)
{
  return self.init(smarts);
}

bool Smarts_init_2(Helium::Smarts &self, const std::string &smarts, int mode)
{
  return self.init(smarts, mode);
}

bool findMapping_1(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    Helium::NoMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, rings, mapping, uniqueComponents); }

bool findMapping_2(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    Helium::CountMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, rings, mapping, uniqueComponents); }

bool findMapping_3(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    Helium::SingleMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, rings, mapping, uniqueComponents); }

bool findMapping_4(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    Helium::MappingList &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, rings, mapping, uniqueComponents); }

BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_1, findMapping_1, 4, 5)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_2, findMapping_2, 4, 5)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_3, findMapping_3, 4, 5)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_4, findMapping_4, 4, 5)

bool findMapping_5(Helium::Smarts &smarts, const Molecule &mol,
    Helium::NoMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, mapping, uniqueComponents); }

bool findMapping_6(Helium::Smarts &smarts, const Molecule &mol,
    Helium::CountMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, mapping, uniqueComponents); }

bool findMapping_7(Helium::Smarts &smarts, const Molecule &mol,
    Helium::SingleMapping &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, mapping, uniqueComponents); }

bool findMapping_8(Helium::Smarts &smarts, const Molecule &mol,
    Helium::MappingList &mapping, bool uniqueComponents = true)
{  return smarts.findMapping(mol, mapping, uniqueComponents); }

BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_5, findMapping_5, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_6, findMapping_6, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_7, findMapping_7, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(findMapping_overloads_8, findMapping_8, 3, 4)

bool find_1(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    bool uniqueComponents = true)
{  return smarts.find(mol, rings, uniqueComponents); }

bool find_2(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    bool uniqueComponents = true)
{  return smarts.find(mol, rings, uniqueComponents); }

bool find_3(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    bool uniqueComponents = true)
{  return smarts.find(mol, rings, uniqueComponents); }

bool find_4(Helium::Smarts &smarts, const Molecule &mol, const Helium::RingSet<Molecule> &rings,
    bool uniqueComponents = true)
{  return smarts.find(mol, rings, uniqueComponents); }

BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_1, find_1, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_2, find_2, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_3, find_3, 3, 4)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_4, find_4, 3, 4)

bool find_5(Helium::Smarts &smarts, const Molecule &mol,
    bool uniqueComponents = true)
{  return smarts.find(mol, uniqueComponents); }

bool find_6(Helium::Smarts &smarts, const Molecule &mol,
    bool uniqueComponents = true)
{  return smarts.find(mol, uniqueComponents); }

bool find_7(Helium::Smarts &smarts, const Molecule &mol,
    bool uniqueComponents = true)
{  return smarts.find(mol, uniqueComponents); }

bool find_8(Helium::Smarts &smarts, const Molecule &mol,
    bool uniqueComponents = true)
{  return smarts.find(mol, uniqueComponents); }

BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_5, find_5, 2, 3)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_6, find_6, 2, 3)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_7, find_7, 2, 3)
BOOST_PYTHON_FUNCTION_OVERLOADS(find_overloads_8, find_8, 2, 3)

DATA_MEMBER_TO_FUNCTION(Helium::SingleMapping, std::vector<unsigned int>, map)
DATA_MEMBER_TO_FUNCTION(Helium::MappingList, std::vector<std::vector<unsigned int> >, maps)

void export_smarts()
{

  class_<Helium::NoMapping>("NoMapping")
    .def_readonly("match", &Helium::NoMapping::match)
    ;

  class_<Helium::CountMapping>("CountMapping")
    .def_readonly("count", &Helium::CountMapping::count)
    ;

  class_<Helium::SingleMapping>("SingleMapping")
    .add_property("map", make_function(&map, return_value_policy<copy_const_reference>()))
    ;

  class_<Helium::MappingList>("MappingList")
    .add_property("maps", make_function(&maps, return_value_policy<copy_const_reference>()))
    ;

  class_<Helium::Smarts>("Smarts")
    .def("init", &Smarts_init_1)
    .def("init", &Smarts_init_2)
    .def("error", &Helium::Smarts::error, return_internal_reference<>())
    .def("requiresRingSet", &Helium::Smarts::requiresRingSet)
    .def("requiresCyclicity", &Helium::Smarts::requiresCyclicity)
    .def("requiresExplicitHydrogens", &Helium::Smarts::requiresExplicitHydrogens)
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, Helium::NoMapping&, bool)) 0,
        findMapping_overloads_1())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, Helium::CountMapping&, bool)) 0,
        findMapping_overloads_2())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, Helium::SingleMapping&, bool)) 0,
        findMapping_overloads_3())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, Helium::MappingList&, bool)) 0,
        findMapping_overloads_4())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, Helium::NoMapping&, bool)) 0,
        findMapping_overloads_5())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, Helium::CountMapping&, bool)) 0,
        findMapping_overloads_6())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, Helium::SingleMapping&, bool)) 0,
        findMapping_overloads_7())
    .def("findMapping", (bool(*)(Helium::Smarts&, const Molecule&, Helium::MappingList&, bool)) 0,
        findMapping_overloads_8())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, bool)) 0,
        find_overloads_1())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, bool)) 0,
        find_overloads_2())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, bool)) 0,
        find_overloads_3())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, const Helium::RingSet<Molecule>&, bool)) 0,
        find_overloads_4())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, bool)) 0,
        find_overloads_5())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, bool)) 0,
        find_overloads_6())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, bool)) 0,
        find_overloads_7())
    .def("find", (bool(*)(Helium::Smarts&, const Molecule&, bool)) 0,
        find_overloads_8())
    ;

}

redpajama_set_name: RedPajamaGithub


text:
package com.hospital.fase.prog3.Model;

public class Paciente {

	private int prontuario;
	private String nomePaciente;
	private String nomePai;
	private String nomeMae;
	private String dtNascimento;
	private String rg;
	private String cpf;
	private String cns;
	private String tipoAtendimento;
	private String telefoneFixo;
	private String telefoneCel;

	public int getProntuario() {
		return prontuario;
	}
	public void setProntuario(int prontuario) {
		this.prontuario = prontuario;
	}
	public String getNomePaciente() {
		return nomePaciente;
	}
	public void setNomePaciente(String nomePaciente) {
		this.nomePaciente = nomePaciente;
	}
	public String getNomePai() {
		return nomePai;
	}
	public void setNomePai(String nomePai) {
		this.nomePai = nomePai;
	}
	public String getNomeMae() {
		return nomeMae;
	}
	public void setNomeMae(String nomeMae) {
		this.nomeMae = nomeMae;
	}
	public String getDtNascimento() {
		return dtNascimento;
	}
	public void setDtNascimento(String dtNascimento) {
		this.dtNascimento = dtNascimento;
	}
	public String getRg() {
		return rg;
	}
	public void setRg(String rg) {
		this.rg = rg;
	}
	public String getCpf() {
		return cpf;
	}
	public void setCpf(String cpf) {
		this.cpf = cpf;
	}
	public String getCns() {
		return cns;
	}
	public void setCns(String cns) {
		this.cns = cns;
	}
	public String getTipoAtendimento() {
		return tipoAtendimento;
	}
	public void setTipoAtendimento(String tipoAtendimento) {
		this.tipoAtendimento = tipoAtendimento;
	}
	public String getTelefoneFixo() {
		return telefoneFixo;
	}
	public void setTelefoneFixo(String telefoneFixo) {
		this.telefoneFixo = telefoneFixo;
	}
	public String getTelefoneCel() {
		return telefoneCel;
	}
	public void setTelefoneCel(String telefoneCel) {
		this.telefoneCel = telefoneCel;
	}

}


text:
|LF_STANDARD|
|LF_TICKET|
|?TREE=» `LANG_MESS_SYS` » <a class=tree href="/CMD_TICKET?action=view&number=`number`&type=ticket">`LANG_VIEW` `type` `number` » <a class=tree href="/HTM_TICKET_REPLY?number=`number`&action=`action`&subject=`subject`&user=`user`&priority=`priority`">`LANG_REPLY_TO`|
|?HELP_SECTION=`USER_HELPER`/gettingstarted.html#ticket|

|HTM_USER_TOP|

|LANG_ADD_REPLY|

			<form name=info action="CMD_TICKET" method="post">
				<input type=hidden name=action value="|action|">
				<input type=hidden name=type value="reply">
				<input type=hidden name=number value="|number|">
				<input type=hidden name=user value="|user|">
				<input type=hidden name=subject value="|subject|">
				<input type=hidden name=priority value="|priority|">

|LANG_SUBJECT|	|subject|

|LANG_MESSAGE|	<textarea name=message rows=16 cols=65></textarea>

				<input type=submit name=submit value="|LANG_SAVE|">

			</form>

|HTM_USER_BOTTOM|


text:
<?xml version="1.0" encoding="utf-8"?>
<View xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="@dimen/dp_10"
    android:background="@color/color_fafafa"
    android:orientation="vertical">

</View>


text:
/**
 * @Author: Amir Ahmetovic <choxnox>
 * @License: MIT
 */

var app = require("../index");

var qs = require("querystring");
var _ = require("lodash");

exports.getUrl = function(routeName, params, fullUrl) {
    var route = app.Router.getRoute(routeName);

    if (!_.isObject(params))
        params = {};

    if (!route)
        throw "There is no route named \"" + routeName + "\"";
    else
    {
        route = route.route;

        var regex = /(:[a-zA-Z]+)/g;
        var routeParams = _(route.match(regex))
            .map(function(param) {
                return param.replace(":", "")
            })
            .zipObject([])
            .mapValues(function(value, key) {
                return (params[key] ? params[key] : "");
            })
            .value()
        ;

        _.each(routeParams, function(value, key) {
            route = route.replace(":" + key, value);
        });

        route = route.replace("?", "", "g");
        route = route.replace(/ *\([^)]*\) */g, "");

        // remove trailing slash
        if (route.length > 1 && route.charAt(route.length - 1) == "/")
            route = route.substr(0, route.length - 1);

        var routeQuery = _.pick(params, _.difference(_.keys(params), _.keys(routeParams)));

        if (_.size(routeQuery))
            route += "?" + qs.stringify(routeQuery);

        if (fullUrl)
            route = app.getOptions()["baseDomain"] + route;
    }

    return route;
}


text:
#pragma once
#include <aws/codecommit/CodeCommit_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/codecommit/model/FileModeTypeEnum.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace CodeCommit
{
namespace Model
{

  /**
   *
Returns information about a file in a repository.

See Also:

   * AWS
   * API Reference

   */
  class AWS_CODECOMMIT_API File
  {
  public:
    File();
    File(Aws::Utils::Json::JsonView jsonValue);
    File& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     *
The blob ID that contains the file information.

     */
    inline const Aws::String& GetBlobId() const{ return m_blobId; }

    /**
     *
The blob ID that contains the file information.

     */
    inline bool BlobIdHasBeenSet() const { return m_blobIdHasBeenSet; }

    /**
     *
The blob ID that contains the file information.

     */
    inline void SetBlobId(const Aws::String& value) { m_blobIdHasBeenSet = true; m_blobId = value; }

    /**
     *
The blob ID that contains the file information.

     */
    inline void SetBlobId(Aws::String&& value) { m_blobIdHasBeenSet = true; m_blobId = std::move(value); }

    /**
     *
The blob ID that contains the file information.

     */
    inline void SetBlobId(const char* value) { m_blobIdHasBeenSet = true; m_blobId.assign(value); }

    /**
     *
The blob ID that contains the file information.

     */
    inline File& WithBlobId(const Aws::String& value) { SetBlobId(value); return *this;}

    /**
     *
The blob ID that contains the file information.

     */
    inline File& WithBlobId(Aws::String&& value) { SetBlobId(std::move(value)); return *this;}

    /**
     *
The blob ID that contains the file information.

     */
    inline File& WithBlobId(const char* value) { SetBlobId(value); return *this;}

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline const Aws::String& GetAbsolutePath() const{ return m_absolutePath; }

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline bool AbsolutePathHasBeenSet() const { return m_absolutePathHasBeenSet; }

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline void SetAbsolutePath(const Aws::String& value) { m_absolutePathHasBeenSet = true; m_absolutePath = value; }

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline void SetAbsolutePath(Aws::String&& value) { m_absolutePathHasBeenSet = true; m_absolutePath = std::move(value); }

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline void SetAbsolutePath(const char* value) { m_absolutePathHasBeenSet = true; m_absolutePath.assign(value); }

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline File& WithAbsolutePath(const Aws::String& value) { SetAbsolutePath(value); return *this;}

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline File& WithAbsolutePath(Aws::String&& value) { SetAbsolutePath(std::move(value)); return *this;}

    /**
     *
The fully qualified path to the file in the repository.

     */
    inline File& WithAbsolutePath(const char* value) { SetAbsolutePath(value); return *this;}

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline const Aws::String& GetRelativePath() const{ return m_relativePath; }

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline bool RelativePathHasBeenSet() const { return m_relativePathHasBeenSet; }

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline void SetRelativePath(const Aws::String& value) { m_relativePathHasBeenSet = true; m_relativePath = value; }

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline void SetRelativePath(Aws::String&& value) { m_relativePathHasBeenSet = true; m_relativePath = std::move(value); }

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline void SetRelativePath(const char* value) { m_relativePathHasBeenSet = true; m_relativePath.assign(value); }

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline File& WithRelativePath(const Aws::String& value) { SetRelativePath(value); return *this;}

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline File& WithRelativePath(Aws::String&& value) { SetRelativePath(std::move(value)); return *this;}

    /**
     *
The relative path of the file from the folder where the query originated.

     */
    inline File& WithRelativePath(const char* value) { SetRelativePath(value); return *this;}

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline const FileModeTypeEnum& GetFileMode() const{ return m_fileMode; }

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline bool FileModeHasBeenSet() const { return m_fileModeHasBeenSet; }

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline void SetFileMode(const FileModeTypeEnum& value) { m_fileModeHasBeenSet = true; m_fileMode = value; }

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline void SetFileMode(FileModeTypeEnum&& value) { m_fileModeHasBeenSet = true; m_fileMode = std::move(value); }

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline File& WithFileMode(const FileModeTypeEnum& value) { SetFileMode(value); return *this;}

    /**
     *
The extrapolated file mode permissions for the file. Valid values include
     * EXECUTABLE and NORMAL.

     */
    inline File& WithFileMode(FileModeTypeEnum&& value) { SetFileMode(std::move(value)); return *this;}

  private:

    Aws::String m_blobId;
    bool m_blobIdHasBeenSet = false;

    Aws::String m_absolutePath;
    bool m_absolutePathHasBeenSet = false;

    Aws::String m_relativePath;
    bool m_relativePathHasBeenSet = false;

    FileModeTypeEnum m_fileMode;
    bool m_fileModeHasBeenSet = false;
  };

} // namespace Model
} // namespace CodeCommit
} // namespace Aws


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

    <string name="app_name">MeetUp</string>
    <string name="action_settings">Settings</string>
    <string name="hello_world">Hello world!</string>
    <string name="title_activity_timeline">Timeline</string>
    <string name="title_section1">Section 1</string>
    <string name="title_section2">Section 2</string>
    <string name="title_section3">Section 3</string>
    <string name="title_activity_create_event">Create event</string>
    <string name="title_activity_select_date">SelectDate</string>
    <string name="back_btn">戻る</string>
    <string name="save_btn">保存</string>
    <string name="title_activity_select_time">SelectTimeActivity</string>
    <string name="title_activity_select_contacts">SelectContactsActivity</string>
    <string name="title_activity_show_event">ShowEventActivity</string>
    <string name="refresh">更新</string>

</resources>


text:
class User < ActiveRecord::Base

  attr_accessor :groups, :applications

  validates :login, :presence => true

  record_timestamps = false

end


text:
<!DOCTYPE html>

	<title>	all classes	</title>

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

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

<link href='https://fonts.googleapis.com/css?family=Ubuntu:400,300,300italic,400italic,700,700italic|Ubuntu+Mono' rel='stylesheet' type='text/css' />

all classes

				ANTJUnitReporter

				Assertion

				BaseRunner

				BaseSpec

				BDDRunner

				CodexWikiReporter

				ConsoleReporter

				DirectoryTestSuite

				DocReporter

				DotReporter

				Expectation

				IReporter

				IRunner

				JSONReporter

				JUnitReporter

				MinReporter

				MixerUtil

				MockBox

				MockGenerator

				RawReporter

				Results

				Results

				SimpleReporter

				Stub

				TapReporter

				TestBox

				TestCase

				TestResult

				TestSuite

				TextReporter

				UnitRunner

				Util

				XMLConverter

				XMLReporter


text:
package eu.ydp.empiria.player.client.rebind;

public interface SimpleFactory {
    SimpleInject getSimpleInject();

    SimpleInject getSimpleInject(String module);
}


text:
<?php

if($common){
?>

                <a href="<?php echo base_url(); ?>schoolsession/session_list"
                   data-url="<?php echo base_url(); ?>schoolsession/session_list" data-toggle="tab"
                   aria-expanded="false">
                    Session Setup

                <a href="<?php echo base_url(); ?>schoolsection/section_list"
                   data-url="<?php echo base_url(); ?>schoolsection/section_list" data-toggle="tab"
                   aria-expanded="false">
                    Section Setup

                <a href="<?php echo base_url(); ?>room/room_list"
                   data-url="<?php echo base_url(); ?>room/room_list" data-toggle="tab" aria-expanded="false">
                    Room Setup

                <a href="<?php echo base_url(); ?>classes/classes_list"
                   data-url="<?php echo base_url(); ?>classes/classes_list" data-toggle="tab" aria-expanded="false">
                    Class Setup

                <a href="<?php echo base_url(); ?>times/times_list"
                   data-url="<?php echo base_url(); ?>times/times_list" data-toggle="tab" aria-expanded="false">
                    Times Setup

                <a href="<?php echo base_url(); ?>schedule/schedule_list"
                   data-url="<?php echo base_url(); ?>schedule/schedule_list" data-toggle="tab" aria-expanded="false">
                    Schedule Setup

                <a href="<?php echo base_url(); ?>course/course_list"
                   data-url="<?php echo base_url(); ?>course/course_list" data-toggle="tab" aria-expanded="false">
                    Subject Setup

Loading...

<?php
    }else{

?>

                        Please setup common information first, will you use this page!

<?php

}

?>


text:
#ifndef _IRTKGRADIENTDESCENT_H
#define _IRTKGRADIENTDESCENT_H

#include <irtkLocalOptimizer.h>
#include <irtkLineSearch.h>
#include <irtkEventDelegate.h>

/**
 * Minimizes objective function using gradient descent
 */
class irtkGradientDescent : public irtkLocalOptimizer
{
  irtkOptimizerMacro(irtkGradientDescent, GradientDescent);

  // ---------------------------------------------------------------------------
  // Attributes

  /// Maximum number of gradient descent steps
  irtkPublicAttributeMacro(int, NumberOfSteps);

  /// Maximum number of restarts after upgrade of energy function
  irtkPublicAttributeMacro(int, NumberOfRestarts);

  /// Maximum streak of unsuccessful restarts without improvement
  irtkPublicAttributeMacro(int, NumberOfFailedRestarts);

  /// Line search strategy
  irtkPublicAttributeMacro(irtkLineSearchStrategy, LineSearchStrategy);

  /// (Possible) Line search parameter
  irtkAttributeMacro(irtkParameterList, LineSearchParameter);

  /// Line search optimization method
  irtkReadOnlyAggregateMacro(irtkLineSearch, LineSearch);

  /// Whether line search object is owned by this optimizer
  irtkAttributeMacro(bool, LineSearchOwner);

  /// Forwards line search event messages to observers of optimization
  irtkEventDelegate _EventDelegate;

protected:

  /// Allocated memory for line search direction
  irtkComponentMacro(double, Gradient);

  /// Whether to allow function parameter sign to change
  ///
  /// If \c false for a particular function parameter, the line search sets
  /// the function parameter to zero whenever the sign of the parameter would
  /// change when taking a full step along the scaled gradient direction.
  irtkComponentMacro(bool, AllowSignChange);

  // ---------------------------------------------------------------------------
  // Construction/Destruction
public:

  /// Constructor
  irtkGradientDescent(irtkObjectiveFunction * = NULL);

  /// Copy constructor
  irtkGradientDescent(const irtkGradientDescent &);

  /// Assignment operator
  irtkGradientDescent &operator =(const irtkGradientDescent &);

  /// Destructor
  virtual ~irtkGradientDescent();

  // Import overloads from base class
  using irtkLocalOptimizer::Function;

  /// Set objective function
  virtual void Function(irtkObjectiveFunction *);

  /// Set line search object
  virtual void LineSearch(irtkLineSearch *, bool = false);

  // ---------------------------------------------------------------------------
  // Parameters
  using irtkLocalOptimizer::Parameter;

  /// Set parameter value from string
  virtual bool Set(const char *, const char *);

  /// Get parameters as key/value as string map
  virtual irtkParameterList Parameter() const;

  // ---------------------------------------------------------------------------
  // Execution

  /// Initialize gradient descent
  ///
  /// This member funtion is implicitly called by Run. It can, however, be
  /// called prior to Run explicitly in order to be able to set up the line
  /// search instance. Otherwise, use the generic Set member function to
  /// change the line search parameters and simply have Run call Initialize.
  virtual void Initialize();

  /// Optimize objective function using gradient descent
  virtual double Run();

protected:

  /// Finalize gradient descent
  virtual void Finalize();

  /// Compute descent direction and corresponding step length unit
  virtual double Gradient(double *, double = .0, bool * = NULL);

};

////////////////////////////////////////////////////////////////////////////////
// Inline definitions
////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
inline double irtkGradientDescent::Gradient(double *gradient, double step, bool *sgn_chg)
{
         Function()->Gradient    (gradient, step, sgn_chg);
  return Function()->GradientNorm(gradient);
}

#endif


text:
const databaseName = 'calendar';

module.exports = {
  development: {
    client: 'postgresql',
    connection: `postgres://localhost:5432/${databaseName}`,
    migrations: {
      directory: __dirname + '/src/server/db/migrations'
    },
    seeds: {
      directory: __dirname + '/src/server/db/seeds'
    }
  },
  test: {
    client: 'postgresql',
    connection: `postgres://localhost:5432/${databaseName}_test`,
    migrations: {
      directory: __dirname + '/src/server/db/migrations'
    },
    seeds: {
      directory: __dirname + '/src/server/db/seeds'
    }
  },
  production: {
    client: 'postgresql',
    connection: {
      database: 'postgresql-crystalline-13985',
      user:     'phil',
      password: 'password'
    }
  }
};


text:
/*
 * ModelShowTable.scala
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package pt.cnbc.wikimodels.client.snippet

import scala.xml.NodeSeq
import net.liftmodules.widgets.tablesorter.TableSorter

class ModelShowTable {
    def render(xhtml: NodeSeq): NodeSeq = TableSorter("table-id")
}


text:
package org.hl7.fhir.dstu3.model.codesystems;

// Generated on Tue, Dec 6, 2016 09:42-0500 for FHIR v1.8.0

import org.hl7.fhir.exceptions.FHIRException;

public enum UnknownContentCode {

        /**
         * The application does not accept either unknown elements or extensions.
         */
        NO,
        /**
         * The application accepts unknown extensions, but not unknown elements.
         */
        EXTENSIONS,
        /**
         * The application accepts unknown elements, but not unknown extensions.
         */
        ELEMENTS,
        /**
         * The application accepts unknown elements and extensions.
         */
        BOTH,
        /**
         * added to help the parsers
         */
        NULL;
        public static UnknownContentCode fromCode(String codeString) throws FHIRException {
            if (codeString == null || "".equals(codeString))
                return null;
        if ("no".equals(codeString))
          return NO;
        if ("extensions".equals(codeString))
          return EXTENSIONS;
        if ("elements".equals(codeString))
          return ELEMENTS;
        if ("both".equals(codeString))
          return BOTH;
        throw new FHIRException("Unknown UnknownContentCode code '"+codeString+"'");
        }
        public String toCode() {
          switch (this) {
            case NO: return "no";
            case EXTENSIONS: return "extensions";
            case ELEMENTS: return "elements";
            case BOTH: return "both";
            default: return "?";
          }
        }
        public String getSystem() {
          return "http://hl7.org/fhir/unknown-content-code";
        }
        public String getDefinition() {
          switch (this) {
            case NO: return "The application does not accept either unknown elements or extensions.";
            case EXTENSIONS: return "The application accepts unknown extensions, but not unknown elements.";
            case ELEMENTS: return "The application accepts unknown elements, but not unknown extensions.";
            case BOTH: return "The application accepts unknown elements and extensions.";
            default: return "?";
          }
        }
        public String getDisplay() {
          switch (this) {
            case NO: return "Neither Elements or Extensions";
            case EXTENSIONS: return "Unknown Extensions";
            case ELEMENTS: return "Unknown Elements";
            case BOTH: return "Unknown Elements and Extensions";
            default: return "?";
          }
    }

}


text:
require 'spec_helper'

describe AwsSnsManager do
  describe '.config' do
    it 'only uses the model' do
      expect(AwsSnsManager::Config.model).to eq('PushEndpoint')
      AwsSnsManager.config do |config|
        config.model = 'UserDefine'
      end
      expect(AwsSnsManager::Config.model).to eq('UserDefine')
    end
  end
end


text:
package mediachooser.fragment;

import android.content.Intent;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.MediaStore;
import android.provider.MediaStore.Images.ImageColumns;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.GridView;
import android.widget.Toast;
import com.synconset.FakeR;
import com.synconset.MultiImageChooserActivity;
import mediachooser.BucketEntry;
import mediachooser.MediaChooserConstants;
import mediachooser.activity.HomeFragmentActivity;
import mediachooser.adapter.BucketGridAdapter;

import java.util.ArrayList;

public class BucketImageFragment extends Fragment{

	// The indices should match the following projections.
	private final int INDEX_BUCKET_ID     = 0;
	private final int INDEX_BUCKET_NAME   = 1;
	private final int INDEX_BUCKET_URL    = 2;

	private static final String[] PROJECTION_BUCKET = {
		ImageColumns.BUCKET_ID,
		ImageColumns.BUCKET_DISPLAY_NAME,
		ImageColumns.DATA};

	private View mView;
	private GridView mGridView;
	private BucketGridAdapter mBucketAdapter;

	private Cursor mCursor;

	public BucketImageFragment(){
		setRetainInstance(true);
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState) {
		if(mView == null){
			mView     = inflater.inflate(getRLayoutId("view_grid_layout_media_chooser"), container, false);
			mGridView = (GridView)mView.findViewById(getRIntId("gridViewFromMediaChooser"));
			init();
		}else{
			((ViewGroup) mView.getParent()).removeView(mView);
			if(mBucketAdapter == null){
				Toast.makeText(getActivity(), getActivity().getString(getRStringId("no_media_file_available")), Toast.LENGTH_SHORT).show();
			}
		}
		return mView;
	}

	private void init() {
		Intent intent = getActivity().getIntent();
		final int maxImages = intent.getIntExtra(MultiImageChooserActivity.MAX_IMAGES_KEY, MultiImageChooserActivity.NOLIMIT);
		final int desiredWidth = intent.getIntExtra(MultiImageChooserActivity.WIDTH_KEY, 0);
		final int desiredHeight = intent.getIntExtra(MultiImageChooserActivity.HEIGHT_KEY, 0);
		final int quality = intent.getIntExtra(MultiImageChooserActivity.QUALITY_KEY, 0);
		final int thumbSize = intent.getIntExtra(MultiImageChooserActivity.THUMB_SIZE_KEY, 0);

		final String orderBy = MediaStore.Images.Media.DATE_TAKEN;
		mCursor = getActivity().getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, PROJECTION_BUCKET, null, null, orderBy + " DESC");
		ArrayList<BucketEntry> buffer = new ArrayList<BucketEntry>();
		try {
			while (mCursor.moveToNext()) {
				BucketEntry entry = new BucketEntry(
						mCursor.getInt(INDEX_BUCKET_ID),
						mCursor.getString(INDEX_BUCKET_NAME), mCursor.getString(INDEX_BUCKET_URL));

				if (!buffer.contains(entry)) {
					buffer.add(entry);
				}
			}

			if (mCursor.getCount() > 0) {
				mBucketAdapter = new BucketGridAdapter(getActivity(), 0, buffer, false);
				mGridView.setAdapter(mBucketAdapter);
			} else {
				Toast.makeText(getActivity(), getActivity().getString(getRStringId("no_media_file_available")), Toast.LENGTH_SHORT).show();
			}

			mGridView.setOnItemClickListener(new OnItemClickListener() {

				@Override
				public void onItemClick(AdapterView<?> adapter, View view, int position, long id) {

					BucketEntry bucketEntry = (BucketEntry) adapter.getItemAtPosition(position);
					Intent selectImageIntent = new Intent(getActivity(), HomeFragmentActivity.class);
					selectImageIntent.putExtra("name", bucketEntry.bucketName);
					selectImageIntent.putExtra("image", true);
					selectImageIntent.putExtra("isFromBucket", true);

					selectImageIntent.putExtra(MultiImageChooserActivity.MAX_IMAGES_KEY, maxImages);
					selectImageIntent.putExtra(MultiImageChooserActivity.WIDTH_KEY, desiredWidth);
					selectImageIntent.putExtra(MultiImageChooserActivity.HEIGHT_KEY, desiredHeight);
					selectImageIntent.putExtra(MultiImageChooserActivity.QUALITY_KEY, quality);
					selectImageIntent.putExtra(MultiImageChooserActivity.THUMB_SIZE_KEY, thumbSize);

					getActivity().startActivityForResult(selectImageIntent, MediaChooserConstants.BUCKET_SELECT_IMAGE_CODE);
				}
			});

		} finally {
			mCursor.close();
		}
	}

	public BucketGridAdapter getAdapter() {
		return	mBucketAdapter;
	}

	public int getRStringId(String resourceId){
		return FakeR.getId(getActivity(), "string", resourceId);
	}

	public int getRIntId(String resourceId){
		return FakeR.getId(getActivity(), "id", resourceId);
	}

	public int getRColorId(String resourceId){
		return FakeR.getId(getActivity(), "color", resourceId);
	}

	public int getRDrawableId(String resourceId){
		return FakeR.getId(getActivity(), "drawable", resourceId);
	}
	public int getRLayoutId(String resourceId){
		return FakeR.getId(getActivity(), "layout", resourceId);
	}

}


text:
class RemoveImageUrlFromCampuses < ActiveRecord::Migration[4.2]
  def change
    remove_column :campuses, :image_url, :string
  end
end


text:
**No muss, no fuss**
he **stone-faced** to me
I **deftly** played Ross Loma against Index Ventures.
It's my **Mona Lisa**
That's **preposterous**
We're thrilled to be getting into Pied Piper right at this **inflection point**.
**click farm**
suddenly grew a thick, **girthy** **conscience** and fucked me with it.
you **caked my pants**
Even **a whiff of** fraud is a **mortal sin** for VCs.
I'll expect you **off the premises** by end of day
a firm **no-shop clause**
as a **contemptible** asshole, you were talking about Erlich?

## E 9
You and I have never really had much of a **rapport**, have we?
It... **wanting**
Gilfoyle, you **crack me up**
to do **outreach**, tutorials, user meetups, create a **guerrilla marketing** **campaign** that explains how cool the platform is
Your **tepid** response to our **intrepid** boss makes me ill.
I'm the **possum** to which I refer. Playing dead to **outwit** those who wish me harm, but it's time to end the **charade**.
are you **indisposed**?
we still have few weeks of **runway**
You **pulled** us **out** of a **nosedive**

## E 8
Monica, **throw me a bone** here.
It may appear he is losing in his race against his **nemesis**, the **insolent** and **cocksure** **hare**.
he plays **coy**
rumors spread like **light speed**
This is **thorny**
the same **onerous** terms you accepted when you took Russ Hanneman's money

## E 7

It's going to be **rad**
**Shuttering** a company in the tech world is almost a **rite of passage**, like **herpes simplex** one.
we only got 10 each, this could be **prickly**
sure, **knock yourself out**.
you're accusing me of **impropriety**?
We may have a healthy **brood** on our hands.
You're **flipping out**
I have an inbox full of **raves** here
I'd like to **vie** for a lesser **sentence** **if after** he makes full **restitution** he would write a very **convincing** public apology.
that's a **tough sell**
even for a **plaintiff** who's more, uh, **sympathetic**
I see two **able-bodied**, entitled young white men...
**dummy** out an email account in his name, sent a beta request to Hendricks, and then **voila**.
you're so **needy**
when we have a totally open and **hedonistic** relationship that allows for behavior like that. (She still lied to me)

## E 6

She is **magnificent**
she could be **hideous**
maybe now I'll **fan out** my xx, so to speak, and see what pretty **birdies** might share my nest.
what other company's secret did he **blab** to you?
The rest is **untoward**
Who was that gorgeous **gazelle** in the driveway?
you're the **dogface**
I'm **on the fence**

## E 5

You do tend to **babble** on when you're under pressure.
**shylock**
Laurie Bream is out there **gallivanting** around the Valley, interviewing every **dickhole** on Earth for my job.
Richard must not be perceived as being the most **expedient** candidate.
he's shown **mettle**.
I found my **retainer** in the school dumpster.
Did you tell them that my Fage's **off-limits**?

## E 4
This baby gonna **purr**
She has a **fiduciary** obligation as a member of the board
that's **factually** correct
**motion denied**
We will be **reconvening** tomorrow
fuck me **sideways**
she is **slandering** my tech

## E 3

She was pretty **adamant** that the whole box project here at Pied Piper was woefully misguided.
If I can control Laurie, do you really think I'd be looking out my office door at that **monstrosity**?
at this time we just have to **roll over** and do it.
we build a **skunk works**
If anyone **catched wind** of anything here, we're fucked.
This is it, **no turning back** now.
**shredder**

## E 2
the **flute**-playing guy
I don't know you guys realize it, it was a little **phallic**
the **conjoined** triangle of success?
I made some major **inroads** with **Hiroki**.
It kinda all **evens out**, right?
**get to know one another**
in every relationship, there are **ebbs and flows**.
don't **sneak up on** people like that, you **devious** little bastard
you four eyes **turd**
I stay here for a year, I pay no rent, you have no **recourse**

## E 1
You madam, are a **shrew** **of the first order**.
if I didn't vote to remove you, then Laurie would've **adjourned** the meeting, replace my seat on the board with someone else at Raviga
That's the **gutsiest** thing I've ever seen.
why should we give up our shares because he's too much of a **prima donna** to let someone experienced come in
You're the **belle of the ball**, and these are all your **swains**, hoping for a glimpse of ankle.
**phonograph**
I got to warn you though, it's pretty **rad**.
Your **pumpedness** makes me **pumped**.
We quit **out of solidarity** with Richard.
1,700 people **slated** for exiting.


text:
package com.fabway.smartquerybuilder.builders;

import com.fabway.smartquerybuilder.AbstractBuilder;

/**
 * Builds a statement using preconditions.
 */
public class StatementBuilder extends AbstractBuilder<StatementBuilder, StatementTemplate> {

    /**
     * Default constructor.
     */
    public StatementBuilder() {
        super();
    }

    /**
     * Creates a copy from the source.
     *
     * @param source
     */
    public StatementBuilder(StatementBuilder source) {
        super.setContext(source.getContext().copy());
        super.setTemplate(source.getTemplate().copy());
    }

    /**
     * Apply the method {@link StatementTemplate#put(String)}.
     *
     * @param text
     * @param conditions
     *            the precondition keys
     * @return this builder
     */
    public StatementBuilder put(String text, String... conditions) {
        if (getContext().results(conditions)) {
            getTemplate().put(text);
        }
        return this;
    }

    @Override
    public StatementBuilder copy() {
        return new StatementBuilder(this);
    }

    protected StatementBuilder builder() {
        return this;
    }

    @Override
    protected StatementTemplate createTemplate() {
        return new StatementTemplate();
    }

}


text:
import traceback
from django.http import JsonResponse
from django.forms.models import model_to_dict
from django.conf import settings
import api.models as mdl
from meta import get_schema_instance

import logging
import json
logger = logging.getLogger('django')

# Create your views here.

def db_map_view(request):
    """returns the dbmap loaded on cache"""

    try:
        result = list()
        for scm in mdl.Schema.objects.all():
            r = model_to_dict(scm)

            r['tables'] = list()
            for tbl in scm.table_set.all():
                t_props = dict()
                data = list()
                if len(tbl.tablefield_set.all()) > 0:
                    data = [model_to_dict(tf) for tf in tbl.tablefield_set
                            .all().order_by('-is_primary_key')]
                t_props["fields"] = data
                t = model_to_dict(tbl)
                t["props"] = t_props
                r['tables'].append(t)
            result.append(r)
        return JsonResponse(result, safe=False)
    except Exception as e:
        return JsonResponse({
            'success': False,
            'err': str(e),
            'errStack': traceback.format_exc()
        })

def table_info(request, name=None, get_table_size=False):
    """Return the metadata of the requested table"""

    try:
        if name is None:
            return JsonResponse({
                'success': False,
                'err': "Invalid table name"
            })

        t = mdl.Table.objects.filter(table_name=name)[0]

        if not t:
            return JsonResponse({'success': False, 'err': "Table not found"})

        t_props = dict()
        data = list()
        if len(t.tablefield_set.all()) > 0:
            data = [model_to_dict(tf) for tf in t.tablefield_set.all(
            ).order_by('-is_primary_key')]
        t_props["fields"] = data
        this_tbl = model_to_dict(t)
        this_tbl["props"] = t_props

        if get_table_size:
            schemas = getattr(settings, "META_DB_SCHEMAS", None)
            if not schemas:
                raise Exception('Schemas not configured')

            with get_schema_instance(schemas) as s:
                this_tbl["props"]["table_size"] = s.get_table_info(schemas[0], name).get_table_size(s)

        return JsonResponse(this_tbl, safe=False)
    except Exception as e:
        return JsonResponse({
            'success': False,
            'err': str(e),
            'errStack': traceback.format_exc()
        })

def rebuild_db_map(request):
    """Collect the information of the observed database"""

    CACHE = None
    try:
        schemas = getattr(settings, "META_DB_SCHEMAS", None)
        if not schemas:
            raise Exception('Schemas not configured')
        with get_schema_instance(schemas) as s:
            CACHE = s.tables

        mdl.Schema.objects.all().delete()
        log_d = dict()
        for scm in schemas:
            s = mdl.Schema.objects.create(schema_name=scm)

            for tbl in [CACHE[t] for t in CACHE if CACHE[t].db_schema == scm]:
                # I don't bother saving table disk usage in the DB because it changes so
                # often that almost every query on it would be outdated. Insted, in the
                # "/table_info" endpoint there is a parameter to return it
                t = mdl.Table.objects.create(schema=s, table_name=tbl.name)
                for clm in tbl.columns:
                    mdl.TableField.objects.create(
                        table=t,
                        field_name=clm,
                        inner_type=tbl.columns[clm].column_type,
                        allow_null=tbl.columns[clm].allow_null,
                        is_primary_key=clm in tbl.pk
                    )

        with open('dump.json', 'w') as f:
            f.write(json.dumps(log_d, indent=4))

        return JsonResponse({'success': True})
    except Exception as e:
        print(traceback.format_exc())
        return JsonResponse({
            'success': False,
            'errTrace': traceback.format_exc(),
            'err': str(e)
        })

def tables_with_pks(request):
    """Return a list of the tables with their respective PKs"""

    try:
        result = list()
        for scm in mdl.Schema.objects.all():
            for tbl in scm.table_set.all():
                t = {"Table Name": tbl.table_name}
                t["Primary Keys"] = ", ".join([
                    f.field_name
                    for f in
                    tbl.tablefield_set.filter(is_primary_key=True).all()
                ])

                result.append(t)
        return JsonResponse(result, safe=False)
    except Exception as e:
        return JsonResponse({
            'success': False,
            'err': str(e),
            'errTrace': traceback.format_exc()
        })


text:
.content {
  flex: 1;
  justify-content: center;
  align-items: center;
}


text:
<?php

namespace ec2m\ec2mBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

class Ec2mRegistrarType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $em = $GLOBALS['kernel']->getContainer()->GET('doctrine')->getEntityManager();
        $paises = $em->getRepository('ec2mBundle:Ec2mPais')->cadenaPaisesOrdenados();
        $builder
            ->add('nombre')
            ->add('razonSocial', 'text', array('required' => false))
            ->add('nif', 'text', array('required' => false))
            ->add('fechaAlta')
            ->add('telefono')
            ->add('movil')
            ->add('email')
            ->add('web', 'text', array('required' => false))
            ->add('usuario')
            ->add('clave', 'password')
            ->add('clave2', 'password')
            ->add('pais', 'choice', array('choices' => array($paises)))
            ->add('orden')
            ->add('nombredestinatario')
            ->add('direccion')
            ->add('cp')
            ->add('poblacion')
            ->add('provincia')
            ->add('paisdestinatario', 'choice', array('choices' => array($paises)))
            ->add('telefonodestinatario', 'text', array('required' => false))
            ->add('observaciones', 'textarea', array('required' => false))
        ;
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'ec2m\ec2mBundle\Entity\Ec2mRegistrar'
        ));
    }

    public function getName()
    {
        return 'ec2m_ec2mbundle_ec2mregistrartype';
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
    <selector xmlns:android="http://schemas.android.com/apk/res/android">
        <item android:drawable="@drawable/app_list_corner_round_bottom"
              android:state_pressed="true" />
              <item android:drawable="@drawable/settings_corner_bg" />
    </selector>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

    <title>{% block title %}{{ headers.title }}{% endblock %}</title>

    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
    <meta property="og:image" content="http://www.apache.org/images/asf_logo.gif" />

    <link rel="stylesheet" type="text/css" media="screen" href="http://www.apache.org/css/style.css">
    <link rel="stylesheet" type="text/css" media="screen" href="http://www.apache.org/css/code.css">

    {% if headers.atom %}
      <link rel="alternate" href="{{ headers.atom.url }}"
            type="application/atom+xml" title="{{ headers.atom.title }}" />
    {% endif %}

    {% if headers.base %}<base href="{{ headers.base }}" />{% endif %}
    {% if headers.notice %}{% endif %}

The Apache Software Foundation

{% block tagline %}{{ headers.title }}{% endblock %}

Foundation

Projects

People

Get Involved

Download

Support Apache

{{ breadcrumbs|safe }}

        <form name="search" id="search" action="http://www.google.com/search" method="get">
          <input value="*.apache.org" name="sitesearch" type="hidden"/>
          <input type="text" name="q" id="query">
          <input type="submit" id="submit" value="Search">
        </form>

      {% block content %}

{{ content|markdown }}

{% endblock %}

Copyright © 2011 The Apache Software Foundation, Licensed under the Apache License, Version 2.0.
Apache and the Apache feather logo are trademarks of The Apache Software Foundation.


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@color/tan_background"
    android:minHeight="@dimen/list_item_height"
    android:orientation="horizontal">

    <ImageView
        android:id="@+id/image"
        android:layout_width="@dimen/list_item_height"
        android:layout_height="@dimen/list_item_height"

        />

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

        <LinearLayout
            android:id="@+id/word_ll"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center_vertical"
            android:orientation="vertical"
            android:paddingLeft="16dp">

            <TextView
                android:id="@+id/miwok"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:textAppearance="?android:textAppearanceMedium"
                android:textColor="@android:color/white"
                android:textStyle="bold"
                tools:text="lutti" />

            <TextView
                android:id="@+id/english"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:textAppearance="?android:textAppearanceMedium"
                android:textColor="@android:color/white"
                tools:text="one" />
        </LinearLayout>

        <ImageView
            android:id="@+id/sound_icon"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true"
            android:layout_centerVertical="true"
            android:layout_marginRight="16dp"
            android:src="@drawable/sound"
            />
    </RelativeLayout>
</LinearLayout>


text:
// moment.js
// version : 1.7.0
// author : Tim Wood
// license : MIT
// momentjs.com

(function (Date, undefined) {

    /************************************
        Constants
    ************************************/

    var moment,
        VERSION = "1.7.0",
        round = Math.round, i,
        // internal storage for language config files
        languages = {},
        currentLanguage = 'en',

        // check for nodeJS
        hasModule = (typeof module !== 'undefined' && module.exports),

        // Parameters to check for on the lang config.  This list of properties
        // will be inherited from English if not provided in a language
        // definition.  monthsParse is also a lang config property, but it
        // cannot be inherited and as such cannot be enumerated here.
        langConfigProperties = 'months|monthsShort|weekdays|weekdaysShort|weekdaysMin|longDateFormat|calendar|relativeTime|ordinal|meridiem'.split('|'),

        // ASP.NET json date format regex
        aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,

        // format tokens
        formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|YYYY|YY|a|A|hh?|HH?|mm?|ss?|SS?S?|zz?|ZZ?)/g,
        localFormattingTokens = /(LT|LL?L?L?)/g,
        formattingRemoveEscapes = /(^\[)|(\\)|\]$/g,

        // parsing tokens
        parseMultipleFormatChunker = /([0-9a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)/gi,

        // parsing token regexes
        parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
        parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
        parseTokenThreeDigits = /\d{3}/, // 000 - 999
        parseTokenFourDigits = /\d{1,4}/, // 0 - 9999
        parseTokenWord = /[0-9a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+/i, // any word characters or numbers
        parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/i, // +00:00 -00:00 +0000 -0000 or Z
        parseTokenT = /T/i, // T (ISO seperator)

        // preliminary iso regex
        // 0000-00-00 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000
        isoRegex = /^\s*\d{4}-\d\d-\d\d(T(\d\d(:\d\d(:\d\d(\.\d\d?\d?)?)?)?)?([\+\-]\d\d:?\d\d)?)?/,
        isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',

        // iso time formats and regexes
        isoTimes = [
            ['HH:mm:ss.S', /T\d\d:\d\d:\d\d\.\d{1,3}/],
            ['HH:mm:ss', /T\d\d:\d\d:\d\d/],
            ['HH:mm', /T\d\d:\d\d/],
            ['HH', /T\d\d/]
        ],

        // timezone chunker "+10:00" > ["10", "00"] or "-1530" > ["-15", "30"]
        parseTimezoneChunker = /([\+\-]|\d\d)/gi,

        // getter and setter names
        proxyGettersAndSetters = 'Month|Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
        unitMillisecondFactors = {
            'Milliseconds' : 1,
            'Seconds' : 1e3,
            'Minutes' : 6e4,
            'Hours' : 36e5,
            'Days' : 864e5,
            'Months' : 2592e6,
            'Years' : 31536e6
        },

        // format function strings
        formatFunctions = {},

        /*
         * moment.fn.format uses new Function() to create an inlined formatting function.
         * Results are a 3x speed boost
         * http://jsperf.com/momentjs-cached-format-functions
         *
         * These strings are appended into a function using replaceFormatTokens and makeFormatFunction
         */
        formatFunctionStrings = {
            // a = placeholder
            // b = placeholder
            // t = the current moment being formatted
            // v = getValueAtKey function
            // o = language.ordinal function
            // p = leftZeroFill function
            // m = language.meridiem value or function
            M    : '(a=t.month()+1)',
            MMM  : 'v("monthsShort",t.month())',
            MMMM : 'v("months",t.month())',
            D    : '(a=t.date())',
            DDD  : '(a=new Date(t.year(),t.month(),t.date()),b=new Date(t.year(),0,1),a=~~(((a-b)/864e5)+1.5))',
            d    : '(a=t.day())',
            dd   : 'v("weekdaysMin",t.day())',
            ddd  : 'v("weekdaysShort",t.day())',
            dddd : 'v("weekdays",t.day())',
            w    : '(a=new Date(t.year(),t.month(),t.date()-t.day()+5),b=new Date(a.getFullYear(),0,4),a=~~((a-b)/864e5/7+1.5))',
            YY   : 'p(t.year()%100,2)',
            YYYY : 'p(t.year(),4)',
            a    : 'm(t.hours(),t.minutes(),!0)',
            A    : 'm(t.hours(),t.minutes(),!1)',
            H    : 't.hours()',
            h    : 't.hours()%12||12',
            m    : 't.minutes()',
            s    : 't.seconds()',
            S    : '~~(t.milliseconds()/100)',
            SS   : 'p(~~(t.milliseconds()/10),2)',
            SSS  : 'p(t.milliseconds(),3)',
            Z    : '((a=-t.zone())<0?((a=-a),"-"):"+")+p(~~(a/60),2)+":"+p(~~a%60,2)',
            ZZ   : '((a=-t.zone())<0?((a=-a),"-"):"+")+p(~~(10*a/6),4)'
        },

        ordinalizeTokens = 'DDD w M D d'.split(' '),
        paddedTokens = 'M D H h m s w'.split(' ');

    while (ordinalizeTokens.length) {
        i = ordinalizeTokens.pop();
        formatFunctionStrings[i + 'o'] = formatFunctionStrings[i] + '+o(a)';
    }
    while (paddedTokens.length) {
        i = paddedTokens.pop();
        formatFunctionStrings[i + i] = 'p(' + formatFunctionStrings[i] + ',2)';
    }
    formatFunctionStrings.DDDD = 'p(' + formatFunctionStrings.DDD + ',3)';

    /************************************
        Constructors
    ************************************/

    // Moment prototype object
    function Moment(date, isUTC, lang) {
        this._d = date;
        this._isUTC = !!isUTC;
        this._a = date._a || null;
        date._a = null;
        this._lang = lang || false;
    }

    // Duration Constructor
    function Duration(duration) {
        var data = this._data = {},
            years = duration.years || duration.y || 0,
            months = duration.months || duration.M || 0,
            weeks = duration.weeks || duration.w || 0,
            days = duration.days || duration.d || 0,
            hours = duration.hours || duration.h || 0,
            minutes = duration.minutes || duration.m || 0,
            seconds = duration.seconds || duration.s || 0,
            milliseconds = duration.milliseconds || duration.ms || 0;

        // representation for dateAddRemove
        this._milliseconds = milliseconds +
            seconds * 1e3 + // 1000
            minutes * 6e4 + // 1000 * 60
            hours * 36e5; // 1000 * 60 * 60
        // Because of dateAddRemove treats 24 hours as different from a
        // day when working around DST, we need to store them separately
        this._days = days +
            weeks * 7;
        // It is impossible translate months into days without knowing
        // which months you are are talking about, so we have to store
        // it separately.
        this._months = months +
            years * 12;

        // The following code bubbles up values, see the tests for
        // examples of what that means.
        data.milliseconds = milliseconds % 1000;
        seconds += absRound(milliseconds / 1000);

        data.seconds = seconds % 60;
        minutes += absRound(seconds / 60);

        data.minutes = minutes % 60;
        hours += absRound(minutes / 60);

        data.hours = hours % 24;
        days += absRound(hours / 24);

        days += weeks * 7;
        data.days = days % 30;

        months += absRound(days / 30);

        data.months = months % 12;
        years += absRound(months / 12);

        data.years = years;

        this._lang = false;
    }

    /************************************
        Helpers
    ************************************/

    function absRound(number) {
        if (number < 0) {
            return Math.ceil(number);
        } else {
            return Math.floor(number);
        }
    }

    // left zero fill a number
    // see http://jsperf.com/left-zero-filling for performance comparison
    function leftZeroFill(number, targetLength) {
        var output = number + '';
        while (output.length < targetLength) {
            output = '0' + output;
        }
        return output;
    }

    // helper function for _.addTime and _.subtractTime
    function addOrSubtractDurationFromMoment(mom, duration, isAdding) {
        var ms = duration._milliseconds,
            d = duration._days,
            M = duration._months,
            currentDate;

        if (ms) {
            mom._d.setTime(+mom + ms * isAdding);
        }
        if (d) {
            mom.date(mom.date() + d * isAdding);
        }
        if (M) {
            currentDate = mom.date();
            mom.date(1)
                .month(mom.month() + M * isAdding)
                .date(Math.min(currentDate, mom.daysInMonth()));
        }
    }

    // check if is an array
    function isArray(input) {
        return Object.prototype.toString.call(input) === '[object Array]';
    }

    // compare two arrays, return the number of differences
    function compareArrays(array1, array2) {
        var len = Math.min(array1.length, array2.length),
            lengthDiff = Math.abs(array1.length - array2.length),
            diffs = 0,
            i;
        for (i = 0; i < len; i++) {
            if (~~array1[i] !== ~~array2[i]) {
                diffs++;
            }
        }
        return diffs + lengthDiff;
    }

    // convert an array to a date.
    // the array should mirror the parameters below
    // note: all values past the year are optional and will default to the lowest possible value.
    // [year, month, day , hour, minute, second, millisecond]
    function dateFromArray(input, asUTC) {
        var i, date;
        for (i = 1; i < 7; i++) {
            input[i] = (input[i] == null) ? (i === 2 ? 1 : 0) : input[i];
        }
        // we store whether we used utc or not in the input array
        input[7] = asUTC;
        date = new Date(0);
        if (asUTC) {
            date.setUTCFullYear(input[0], input[1], input[2]);
            date.setUTCHours(input[3], input[4], input[5], input[6]);
        } else {
            date.setFullYear(input[0], input[1], input[2]);
            date.setHours(input[3], input[4], input[5], input[6]);
        }
        date._a = input;
        return date;
    }

    // Loads a language definition into the `languages` cache.  The function
    // takes a key and optionally values.  If not in the browser and no values
    // are provided, it will load the language file module.  As a convenience,
    // this function also returns the language values.
    function loadLang(key, values) {
        var i, m,
            parse = [];

        if (!values && hasModule) {
            values = require('./lang/' + key);
        }

        for (i = 0; i < langConfigProperties.length; i++) {
            // If a language definition does not provide a value, inherit
            // from English
            values[langConfigProperties[i]] = values[langConfigProperties[i]] ||
              languages.en[langConfigProperties[i]];
        }

        for (i = 0; i < 12; i++) {
            m = moment([2000, i]);
            parse[i] = new RegExp('^' + (values.months[i] || values.months(m, '')) +
                '|^' + (values.monthsShort[i] || values.monthsShort(m, '')).replace('.', ''), 'i');
        }
        values.monthsParse = values.monthsParse || parse;

        languages[key] = values;

        return values;
    }

    // Determines which language definition to use and returns it.
    //
    // With no parameters, it will return the global language.  If you
    // pass in a language key, such as 'en', it will return the
    // definition for 'en', so long as 'en' has already been loaded using
    // moment.lang.  If you pass in a moment or duration instance, it
    // will decide the language based on that, or default to the global
    // language.
    function getLangDefinition(m) {
        var langKey = (typeof m === 'string') && m ||
                      m && m._lang ||
                      null;

        return langKey ? (languages[langKey] || loadLang(langKey)) : moment;
    }

    /************************************
        Formatting
    ************************************/

    // helper for building inline formatting functions
    function replaceFormatTokens(token) {
        return formatFunctionStrings[token] ?
            ("'+(" + formatFunctionStrings[token] + ")+'") :
            token.replace(formattingRemoveEscapes, "").replace(/\\?'/g, "\\'");
    }

    // helper for recursing long date formatting tokens
    function replaceLongDateFormatTokens(input) {
        return getLangDefinition().longDateFormat[input] || input;
    }

    function makeFormatFunction(format) {
        var output = "var a,b;return '" +
            format.replace(formattingTokens, replaceFormatTokens) + "';",
            Fn = Function; // get around jshint
        // t = the current moment being formatted
        // v = getValueAtKey function
        // o = language.ordinal function
        // p = leftZeroFill function
        // m = language.meridiem value or function
        return new Fn('t', 'v', 'o', 'p', 'm', output);
    }

    function makeOrGetFormatFunction(format) {
        if (!formatFunctions[format]) {
            formatFunctions[format] = makeFormatFunction(format);
        }
        return formatFunctions[format];
    }

    // format date using native date object
    function formatMoment(m, format) {
        var lang = getLangDefinition(m);

        function getValueFromArray(key, index) {
            return lang[key].call ? lang[key](m, format) : lang[key][index];
        }

        while (localFormattingTokens.test(format)) {
            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
        }

        if (!formatFunctions[format]) {
            formatFunctions[format] = makeFormatFunction(format);
        }

        return formatFunctions[format](m, getValueFromArray, lang.ordinal, leftZeroFill, lang.meridiem);
    }

    /************************************
        Parsing
    ************************************/

    // get the regex to find the next token
    function getParseRegexForToken(token) {
        switch (token) {
        case 'DDDD':
            return parseTokenThreeDigits;
        case 'YYYY':
            return parseTokenFourDigits;
        case 'S':
        case 'SS':
        case 'SSS':
        case 'DDD':
            return parseTokenOneToThreeDigits;
        case 'MMM':
        case 'MMMM':
        case 'dd':
        case 'ddd':
        case 'dddd':
        case 'a':
        case 'A':
            return parseTokenWord;
        case 'Z':
        case 'ZZ':
            return parseTokenTimezone;
        case 'T':
            return parseTokenT;
        case 'MM':
        case 'DD':
        case 'YY':
        case 'HH':
        case 'hh':
        case 'mm':
        case 'ss':
        case 'M':
        case 'D':
        case 'd':
        case 'H':
        case 'h':
        case 'm':
        case 's':
            return parseTokenOneOrTwoDigits;
        default :
            return new RegExp(token.replace('\\', ''));
        }
    }

    // function to convert string input to date
    function addTimeToArrayFromToken(token, input, datePartArray, config) {
        var a;
        //console.log('addTime', format, input);
        switch (token) {
        // MONTH
        case 'M' : // fall through to MM
        case 'MM' :
            datePartArray[1] = (input == null) ? 0 : ~~input - 1;
            break;
        case 'MMM' : // fall through to MMMM
        case 'MMMM' :
            for (a = 0; a < 12; a++) {
                if (getLangDefinition().monthsParse[a].test(input)) {
                    datePartArray[1] = a;
                    break;
                }
            }
            break;
        // DAY OF MONTH
        case 'D' : // fall through to DDDD
        case 'DD' : // fall through to DDDD
        case 'DDD' : // fall through to DDDD
        case 'DDDD' :
            if (input != null) {
                datePartArray[2] = ~~input;
            }
            break;
        // YEAR
        case 'YY' :
            input = ~~input;
            datePartArray[0] = input + (input > 70 ? 1900 : 2000);
            break;
        case 'YYYY' :
            datePartArray[0] = ~~Math.abs(input);
            break;
        // AM / PM
        case 'a' : // fall through to A
        case 'A' :
            config.isPm = ((input + '').toLowerCase() === 'pm');
            break;
        // 24 HOUR
        case 'H' : // fall through to hh
        case 'HH' : // fall through to hh
        case 'h' : // fall through to hh
        case 'hh' :
            datePartArray[3] = ~~input;
            break;
        // MINUTE
        case 'm' : // fall through to mm
        case 'mm' :
            datePartArray[4] = ~~input;
            break;
        // SECOND
        case 's' : // fall through to ss
        case 'ss' :
            datePartArray[5] = ~~input;
            break;
        // MILLISECOND
        case 'S' :
        case 'SS' :
        case 'SSS' :
            datePartArray[6] = ~~ (('0.' + input) * 1000);
            break;
        // TIMEZONE
        case 'Z' : // fall through to ZZ
        case 'ZZ' :
            config.isUTC = true;
            a = (input + '').match(parseTimezoneChunker);
            if (a && a[1]) {
                config.tzh = ~~a[1];
            }
            if (a && a[2]) {
                config.tzm = ~~a[2];
            }
            // reverse offsets
            if (a && a[0] === '+') {
                config.tzh = -config.tzh;
                config.tzm = -config.tzm;
            }
            break;
        }
    }

    // date from string and format string
    function makeDateFromStringAndFormat(string, format) {
        var datePartArray = [0, 0, 1, 0, 0, 0, 0],
            config = {
                tzh : 0, // timezone hour offset
                tzm : 0  // timezone minute offset
            },
            tokens = format.match(formattingTokens),
            i, parsedInput;

        for (i = 0; i < tokens.length; i++) {
            parsedInput = (getParseRegexForToken(tokens[i]).exec(string) || [])[0];
            string = string.replace(getParseRegexForToken(tokens[i]), '');
            addTimeToArrayFromToken(tokens[i], parsedInput, datePartArray, config);
        }
        // handle am pm
        if (config.isPm && datePartArray[3] < 12) {
            datePartArray[3] += 12;
        }
        // if is 12 am, change hours to 0
        if (config.isPm === false && datePartArray[3] === 12) {
            datePartArray[3] = 0;
        }
        // handle timezone
        datePartArray[3] += config.tzh;
        datePartArray[4] += config.tzm;
        // return
        return dateFromArray(datePartArray, config.isUTC);
    }

    // date from string and array of format strings
    function makeDateFromStringAndArray(string, formats) {
        var output,
            inputParts = string.match(parseMultipleFormatChunker) || [],
            formattedInputParts,
            scoreToBeat = 99,
            i,
            currentDate,
            currentScore;
        for (i = 0; i < formats.length; i++) {
            currentDate = makeDateFromStringAndFormat(string, formats[i]);
            formattedInputParts = formatMoment(new Moment(currentDate), formats[i]).match(parseMultipleFormatChunker) || [];
            currentScore = compareArrays(inputParts, formattedInputParts);
            if (currentScore < scoreToBeat) {
                scoreToBeat = currentScore;
                output = currentDate;
            }
        }
        return output;
    }

    // date from iso format
    function makeDateFromString(string) {
        var format = 'YYYY-MM-DDT',
            i;
        if (isoRegex.exec(string)) {
            for (i = 0; i < 4; i++) {
                if (isoTimes[i][1].exec(string)) {
                    format += isoTimes[i][0];
                    break;
                }
            }
            return parseTokenTimezone.exec(string) ?
                makeDateFromStringAndFormat(string, format + ' Z') :
                makeDateFromStringAndFormat(string, format);
        }
        return new Date(string);
    }

    /************************************
        Relative Time
    ************************************/

    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
    function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
        var rt = lang.relativeTime[string];
        return (typeof rt === 'function') ?
            rt(number || 1, !!withoutSuffix, string, isFuture) :
            rt.replace(/%d/i, number || 1);
    }

    function relativeTime(milliseconds, withoutSuffix, lang) {
        var seconds = round(Math.abs(milliseconds) / 1000),
            minutes = round(seconds / 60),
            hours = round(minutes / 60),
            days = round(hours / 24),
            years = round(days / 365),
            args = seconds < 45 && ['s', seconds] ||
                minutes === 1 && ['m'] ||
                minutes < 45 && ['mm', minutes] ||
                hours === 1 && ['h'] ||
                hours < 22 && ['hh', hours] ||
                days === 1 && ['d'] ||
                days <= 25 && ['dd', days] ||
                days <= 45 && ['M'] ||
                days < 345 && ['MM', round(days / 30)] ||
                years === 1 && ['y'] || ['yy', years];
        args[2] = withoutSuffix;
        args[3] = milliseconds > 0;
        args[4] = lang;
        return substituteTimeAgo.apply({}, args);
    }

    /************************************
        Top Level Functions
    ************************************/

    moment = function (input, format) {
        if (input === null || input === '') {
            return null;
        }
        var date,
            matched;
        // parse Moment object
        if (moment.isMoment(input)) {
            return new Moment(new Date(+input._d), input._isUTC, input._lang);
        // parse string and format
        } else if (format) {
            if (isArray(format)) {
                date = makeDateFromStringAndArray(input, format);
            } else {
                date = makeDateFromStringAndFormat(input, format);
            }
        // evaluate it as a JSON-encoded date
        } else {
            matched = aspNetJsonRegex.exec(input);
            date = input === undefined ? new Date() :
                matched ? new Date(+matched[1]) :
                input instanceof Date ? input :
                isArray(input) ? dateFromArray(input) :
                typeof input === 'string' ? makeDateFromString(input) :
                new Date(input);
        }

        return new Moment(date);
    };

    // creating with utc
    moment.utc = function (input, format) {
        if (isArray(input)) {
            return new Moment(dateFromArray(input, true), true);
        }
        // if we don't have a timezone, we need to add one to trigger parsing into utc
        if (typeof input === 'string' && !parseTokenTimezone.exec(input)) {
            input += ' +0000';
            if (format) {
                format += ' Z';
            }
        }
        return moment(input, format).utc();
    };

    // creating with unix timestamp (in seconds)
    moment.unix = function (input) {
        return moment(input * 1000);
    };

    // duration
    moment.duration = function (input, key) {
        var isDuration = moment.isDuration(input),
            isNumber = (typeof input === 'number'),
            duration = (isDuration ? input._data : (isNumber ? {} : input)),
            ret;

        if (isNumber) {
            if (key) {
                duration[key] = input;
            } else {
                duration.milliseconds = input;
            }
        }

        ret = new Duration(duration);

        if (isDuration) {
            ret._lang = input._lang;
        }

        return ret;
    };

    // humanizeDuration
    // This method is deprecated in favor of the new Duration object.  Please
    // see the moment.duration method.
    moment.humanizeDuration = function (num, type, withSuffix) {
        return moment.duration(num, type === true ? null : type).humanize(type === true ? true : withSuffix);
    };

    // version number
    moment.version = VERSION;

    // default format
    moment.defaultFormat = isoFormat;

    // This function will load languages and then set the global language.  If
    // no arguments are passed in, it will simply return the current global
    // language key.
    moment.lang = function (key, values) {
        var i;

        if (!key) {
            return currentLanguage;
        }
        if (values || !languages[key]) {
            loadLang(key, values);
        }
        if (languages[key]) {
            // deprecated, to get the language definition variables, use the
            // moment.fn.lang method or the getLangDefinition function.
            for (i = 0; i < langConfigProperties.length; i++) {
                moment[langConfigProperties[i]] = languages[key][langConfigProperties[i]];
            }
            moment.monthsParse = languages[key].monthsParse;
            currentLanguage = key;
        }
    };

    // returns language data
    moment.langData = getLangDefinition;

    // compare moment object
    moment.isMoment = function (obj) {
        return obj instanceof Moment;
    };

    // for typechecking Duration objects
    moment.isDuration = function (obj) {
        return obj instanceof Duration;
    };

    // Set default language, other languages will inherit from English.
    moment.lang('en', {
        months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
        monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
        weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
        weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
        weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
        longDateFormat : {
            LT : "h:mm A",
            L : "MM/DD/YYYY",
            LL : "MMMM D YYYY",
            LLL : "MMMM D YYYY LT",
            LLLL : "dddd, MMMM D YYYY LT"
        },
        meridiem : function (hours, minutes, isLower) {
            if (hours > 11) {
                return isLower ? 'pm' : 'PM';
            } else {
                return isLower ? 'am' : 'AM';
            }
        },
        calendar : {
            sameDay : '[Today at] LT',
            nextDay : '[Tomorrow at] LT',
            nextWeek : 'dddd [at] LT',
            lastDay : '[Yesterday at] LT',
            lastWeek : '[last] dddd [at] LT',
            sameElse : 'L'
        },
        relativeTime : {
            future : "in %s",
            past : "%s ago",
            s : "a few seconds",
            m : "a minute",
            mm : "%d minutes",
            h : "an hour",
            hh : "%d hours",
            d : "a day",
            dd : "%d days",
            M : "a month",
            MM : "%d months",
            y : "a year",
            yy : "%d years"
        },
        ordinal : function (number) {
            var b = number % 10;
            return (~~ (number % 100 / 10) === 1) ? 'th' :
                (b === 1) ? 'st' :
                (b === 2) ? 'nd' :
                (b === 3) ? 'rd' : 'th';
        }
    });

    /************************************
        Moment Prototype
    ************************************/

    moment.fn = Moment.prototype = {

        clone : function () {
            return moment(this);
        },

        valueOf : function () {
            return +this._d;
        },

        unix : function () {
            return Math.floor(+this._d / 1000);
        },

        toString : function () {
            return this._d.toString();
        },

        toDate : function () {
            return this._d;
        },

        toArray : function () {
            var m = this;
            return [
                m.year(),
                m.month(),
                m.date(),
                m.hours(),
                m.minutes(),
                m.seconds(),
                m.milliseconds(),
                !!this._isUTC
            ];
        },

        isValid : function () {
            if (this._a) {
                return !compareArrays(this._a, (this._a[7] ? moment.utc(this) : this).toArray());
            }
            return !isNaN(this._d.getTime());
        },

        utc : function () {
            this._isUTC = true;
            return this;
        },

        local : function () {
            this._isUTC = false;
            return this;
        },

        format : function (inputString) {
            return formatMoment(this, inputString ? inputString : moment.defaultFormat);
        },

        add : function (input, val) {
            var dur = val ? moment.duration(+val, input) : moment.duration(input);
            addOrSubtractDurationFromMoment(this, dur, 1);
            return this;
        },

        subtract : function (input, val) {
            var dur = val ? moment.duration(+val, input) : moment.duration(input);
            addOrSubtractDurationFromMoment(this, dur, -1);
            return this;
        },

        diff : function (input, val, asFloat) {
            var inputMoment = this._isUTC ? moment(input).utc() : moment(input).local(),
                zoneDiff = (this.zone() - inputMoment.zone()) * 6e4,
                diff = this._d - inputMoment._d - zoneDiff,
                year = this.year() - inputMoment.year(),
                month = this.month() - inputMoment.month(),
                date = this.date() - inputMoment.date(),
                output;
            if (val === 'months') {
                output = year * 12 + month + date / 30;
            } else if (val === 'years') {
                output = year + (month + date / 30) / 12;
            } else {
                output = val === 'seconds' ? diff / 1e3 : // 1000
                    val === 'minutes' ? diff / 6e4 : // 1000 * 60
                    val === 'hours' ? diff / 36e5 : // 1000 * 60 * 60
                    val === 'days' ? diff / 864e5 : // 1000 * 60 * 60 * 24
                    val === 'weeks' ? diff / 6048e5 : // 1000 * 60 * 60 * 24 * 7
                    diff;
            }
            return asFloat ? output : round(output);
        },

        from : function (time, withoutSuffix) {
            return moment.duration(this.diff(time)).lang(this._lang).humanize(!withoutSuffix);
        },

        fromNow : function (withoutSuffix) {
            return this.from(moment(), withoutSuffix);
        },

        calendar : function () {
            var diff = this.diff(moment().sod(), 'days', true),
                calendar = this.lang().calendar,
                allElse = calendar.sameElse,
                format = diff < -6 ? allElse :
                diff < -1 ? calendar.lastWeek :
                diff < 0 ? calendar.lastDay :
                diff < 1 ? calendar.sameDay :
                diff < 2 ? calendar.nextDay :
                diff < 7 ? calendar.nextWeek : allElse;
            return this.format(typeof format === 'function' ? format.apply(this) : format);
        },

        isLeapYear : function () {
            var year = this.year();
            return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
        },

        isDST : function () {
            return (this.zone() < moment([this.year()]).zone() ||
                this.zone() < moment([this.year(), 5]).zone());
        },

        day : function (input) {
            var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
            return input == null ? day :
                this.add({ d : input - day });
        },

        startOf: function (val) {
            // the following switch intentionally omits break keywords
            // to utilize falling through the cases.
            switch (val.replace(/s$/, '')) {
            case 'year':
                this.month(0);
                /* falls through */
            case 'month':
                this.date(1);
                /* falls through */
            case 'day':
                this.hours(0);
                /* falls through */
            case 'hour':
                this.minutes(0);
                /* falls through */
            case 'minute':
                this.seconds(0);
                /* falls through */
            case 'second':
                this.milliseconds(0);
                /* falls through */
            }
            return this;
        },

        endOf: function (val) {
            return this.startOf(val).add(val.replace(/s?$/, 's'), 1).subtract('ms', 1);
        },

        sod: function () {
            return this.clone().startOf('day');
        },

        eod: function () {
            // end of day = start of day plus 1 day, minus 1 millisecond
            return this.clone().endOf('day');
        },

        zone : function () {
            return this._isUTC ? 0 : this._d.getTimezoneOffset();
        },

        daysInMonth : function () {
            return moment.utc([this.year(), this.month() + 1, 0]).date();
        },

        // If passed a language key, it will set the language for this
        // instance.  Otherwise, it will return the language configuration
        // variables for this instance.
        lang : function (lang) {
            if (lang === undefined) {
                return getLangDefinition(this);
            } else {
                this._lang = lang;
                return this;
            }
        }
    };

    // helper for adding shortcuts
    function makeGetterAndSetter(name, key) {
        moment.fn[name] = function (input) {
            var utc = this._isUTC ? 'UTC' : '';
            if (input != null) {
                this._d['set' + utc + key](input);
                return this;
            } else {
                return this._d['get' + utc + key]();
            }
        };
    }

    // loop through and add shortcuts (Month, Date, Hours, Minutes, Seconds, Milliseconds)
    for (i = 0; i < proxyGettersAndSetters.length; i ++) {
        makeGetterAndSetter(proxyGettersAndSetters[i].toLowerCase(), proxyGettersAndSetters[i]);
    }

    // add shortcut for year (uses different syntax than the getter/setter 'year' == 'FullYear')
    makeGetterAndSetter('year', 'FullYear');

    /************************************
        Duration Prototype
    ************************************/

    moment.duration.fn = Duration.prototype = {
        weeks : function () {
            return absRound(this.days() / 7);
        },

        valueOf : function () {
            return this._milliseconds +
              this._days * 864e5 +
              this._months * 2592e6;
        },

        humanize : function (withSuffix) {
            var difference = +this,
                rel = this.lang().relativeTime,
                output = relativeTime(difference, !withSuffix, this.lang());

            if (withSuffix) {
                output = (difference <= 0 ? rel.past : rel.future).replace(/%s/i, output);
            }

            return output;
        },

        lang : moment.fn.lang
    };

    function makeDurationGetter(name) {
        moment.duration.fn[name] = function () {
            return this._data[name];
        };
    }

    function makeDurationAsGetter(name, factor) {
        moment.duration.fn['as' + name] = function () {
            return +this / factor;
        };
    }

    for (i in unitMillisecondFactors) {
        if (unitMillisecondFactors.hasOwnProperty(i)) {
            makeDurationAsGetter(i, unitMillisecondFactors[i]);
            makeDurationGetter(i.toLowerCase());
        }
    }

    makeDurationAsGetter('Weeks', 6048e5);

    /************************************
        Exposing Moment
    ************************************/

    // CommonJS module is defined
    if (hasModule) {
        module.exports = moment;
    }
    /*global ender:false */
    if (typeof ender === 'undefined') {
        // here, `this` means `window` in the browser, or `global` on the server
        // add `moment` as a global object via a string identifier,
        // for Closure Compiler "advanced" mode
        this['moment'] = moment;
    }
    /*global define:false */
    if (typeof define === "function" && define.amd) {
        define("moment", [], function () {
            return moment;
        });
    }
}).call(this, Date);


text:
from powerdns.models import Record
from powerdns.tests.utils import RecordTestCase, RecordFactory
from powerdns.utils import AutoPtrOptions

class TestSOASerialUpdate(RecordTestCase):

    def setUp(self):
        super(TestSOASerialUpdate, self).setUp()
        self.soa_record = RecordFactory(
            domain=self.domain,
            type='SOA',
            name='example.com',
            content=(
                'na1.example.com. hostmaster.example.com. '
                '0 43200 600 1209600 600'
            ),
        )
        # Less than 1 second will elapse until the test runs, so we update
        # this manually while circumventing save()
        Record.objects.filter(pk=self.soa_record.pk).update(
            change_date=1432720132
        )
        self.a_record = RecordFactory(
            domain=self.domain,
            type='A',
            name='www.example.com',
            content='192.168.1.1',
            auto_ptr=AutoPtrOptions.NEVER,
        )
        self.cname_record = RecordFactory(
            domain=self.domain,
            type='CNAME',
            name='blog.example.com',
            content='www.example.com',
            auto_ptr=AutoPtrOptions.NEVER,
        )

    def test_soa_update(self):
        """Test if SOA change_date is updated when a record is removed"""
        old_serial = Record.objects.get(pk=self.soa_record.pk).change_date
        self.a_record.delete()
        new_serial = Record.objects.get(pk=self.soa_record.pk).change_date
        self.assertGreater(new_serial, old_serial)


text:
var app = {
    // Application Constructor
    initialize: function() {
        this.bindEvents();
    },
    // Bind Event Listeners
    //
    // Bind any events that are required on startup. Common events are:
    // 'load', 'deviceready', 'offline', and 'online'.
    bindEvents: function() {
        document.addEventListener('deviceready', this.onDeviceReady, false);
    },
    // deviceready Event Handler
    //
    // The scope of 'this' is the event. In order to call the 'receivedEvent'
    // function, we must explicity call 'app.receivedEvent(...);'
    onDeviceReady: function() {
        app.receivedEvent('deviceready');

    },
    // Update DOM on a Received Event
    receivedEvent: function(id) {
        if (id == "deviceready") {
			$("#deviceLoading").hide();
			$("#deviceReady").show();
			$("#loading").show();
			update();
			setInterval(update(), 60000)
		}
        //console.log('Received Event: ' + id);
    }
};

//Lab Update
function update() {
	$("#lab-list").empty();
	$.getJSON( "http://mc05.cs.purdue.edu:8000/labs", function( data ) {
		$.each(data.labs, function (i, lab) {
			$("#lab-list").append("
 \
									 \
									" + lab.name + " Lab \
									" + lab.people.current + "/" + lab.people.capacity + "\
									" + lab.room + "\
									\

");

		});
	}).done(function() {
		$("#loading").hide(400);
		$("#success").show(500);
	}).fail(function () {
		$("#loading").hide(400);
		$("#failed").show(500);
		$("#failed").click(function() {
			$("#failed").hide();
			$("#loading").show();
			update();
		});
	});
}


text:
#!/bin/bash

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

set -o errexit
set -o nounset
set -o pipefail

QING_ROOT=$(dirname "${BASH_SOURCE}")/..
boiler="${QING_ROOT}/hooks/boilerplate.py"

cd ${QING_ROOT}

find_files() {
  local ext=$1
  find . -not \( \
      \( \
        -wholename './output' \
        -o -wholename './_output' \
        -o -wholename './release' \
        -o -wholename './target' \
        -o -wholename './.git' \
        -o -wholename '*/third_party/*' \
        -o -wholename '*/Godeps/*' \
      \) -prune \
    \) -name "*.${ext}"
}

files_need_boilerplate=()

files=($(find_files "go"))
files_need_boilerplate+=($(${boiler} "go" "${files[@]}"))

files=($(find_files "sh"))
files_need_boilerplate+=($(${boiler} "sh" "${files[@]}"))

files=($(find_files "py"))
files_need_boilerplate+=($(${boiler} "py" "${files[@]}"))

if [[ ${#files_need_boilerplate[@]} -gt 0 ]]; then
  for file in "${files_need_boilerplate[@]}"; do
    echo "Boilerplate header is wrong for: ${file}"
  done

  exit 1
fi


text:
===========================
 automaton Release Notes
===========================

.. toctree::
   :maxdepth: 1

   unreleased
   zed
   yoga
   xena
   wallaby
   victoria
   ussuri
   train
   stein
   rocky
   queens
   pike
   ocata


text:
package com.dc.smarteam.modules.sys.listener;

import javax.servlet.ServletContext;

import org.springframework.web.context.WebApplicationContext;

import com.dc.smarteam.modules.sys.service.SystemService;

public class WebContextListener extends org.springframework.web.context.ContextLoaderListener {

	@Override
	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		if (!SystemService.printKeyLoadMessage()){
			return null;
		}
		return super.initWebApplicationContext(servletContext);
	}
}


text:
package org.openid4java.consumer;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;

import org.junit.After;
import org.junit.Before;

/**
 * @author Marius Scurtescu, Johnny Bufu
 */
public class EhcacheNonceVerifierTest extends AbstractNonceVerifierTest
{
	private CacheManager _cacheManager;

	@Override
	@Before
	public void setUp() throws Exception
	{
		_cacheManager = new CacheManager();

		super.setUp();
	}

	@After
	public void tearDown() throws Exception
	{
		_cacheManager = null;
	}

	@Override
	public NonceVerifier createVerifier(int maxAge)
	{
		_cacheManager.removalAll();
		_cacheManager.addCache(new Cache("testCache", 100, false, false, maxAge, maxAge));

		EhcacheNonceVerifier nonceVerifier = new EhcacheNonceVerifier(maxAge);
		nonceVerifier.setCache(_cacheManager.getCache("testCache"));

		return nonceVerifier;
	}
}


text:
package dmytro.kuzenko.core.operation;

import java.util.Map;

import dmytro.kuzenko.core.DatabaseHandler;
import dmytro.kuzenko.core.OperationHandler;

public class OperationRemoveTable implements Operation {

    private Map<String,String> parameters;
    private DatabaseHandler databaseHandler;

    public void setState(Map<String,String> parameters, DatabaseHandler databaseHandler){
        this.databaseHandler = databaseHandler;
        this.parameters = parameters;
    }

    @Override
    public void execute(OperationHandler ioManager) throws Exception {
        final String tableName = OperationBuilder.getStringParameter(parameters, "name");
        databaseHandler.removeTable(tableName);
        ioManager.outputTableRemoved(tableName);
    }

}