text:
<!DOCTYPE html>

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

    <title>Pueblos Magicos en el Estado de México</title>

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

    <link href="css/freelancer.min.css" rel="stylesheet">

    <link href="vendor/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href="https://fonts.googleapis.com/css?family=Montserrat:400,700" rel="stylesheet" type="text/css">
    <link href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic" rel="stylesheet" type="text/css">

                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
                    Toggle navigation Menu
                </button>

                        Inicio

                        El oro

                        Malinalco

                        Metepec

                        Tepotzotlán

                        Valle de bravo

El oro

                    El Oro, Pueblo Mágico del Estado de México, es una de las antiguas glorias mineras de esta entidad del país. Y aunque su esplendor minero, hace mucho tiempo que se agotó, aún sigue destacando como un imán turístico de gran respeto. Posee señoriales edificios que cautivan la atención de los visitantes y los incita a buscar mayores referencias de su apasionante historia.

                    Si se llega temprano a esta comunidad mexiquense, se tendrá la oportunidad de ver como abren los diferentes negocios. Luego, conviene recorrer sus calles pintorescas de suelos empedrados y así llegar al tradicional Jardín Madero. Se trata de un apacible lugar, con encantadoras bancas y una densa arboleda, excelente para observar al pueblo despertando paulatinamente. En las panaderías colindantes al Jardín Madero, sirven rico café caliente y suculentos biscochos.

                <audio controls autoplay>
                  <source src="audio/eloro1.mp3" type="audio/mpeg">
                  Tu navegador no soporta este elemento.
                </audio>

Desarrollo multimedia

FI UAEMex

Cerro de Coatepec S/N

Contacto

DESARROLLADO POR:

Jhonatan Saúl Ramírez Bravo.

                        Copyright © Desarrollo multimedia 2016


text:
import { Fragment, Indexed, Interface, JsonFragment, Result } from "@ethersproject/abi";
import { Block, BlockTag, Listener, Log, Provider, TransactionReceipt, TransactionRequest, TransactionResponse } from "@ethersproject/abstract-provider";
import { Signer } from "@ethersproject/abstract-signer";
import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
import { BytesLike } from "@ethersproject/bytes";
import { AccessList, AccessListish } from "@ethersproject/transactions";
export interface Overrides {
    gasLimit?: BigNumberish | Promise<BigNumberish>;
    gasPrice?: BigNumberish | Promise<BigNumberish>;
    maxFeePerGas?: BigNumberish | Promise<BigNumberish>;
    maxPriorityFeePerGas?: BigNumberish | Promise<BigNumberish>;
    nonce?: BigNumberish | Promise<BigNumberish>;
    type?: number;
    accessList?: AccessListish;
    customData?: Record<string, any>;
    ccipReadEnabled?: boolean;
}
export interface PayableOverrides extends Overrides {
    value?: BigNumberish | Promise<BigNumberish>;
}
export interface CallOverrides extends PayableOverrides {
    blockTag?: BlockTag | Promise<BlockTag>;
    from?: string | Promise<string>;
}
export interface PopulatedTransaction {
    to?: string;
    from?: string;
    nonce?: number;
    gasLimit?: BigNumber;
    gasPrice?: BigNumber;
    data?: string;
    value?: BigNumber;
    chainId?: number;
    type?: number;
    accessList?: AccessList;
    maxFeePerGas?: BigNumber;
    maxPriorityFeePerGas?: BigNumber;
    customData?: Record<string, any>;
    ccipReadEnabled?: boolean;
}
export declare type EventFilter = {
    address?: string;
    topics?: Array<string | Array<string>>;
};
export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
export interface Event extends Log {
    event?: string;
    eventSignature?: string;
    args?: Result;
    decodeError?: Error;
    decode?: (data: string, topics?: Array<string>) => any;
    removeListener: () => void;
    getBlock: () => Promise<Block>;
    getTransaction: () => Promise<TransactionResponse>;
    getTransactionReceipt: () => Promise<TransactionReceipt>;
}
export interface ContractReceipt extends TransactionReceipt {
    events?: Array<Event>;
}
export interface ContractTransaction extends TransactionResponse {
    wait(confirmations?: number): Promise<ContractReceipt>;
}
declare class RunningEvent {
    readonly tag: string;
    readonly filter: EventFilter;
    private _listeners;
    constructor(tag: string, filter: EventFilter);
    addListener(listener: Listener, once: boolean): void;
    removeListener(listener: Listener): void;
    removeAllListeners(): void;
    listeners(): Array<Listener>;
    listenerCount(): number;
    run(args: Array<any>): number;
    prepareEvent(event: Event): void;
    getEmit(event: Event): Array<any>;
}
export declare type ContractInterface = string | ReadonlyArray<Fragment | JsonFragment | string> | Interface;
export declare class BaseContract {
    readonly address: string;
    readonly interface: Interface;
    readonly signer: Signer;
    readonly provider: Provider;
    readonly functions: {
        [name: string]: ContractFunction;
    };
    readonly callStatic: {
        [name: string]: ContractFunction;
    };
    readonly estimateGas: {
        [name: string]: ContractFunction<BigNumber>;
    };
    readonly populateTransaction: {
        [name: string]: ContractFunction<PopulatedTransaction>;
    };
    readonly filters: {
        [name: string]: (...args: Array<any>) => EventFilter;
    };
    readonly resolvedAddress: Promise<string>;
    readonly deployTransaction: TransactionResponse;
    _deployedPromise: Promise<Contract>;
    _runningEvents: {
        [eventTag: string]: RunningEvent;
    };
    _wrappedEmits: {
        [eventTag: string]: (...args: Array<any>) => void;
    };
    constructor(addressOrName: string, contractInterface: ContractInterface, signerOrProvider?: Signer | Provider);
    static getContractAddress(transaction: {
        from: string;
        nonce: BigNumberish;
    }): string;
    static getInterface(contractInterface: ContractInterface): Interface;
    deployed(): Promise<Contract>;
    _deployed(blockTag?: BlockTag): Promise<Contract>;
    fallback(overrides?: TransactionRequest): Promise<TransactionResponse>;
    connect(signerOrProvider: Signer | Provider | string): Contract;
    attach(addressOrName: string): Contract;
    static isIndexed(value: any): value is Indexed;
    private _normalizeRunningEvent;
    private _getRunningEvent;
    _checkRunningEvents(runningEvent: RunningEvent): void;
    _wrapEvent(runningEvent: RunningEvent, log: Log, listener: Listener): Event;
    private _addEventListener;
    queryFilter(event: EventFilter | string, fromBlockOrBlockhash?: BlockTag | string, toBlock?: BlockTag): Promise<Array<Event>>;
    on(event: EventFilter | string, listener: Listener): this;
    once(event: EventFilter | string, listener: Listener): this;
    emit(eventName: EventFilter | string, ...args: Array<any>): boolean;
    listenerCount(eventName?: EventFilter | string): number;
    listeners(eventName?: EventFilter | string): Array<Listener>;
    removeAllListeners(eventName?: EventFilter | string): this;
    off(eventName: EventFilter | string, listener: Listener): this;
    removeListener(eventName: EventFilter | string, listener: Listener): this;
}
export declare class Contract extends BaseContract {
    readonly [key: string]: ContractFunction | any;
}
export declare class ContractFactory {
    readonly interface: Interface;
    readonly bytecode: string;
    readonly signer: Signer;
    constructor(contractInterface: ContractInterface, bytecode: BytesLike | {
        object: string;
    }, signer?: Signer);
    getDeployTransaction(...args: Array<any>): TransactionRequest;
    deploy(...args: Array<any>): Promise<Contract>;
    attach(address: string): Contract;
    connect(signer: Signer): ContractFactory;
    static fromSolidity(compilerOutput: any, signer?: Signer): ContractFactory;
    static getInterface(contractInterface: ContractInterface): Interface;
    static getContractAddress(tx: {
        from: string;
        nonce: BytesLike | BigNumber | number;
    }): string;
    static getContract(address: string, contractInterface: ContractInterface, signer?: Signer): Contract;
}
export {};
//# sourceMappingURL=index.d.ts.map

redpajama_set_name: RedPajamaGithub


text:
package model

// resource const
const (
	// PlatAndroid is int8 for android.
	PlatAndroid = int8(0)
	// PlatIPhone is int8 for iphone.
	PlatIPhone = int8(1)
	// PlatIPad is int8 for ipad.
	PlatIPad = int8(2)
	// PlatWPhone is int8 for wphone.
	PlatWPhone = int8(3)
	// PlatAndroidG is int8 for Android Googleplay.
	PlatAndroidG = int8(4)
	// PlatIPhoneI is int8 for Iphone Global.
	PlatIPhoneI = int8(5)
	// PlatIPadI is int8 for IPAD Global.
	PlatIPadI = int8(6)
	// PlatAndroidTV is int8 for AndroidTV Global.
	PlatAndroidTV = int8(7)
	// PlatAndroidI is int8 for Android Global.
	PlatAndroidI = int8(8)
	// PlatAndroidB is int8 for Android Bule.
	PlatAndroidB = int8(9)
	// PlatWEB is int8 for web.
	PlatWEB = int8(99)

	// goto
	GotoAv          = "av"
	GotoWeb         = "web"
	GotoBangumi     = "bangumi"
	GotoBangumiWeb  = "bangumi_web"
	GotoSp          = "sp"
	GotoLive        = "live"
	GotoGame        = "game"
	GotoArticle     = "article"
	GotoActivity    = "activity_new"
	GotoTopic       = "topic_new"
	GotoDaily       = "daily"
	GotoRank        = "rank"
	GotoCard        = "card"
	GotoVeidoCard   = "video_card"
	GotoSpecialCard = "special_card"
	GotoTagCard     = "tag_card"
	GotoColumn      = "column"
	GotoColumnStage = "column_stage"
	GotoTagID       = "tag_id"

	CardGotoAv       = int8(1)
	CardGotoTopic    = int8(2)
	CardGotoActivity = int8(3)
)

// InvalidBuild check source build is not allow by config build and condition.
// eg: when condition is gt, means srcBuild must gt cfgBuild, otherwise is invalid srcBuild.
func InvalidBuild(srcBuild, cfgBuild int, cfgCond string) bool {
	if cfgBuild != 0 && cfgCond != "" {
		switch cfgCond {
		case "gt":
			if cfgBuild >= srcBuild {
				return true
			}
		case "lt":
			if cfgBuild <= srcBuild {
				return true
			}
		case "eq":
			if cfgBuild != srcBuild {
				return true
			}
		case "ne":
			if cfgBuild == srcBuild {
				return true
			}
		}
	}
	return false
}

// InvalidChannel check source channel is not allow by config channel.
func InvalidChannel(plat int8, srcCh, cfgCh string) bool {
	return plat == PlatAndroid && cfgCh != "*" && cfgCh != srcCh
}

// Plat return plat by platStr or mobiApp
func Plat(mobiApp, device string) int8 {
	switch mobiApp {
	case "iphone":
		if device == "pad" {
			return PlatIPad
		}
		return PlatIPhone
	case "white":
		return PlatIPhone
	case "ipad":
		return PlatIPad
	case "android":
		return PlatAndroid
	case "win":
		return PlatWPhone
	case "android_G":
		return PlatAndroidG
	case "android_I":
		return PlatAndroidI
	case "iphone_I":
		if device == "pad" {
			return PlatIPadI
		}
		return PlatIPhoneI
	case "ipad_I":
		return PlatIPadI
	case "android_tv":
		return PlatAndroidTV
	}
	return PlatIPhone
}

// FillURI deal app schema.
func FillURI(gt, param string) (uri string) {
	if param == "" {
		return
	}
	switch gt {
	case GotoAv, "":
		uri = "bilibili://video/" + param
	case GotoLive:
		uri = "bilibili://live/" + param
	case GotoBangumi:
		uri = "bilibili://bangumi/season/" + param
	case GotoBangumiWeb:
		uri = "http://bangumi.bilibili.com/anime/" + param
	case GotoGame:
		uri = "bilibili://game/" + param
	case GotoSp:
		uri = "bilibili://splist/" + param
	case GotoWeb:
		uri = param
	case GotoDaily:
		uri = "bilibili://daily/" + param
	case GotoColumn:
		uri = "bilibili://pegasus/list/column/" + param
	case GotoArticle:
		uri = "bilibili://article/" + param
	}
	return
}


text:
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

// Include required modules
var addons = require("../../../../lib/addons");
var endurance = require("../../../../lib/endurance");
var tabs = require("../../../lib/tabs");

const BASE_URL = collector.addHttpResource("../../../../data/");
const TEST_DATA = BASE_URL + "pages/test_swf_embed_nosound.htm";

const TIMEOUT_PAGE = 50000;

function setupModule(aModule) {
  aModule.controller = mozmill.getBrowserController();

  aModule.enduranceManager = new endurance.EnduranceManager(aModule.controller);
  aModule.tabBrowser = new tabs.tabBrowser(aModule.controller);

  tabs.closeAllTabs(aModule.controller);

  // Skip test if we don't have Flash plugin enabled
  var isFlashActive = addons.getInstalledAddons(function (aAddon) {
    if (aAddon.isActive && aAddon.type === "plugin" && aAddon.name === "Shockwave Flash")
      return true;
  });

  if (isFlashActive[0] !== true) {
    testFlashViaEmbedTag.__force_skip__ = "No enabled Flash plugin detected";
  }
}

function teardownModule(aModule) {
  aModule.tabBrowser.closeAllTabs();
}

/*
 * Test opening embeded flash content
 */
function testFlashViaEmbedTag() {
  enduranceManager.run(function () {
    enduranceManager.loop(function () {
      // If entity > 1 then open a new tab
      if (enduranceManager.currentEntity > 1) {
        tabBrowser.openTab();
      }

      // Load the test page in the currently opened tab
      enduranceManager.addCheckpoint("Load a web page with embeded flash content");
      controller.open(TEST_DATA);
      controller.waitForPageLoad(TIMEOUT_PAGE);
      enduranceManager.addCheckpoint("Web page has been loaded");
    });

    // Close all tabs
    tabBrowser.closeAllTabs();
  });
}


text:
using System;
using UnityEngine;

namespace InControl
{
	// This is kind of "beta"... while it works on iOS, gyro controls are
	// inconsistent and are usually fine tuned to the games that use them
	// which is somewhat beyond the scope of this project. But, if you
	// are curious how to go about it, here you go.
	//
	public class UnityGyroAxisSource : InputControlSource
	{
		public enum GyroAxis
		{
			X = 0,
			Y = 1,
		}

		int axis;

		static Quaternion zeroAttitude;

		public UnityGyroAxisSource( GyroAxis axis )
		{
			this.axis = (int) axis;
			Calibrate();
		}

		public float GetValue( InputDevice inputDevice )
		{
			return GetAxis()[ (int) axis ];
		}

		public bool GetState( InputDevice inputDevice )
		{
			return !Mathf.Approximately( GetValue( inputDevice ), 0.0f );
		}

		static Quaternion GetAttitude()
		{
			return Quaternion.Inverse( zeroAttitude ) * Input.gyro.attitude;
		}

		static Vector3 GetAxis()
		{
			var gv = GetAttitude() * Vector3.forward;
			var gx = ApplyDeadZone( Mathf.Clamp( gv.x, -1.0f, 1.0f ) );
			var gy = ApplyDeadZone( Mathf.Clamp( gv.y, -1.0f, 1.0f ) );
			return new Vector3( gx, gy );
		}

		static float ApplyDeadZone( float value )
		{
			return Mathf.InverseLerp( 0.05f, 1.0f, Mathf.Abs( value ) ) * Mathf.Sign( value );
		}

		public static void Calibrate()
		{
			zeroAttitude = Input.gyro.attitude;
		}
	}
}


text:
.class Landroid/widget/ListPopupWindow$PopupScrollListener;
.super Ljava/lang/Object;
.source "ListPopupWindow.java"

# interfaces
.implements Landroid/widget/AbsListView$OnScrollListener;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/widget/ListPopupWindow;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "PopupScrollListener"
.end annotation

# instance fields
.field final synthetic this$0:Landroid/widget/ListPopupWindow;

# direct methods
.method private constructor <init>(Landroid/widget/ListPopupWindow;)V
    .locals 0

    iput-object p1, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method

.method synthetic constructor <init>(Landroid/widget/ListPopupWindow;Landroid/widget/ListPopupWindow$PopupScrollListener;)V
    .locals 0

    invoke-direct {p0, p1}, Landroid/widget/ListPopupWindow$PopupScrollListener;-><init>(Landroid/widget/ListPopupWindow;)V

    return-void
.end method

# virtual methods
.method public onScroll(Landroid/widget/AbsListView;III)V
    .locals 0

    return-void
.end method

.method public onScrollStateChanged(Landroid/widget/AbsListView;I)V
    .locals 2

    const/4 v0, 0x1

    if-ne p2, v0, :cond_0

    iget-object v0, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    invoke-virtual {v0}, Landroid/widget/ListPopupWindow;->isInputMethodNotNeeded()Z

    move-result v0

    xor-int/lit8 v0, v0, 0x1

    if-eqz v0, :cond_0

    iget-object v0, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    iget-object v0, v0, Landroid/widget/ListPopupWindow;->mPopup:Landroid/widget/PopupWindow;

    invoke-virtual {v0}, Landroid/widget/PopupWindow;->getContentView()Landroid/view/View;

    move-result-object v0

    if-eqz v0, :cond_0

    iget-object v0, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    invoke-static {v0}, Landroid/widget/ListPopupWindow;->-get1(Landroid/widget/ListPopupWindow;)Landroid/os/Handler;

    move-result-object v0

    iget-object v1, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    invoke-static {v1}, Landroid/widget/ListPopupWindow;->-get3(Landroid/widget/ListPopupWindow;)Landroid/widget/ListPopupWindow$ResizePopupRunnable;

    move-result-object v1

    invoke-virtual {v0, v1}, Landroid/os/Handler;->removeCallbacks(Ljava/lang/Runnable;)V

    iget-object v0, p0, Landroid/widget/ListPopupWindow$PopupScrollListener;->this$0:Landroid/widget/ListPopupWindow;

    invoke-static {v0}, Landroid/widget/ListPopupWindow;->-get3(Landroid/widget/ListPopupWindow;)Landroid/widget/ListPopupWindow$ResizePopupRunnable;

    move-result-object v0

    invoke-virtual {v0}, Landroid/widget/ListPopupWindow$ResizePopupRunnable;->run()V

    :cond_0
    return-void
.end method


text:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Encoding Hint: 雀の往来 -->
<project>
 <property name="jnlp.title"    value="JST カラムで幅を指定" />
 <property name="jnlp.Name"     value="SetColumns" />
 <property name="jnlp.name"     value="setcolumns" />
 <property name="jnlp.codebase" value="http://ateraimemo.com/swing/${jnlp.name}/" />
 <property name="jnlp.homepage" value="http://ateraimemo.com/Swing/${jnlp.Name}.html" />
</project>


text:
package datastore

import (
	"context"

	"github.com/google/ent/log"
	"google.golang.org/appengine/v2/memcache"
)

type Memcache struct {
	Inner DataStore
}

func (s Memcache) Get(ctx context.Context, name string) ([]byte, error) {
	item, err := memcache.Get(ctx, name)
	if err != nil {
		if err != memcache.ErrCacheMiss {
			log.Errorf(ctx, "error getting %q from memcache: %v", name, err)
		}
		b, err := s.Inner.Get(ctx, name)
		if err != nil {
			return nil, err
		}
		go s.TrySet(ctx, name, b)
		return b, nil
	}
	log.Infof(ctx, "got %q from memcache", name)
	return item.Value, nil
}

func (s Memcache) Put(ctx context.Context, name string, value []byte) error {
	err := s.Inner.Put(ctx, name, value)
	if err != nil {
		return err
	}
	go s.TrySet(ctx, name, value)
	return nil
}

func (s Memcache) Has(ctx context.Context, name string) (bool, error) {
	return s.Inner.Has(ctx, name)
}

func (s Memcache) TrySet(ctx context.Context, name string, value []byte) {
	err := memcache.Set(ctx, &memcache.Item{
		Key:   name,
		Value: value,
	})
	if err != nil {
		log.Errorf(ctx, "error adding %q to memcache: %v", name, err)
	} else {
		log.Infof(ctx, "added %q to memcache", name)
	}
}


text:
namespace Merchello.Plugin.Payments.Braintree.Services
{
    using Merchello.Plugin.Payments.Braintree.Models;

    /// <summary>
    /// Defines the <see cref="BraintreeApiService"/>.
    /// </summary>
    public interface IBraintreeApiService
    {
        /// <summary>
        /// Gets the <see cref="BraintreeProviderSettings"/>.
        /// </summary>
        BraintreeProviderSettings BraintreeProviderSettings { get; }

        /// <summary>
        /// Gets the <see cref="IBraintreeCustomerApiService"/>.
        /// </summary>
        IBraintreeCustomerApiService Customer { get; }

        /// <summary>
        /// Gets the <see cref="IBraintreePaymentMethodApiService"/>.
        /// </summary>
        IBraintreePaymentMethodApiService PaymentMethod { get; }

        /// <summary>
        /// Gets the <see cref="IBraintreeSubscriptionApiService"/>.
        /// </summary>
        IBraintreeSubscriptionApiService Subscription { get; }

        /// <summary>
        /// Gets the <see cref="IBraintreeTransactionApiService"/>.
        /// </summary>
        IBraintreeTransactionApiService Transaction { get; }

        /// <summary>
        /// Gets the <see cref="IBraintreeWebhooksApiService"/>
        /// </summary>
        IBraintreeWebhooksApiService Webhook { get; }
    }
}


text:
FROM nginx:1.11

COPY start.sh /
RUN chmod +x /start.sh
COPY osc.conf /etc/nginx/conf.d/
COPY *.conf /etc/nginx/

RUN openssl dhparam -dsaparam -out /etc/ssl/private/dhparam.pem 4096

CMD /start.sh


text: - Added the Carbon Black EDR Unique ID.


text:
<?php

namespace talma\widgets;

use yii\web\AssetBundle;
use Yii;

/**
 * Asset bundle for FullCalendar
 *
 * @author Thiago Talma <thiago@thiagomt.com>
 * @since 1.0
 */
class FullCalendarAsset extends AssetBundle
{
    /**
     * @inheritdoc
     */
    public $depends = ['yii\jui\JuiAsset'];

    /**
     * @inheritdoc
     */
    public $js = ['lib/moment.min.js', 'fullcalendar.js'];

    /**
     * @var string App language
     */
    public $language;

    /**
     * @var boolean If the plugin displays a Google calendar.
     */
    public $googleCalendar = false;

    /**
     * @inheritdoc
     */
    public function init()
    {
        $this->css = ['fullcalendar.css'];
        $this->sourcePath = __DIR__ . '/../assets';
        parent::init();
    }

    /**
     * @inheritdoc
     */
    public function registerAssetFiles($view)
    {
        $language = strtolower($this->language ? $this->language : Yii::$app->language);

        if ($language != 'en-us') {
            $this->js[] = "lang/{$language}.js";
        }

        if ($this->googleCalendar) {
            $this->js[] = "gcal.js";
        }

        $view->registerCssFile($this->baseUrl . '/' . 'fullcalendar.print.css', ['media' => 'print']);

        parent::registerAssetFiles($view);
    }
}


text:
package scripts.measurementcollectionscripts;

import com.google.monitoring.v3.Aggregation;
import com.google.protobuf.Duration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scripts.measurementcollectionscripts.baseclasses.GoogleMetric;

public class MemoryUsedBytesMetric extends GoogleMetric {
  private static final Logger logger = LoggerFactory.getLogger(MemoryUsedBytesMetric.class);

  /** Public constructor so that this class can be instantiated via reflection. */
  public MemoryUsedBytesMetric() {
    super();
    identifier = "kubernetes.io/container/memory/used_bytes";
    aggregation =
        Aggregation.newBuilder()
            .setAlignmentPeriod(Duration.newBuilder().setSeconds(60).build())
            .setPerSeriesAligner(Aggregation.Aligner.ALIGN_MEAN)
            .setCrossSeriesReducer(Aggregation.Reducer.REDUCE_MEAN)
            .build();
  }
}


text:
'use strict';
const common = require('../common');

if (!common.hasCrypto)
  common.skip('missing crypto');

const assert = require('assert');
const tls = require('tls');
const fixtures = require('../common/fixtures');

function loadPEM(n) {
  return fixtures.readKey(`${n}.pem`);
}

const serverIP = common.localhostIPv4;

function checkResults(result, expected) {
  assert.strictEqual(result.server.ALPN, expected.server.ALPN);
  assert.strictEqual(result.client.ALPN, expected.client.ALPN);
}

function runTest(clientsOptions, serverOptions, cb) {
  serverOptions.key = loadPEM('agent2-key');
  serverOptions.cert = loadPEM('agent2-cert');
  const results = [];
  let clientIndex = 0;
  let serverIndex = 0;
  const server = tls.createServer(serverOptions, function(c) {
    results[serverIndex++].server = { ALPN: c.alpnProtocol };
  });

  server.listen(0, serverIP, function() {
    connectClient(clientsOptions);
  });

  function connectClient(options) {
    const opt = options.shift();
    opt.port = server.address().port;
    opt.host = serverIP;
    opt.rejectUnauthorized = false;

    results[clientIndex] = {};
    const client = tls.connect(opt, function() {
      results[clientIndex].client = { ALPN: client.alpnProtocol };
      client.end();
      if (options.length) {
        clientIndex++;
        connectClient(options);
      } else {
        server.close();
        server.on('close', () => {
          cb(results);
        });
      }
    });
  }

}

// Server: ALPN, Client: ALPN
function Test1() {
  const serverOptions = {
    ALPNProtocols: ['a', 'b', 'c'],
  };

  const clientsOptions = [{
    ALPNProtocols: ['a', 'b', 'c'],
  }, {
    ALPNProtocols: ['c', 'b', 'e'],
  }, {
    ALPNProtocols: ['first-priority-unsupported', 'x', 'y'],
  }];

  runTest(clientsOptions, serverOptions, function(results) {
    // 'a' is selected by ALPN
    checkResults(results[0],
                 { server: { ALPN: 'a' },
                   client: { ALPN: 'a' } });
    // 'b' is selected by ALPN
    checkResults(results[1],
                 { server: { ALPN: 'b' },
                   client: { ALPN: 'b' } });
    // Nothing is selected by ALPN
    checkResults(results[2],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
    // execute next test
    Test2();
  });
}

// Server: ALPN, Client: Nothing
function Test2() {
  const serverOptions = {
    ALPNProtocols: ['a', 'b', 'c'],
  };

  const clientsOptions = [{}, {}, {}];

  runTest(clientsOptions, serverOptions, function(results) {
    // Nothing is selected by ALPN
    checkResults(results[0],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
    // Nothing is selected by ALPN
    checkResults(results[1],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
    // Nothing is selected by ALPN
    checkResults(results[2],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
    // execute next test
    Test3();
  });
}

// Server: Nothing, Client: ALPN
function Test3() {
  const serverOptions = {};

  const clientsOptions = [{
    ALPNrotocols: ['a', 'b', 'c'],
  }, {
    ALPNProtocols: ['c', 'b', 'e'],
  }, {
    ALPNProtocols: ['first-priority-unsupported', 'x', 'y'],
  }];

  runTest(clientsOptions, serverOptions, function(results) {
    // nothing is selected
    checkResults(results[0], { server: { ALPN: false },
                               client: { ALPN: false } });
    // nothing is selected
    checkResults(results[1], { server: { ALPN: false },
                               client: { ALPN: false } });
    // nothing is selected
    checkResults(results[2],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
    // execute next test
    Test4();
  });
}

// Server: Nothing, Client: Nothing
function Test4() {
  const serverOptions = {};

  const clientsOptions = [{}, {}, {}];

  runTest(clientsOptions, serverOptions, function(results) {
    // nothing is selected
    checkResults(results[0], { server: { ALPN: false },
                               client: { ALPN: false } });
    // nothing is selected
    checkResults(results[1], { server: { ALPN: false },
                               client: { ALPN: false } });
    // nothing is selected
    checkResults(results[2],
                 { server: { ALPN: false },
                   client: { ALPN: false } });
  });
}

Test1();


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
ClassCompiler (Rhino)
</TITLE>

<META NAME="date" CONTENT="2011-05-09">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../stylesheet.css" TITLE="Style">

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.mozilla.javascript.optimizer

Class ClassCompiler

java.lang.Object
  org.mozilla.javascript.optimizer.ClassCompiler

public class ClassCompiler
extends java.lang.Object

Generates class files from script sources.

 since 1.5 Release 5

Author:

Igor Bukanov

Constructor Summary

ClassCompiler(CompilerEnvirons compilerEnv)

          Construct ClassCompiler that uses the specified compiler environment
 when generating classes.

Method Summary

 java.lang.Object[]
compileToClassFiles(java.lang.String source,
                    java.lang.String sourceLocation,
                    int lineno,
                    java.lang.String mainClassName)

          Compile JavaScript source into one or more Java class files.

 CompilerEnvirons
getCompilerEnv()

          Get the compiler environment the compiler uses.

 java.lang.String
getMainMethodClass()

          Get the name of the class for main method implementation.

 java.lang.Class<?>
getTargetExtends()

          Get the class that the generated target will extend.

 java.lang.Class<?>[]
getTargetImplements()

          Get the interfaces that the generated target will implement.

protected  java.lang.String
makeAuxiliaryClassName(java.lang.String mainClassName,
                       java.lang.String auxMarker)

          Build class name for a auxiliary class generated by compiler.

 void
setMainMethodClass(java.lang.String className)

          Set the class name to use for main method implementation.

 void
setTargetExtends(java.lang.Class<?> extendsClass)

          Set the class that the generated target will extend.

 void
setTargetImplements(java.lang.Class<?>[] implementsClasses)

          Set the interfaces that the generated target will implement.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ClassCompiler

public ClassCompiler(CompilerEnvirons compilerEnv)

Construct ClassCompiler that uses the specified compiler environment
 when generating classes.

Method Detail

setMainMethodClass

public void setMainMethodClass(java.lang.String className)

Set the class name to use for main method implementation.
 The class must have a method matching
 <tt>public static void main(Script sc, String[] args)</tt>, it will be
 called when <tt>main(String[] args)</tt> is called in the generated
 class. The class name should be fully qulified name and include the
 package name like in <tt>org.foo.Bar<tt>.

getMainMethodClass

public java.lang.String getMainMethodClass()

Get the name of the class for main method implementation.

See Also:
setMainMethodClass(String)

getCompilerEnv

public CompilerEnvirons getCompilerEnv()

Get the compiler environment the compiler uses.

getTargetExtends

public java.lang.Class<?> getTargetExtends()

Get the class that the generated target will extend.

setTargetExtends

public void setTargetExtends(java.lang.Class<?> extendsClass)

Set the class that the generated target will extend.

Parameters:
extendsClass - the class it extends

getTargetImplements

public java.lang.Class<?>[] getTargetImplements()

Get the interfaces that the generated target will implement.

setTargetImplements

public void setTargetImplements(java.lang.Class<?>[] implementsClasses)

Set the interfaces that the generated target will implement.

Parameters:
implementsClasses - an array of Class objects, one for each
                          interface the target will extend

makeAuxiliaryClassName

protected java.lang.String makeAuxiliaryClassName(java.lang.String mainClassName,
                                                  java.lang.String auxMarker)

Build class name for a auxiliary class generated by compiler.
 If the compiler needs to generate extra classes beyond the main class,
 it will call this function to build the auxiliary class name.
 The default implementation simply appends auxMarker to mainClassName
 but this can be overridden.

compileToClassFiles

public java.lang.Object[] compileToClassFiles(java.lang.String source,
                                              java.lang.String sourceLocation,
                                              int lineno,
                                              java.lang.String mainClassName)

Compile JavaScript source into one or more Java class files.
 The first compiled class will have name mainClassName.
 If the results of getTargetExtends() or
 getTargetImplements() are not null, then the first compiled
 class will extend the specified super class and implement
 specified interfaces.

Returns:
array where elements with even indexes specifies class name
         and the following odd index gives class file body as byte[]
         array. The initial element of the array always holds
         mainClassName and array[1] holds its byte code.

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD


text:
package org.killbill.billing.jaxrs.json;

import java.math.BigDecimal;
import java.util.List;
import java.util.UUID;

import javax.annotation.Nullable;

import org.killbill.billing.payment.api.Payment;
import org.killbill.billing.util.audit.AccountAuditLogs;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.wordnik.swagger.annotations.ApiModelProperty;

public class InvoicePaymentJson extends PaymentJson {

    @ApiModelProperty(dataType = "java.util.UUID")
    private final String targetInvoiceId;

    @JsonCreator
    public InvoicePaymentJson(@JsonProperty("targetInvoiceId") final String targetInvoiceId,
                              @JsonProperty("accountId") final String accountId,
                              @JsonProperty("paymentId") final String paymentId,
                              @JsonProperty("paymentNumber") final String paymentNumber,
                              @JsonProperty("paymentExternalKey") final String paymentExternalKey,
                              @JsonProperty("authAmount") final BigDecimal authAmount,
                              @JsonProperty("capturedAmount") final BigDecimal capturedAmount,
                              @JsonProperty("purchasedAmount") final BigDecimal purchasedAmount,
                              @JsonProperty("refundedAmount") final BigDecimal refundedAmount,
                              @JsonProperty("creditedAmount") final BigDecimal creditedAmount,
                              @JsonProperty("currency") final String currency,
                              @JsonProperty("paymentMethodId") final String paymentMethodId,
                              @JsonProperty("transactions") final List<? extends PaymentTransactionJson> transactions,
                              @JsonProperty("auditLogs") @Nullable final List<AuditLogJson> auditLogs) {
        super(accountId, paymentId, paymentNumber, paymentExternalKey, authAmount, capturedAmount, purchasedAmount, refundedAmount, creditedAmount, currency, paymentMethodId, transactions, auditLogs);
        this.targetInvoiceId = targetInvoiceId;
    }

    public InvoicePaymentJson(final Payment payment, @Nullable final UUID invoiceId, @Nullable final AccountAuditLogs accountAuditLogs) {
        super(payment, accountAuditLogs);
        //  TODO should build InvoicePaymentTransactionJson instead of PaymentTransactionJson here.
        this.targetInvoiceId = invoiceId != null ? invoiceId.toString() : null;
    }

        public String getTargetInvoiceId() {
        return targetInvoiceId;
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof InvoicePaymentJson)) {
            return false;
        }
        if (!super.equals(o)) {
            return false;
        }

        final InvoicePaymentJson that = (InvoicePaymentJson) o;

        if (targetInvoiceId != null ? !targetInvoiceId.equals(that.targetInvoiceId) : that.targetInvoiceId != null) {
            return false;
        }

        return true;
    }

    @Override
    public int hashCode() {
        int result = super.hashCode();
        result = 31 * result + (targetInvoiceId != null ? targetInvoiceId.hashCode() : 0);
        return result;
    }
}


text:
SerialEcho
==========

Dumps a line to serial debug output.

Supported Operating Systems
---------------------------

* Commodore's Amiga OS (680x0)
* AROS (x86/ PowerPC/ …)
* Hyperion's OS4 (PowerPC)
* MorphOS (PowerPC)

Binary Downloads
----------------

This is a source code archive, but ready-built binaries for the above mentioned operating systems can be downloaded at https://tokai.binaryriot.org/public/


text:
app.controller('MainCtrl', function ($scope, SETTINGS) {

    $scope.colors = ['green', 'blue', 'red'];

    $scope.farve = 'green';
});


text:
import { combineReducers } from 'redux';
import navigation from './navigation';
import auth from './auth';
import cards from './cards';
import games from './games';
import socket from './socket';
import chat from './chat';
import news from './news';
import api from './api';
import admin from './admin';
import user from './user';
import {reducer as toastrReducer} from 'react-redux-toastr';

const rootReducer = combineReducers({
    navigation, auth, cards, games, socket, chat, news, toastr: toastrReducer, api, admin, user
});

export default rootReducer;


text:
<?php
namespace Itransition\ParserBundle\Exceptions;

class FileNotFoundException extends ParserException
{
    public function __construct($message = null, $code = 0, Exception $previous = null)
    {
        parent::__construct($message ?? 'File not found', $code = 0, $previous);
    }
}


text:
package categoriplus.dataccesobject;

import categoriplus.dataccesobject.interfaces.CategoriaDAO;
import categoriplus.modelo.Categoria;
import java.util.List;

/**
 *
 * @author Antonio López Marín
 */
public class OracleCategoriaDAO implements CategoriaDAO{

    @Override
    public Categoria insert(Categoria dto) throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public boolean update(Categoria dto) throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public boolean delete(Categoria dto) throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public Categoria read(int id) throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public List<Categoria> getAll() throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

}


text:
using System;
using System.Collections.Generic;
using XCommon.Patterns.Repository.Entity;

namespace XCommon.Test.Entity
{
    public class PersonFilter : FilterBase
    {
        public PersonFilter()
        {
            Ids = new List<Guid>();
        }

        public Guid? Id { get; set; }

        public List<Guid> Ids { get; set; }

        public string Name { get; set; }

        public string Email { get; set; }

        public int? Age { get; set; }
    }
}


text:
package org.apache.shardingsphere.data.pipeline.core.task;

import lombok.Getter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.data.pipeline.api.config.ingest.DumperConfiguration;
import org.apache.shardingsphere.data.pipeline.api.config.rulealtered.ImporterConfiguration;
import org.apache.shardingsphere.data.pipeline.api.executor.AbstractLifecycleExecutor;
import org.apache.shardingsphere.data.pipeline.api.ingest.channel.PipelineChannel;
import org.apache.shardingsphere.data.pipeline.api.ingest.position.IngestPosition;
import org.apache.shardingsphere.data.pipeline.api.ingest.position.PlaceholderPosition;
import org.apache.shardingsphere.data.pipeline.api.ingest.record.Record;
import org.apache.shardingsphere.data.pipeline.api.task.progress.IncrementalTaskProgress;
import org.apache.shardingsphere.data.pipeline.core.datasource.PipelineDataSourceManager;
import org.apache.shardingsphere.data.pipeline.core.exception.PipelineJobExecutionException;
import org.apache.shardingsphere.data.pipeline.core.execute.ExecuteCallback;
import org.apache.shardingsphere.data.pipeline.core.execute.ExecuteEngine;
import org.apache.shardingsphere.data.pipeline.core.metadata.loader.PipelineTableMetaDataLoader;
import org.apache.shardingsphere.data.pipeline.spi.importer.Importer;
import org.apache.shardingsphere.data.pipeline.spi.ingest.channel.PipelineChannelFactory;
import org.apache.shardingsphere.data.pipeline.spi.ingest.dumper.Dumper;
import org.apache.shardingsphere.scaling.core.job.dumper.DumperFactory;
import org.apache.shardingsphere.scaling.core.job.importer.ImporterFactory;

import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * Incremental task.
 */
@Slf4j
@ToString(exclude = {"incrementalDumperExecuteEngine", "channel", "dumper", "importers", "progress"})
public final class IncrementalTask extends AbstractLifecycleExecutor implements PipelineTask, AutoCloseable {

    @Getter
    private final String taskId;

    private final ExecuteEngine incrementalDumperExecuteEngine;

    private final PipelineChannel channel;

    private final Dumper dumper;

    private final Collection<Importer> importers;

    @Getter
    private final IncrementalTaskProgress progress;

    public IncrementalTask(final int concurrency, final DumperConfiguration dumperConfig, final ImporterConfiguration importerConfig,
                           final PipelineChannelFactory pipelineChannelFactory, final PipelineDataSourceManager dataSourceManager,
                           final PipelineTableMetaDataLoader sourceMetaDataLoader, final ExecuteEngine incrementalDumperExecuteEngine) {
        this.incrementalDumperExecuteEngine = incrementalDumperExecuteEngine;
        taskId = dumperConfig.getDataSourceName();
        progress = new IncrementalTaskProgress();
        IngestPosition<?> position = dumperConfig.getPosition();
        progress.setPosition(position);
        channel = createChannel(concurrency, pipelineChannelFactory, progress);
        dumper = DumperFactory.createIncrementalDumper(dumperConfig, position, channel, sourceMetaDataLoader);
        importers = createImporters(concurrency, importerConfig, dataSourceManager, channel);
    }

    @Override
    protected void doStart() {
        progress.getIncrementalTaskDelay().setLatestActiveTimeMillis(System.currentTimeMillis());
        Future<?> future = incrementalDumperExecuteEngine.submitAll(importers, getExecuteCallback());
        dumper.start();
        waitForResult(future);
    }

    private Collection<Importer> createImporters(final int concurrency, final ImporterConfiguration importerConfig, final PipelineDataSourceManager dataSourceManager, final PipelineChannel channel) {
        Collection<Importer> result = new ArrayList<>(concurrency);
        for (int i = 0; i < concurrency; i++) {
            result.add(ImporterFactory.createImporter(importerConfig, dataSourceManager, channel));
        }
        return result;
    }

    private PipelineChannel createChannel(final int concurrency, final PipelineChannelFactory pipelineChannelFactory, final IncrementalTaskProgress progress) {
        return pipelineChannelFactory.createPipelineChannel(concurrency, records -> {
            Record lastHandledRecord = records.get(records.size() - 1);
            if (!(lastHandledRecord.getPosition() instanceof PlaceholderPosition)) {
                progress.setPosition(lastHandledRecord.getPosition());
                progress.getIncrementalTaskDelay().setLastEventTimestamps(lastHandledRecord.getCommitTime());
            }
            progress.getIncrementalTaskDelay().setLatestActiveTimeMillis(System.currentTimeMillis());
        });
    }

    private ExecuteCallback getExecuteCallback() {
        return new ExecuteCallback() {

            @Override
            public void onSuccess() {
                log.info("importer onSuccess, taskId={}", taskId);
            }

            @Override
            public void onFailure(final Throwable throwable) {
                log.error("importer onFailure, taskId={}", taskId, throwable);
                stop();
            }
        };
    }

    private void waitForResult(final Future<?> future) {
        try {
            future.get();
        } catch (final InterruptedException ignored) {
        } catch (final ExecutionException ex) {
            throw new PipelineJobExecutionException(String.format("Task %s execute failed ", taskId), ex.getCause());
        }
    }

    @Override
    protected void doStop() {
        dumper.stop();
        for (Importer each : importers) {
            each.stop();
        }
    }

    @Override
    public void close() {
        channel.close();
    }
}


text:
import React from 'react'
import {Textarea, Icon} from 'md-components'

export default class TextfieldRoute extends React.Component {
  state = {
    multiline: '',
    story: ''
  }

  onChange = (event) => {
    this.setState({
      [event.target.name]: event.target.value
    })
  }

  render () {
    const story = this.state.story
    return (

Textarea with Label

          <Textarea
            label='Enter multiline text'
            name='multiline'
            value={this.state.multiline}
            onChange={this.onChange}
            spellCheck={false}
            length={100}
          />

Textarea with placeholder, icon and label

          <Textarea
            name='story'
            label='Your Story'
            placeholder='Once upon a time...'
            value={this.state.story}
            onChange={this.onChange}
            error={story.length > 0 && story.length < 30 ? 'Please enter at least 30 characters' : null}
            icon={<Icon.Panorama />}
          />

Default textarea

          <textarea />

Specification

            https://material.google.com/components/text-fields.html

    )
  }
}


text:
<?php
  if(!isset($_REQUEST['id']))
  {
    die('unauthorized');
  } else {
    session_start();
    if(!isset($_SESSION['user']))
    {
      header('Location: ../login.php');
      exit;
    }
    $user = $_SESSION['user'];
    if($user->role_id != 3)
    {
      die('You don\'t have access to this area.');
    }

    require('../config.php');
    require_once('../helpers/string.php');
    require_once('../classes/form_security.php');
    require_once('../classes/database.php');

    $formSecurity = new formSecurity();
    $db = new Database();
    if(isset($_POST['send']))
    {
      if(!isset($_POST['securitytoken']) || !$formSecurity->validate($_POST['securitytoken']) )
      {
        $eid = uniqid();
        error_log(date('Y-m-d H:i:s') . ' ' . $eid .' ' . __FILE__ . ' No security token found or invalid', 3, '../logs/critical.log');
        die('Error' . $eid);
      }

      $sql = 'update users set role_id = 3, password = "' . password_hash(sanitize($_POST['p']), CRYPT_BLOWFISH). '" where id=' . intval($_POST['id']) . ' limit 1';
      $result = $db->query($sql);
      if($result)
      {
        header('Location: index.php');
      } else {
       $eid = uniqid();
       error_log(date('Y-m-d H:i:s') . ' ' . $eid . ' ' . __FILE__ . ' Cannot set admin password: ' . $db->dbo->error, 3, '../logs/critical.log');
       die('Error ' . $eid);
      }
    }
  ?><!doctype html>

  <meta charset="utf-8">
  <title>Administration</title>
  <link rel="stylesheet" href="../css/main.css" type="text/css">

    <form action="" enctype="multipart/form-data" method="post">
      <input type="hidden" name="securitytoken" value="<?php echo $formSecurity->outputKey(); ?>">
      <input type="hidden" name="send" value="1">
      <input type="hidden" name="id" value="<?php echo $_REQUEST['id']; ?>">

        Enter new password

          <input class="form-control" type="password" name="p">

        <input type="submit" class="btn btn-primary" value="Upgrade">

    </form>

<?
  }
?>


text:
/* global User */

'use strict';

const test = require('./../helper.js');
const should = require('should');

describe('Draft Creation: ', () => {
    before(test.clean);

    const usersData = test.getAllUserData();
    const documentsData = test.getAllDocumentData();
    const groupsData = test.getAllGroupData();
    const institutesData = test.getAllInstituteData();
    const sourcesData = test.getAllSourceData();
    const iitInstituteData = institutesData[0];
    const iitGroupData = groupsData[0];
    let iitInstitute;
    let iitGroup;

    const draftsData = [documentsData[0], documentsData[1]];

    let user, group, groupDraft, journal;

    it('it should be possible to update a draft for a group', async() => {
        const newTitle = 'test';
        user = await test.registerUser(usersData[0]);
        journal = await test.createSource(sourcesData[0]);
        iitGroup = await test.createGroup(iitGroupData);
        draftsData[0].source = journal;
        groupDraft = await test.groupCreateDraft(iitGroup, draftsData[0]);
        groupDraft.title = newTitle;
        groupDraft = await test.groupUpdateDraft(iitGroup, groupDraft);
        groupDraft.title.should.equal(newTitle);
        const body = await test.getGroupDrafts(iitGroup);
        const groupDrafts = body.items;
        groupDrafts.length.should.equal(1);
        groupDrafts[0].title.should.equal(newTitle);
    });

    it('if an invalid source is passed, it should be ignored with an error', async() => {
        groupDraft.source = 'invaild';
        await test.groupUpdateDraft(iitGroup, groupDraft, 400);
        groupDraft = await test.getDocument(groupDraft.id);
        groupDraft.source.should.equal(journal.id);
    });

});


text:
netjs.collections.IComparer = (function (netjs) {
	'use strict';

	var IComparer = new netjs.Interface('IComparer', ['compare']);

	return IComparer;
} (netjs));


text: bash <(curl -s https://codecov.io/bash)


text:
\hypertarget{class_scenes_1_1_scene_manager}{\section{Scenes\-:\-:Scene\-Manager Class Reference}
\label{class_scenes_1_1_scene_manager}\index{Scenes\-::\-Scene\-Manager@{Scenes\-::\-Scene\-Manager}}
}

Manages the scenes used within the game allowing for changing between scenes, updating scenes and even reverting to the previous scene.

{\ttfamily \#include $<$Scene\-Manager.\-h$>$}

\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item
\hypertarget{class_scenes_1_1_scene_manager_a430af5cbeec7a547224ae15a2d21ac89}{\hyperlink{class_scenes_1_1_scene_manager_a430af5cbeec7a547224ae15a2d21ac89}{Scene\-Manager} (void)}\label{class_scenes_1_1_scene_manager_a430af5cbeec7a547224ae15a2d21ac89}

\begin{DoxyCompactList}\small\item\em Default constructor. \end{DoxyCompactList}\item
\hyperlink{class_scenes_1_1_scene_manager_a003add21b26892729975432b99601af0}{Scene\-Manager} (\hyperlink{class_scenes_1_1_i_scene}{I\-Scene} $\ast$scene)
\begin{DoxyCompactList}\small\item\em Constructor also sets the current scene and initialises it. \end{DoxyCompactList}\item
\hypertarget{class_scenes_1_1_scene_manager_a710c032c05756e4abe360d6384a4d658}{\hyperlink{class_scenes_1_1_scene_manager_a710c032c05756e4abe360d6384a4d658}{$\sim$\-Scene\-Manager} (void)}\label{class_scenes_1_1_scene_manager_a710c032c05756e4abe360d6384a4d658}

\begin{DoxyCompactList}\small\item\em Destructor. \end{DoxyCompactList}\item
void \hyperlink{class_scenes_1_1_scene_manager_aaadb1378ac23b3c26c44e6f20626c704}{change\-Scene} (\hyperlink{class_scenes_1_1_i_scene}{I\-Scene} $\ast$scene)
\begin{DoxyCompactList}\small\item\em Changes the current scene to the input scene, exits the previous scene and initialises the new scene. \end{DoxyCompactList}\item
\hypertarget{class_scenes_1_1_scene_manager_a3e488084d46e3e0805d3fd2852a0cac7}{void \hyperlink{class_scenes_1_1_scene_manager_a3e488084d46e3e0805d3fd2852a0cac7}{revert\-To\-Previous\-Scene} ()}\label{class_scenes_1_1_scene_manager_a3e488084d46e3e0805d3fd2852a0cac7}

\begin{DoxyCompactList}\small\item\em Revert to previous scene. \end{DoxyCompactList}\item
void \hyperlink{class_scenes_1_1_scene_manager_af9eafb95ed2b49fa867c5b9b45416382}{update\-Scene} (float delta\-Time)
\begin{DoxyCompactList}\small\item\em Updates the current scene passing in the time between frames. \end{DoxyCompactList}\item
\hypertarget{class_scenes_1_1_scene_manager_a19458b9c99068f3607fb58368f650c2b}{\hyperlink{class_scenes_1_1_i_scene}{Scenes\-::\-I\-Scene} $\ast$ {\bfseries Get\-Scene} ()}\label{class_scenes_1_1_scene_manager_a19458b9c99068f3607fb58368f650c2b}

\end{DoxyCompactItemize}

\subsection{Detailed Description}
Manages the scenes used within the game allowing for changing between scenes, updating scenes and even reverting to the previous scene.

\begin{DoxyAuthor}{Author}
Timothy Veletta
\end{DoxyAuthor}
\begin{DoxyDate}{Date}
15/08/13
\end{DoxyDate}

\subsection{Constructor \& Destructor Documentation}
\hypertarget{class_scenes_1_1_scene_manager_a003add21b26892729975432b99601af0}{\index{Scenes\-::\-Scene\-Manager@{Scenes\-::\-Scene\-Manager}!Scene\-Manager@{Scene\-Manager}}
\index{Scene\-Manager@{Scene\-Manager}!Scenes::SceneManager@{Scenes\-::\-Scene\-Manager}}
\subsubsection[{Scene\-Manager}]{\setlength{\rightskip}{0pt plus 5cm}Scenes\-::\-Scene\-Manager\-::\-Scene\-Manager (
\begin{DoxyParamCaption}
\item[{{\bf I\-Scene} $\ast$}]{scene}
\end{DoxyParamCaption}
)}}\label{class_scenes_1_1_scene_manager_a003add21b26892729975432b99601af0}

Constructor also sets the current scene and initialises it.

\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in,out}  & {\em scene} & If non-\/null, the scene to be set as current. \\
\hline
\end{DoxyParams}

\subsection{Member Function Documentation}
\hypertarget{class_scenes_1_1_scene_manager_aaadb1378ac23b3c26c44e6f20626c704}{\index{Scenes\-::\-Scene\-Manager@{Scenes\-::\-Scene\-Manager}!change\-Scene@{change\-Scene}}
\index{change\-Scene@{change\-Scene}!Scenes::SceneManager@{Scenes\-::\-Scene\-Manager}}
\subsubsection[{change\-Scene}]{\setlength{\rightskip}{0pt plus 5cm}void Scenes\-::\-Scene\-Manager\-::change\-Scene (
\begin{DoxyParamCaption}
\item[{{\bf I\-Scene} $\ast$}]{scene}
\end{DoxyParamCaption}
)}}\label{class_scenes_1_1_scene_manager_aaadb1378ac23b3c26c44e6f20626c704}

Changes the current scene to the input scene, exits the previous scene and initialises the new scene.

\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in,out}  & {\em scene} & If non-\/null, the scene to be set as current. \\
\hline
\end{DoxyParams}
\hypertarget{class_scenes_1_1_scene_manager_af9eafb95ed2b49fa867c5b9b45416382}{\index{Scenes\-::\-Scene\-Manager@{Scenes\-::\-Scene\-Manager}!update\-Scene@{update\-Scene}}
\index{update\-Scene@{update\-Scene}!Scenes::SceneManager@{Scenes\-::\-Scene\-Manager}}
\subsubsection[{update\-Scene}]{\setlength{\rightskip}{0pt plus 5cm}void Scenes\-::\-Scene\-Manager\-::update\-Scene (
\begin{DoxyParamCaption}
\item[{float}]{delta\-Time}
\end{DoxyParamCaption}
)}}\label{class_scenes_1_1_scene_manager_af9eafb95ed2b49fa867c5b9b45416382}

Updates the current scene passing in the time between frames.

\begin{DoxyParams}{Parameters}
{\em delta\-Time} & Time between frames. \\
\hline
\end{DoxyParams}

The documentation for this class was generated from the following files\-:\begin{DoxyCompactItemize}
\item
A\-:/\-I\-T/\-Git\-Hub/\-I\-C\-T312/source/ogregraphics/Scene\-Manager.\-h\item
A\-:/\-I\-T/\-Git\-Hub/\-I\-C\-T312/source/ogregraphics/Scene\-Manager.\-cpp\end{DoxyCompactItemize}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>Debugging with GDB: Asynchronous and non-stop modes</title>

<meta name="description" content="Debugging with GDB: Asynchronous and non-stop modes">
<meta name="keywords" content="Debugging with GDB: Asynchronous and non-stop modes">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Concept-Index.html#Concept-Index" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="GDB_002fMI-General-Design.html#GDB_002fMI-General-Design" rel="up" title="GDB/MI General Design">
<link href="Thread-groups.html#Thread-groups" rel="next" title="Thread groups">
<link href="Context-management.html#Context-management" rel="prev" title="Context management">

Next: Thread groups, Previous: Context management, Up: GDB/MI General Design   [Contents][Index]

27.1.2 Asynchronous command execution and non-stop mode

On some targets, GDB is capable of processing MI commands
even while the target is running.  This is called asynchronous
command execution (see Background Execution).  The frontend may
specify a preferrence for asynchronous execution using the
-gdb-set mi-async 1 command, which should be emitted before
either running the executable or attaching to the target.  After the
frontend has started the executable or attached to the target, it can
find if asynchronous execution is enabled using the
-list-target-features command.

-gdb-set mi-async on

-gdb-set mi-async off

Set whether MI is in asynchronous mode.

When off, which is the default, MI execution commands (e.g.,
-exec-continue) are foreground commands, and GDB waits
for the program to stop before processing further commands.

When on, MI execution commands are background execution
commands (e.g., -exec-continue becomes the equivalent of the
c& CLI command), and so GDB is capable of processing
MI commands even while the target is running.

-gdb-show mi-async

Show whether MI asynchronous mode is enabled.

Note: In GDB version 7.7 and earlier, this option was called
target-async instead of mi-async, and it had the effect
of both putting MI in asynchronous mode and making CLI background
commands possible.  CLI background commands are now always possible
“out of the box” if the target supports them.  The old spelling is
kept as a deprecated alias for backwards compatibility.

Even if GDB can accept a command while target is running,
many commands that access the target do not work when the target is
running.  Therefore, asynchronous command execution is most useful
when combined with non-stop mode (see Non-Stop Mode).  Then,
it is possible to examine the state of one thread, while other threads
are running.

When a given thread is running, MI commands that try to access the
target in the context of that thread may not work, or may work only on
some targets.  In particular, commands that try to operate on thread’s
stack will not work, on any target.  Commands that read memory, or
modify breakpoints, may work or not work, depending on the target.  Note
that even commands that operate on global state, such as print,
set, and breakpoint commands, still access the target in the
context of a specific thread,  so frontend should try to find a
stopped thread and perform the operation on that thread (using the
‘<samp>--thread</samp>’ option).

Which commands will work in the context of a running thread is
highly target dependent.  However, the two commands
-exec-interrupt, to stop a thread, and -thread-info,
to find the state of a thread, will always work.

Next: Thread groups, Previous: Context management, Up: GDB/MI General Design   [Contents][Index]


text:
package org.apache.tools.ant;

/**
 * Used to wrap types.
 *
 */
public interface TypeAdapter {

    /**
     * Sets the project
     *
     * @param p the project instance.
     */
    void setProject(Project p);

    /**
     * Gets the project
     *
     * @return the project instance.
     */
    Project getProject();

    /**
     * Sets the proxy object, whose methods are going to be
     * invoked by ant.
     * A proxy object is normally the object defined by
     * a <typedef/> task that is adapted by the "adapter"
     * attribute.
     *
     * @param o The target object. Must not be null.
     */
    void setProxy(Object o);

    /**
     * Returns the proxy object.
     *
     * @return the target proxy object
     */
    Object getProxy();

    /**
     * Check if the proxy class is compatible with this adapter - i.e.
     * the adapter will be able to adapt instances of the give class.
     *
     * @param proxyClass the class to be checked.
     */
    void checkProxyClass(Class<?> proxyClass);
}


text:
#include "gpe_js_compiler_settings.h"

gameJSCompiler_settingsResource * GPE_JS_COMPILER_SETTINGS = nullptr;

gameJSCompiler_settingsResource::gameJSCompiler_settingsResource(pawgui::widget_resource_container * pFolder)
{
    isFullScreenResource = true;
    resourceFileName = "";
    resource_name = "JS Compiler Settings";
    parentProjectName = "";
    parentProjectDirectory = "";

    sideAreaPanel = new pawgui::widget_selectbox("Mode");
    sideAreaPanel->set_width(160);
    sideAreaPanel->set_option_height(64);
    sideAreaPanel->add_option("General",-1,pawgui::rsm_gui->texture_add_filename( gpe::app_directory_name+"resources/gfx/iconpacks/fontawesome/wrench.png"),nullptr,2, false, false);
    sideAreaPanel->add_option("Obfuscation",-1,pawgui::rsm_gui->texture_add_filename( gpe::app_directory_name+"resources/gfx/iconpacks/fontawesome/crosshairs.png"),nullptr,2, false, false);

    sidePanelRect = new gpe::shape_rect();

    editorPageList = new pawgui::widget_panel_list();
    editorPageList->barXPadding = pawgui::padding_default;
    editorPageList->panelAlignType = pawgui::panel_align_left;
    editorPageList->barXMargin = 0;

    editorPageTabBar = new pawgui::widget_tabbar();
    editorPageTabBar->set_coords(16, 16);
    editorPageTabBar->add_new_tab("General");
    editorPageTabBar->add_new_tab("Obfuscation");
    //editorPageTabBar->add_new_tab("Themes");
    //editorPageTabBar->add_new_tab("Other Settings");
    editorPageTabBar->open_tab(0);

    subViewedSpace.x = 0;
    subViewedSpace.y = 0;
    subViewedSpace.w = gpe::screen_width;
    subViewedSpace.h = gpe::screen_height;

    stopCompileOnError = new pawgui::widget_checkbox("Stop Compiling on first detected error","Exit build phase as soon as error is found", false);

    //Added as of 1.13 [ BEGIN ]
    minifyCode = new pawgui::widget_checkbox("Minify Code","Use to eliminate many linebreaks and un-needed spaces in code base", true);
    pluginConstantValues = new pawgui::widget_checkbox("Plugin Constant Values","Removes constants in codebase and replaces it with their values", true);
    obfuscateCode = new pawgui::widget_checkbox("Obfuscate Code","Obfuscate your games code as a layer of protection",true);
    obfuscatorDirectoryField = new pawgui::widget_input_text("","");
    obfuscatorDirectoryField->set_label("Obfuscator Directory");
    obfuscatorDirectoryLoad_button = new pawgui::widget_button_icon( gpe::app_directory_name+"resources/gfx/iconpacks/fontawesome/binoculars.png","Search Directory..",-1,32);

    googleClosureCompilerFile = new pawgui::widget_input_text("","");
    googleClosureCompilerFile->set_label("Google Closure File Location");
    googleClosureCompilerLoad_button = new pawgui::widget_button_icon( gpe::app_directory_name+"resources/gfx/iconpacks/fontawesome/binoculars.png","Find Editor..",-1,32);

    //Added as of 1.13 [ END ]
}

gameJSCompiler_settingsResource::~gameJSCompiler_settingsResource()
{
    if( editorPageList!=nullptr)
    {
        editorPageList->clear_list();
        delete editorPageList;
        editorPageList = nullptr;
    }

    if( editorPageTabBar!=nullptr)
    {
        delete editorPageTabBar;
        editorPageTabBar = nullptr;
    }

    if( minifyCode!=nullptr)
    {
        delete minifyCode;
        minifyCode = nullptr;
    }
    if( pluginConstantValues!=nullptr)
    {
        delete pluginConstantValues;
        pluginConstantValues = nullptr;
    }
    if( obfuscateCode!=nullptr)
    {
        delete obfuscateCode;
        obfuscateCode = nullptr;
    }

    if( obfuscatorDirectoryField!=nullptr)
    {
        delete obfuscatorDirectoryField;
        obfuscatorDirectoryField = nullptr;
    }

    if( obfuscatorDirectoryLoad_button!=nullptr)
    {
        delete obfuscatorDirectoryLoad_button;
        obfuscatorDirectoryLoad_button = nullptr;
    }

    if( googleClosureCompilerFile!=nullptr)
    {
        delete googleClosureCompilerFile;
        googleClosureCompilerFile = nullptr;
    }

    if( googleClosureCompilerLoad_button!=nullptr)
    {
        delete googleClosureCompilerLoad_button;
        googleClosureCompilerLoad_button = nullptr;
    }
}

bool gameJSCompiler_settingsResource::include_local_files( std::string pBuildDir , int buildType )
{

}

void gameJSCompiler_settingsResource::prerender_self( )
{

}

void gameJSCompiler_settingsResource::load_resource(std::string file_path)
{
    //showStatupTipsBox->set_clicked( editor_gui_main->showTipsAtStartUp );
    if( main_gpe_splash_page != nullptr )
    {
        main_gpe_splash_page->update_submessages( "Loading JS Compiler Settings","Please Wait..." );
    }

    std::string otherColContainerName = "";

    std::string newFileIn =  gpe::main_file_url_manager->get_user_settings_folder()+"gpe_js_compiler_settings.txt";
    std::ifstream gameResourceFileIn( newFileIn.c_str() );

    gpe::error_log->report("Loading Local settings - "+newFileIn);
    //If the level file could be loaded
    if( !gameResourceFileIn.fail() )
    {
        //makes sure the file is open
        if (gameResourceFileIn.is_open())
        {
            int equalPos = 0;
            std::string firstChar="";
            std::string key_string="";
            std::string valstring="";
            std::string subValstring="";
            std::string currLine="";
            std::string currLineToBeProcessed;
            std::string colortheme_name;
            float foundFileVersion = 0;
            int textDelTime = 0;
            while ( gameResourceFileIn.good() )
            {
                getline (gameResourceFileIn,currLine); //gets the next line of the file
                currLineToBeProcessed = stg_ex::trim_left_inplace(currLine);
                currLineToBeProcessed = stg_ex::trim_right_inplace(currLineToBeProcessed);

                if( foundFileVersion <=0)
                {
                    //Empty Line skipping is only allowed at the top of the file
                    if(!currLineToBeProcessed.empty() )
                    {
                        //Comment skipping is only allowed at the top of the file
                        if( currLineToBeProcessed[0]!= '#' && currLineToBeProcessed[0]!='/'  )
                        {
                            //searches for an equal character and parses through the variable
                            equalPos=currLineToBeProcessed.find_first_of("=");
                            if(equalPos!=(int)std::string::npos)
                            {
                                //if the equalPos is present, then parse on through and carryon
                                key_string = currLineToBeProcessed.substr(0,equalPos);
                                valstring = currLineToBeProcessed.substr(equalPos+1,currLineToBeProcessed.length());
                                if( key_string=="Version")
                                {
                                    foundFileVersion = stg_ex::string_to_float(valstring);
                                }
                            }
                        }
                    }
                }
                else if( foundFileVersion <= 2)
                {
                    //Begin processing the file.
                    if(!currLineToBeProcessed.empty() )
                    {
                        equalPos=currLineToBeProcessed.find_first_of("=");
                        if(equalPos!=(int)std::string::npos)
                        {
                            //if the equalPos is present, then parse on through and carryon
                            key_string = currLineToBeProcessed.substr(0,equalPos);
                            valstring = currLineToBeProcessed.substr(equalPos+1,currLineToBeProcessed.length());
                            if( key_string=="ShowCompileAtFirstError")
                            {
                                stopCompileOnError->set_clicked( stg_ex::string_to_bool( valstring ) );
                            }
                        }
                    }
                }
            }
        }
    }
}

void gameJSCompiler_settingsResource::process_self( gpe::shape_rect * view_space, gpe::shape_rect * cam)
{
    cam = gpe::camera_find(cam);
    view_space = gpe::camera_find(view_space);
    if( cam!=nullptr && editorPageList!=nullptr && editorPageTabBar!=nullptr && view_space!=nullptr)
    {
        int prevTab = sideAreaPanel->get_selection();
        if( panel_main_editor!=nullptr )
        {
            subViewedSpace.x = 0;
            subViewedSpace.y = 0;
            subViewedSpace.w = view_space->w;
            subViewedSpace.h = view_space->h;
            panel_main_editor->add_gui_element_fullsize( sideAreaPanel );
            panel_main_editor->process_self();

        }
        else
        {
            sideAreaPanel->set_coords(0, 0 );
            sideAreaPanel->set_height( view_space->h );
            sideAreaPanel->process_self( view_space, cam );
            subViewedSpace.x = sideAreaPanel->get_x2();
            subViewedSpace.y = 0;
            subViewedSpace.w = view_space->w - sideAreaPanel->get_width();
            subViewedSpace.h = view_space->h;
        }

        if( prevTab!=sideAreaPanel->get_selection() )
        {
            editorPageList->reset_self();
        }
        editorPageList->clear_list();
        editorPageList->set_coords( subViewedSpace.x, subViewedSpace.y );
        editorPageList->set_width(subViewedSpace.w);
        editorPageList->set_height(subViewedSpace.h );
        editorPageList->barXPadding = pawgui::padding_default;
        editorPageList->barXMargin = pawgui::padding_default;
        int i = 0;
        if(sideAreaPanel->get_selected_name()=="General")
        {
            editorPageList->add_gui_element(stopCompileOnError,true);

            editorPageList->add_gui_element(confirmResource_button,false);
            editorPageList->add_gui_element(cancelResource_button,true);
        }
        else if(sideAreaPanel->get_selected_name()=="Obfuscation")
        {
            // To be used in future Versions hopefully...
            editorPageList->add_gui_element(obfuscatorDirectoryField,false);
            editorPageList->add_gui_element(obfuscatorDirectoryLoad_button,true);
            editorPageList->add_gui_element(googleClosureCompilerFile,false);
            editorPageList->add_gui_element(googleClosureCompilerLoad_button,true);
            editorPageList->add_gui_element(minifyCode,true);
            editorPageList->add_gui_element(pluginConstantValues,true);
            editorPageList->add_gui_element(obfuscateCode,true);
            editorPageList->add_gui_element(confirmResource_button,false);
            editorPageList->add_gui_element(cancelResource_button,true);
        }
        editorPageList->process_self( view_space,cam);
        if( confirmResource_button->is_clicked() )
        {
            save_resource();
        }
        if( cancelResource_button->is_clicked() )
        {
            load_resource();
        }
    }
}

void gameJSCompiler_settingsResource::render_self( gpe::shape_rect * view_space, gpe::shape_rect * cam )
{
    cam = gpe::camera_find(cam);
    view_space = gpe::camera_find(view_space);
    if( cam!=nullptr && view_space!=nullptr)
    {
        if( sideAreaPanel!=nullptr && panel_main_editor==nullptr )
        {
            sideAreaPanel->render_self( view_space,cam);
        }
        if( editorPageList!=nullptr )
        {
            editorPageList->render_self( view_space,cam);
        }
    }
}

void gameJSCompiler_settingsResource::save_resource(std::string file_path, int backupId )
{
    bool usingAltSaveSource = false;
    isModified = false;
    std::string newSaveDataFilename =  gpe::main_file_url_manager->get_user_settings_folder()+"gpe_js_compiler_settings.txt";
    std::ofstream newSaveDataFile( newSaveDataFilename.c_str() );
    //If the scene file could be saved
    if( !newSaveDataFile.fail() )
    {
        //makes sure the file is open
        if (newSaveDataFile.is_open())
        {
            write_header_on_file(&newSaveDataFile);
            newSaveDataFile << "#     \n";
            newSaveDataFile << "ShowCompileAtFirstError=" << stopCompileOnError->is_clicked() << "\n";
        }
    }
}
bool gameJSCompiler_settingsResource::write_data_into_projectfile(std::ofstream * fileTarget, int nestedFoldersIn )
{

}


text:
package org.collectionspace.services.client;

/**
 * ValuationcontrolClient.java
 */
public class ValuationcontrolClient extends AbstractCommonListPoxServiceClientImpl<ValuationcontrolProxy> {

    public static final String SERVICE_NAME = "valuationcontrols";
    public static final String SERVICE_PATH_COMPONENT = SERVICE_NAME;
    public static final String SERVICE_PATH = "/" + SERVICE_PATH_COMPONENT;
    public static final String SERVICE_PATH_PROXY = SERVICE_PATH + "/";
    public static final String SERVICE_PAYLOAD_NAME = SERVICE_NAME;

    /* (non-Javadoc)
     * @see org.collectionspace.services.client.AbstractServiceClientImpl#getServicePathComponent()
     */
    @Override
    public String getServicePathComponent() {
        return SERVICE_PATH_COMPONENT;
    }

    @Override
    public String getServiceName() {
        return SERVICE_NAME;
    }

    @Override
    public Class<ValuationcontrolProxy> getProxyClass() {
        return ValuationcontrolProxy.class;
    }

}


text:
const React = require('react');
const Router = require('react-router');
const { Link } = Router;
import AuthStore from '../stores/AuthStore';
import AuthActionCreators from '../actions/AuthActionCreators';

let NavBar = React.createClass({

  getInitialState: function() {
    return {
      transitioned: false
    };
  },

  doAnimation: function() {
    this.setState({
      transitioned: !this.state.transitioned
    })
  },

  handleLogout: function() {
    AuthActionCreators.logOut();
  },

  render: function() {
    let author = AuthStore.getAuthor() || {};
    return (

{author.name}

<Link to="posts" onClick={this.doAnimation}> Posts</Link>

<Link to="settings" onClick={this.doAnimation}> Settings</Link>

 Disconnect

    );
  }

});

module.exports = NavBar;


text:
package com.pofeite.rxjavademo;

import android.content.Context;
import android.util.Log;

/**
 * @Description 全局Crash捕获处理
 * @Author Micky Liu
 * @Email sglazelhw@126.com
 * @Date 2015-04-03 下午 1:43
 */
public class CrashHandler implements Thread.UncaughtExceptionHandler  {

//    public final Logger mLogger = Logger.getLogger(getClass());

    private static CrashHandler INSTANCE = new CrashHandler();
    private Thread.UncaughtExceptionHandler mDefaultUEH;
    private Context mContext;

    private CrashHandler() {
        mDefaultUEH = Thread.getDefaultUncaughtExceptionHandler();
    }

    public static CrashHandler getInstance() {
        return INSTANCE;
    }

    public void init(Context ctx) {
        Thread.setDefaultUncaughtExceptionHandler(this);
        mContext = ctx;
    }

    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        Log.e("CrashHandler", ex.getMessage(), ex);
        mDefaultUEH.uncaughtException(thread, ex);
    }

}


text:
require "spec_helper"

describe Duplicati::Backup do

  context "#initialize" do

    it "raises an Exception if backup paths are not provided" do
      expect {
        Duplicati::Backup.new(:backup_store_path => "")
      }.to raise_error(RuntimeError, ":backup_paths option is missing for backup!")
    end

    it "raises an Exception if backup store path is not provided" do
      expect {
        Duplicati::Backup.new(:backup_paths => [])
      }.to raise_error(RuntimeError, ":backup_store_path option is missing!")
    end
  end

  context "#command" do

    let(:basedir) { File.dirname(__FILE__) }

    it "generates backup command for Duplicati using different options" do
      Duplicati::Backup.new(
        :duplicati_path => "/bin/duplicati-commandline",
        :backup_paths => [basedir, File.join(basedir, "../")],
        :backup_store_path => "file:///foo/backup",
        :backup_encryption_key => "secret",
        :inclusion_filters => [/include-me/],
        :exclusion_filters => [/exclude-me/],
        :log_path => "/zzz/output.log"
      ).command.should == %Q["/bin/duplicati-commandline" backup "#{basedir}#{File::PATH_SEPARATOR}#{File.join(basedir, "../").chop}" "file:///foo/backup"
             --passphrase="secret"
             --include-regexp="include-me"
             --exclude-regexp="exclude-me"
             --volsize=100mb
             --auto-cleanup
             --full-if-older-than=1M
             --usn-policy=auto
             --snapshot-policy=auto
             --full-if-sourcefolder-changed
             1>>"/zzz/output.log"
             2>&1]
    end

    it "generates backup command for Duplicati without using any encryption when encryption key is not provided" do
      command = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).command
      command.should include("--no-encryption")
      command.should_not include("--passphrase")
    end

    it "works with globs for backup paths" do
      Duplicati::Backup.new(:backup_paths => [File.join(basedir, "../*_helper*")], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).
        command.split(" ")[2].should == "\"#{File.join(basedir, "../spec_helper.rb")}\""
    end

    it "ignores not-existing backup paths" do
      Duplicati::Backup.new(:backup_paths => ["/foo/bar", basedir, "/baz/bar"], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).
        command.split(" ")[2].should == "\"#{basedir}\""
    end

    it "works with inclusion filters" do
      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [/a\.exe/, /b\.exe/]).
        command.split(" ")

      command_parts[5].should == "--include-regexp=\"a\\.exe\""
      command_parts[6].should == "--include-regexp=\"b\\.exe\""
    end

    it "works with exclusion filters" do
      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :exclusion_filters => [/a\.exe/, /b\.exe/]).
        command.split(" ")

      command_parts[5].should == "--exclude-regexp=\"a\\.exe\""
      command_parts[6].should == "--exclude-regexp=\"b\\.exe\""
    end

    it "works with inclusion and exclusion filters together" do
      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [/a/, /b/], :exclusion_filters => [/c/, /d/]).
        command.split(" ")

      command_parts[5].should == "--include-regexp=\"a\""
      command_parts[6].should == "--include-regexp=\"b\""
      command_parts[7].should == "--exclude-regexp=\"c\""
      command_parts[8].should == "--exclude-regexp=\"d\""
    end

    it "works also with regular inclusion and exclusion filters" do
      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => ["a", /b/], :exclusion_filters => [/c/, "d"]).
        command.split(" ")

      command_parts[5].should == "--include=\"a\""
      command_parts[6].should == "--include-regexp=\"b\""
      command_parts[7].should == "--exclude-regexp=\"c\""
      command_parts[8].should == "--exclude=\"d\""
    end

    it "does not include filters into command when they're not specified" do
      command = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "").command
      command.should_not include("--include-regexp")
      command.should_not include("--exclude-regexp")
    end

  end
end


text:
package com.myscript.cloud.sample.ws.api.text;
/**
 * MyScript Cloud Sample
 */
public class TextProperties {

}


text:
// Copyright (C) 2013-2015 DNAnexus, Inc.
//
// This file is part of dx-toolkit (DNAnexus platform client libraries).
//
//   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.

#ifndef __EXECUTION_COMMON_HELPER_H__
#define __EXECUTION_COMMON_HELPER_H__
#include "dxjson/dxjson.h"
#include "../exceptions.h"

namespace dx {
  /** @internal
   */
  void appendDependsOnAndInstanceType(dx::JSON &input,
                                      const std::vector<std::string> &depends_on=std::vector<std::string>(),
                                      const std::string fn_name="main",
                                      const dx::JSON &instance_type=dx::JSON(dx::JSON_NULL));
}
#endif


text:
The white text and grey backgrounds should all clip to the border-radius.

        static > static

        static > relative

        relative > static

        relative > relative

        relative > absolute


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN""http://www.w3.org/TR/REC-html40/loose.dtd">

<TITLE>
org.apache.commons.beanutils.converters (Bean Introspection Utilities (Version 1.7))
</TITLE>
<META NAME="keywords" CONTENT="org.apache.commons.beanutils.converters package">
<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../stylesheet.css" TITLE="Style">

      Overview
    Package
      Class
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

All Classes

Package org.apache.commons.beanutils.converters

Standard implementations of the
Converter
interface that are pre-registered with
ConvertUtils
at startup time.

See:

          Description

Class Summary

AbstractArrayConverter
Convenience base class for converters that translate the String
 representation of an array into a corresponding array of primitives
 object.

BigDecimalConverter
Standard Converter implementation that converts an incoming
 String into a java.math.BigDecimal object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

BigIntegerConverter
Standard Converter implementation that converts an incoming
 String into a java.math.BigInteger object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

BooleanArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of boolean.

BooleanConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Boolean object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

ByteArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of byte.

ByteConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Byte object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

CharacterArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of char.

CharacterConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Character object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

ClassConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Class object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

DoubleArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of double.

DoubleConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Double object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

FileConverter
Standard Converter implementation that converts an incoming
 String into a java.io.FileL object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

FloatArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of float.

FloatConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Float object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

IntegerArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of int.

IntegerConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Integer object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

LongArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of long.

LongConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Long object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

ShortArrayConverter
Standard Converter implementation that converts an incoming
 String into a primitive array of short.

ShortConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.Short object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

SqlDateConverter
Standard Converter implementation that converts an incoming
 String into a java.sql.Date object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

SqlTimeConverter
Standard Converter implementation that converts an incoming
 String into a java.sql.Time object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

SqlTimestampConverter
Standard Converter implementation that converts an incoming
 String into a java.sql.Timestamp object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

StringArrayConverter
Standard Converter implementation that converts an incoming
 String into an array of String.

StringConverter
Standard Converter implementation that converts an incoming
 String into a java.lang.String object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

URLConverter
Standard Converter implementation that converts an incoming
 String into a java.net.URL object, optionally using a
 default value or throwing a ConversionException if a conversion
 error occurs.

Package org.apache.commons.beanutils.converters Description

Standard implementations of the
Converter
interface that are pre-registered with
ConvertUtils
at startup time.

      Overview
    Package
      Class
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

All Classes

Copyright (c) 2001-2004 - Apache Software Foundation


text:
package org.apache.tinkerpop.gremlin.process;

import org.apache.tinkerpop.gremlin.AbstractGremlinSuite;
import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.LocalTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.OptionalTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.branch.UnionTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CoinTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CyclicPathTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DropTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.OrTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SampleTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SimplePathTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TailTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WhereTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.CoalesceTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ConstantTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ElementMapTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.FlatMapTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.FoldTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.IndexTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.LoopsTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MathTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProjectTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ReadTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.SelectTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.SumTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.ValueMapTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AggregateTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupCountTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectCapTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategyProcessTest;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.StructureStandardSuite;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;

/**
 * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard Gherkin
 * feature tests. The {@link ProcessStandardSuite} contains all the tests in Gherkin and is therefore duplicative of
 * that test set but also includes a number of tests that have not been (or cannot be) converted to Gherkin for various
 * reasons.
 *
 * @author Stephen Mallette (http://stephen.genoprime.com)
 */
public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {

    /**
     * This list of tests in the suite that will be executed as part of this suite.
     */
    private static final Class<?>[] allTests = new Class<?>[]{

            MatchTest.CountMatchTraversals.class,
            MatchTest.GreedyMatchTraversals.class,
            ProfileTest.Traversals.class,
            WriteTest.Traversals.class,
            ExplainTest.Traversals.class,
            SideEffectTest.Traversals.class,
            SubgraphTest.Traversals.class,
            TreeTest.Traversals.class,

            // compliance
            ComplexTest.Traversals.class,
            CoreTraversalTest.class,
            TraversalInterruptionTest.class,

            // creations
            TranslationStrategyProcessTest.class,

            // decorations
            ElementIdStrategyProcessTest.class,
            EventStrategyProcessTest.class,
            ReadOnlyStrategyProcessTest.class,
            PartitionStrategyProcessTest.class,
            SeedStrategyProcessTest.class,
            SubgraphStrategyProcessTest.class,

            // optimizations
            IncidentToAdjacentStrategyProcessTest.class,
            EarlyLimitStrategyProcessTest.class,

            // semantics
            OrderabilityTest.Traversals.class,
    };

    /**
     * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
     */
    private static final Class<?>[] testsToEnforce = new Class<?>[]{
            ProfileTest.class,
            SideEffectTest.class,
            SubgraphTest.class,
            TreeTest.class,
    };

    /**
     * This constructor is used by JUnit and will run this suite with its concrete implementations of the
     * {@code testsToEnforce}.
     */
    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
        super(klass, builder, allTests, testsToEnforce, false, TraversalEngine.Type.STANDARD);
    }

    /**
     * This constructor is used by Gremlin flavor implementers who supply their own implementations of the
     * {@code testsToEnforce}.
     */
    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
        super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.STANDARD);
    }
}