text:
{% extends "base.html" %}
{% block title %}Worlds at War - Vacation Mode{% endblock %}

{% block content %}

Vacation mode

  Your world is in vacation mode!
 Go to the forums and ask for reactivation.

{% endblock %}


text:
    dead_code,
    non_snake_case,
    non_camel_case_types,
    non_upper_case_globals
)]

#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct TestOverload {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_TestOverload() {
    assert_eq!(
        ::std::mem::size_of::<TestOverload>(),
        1usize,
        concat!("Size of: ", stringify!(TestOverload))
    );
    assert_eq!(
        ::std::mem::align_of::<TestOverload>(),
        1usize,
        concat!("Alignment of ", stringify!(TestOverload))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12TestOverloadC1Ei"]
    pub fn TestOverload_TestOverload(
        this: *mut TestOverload,
        arg1: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12TestOverloadC1Ed"]
    pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64);
}
impl TestOverload {
    #[inline]
    pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self {
        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
        TestOverload_TestOverload(__bindgen_tmp.as_mut_ptr(), arg1);
        __bindgen_tmp.assume_init()
    }
    #[inline]
    pub unsafe fn new1(arg1: f64) -> Self {
        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
        TestOverload_TestOverload1(__bindgen_tmp.as_mut_ptr(), arg1);
        __bindgen_tmp.assume_init()
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct TestPublicNoArgs {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_TestPublicNoArgs() {
    assert_eq!(
        ::std::mem::size_of::<TestPublicNoArgs>(),
        1usize,
        concat!("Size of: ", stringify!(TestPublicNoArgs))
    );
    assert_eq!(
        ::std::mem::align_of::<TestPublicNoArgs>(),
        1usize,
        concat!("Alignment of ", stringify!(TestPublicNoArgs))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"]
    pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs);
}
impl TestPublicNoArgs {
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
        TestPublicNoArgs_TestPublicNoArgs(__bindgen_tmp.as_mut_ptr());
        __bindgen_tmp.assume_init()
    }
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using Gtk;

using Banshee.Gui;
using Banshee.MediaEngine;
using Banshee.ServiceStack;

namespace Banshee.NowPlaying
{
    public class FullscreenWindow : Window
    {
        private Gtk.Window parent;
        private FullscreenControls controls;
        private InterfaceActionService action_service;

        public FullscreenWindow (Window parent) : base (WindowType.Toplevel)
        {
            Title = parent.Title;
            AppPaintable = true;

            this.parent = parent;
            this.action_service = ServiceManager.Get<InterfaceActionService> ();

            AddAccelGroup (action_service.UIManager.AccelGroup);

            SetupWidget ();
        }

        protected override bool OnExposeEvent (Gdk.EventExpose evnt)
        {
            evnt.Window.DrawRectangle (Style.BlackGC, true, Allocation);
            return base.OnExposeEvent (evnt);
        }

        protected override bool OnKeyPressEvent (Gdk.EventKey evnt)
        {
            PlayerEngineService player = ServiceManager.PlayerEngine;

            bool control = (evnt.State & Gdk.ModifierType.ShiftMask) != 0;
            bool shift = (evnt.State & Gdk.ModifierType.ControlMask) != 0;
            bool mod = control || shift;

            uint fixed_seek = 15000; // 15 seconds
            uint fast_seek = player.Length > 0 ? (uint)(player.Length * 0.15) : fixed_seek; // 15% or fixed
            uint slow_seek = player.Length > 0 ? (uint)(player.Length * 0.05) : fixed_seek; // 5% or fixed

            switch (evnt.Key) {
                case Gdk.Key.F11:
                case Gdk.Key.Escape:
                    Hide ();
                    return true;
                case Gdk.Key.C:
                case Gdk.Key.c:
                case Gdk.Key.V:
                case Gdk.Key.v:
                case Gdk.Key.Return:
                case Gdk.Key.KP_Enter:
                case Gdk.Key.Tab:
                    if (controls == null || !controls.Visible) {
                        ShowControls ();
                    } else {
                        HideControls ();
                    }
                    return true;
                case Gdk.Key.Right:
                case Gdk.Key.rightarrow:
                    player.Position += mod ? fast_seek : slow_seek;
                    ShowControls ();
                    break;
                case Gdk.Key.Left:
                case Gdk.Key.leftarrow:
                    player.Position -= mod ? fast_seek : slow_seek;
                    ShowControls ();
                    break;
            }

            return base.OnKeyPressEvent (evnt);
        }

#region Widgetry and show/hide logic

        private void SetupWidget ()
        {
            Deletable = false;
            TransientFor = null;
            Decorated = false;
            CanFocus = true;

            ConfigureWindow ();
        }

        private void ConfigureWindow ()
        {
            Gdk.Screen screen = Screen;
            int monitor = screen.GetMonitorAtWindow (parent.GdkWindow);
            Gdk.Rectangle bounds = screen.GetMonitorGeometry (monitor);
            Move (bounds.X, bounds.Y);
            Resize (bounds.Width, bounds.Height);
        }

        protected override void OnRealized ()
        {
            Events |= Gdk.EventMask.PointerMotionMask;

            base.OnRealized ();

            GdkWindow.OverrideRedirect = true;

            Screen.SizeChanged += OnScreenSizeChanged;
        }

        protected override void OnUnrealized ()
        {
            base.OnUnrealized ();
            Screen.SizeChanged -= OnScreenSizeChanged;
        }

        protected override bool OnDeleteEvent (Gdk.Event evnt)
        {
            Hide ();
            return true;
        }

        protected override void OnShown ()
        {
            base.OnShown ();
            if (Child != null) {
                Child.Show ();
            }

            OnHideCursorTimeout ();
            ConfigureWindow ();
            HasFocus = true;
            parent.AddNotification ("is-active", ParentActiveNotification);
        }

        protected override void OnHidden ()
        {
            base.OnHidden ();
            DestroyControls ();
        }

        private void OnScreenSizeChanged (object o, EventArgs args)
        {
            ConfigureWindow ();
        }

        private void ParentActiveNotification (object o, GLib.NotifyArgs args)
        {
            // If our parent window is ever somehow activated while we are
            // visible, this will ensure we merge back into the parent
            if (parent.IsActive) {
                parent.GdkWindow.SkipPagerHint = false;
                parent.GdkWindow.SkipTaskbarHint = false;
                Hide ();
                parent.RemoveNotification ("is-active", ParentActiveNotification);
            } else {
                parent.GdkWindow.SkipPagerHint = true;
                parent.GdkWindow.SkipTaskbarHint = true;
            }
        }

#endregion

#region Control Window

        private void ShowControls ()
        {
            if (controls == null) {
                controls = new FullscreenControls (this, action_service);
            }

            controls.Show ();
        }

        private void HideControls ()
        {
            if (controls != null) {
                controls.Hide ();
                QueueDraw ();
            }
        }

        private void DestroyControls ()
        {
            if (controls != null) {
                controls.Destroy ();
                controls = null;
            }
        }

        private bool ControlsActive {
            get {
                if (controls == null || !controls.Visible) {
                    return false;
                } else if (controls.Active) {
                    return true;
                }

                int cursor_x, cursor_y;
                int window_x, window_y;

                controls.GdkWindow.Screen.Display.GetPointer (out cursor_x, out cursor_y);
                controls.GetPosition (out window_x, out window_y);

                Gdk.Rectangle box = new Gdk.Rectangle (window_x, window_y,
                    controls.Allocation.Width, controls.Allocation.Height);

                return box.Contains (cursor_x, cursor_y);
            }
        }

#endregion

#region Mouse Cursor Logic

        private const int CursorUpdatePositionDelay = 500;   // How long (ms) before the cursor position is updated
        private const int CursorHideDelay = 5000;            // How long (ms) to remain stationary before it hides
        private const int CursorShowMovementThreshold = 150; // How far (px) to move before it shows again

        private uint hide_cursor_timeout_id;
        private uint cursor_update_position_timeout_id;
        private int hide_cursor_x;
        private int hide_cursor_y;
        private bool cursor_is_hidden = false;

        protected override bool OnMotionNotifyEvent (Gdk.EventMotion evnt)
        {
            if (cursor_is_hidden) {
                if (Math.Abs (hide_cursor_x - evnt.X) > CursorShowMovementThreshold ||
                    Math.Abs (hide_cursor_y - evnt.Y) > CursorShowMovementThreshold) {
                    ShowCursor ();
                    ShowControls ();
                } else {
                    if (cursor_update_position_timeout_id > 0) {
                        GLib.Source.Remove (cursor_update_position_timeout_id);
                    }

                    cursor_update_position_timeout_id = GLib.Timeout.Add (CursorUpdatePositionDelay,
                        OnCursorUpdatePositionTimeout);
                }
            } else if (!ControlsActive) {
                if (hide_cursor_timeout_id > 0) {
                    GLib.Source.Remove (hide_cursor_timeout_id);
                }

                hide_cursor_timeout_id = GLib.Timeout.Add (CursorHideDelay, OnHideCursorTimeout);
            }

            return base.OnMotionNotifyEvent (evnt);
        }

        private bool OnCursorUpdatePositionTimeout ()
        {
            UpdateHiddenCursorPosition ();
            cursor_update_position_timeout_id = 0;
            return false;
        }

        private bool OnHideCursorTimeout ()
        {
            if (!ControlsActive) {
                HideCursor ();
                HideControls ();
            }

            hide_cursor_timeout_id = 0;
            return false;
        }

        private void UpdateHiddenCursorPosition ()
        {
            GetPointer (out hide_cursor_x, out hide_cursor_y);
        }

        private void ShowCursor ()
        {
            cursor_is_hidden = false;
            GdkWindow.Cursor = null;
        }

        private void HideCursor ()
        {
            if (GdkWindow == null) {
                return;
            }

            Gdk.Pixmap pixmap = Gdk.Pixmap.CreateBitmapFromData (GdkWindow, "0x0", 1, 1);
            if (pixmap == null) {
                return;
            }

            UpdateHiddenCursorPosition ();
            cursor_is_hidden = true;

            Gdk.Color color = new Gdk.Color (0, 0, 0);
            Gdk.Cursor cursor = new Gdk.Cursor (pixmap, pixmap, color, color, 0, 0);

            GdkWindow.Cursor = cursor;

            pixmap.Dispose ();
            cursor.Dispose ();
        }

#endregion

    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="IdProvider" IDEtalkID="65D3AEC798A0516E8A0CE6ACE59C577C" />
  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" assert-keyword="true" jdk-15="true" />
</project>


text:
require 'rails'
require 'yaml'

require 'honeybadger/util/sanitizer'
require 'honeybadger/util/request_payload'
require 'honeybadger/rack/error_notifier'
require 'honeybadger/rack/user_informer'
require 'honeybadger/rack/user_feedback'

module Honeybadger
  module Init
    module Rails
      class Railtie < ::Rails::Railtie
        rake_tasks do
          load 'honeybadger/tasks.rb'
        end

        initializer 'honeybadger.install' do
          config = Config.new(local_config)
          if Honeybadger.start(config)
            if config.feature?(:notices) && config[:'exceptions.enabled']
              ::Rails.application.config.middleware.tap do |middleware|
                middleware.insert(0, Honeybadger::Rack::ErrorNotifier, config)
                middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer, config) if config[:'user_informer.enabled']
                middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback, config) if config[:'feedback.enabled']
              end
            end

            if config.traces?
              ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |name, started, finished, id, data|
                Trace.create(id)
              end

              ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
                event = ActiveSupport::Notifications::Event.new(*args)
                Trace.current.add_query(event) if Trace.current and event.name != 'SCHEMA'
              end

              ActiveSupport::Notifications.subscribe(/^render_(template|partial|action|collection)\.action_view/) do |*args|
                event = ActiveSupport::Notifications::Event.new(*args)
                Trace.current.add(event) if Trace.current
              end

              ActiveSupport::Notifications.subscribe('net_http.request') do |*args|
                event = ActiveSupport::Notifications::Event.new(*args)
                Trace.current.add(event) if Trace.current
              end

              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
                event = ActiveSupport::Notifications::Event.new(*args)
                if Trace.current && event.payload[:controller] && event.payload[:action]
                  payload = { source: 'web' }
                  payload[:path] = Util::Sanitizer.new(filters: config.params_filters).filter_url(event.payload[:path]) if event.payload[:path]
                  payload[:request] = request_data(event, config)
                  Trace.current.complete(event, payload)
                end
              end
            end

            if config.metrics?
              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
                event = ActiveSupport::Notifications::Event.new(*args)
                status = event.payload[:exception] ? 500 : event.payload[:status]
                Agent.timing("app.request.#{status}", event.duration)
              end
            end
          end
        end

        private

        def local_config
          {
            :root           => ::Rails.root.to_s,
            :env            => ::Rails.env,
            :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
            :logger         => Logging::FormattedLogger.new(::Rails.logger),
            :framework      => :rails
          }
        end

        def request_data(event, config)
          h = {
            url: event.payload[:path],
            component: event.payload[:controller],
            action: event.payload[:action],
            params: event.payload[:params]
          }
          h.merge!(config.request_hash)
          h.delete_if {|k,v| config.excluded_request_keys.include?(k) }
          h[:sanitizer] = Util::Sanitizer.new(filters: config.params_filters)
          Util::RequestPayload.build(h).update({
            context: context_data
          })
        end

        def context_data
          if Thread.current[:__honeybadger_context]
            Util::Sanitizer.new.sanitize(Thread.current[:__honeybadger_context])
          end
        end
      end
    end
  end
end


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout android:id="@+id/main"
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_height="fill_parent"
    android:layout_width="fill_parent">
    <!-- Header -->
    <LinearLayout android:id="@+id/header"
        android:background="#ff347c12"
        android:layout_height="wrap_content"
        android:layout_width="fill_parent"
        >
        <TextView android:id="@+id/txtId"
            android:layout_height="fill_parent"
            android:layout_width="wrap_content"
            android:text="#"
            android:textColor="#ffffff"
            android:gravity="center_vertical"
            android:width="20dip"
            android:height="30dip"
            />
        <TextView android:id="@+id/txtName"
            android:layout_height="fill_parent"
            android:layout_width="wrap_content"
            android:text="Device Name"
            android:textColor="#ffffff"
            android:gravity="center_vertical"
            android:width="100dip"
            android:height="30dip"
            />
        <TextView android:id="@+id/txtMacAddress"
            android:layout_height="fill_parent"
            android:layout_width="fill_parent"
            android:textColor="#ffffff"
            android:text="Device MacAddress"
            android:gravity="center_vertical"
            android:width="100dip"
            android:height="30dip"
            />
    </LinearLayout>

    <!-- List Divider -->
    <View android:layout_width="fill_parent"
        android:layout_height="1dip"
        android:background="?android:attr/listDivider" />

    <!-- ListView (grid_items) -->
    <LinearLayout android:id="@+id/layout"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">
        <ListView android:id="@+id/lstBluetoothDevies"
            android:choiceMode="singleChoice"
            android:listSelector="@android:color/darker_gray"
            android:layout_height="wrap_content"
            android:layout_width="fill_parent">
        </ListView>

    </LinearLayout>
    <LinearLayout android:id="@+id/layoutButton"
        android:orientation="horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">
        <Button
            android:layout_width="120dp"
            android:layout_height="30dp"
            android:text="Rescan Device"
            android:background="@drawable/buttonborder"
            android:id="@+id/Rescan" />
        <Button
            android:layout_width="120dp"
            android:layout_height="30dp"
            android:text="Connect Device"
            android:background="@drawable/buttonborder"
            android:id="@+id/btnConnect" />
        <Button
            android:layout_width="120dp"
            android:layout_height="30dp"
            android:text="UnPair Device"
            android:background="@drawable/buttonborder"
            android:id="@+id/btnUnPair" />

    </LinearLayout>

</LinearLayout>


text:
package org.fusesource.restygwt.rebind;

import java.io.PrintWriter;
import java.util.HashSet;

import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.user.rebind.AbstractSourceCreator;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;

/**
 * provides additional helper methods for generating source..
 *
 * @author Hiram Chirino
 */
public abstract class BaseSourceCreator extends AbstractSourceCreator {

    public static final TreeLogger.Type ERROR = TreeLogger.ERROR;
    public static final TreeLogger.Type WARN = TreeLogger.WARN;
    public static final TreeLogger.Type INFO = TreeLogger.INFO;
    public static final TreeLogger.Type TRACE = TreeLogger.TRACE;
    public static final TreeLogger.Type DEBUG = TreeLogger.DEBUG;
    public static final TreeLogger.Type SPAM = TreeLogger.SPAM;
    public static final TreeLogger.Type ALL = TreeLogger.ALL;

    protected final GeneratorContext context;
    protected final JClassType source;
    protected final String packageName;
    protected final String shortName;
    protected final String name;
    protected SourceWriter sourceWriter;
    private TreeLogger logger;
    private PrintWriter writer;

    static final private ThreadLocal<HashSet<String>> GENERATED_CLASSES = new ThreadLocal<HashSet<String>>();

    static public HashSet<String> getGeneratedClasses() {
        HashSet<String> rc = GENERATED_CLASSES.get();
        if (rc == null) {
            rc = new HashSet<String>();
            GENERATED_CLASSES.set(rc);
        }
        return rc;
    }

    static public void clearGeneratedClasses() {
        GENERATED_CLASSES.set(null);
    }

    public static JClassType find(Class<?> type, TreeLogger logger, GeneratorContext context) throws UnableToCompleteException {
        return RestServiceGenerator.find(logger, context, type.getName().replace('$', '.'));
    }

    public BaseSourceCreator(final TreeLogger logger, GeneratorContext context, JClassType source, String suffix) {
        this.logger = logger;
        this.context = context;
        this.source = source;
        this.packageName = getOpenPackageName( source.getPackage().getName() );

        if(source instanceof JParameterizedType)
        {
    		JParameterizedType ptype = (JParameterizedType)source;
			StringBuilder builder = new StringBuilder();
			for(JClassType type : ptype.getTypeArgs())
			{
				builder.append("__");
				builder.append(type.getParameterizedQualifiedSourceName().replace('.', '_').replace("<", "__").replace(">", "__"));
			}
			this.shortName = getName( source ) + builder.toString() + suffix;
        }
        else
        {
        	this.shortName = getName( source ) + suffix;
        }

        this.name = packageName + "." + shortName;
    }

    protected String getName( JClassType source ){
        if( source.getEnclosingType() != null ){
            return getName( source.getEnclosingType() ) + "_" + source.getSimpleSourceName();
        }
        return source.getSimpleSourceName();
    }

    /**
     * Some packages are protected such that any type we generate in that package can't subsequently be loaded
     * because of a {@link SecurityException}, for example java. and javax. packages.
     *

     * To workaround this issue we add a prefix onto such packages so that the generated code can be loaded
     * later. The prefix added is open.
     *
     * @param name
     * @return
     */
    private String getOpenPackageName(String name) {
      if (name.startsWith("java.") || name.startsWith("javax.")) {
        name = "open."+name;
      }
      return name;
    }

    protected PrintWriter writer() throws UnableToCompleteException {
        HashSet<String> classes = getGeneratedClasses();
        if (classes.contains(name)) {
            return null;
        }
        classes.add(name);
        PrintWriter writer = context.tryCreate(getLogger(), packageName, shortName);
        if (writer == null) {
            return null;
        }
        return writer;
    }

    public interface Branch<R> {
        R execute() throws UnableToCompleteException;
    }

    protected <R> R branch(String msg, Branch<R> callable) throws UnableToCompleteException {
        return branch(DEBUG, msg, callable);
    }

    protected <R> R branch(TreeLogger.Type level, String msg, Branch<R> callable) throws UnableToCompleteException {
        TreeLogger original = getLogger();
        try {
            logger = getLogger().branch(level, msg);
            return callable.execute();
        } finally {
            logger = original;
        }
    }

    public BaseSourceCreator i(int i) {
        if (i == 1) {
            this.sourceWriter.indent();
        } else if (i == -1) {
            this.sourceWriter.outdent();
        } else {
            throw new IllegalArgumentException();
        }
        return this;
    }

    public BaseSourceCreator p(String value) {
        this.sourceWriter.println(value);

        // System.out.println(value);
        return this;
    }

    protected BaseSourceCreator p() {
        this.sourceWriter.println();
        return this;
    }

    protected TreeLogger getLogger()
    {
        return logger;
    }

    static String join(int []values, String sep) {
        StringBuilder sb = new StringBuilder();
        for(int i =0; i < values.length; i++) {
            if( i!=0 ) {
                sb.append(sep);
            }
            sb.append(values[i]);
        }
        return sb.toString();
    }

    static String join(Object []values, String sep) {
        StringBuilder sb = new StringBuilder();
        for(int i =0; i < values.length; i++) {
            if( i!=0 ) {
                sb.append(sep);
            }
            sb.append(values[i]);
        }
        return sb.toString();
    }

    final public String create() throws UnableToCompleteException {
        writer = writer();
        if (writer == null) {
            return name;
        }
        logger = getLogger().branch(TreeLogger.DEBUG, "Generating: " + name);

        ClassSourceFileComposerFactory composerFactory = createComposerFactory();
        sourceWriter = composerFactory.createSourceWriter(context, writer);

        generate();
        sourceWriter.commit(getLogger());
        return name;
    }

    abstract protected ClassSourceFileComposerFactory createComposerFactory() throws UnableToCompleteException;

    abstract protected void generate() throws UnableToCompleteException;
}


text: The page you have requested does not exist


text:
<!DOCTYPE html>

		<meta charset="utf-8"></meta>
		<meta name="generator" content="JsDoc Toolkit"></meta>
		<title>tent.changes.Change | Tent Framework API</title>

		<meta name="viewport" content="width=device-width; initial-scale=1.0; maximum-scale=1.0;"></meta>
		<meta name="mobileoptimized" content="0"></meta>

		<link rel="stylesheet" href="../css/all.css" media="all"></link>
		<link rel="stylesheet" href="../css/handheld.css" media="only screen and (max-width: 660px)"></link>
		<link rel="stylesheet" href="../css/handheld.css" media="handheld"></link>
		<link rel="stylesheet" href="../css/screen.css" media="screen and (min-width: 661px)"></link>

		<link rel="stylesheet" href="../css/shCore.css" media="all"></link>
		<link rel="stylesheet" href="../css/shThemeDefault.css" media="all"></link>

			Classes
			Files

Classes

		<input type="text" name="classFilter" class="classFilter" id="ClassFilter" placeholder="Filter"></input>

_global_

tent

tent . arrays

tent . arrays . functions

tent . changes

tent . changes . Change

tent . changes . LogHandler

tent . changes . Observable

tent . changes . reverseProperties

tent . changes . reverseProperties . Set

tent . connectors

tent . connectors . couchdb

tent . connectors . couchdb . CouchDBConnector

tent . connectors . http

tent . connectors . rest

tent . connectors . rest . filters

tent . connectors . rest . processors

tent . connectors . rest . RestConnector

tent . coreTypes

tent . coreTypes . Enum

tent . coreTypes . NameCounter

tent . databinding

tent . entities

tent . entities . Collection

tent . entities . Context

tent . entities . ContextChangeHandler

tent . entities . ContextChanges

tent . entities . EntityLink

tent . entities . Type

tent . events

tent . events . extendFunctions

tent . logging

tent . logging . Log

tent . Namespace

		©2011

		Documentation generator: JsDoc Toolkit 2.4.0

		Template: Codeview 1.2

		Generated on: 2011-5-18 18:25

			Class tent.changes.Change

				represents a detected change in an Object

Defined in: changes.js

Class Summary

							Constructor Attributes
							Constructor Name and Description

									tent.changes.Change(subject, eventType, data)

Creates a new Change

Field Summary

								Field Attributes
								Field Name and Description

										data

additional information, depending on #eventType

										eventType

the type of change, a value of tent.change.EventTypes

										subject

The Object that changed

Method Summary

								Method Attributes
								Method Name and Description

toString()

						Class Detail

						tent.changes.Change(subject, eventType, data)

						Creates a new Change

Parameters:

									{Object}  subject

the change object

									{Number}  eventType

a value of tent.changes.EventTypes

									{Object}  data
									Optional

additional change data

						Field Detail

							data

							additional information, depending on #eventType

							{Number}

							eventType

							the type of change, a value of tent.change.EventTypes

							{Object|Array}

							subject

							The Object that changed

						Method Detail

									toString()


text:
package hummingbird

// https://github.com/hummingbird-me/hummingbird/wiki/API-v1-Structures#anime-object
type Anime struct {
	Id               uint64
	Slug             string
	Status           string
	Url              string
	Title            string
	Alternate_title  string
	Episode_count    uint64
	Episode_length   uint64
	Cover_image      string
	Synopsis         string
	Show_type        string
	Started_airing   string
	Finished_airing  string
	Community_rating float64
	Age_rating       string
	Genres           []Genre `json:",omitempty"`
}

type Genre struct {
	Name string
}

// https://github.com/hummingbird-me/hummingbird/wiki/API-v1-Structures#library-entry-object
type LibraryEntry struct {
	Id               uint64
	Episodes_watched uint64
	Last_watched     string
	Updated_at       string
	Rewatched_times  uint64
	Notes            string
	Notes_present    bool
	Status           string
	Private          bool
	Rewatching       bool
	Anime            Anime
	Rating           LibraryEntryRating
}

// https://github.com/hummingbird-me/hummingbird/wiki/API-v1-Structures#library-entry-rating-object
type LibraryEntryRating struct {
	Type  string
	Value string
}

// https://github.com/hummingbird-me/hummingbird/wiki/API-v1-Structures#favorite-object
type Favorite struct {
	Id         uint64
	User_id    uint64
	Item_id    uint64
	Item_type  string
	Created_at string
	Updated_at string
	fav_rank   uint64
}

// https://github.com/hummingbird-me/hummingbird/wiki/API-v1-Structures#user-object
type User struct {
	Name                      string
	Waifu                     string
	Waifu_or_husbando         string
	Waifu_slug                string
	Waifu_char_id             string
	Location                  string
	Website                   string
	Avatar                    string
	Cover_image               string
	About                     string
	Bio                       string
	Karma                     uint64
	Life_spent_on_anime       uint64
	Show_adult_content        bool
	Title_language_preference string
	Last_library_update       string
	Online                    bool
	Following                 bool
	Favorites                 []Favorite
}


text:
#if !defined(__CINT__) || defined(__MAKECINT_)
#include "AliFemtoManager.h"
#include "AliFemtoEventReaderESDChain.h"
#include "AliFemtoEventReaderESDChainKine.h"
#include "AliFemtoEventReaderAODChain.h"
#include "AliFemtoSimpleAnalysis.h"
#include "AliFemtoBasicEventCut.h"
#include "AliFemtoESDTrackCut.h"
#include "AliFemtoCorrFctn.h"
#include "AliFemtoCutMonitorParticleYPt.h"
#include "AliFemtoCutMonitorParticleVertPos.h"
#include "AliFemtoCutMonitorParticleMomRes.h"
#include "AliFemtoCutMonitorParticlePID.h"
#include "AliFemtoCutMonitorEventMult.h"
#include "AliFemtoCutMonitorEventVertex.h"
#include "AliFemtoShareQualityTPCEntranceSepPairCut.h"
#include "AliFemtoPairCutAntiGamma.h"
#include "AliFemtoPairCutRadialDistance.h"
#include "AliFemtoQinvCorrFctn.h"
#include "AliFemtoCorrFctnNonIdDR.h"
#include "AliFemtoShareQualityCorrFctn.h"
#include "AliFemtoTPCInnerCorrFctn.h"
#include "AliFemtoVertexMultAnalysis.h"
#include "AliFemtoCorrFctn3DSpherical.h"
#include "AliFemtoChi2CorrFctn.h"
#include "AliFemtoCorrFctnTPCNcls.h"
#include "AliFemtoBPLCMS3DCorrFctn.h"
#include "AliFemtoCorrFctn3DLCMSSym.h"
#include "AliFemtoModelBPLCMSCorrFctn.h"
#include "AliFemtoModelCorrFctn3DSpherical.h"
#include "AliFemtoModelGausLCMSFreezeOutGenerator.h"
#include "AliFemtoModelGausRinvFreezeOutGenerator.h"
#include "AliFemtoModelManager.h"
#include "AliFemtoModelWeightGeneratorBasic.h"
#include "AliFemtoModelWeightGeneratorLednicky.h"
#include "AliFemtoCorrFctnDirectYlm.h"
#include "AliFemtoModelCorrFctnDirectYlm.h"
#include "AliFemtoModelCorrFctnSource.h"
#include "AliFemtoCutMonitorParticlePtPDG.h"
#include "AliFemtoKTPairCut.h"
#include "AliFemtoPairCutPt.h"
#endif

//________________________________________________________________________
AliFemtoManager* ConfigFemtoAnalysis(const char* params) {

	double PionMass = 0.13956995; //masy
	double KaonMass = 0.493677;
	double ProtonMass = 0.9382720813;
	double LambdaMass = 1.115683;

	const int numOfMultBins = 1; //biny w krotniosci
	const int numOfChTypes = 16; // liczba mozliwych par
	const int numOfpTbins = 1; // biny w pedzie poprzecznym

   int runch[numOfChTypes] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0}; // 1 - wlacza czastki do analizy: wlaczone PIpPIm , all
   const char *chrgs[numOfChTypes] = { "PP", "aPaP", "PaP", "KpKp", "KmKm", "KpKm", "PIpPIp", "PImPIm", "PIpPIm", "LL", "aLaL", "LaL", "all", "plus", "minus", "mixed"};
   // pary czastek ktore analizujemy PP - proton proton; KpKp - K plus
   int runktdep = 0; // czy chcemy wlaczac analize w zaleznosci od pedow poprzecznych; 0 - nie ma, 1 - jest
   double ktrng[numOfpTbins+1] = {0.0, 100.0}; // przedzialy sum pedow poprzecznych

   int gammacut = 1;   // cut for e+e- coming from gamma //wlaczenie cuty na konkretne pary czastek

//Ustalamy z ktora analiza mamy do czynienia
   //  ***Reader ESD***
   //AliFemtoEventReaderESDChain *Reader = new AliFemtoEventReaderESDChain();
   //Reader->SetUseMultiplicity(AliFemtoEventReaderESDChain::kReferenceITSTPC); //sposob liczenia multiplicity - ustawione zeby liczyc track po tracku, po ustawieniu konkretnych cutow
//dla olow-olow po centralnosci

   //  ***Reader AOD***
   //AliFemtoEventReaderAODChain *Reader = new AliFemtoEventReaderAODChain();
   //Reader->SetFilterMask(96);		//wpisane DCA w filter bity
   //Reader->SetDCAglobalTrack(kTRUE); //false for FB7, true for the rest //we do not use DCA (distance of closest approach - na przyklad zeby sprawdzic czy 2 czastki pochodza od jednej czastki - matki, primary vertex - punkt zderzenia - z niego pochodza wszystkie pierwotne czastki) at all
   //Reader->SetUseMultiplicity(AliFemtoEventReaderAOD::kReference);
   //Reader->SetMinPlpContribSPD(3); //PileUp - zderzenia nachodza na siebie, ten cut dodatkowo wyrzuca zderzenia pylab, ktorych nie wyrzucaja trigery
   //Reader->SetIsPileUpEvent(kTRUE);

   //  ***Reader Kinematics (Monte Carlo data)***
   AliFemtoEventReaderKinematicsChain* Reader=new AliFemtoEventReaderKinematicsChain();

   AliFemtoManager* Manager = new AliFemtoManager(); //typowy dla alifemto
   Manager->SetEventReader(Reader);
	// * Monitory * - histogramy ktore beda wypelniane podczas analizy - wlasciwie klasy generujace histogramy
   AliFemtoVertexMultAnalysis      *anetaphitpc[640]; //korelujemy eventy tylko podobne w wertexie i multiplicity
   AliFemtoBasicEventCut             *mecetaphitpc[320]; //podstawowy cut na zderzenia
   AliFemtoCutMonitorEventMult    *cutPassEvMetaphitpc[320];
   AliFemtoCutMonitorEventMult    *cutFailEvMetaphitpc[320];
   AliFemtoCutMonitorEventVertex *cutPassEvVetaphitpc[320];
   AliFemtoCutMonitorEventVertex *cutFailEvVetaphitpc[320];
   AliFemtoMCTrackCut          *dtc1etaphitpc[320]; // ograniczenia dla konkretnych czastek
   AliFemtoMCTrackCut          *dtc2etaphitpc[320];
   AliFemtoMCTrackCut          *dtc3etaphitpc[320];
   //AliFemtoCutMonitorParticleYPt *cutPass1YPtetaphitpc[320];
   //AliFemtoCutMonitorParticleYPt *cutFail1YPtetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutPass1PIDetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutFail1PIDetaphitpc[320];
   //AliFemtoCutMonitorParticleYPt *cutPass2YPtetaphitpc[320];
   //AliFemtoCutMonitorParticleYPt *cutFail2YPtetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutPass2PIDetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutFail2PIDetaphitpc[320];
   AliFemtoCutMonitorParticleYPt *cutPass3YPtetaphitpc[320];
   AliFemtoCutMonitorParticleYPt *cutFail3YPtetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutPass3PIDetaphitpc[320];
   AliFemtoCutMonitorParticlePID *cutFail3PIDetaphitpc[320];
   //    AliFemtoShareQualityTPCEntranceSepPairCut         *sqpcetaphitpcsame[320]; //sprawdza jak duzo trackow jest dzielone przez czastki
   AliFemtoPairCutAntiGamma         *sqpcetaphitpc[320]; //ograniczenia na pary czastek
   //AliFemtoPairCutRadialDistance         *sqpcetaphitpc[320];
   //   AliFemtoChi2CorrFctn               *cchiqinvetaphitpc[320];
   AliFemtoPairCutPt                   *ktpcuts[640];
   AliFemtoQinvCorrFctn               *cqinvkttpc[320];
   AliFemtoQinvCorrFctn               *cqinvtpc[320];
   AliFemtoCorrFctnDEtaDPhi         *cdedpetaphi[640];

   //***Delta Eta Delta Phi analysis for identified systems (chg: 0-8)***

   int aniter = 0;
   int runmults[numOfMultBins] = {1}; // 1 - wlaczony przedzial
   int multbins[numOfMultBins+1] = {2, 20000}; // definiujemy przedzialy krotnosci
    // petla po wszystkich czastkach
   for (int imult = 0; imult < numOfMultBins; imult++) // petla po krotnosciach
   {
      if (runmults[imult]) // dla kazdego wlaczonego multiplicity
      {
         for (int ichg = 0; ichg < numOfChTypes; ichg++)
         {
            if (runch[ichg]) //dla kazdych wlaczonych typow czastek
            {

               aniter = ichg * numOfMultBins + imult;
               //miksujemy tylko po podobnych krotnosciach
               int multmix = 200;

               anetaphitpc[aniter] = new AliFemtoVertexMultAnalysis(10, -10.0, 10.0, multmix, multbins[imult], multbins[imult+1]);
               anetaphitpc[aniter]->SetNumEventsToMix(5); //zwiekszamy statystyke w mianowkiku sygnalu korelacji
               anetaphitpc[aniter]->SetMinSizePartCollection(1); //co najmniej jedna czastka na event
               anetaphitpc[aniter]->SetVerboseMode(kFALSE);

               //*** Event cut ***
               mecetaphitpc[aniter] = new AliFemtoBasicEventCut();
               mecetaphitpc[aniter]->SetEventMult(0.001,100000); //(min, max)
               mecetaphitpc[aniter]->SetVertZPos(-10,10);//cm *akceptujemy zderenia ktore mialy miejsce w przedziale od -10cm do 10 cm od srodka detektora

               //****** event monitors **********
               cutPassEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutPass%stpcM%i", chrgs[ichg], imult), 2000, 20000.5);
               cutFailEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutFail%stpcM%i", chrgs[ichg], imult), 2000, 20000.5);
               mecetaphitpc[aniter]->AddCutMonitor(cutPassEvMetaphitpc[aniter], cutFailEvMetaphitpc[aniter]);

               cutPassEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutPass%stpcM%i", chrgs[ichg], imult));
               cutFailEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutFail%stpcM%i", chrgs[ichg], imult));
               mecetaphitpc[aniter]->AddCutMonitor(cutPassEvVetaphitpc[aniter], cutFailEvVetaphitpc[aniter]);

               // ***** single particle track cuts *********
               dtc1etaphitpc[aniter] = new AliFemtoMCTrackCut();
               dtc2etaphitpc[aniter] = new AliFemtoMCTrackCut();
               dtc3etaphitpc[aniter] = new AliFemtoMCTrackCut();

               dtc1etaphitpc[aniter]->SetCharge(1.0);//ustawiamy ograniczenia na ladunek, zostawi dodatnie
               dtc2etaphitpc[aniter]->SetCharge(-1.0);

               dtc1etaphitpc[aniter]->SetEta(-0.8,0.8);// psedopospiesznosc 0 - czastki wyprodukowane prostopadle do osi detektora
               dtc2etaphitpc[aniter]->SetEta(-0.8,0.8);// limit 0.9; powyzej czatka nie zostaje zarejestrowana
               dtc3etaphitpc[aniter]->SetEta(-0.8,0.8);

				if (ichg == 0 ||ichg == 1 ||ichg == 2)//protons 0-2
				{
					dtc1etaphitpc[aniter]->SetPt(1,2); // w zaleznosci od czastki rozne pedy
					dtc2etaphitpc[aniter]->SetPt(1,2);

					dtc1etaphitpc[aniter]->SetPDG(2212); //numer rodzaju czastek
					dtc2etaphitpc[aniter]->SetPDG(2212);

					cutPass3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),ProtonMass);
					cutFail3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),ProtonMass);

					if(ichg==0)
						dtc1etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
					if(ichg==1)
						dtc2etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
				}
				if (ichg == 3 ||ichg == 4 ||ichg == 5)//kaons 3-5
				{
					dtc1etaphitpc[aniter]->SetPt(1,2);
					dtc2etaphitpc[aniter]->SetPt(1,2);

					dtc1etaphitpc[aniter]->SetPDG(321);
					dtc2etaphitpc[aniter]->SetPDG(321);

					cutPass3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),KaonMass);
					cutFail3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),KaonMass);

					if(ichg==3)
						dtc1etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
					if(ichg==4)
						dtc2etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
				}
				if (ichg == 6 ||ichg == 7 ||ichg == 8)//pions 6-8
				{
					dtc1etaphitpc[aniter]->SetPt(1,2);
					dtc2etaphitpc[aniter]->SetPt(1,2);

					dtc1etaphitpc[aniter]->SetPDG(211);
					dtc2etaphitpc[aniter]->SetPDG(211);

					cutPass3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),PionMass);
					cutFail3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),PionMass);

					if(ichg==6)
						dtc1etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
					if(ichg==7)
						dtc2etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
				}
				if (ichg == 9 || ichg == 10 || ichg == 11){ //lambdy 9-11
					dtc1etaphitpc[aniter]->SetCharge(0);//ustawiamy ograniczenia na ladunek, zostawi dodatnie
					dtc2etaphitpc[aniter]->SetCharge(0);

					dtc1etaphitpc[aniter]->SetPt(1,2);
					dtc2etaphitpc[aniter]->SetPt(1,2);

					dtc1etaphitpc[aniter]->SetPDG(3122);
					dtc2etaphitpc[aniter]->SetPDG(-3122);

					cutPass3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),LambdaMass);
					cutFail3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),LambdaMass);

					if(ichg==9)
						dtc1etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
					if(ichg==10)
						dtc2etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
				}
                if (ichg == 12)//all
                {
					dtc3etaphitpc[aniter]->SetPt(1,2);//min 0.12 TPC jeszcze wyciaga
                }
                if (ichg == 13 ||ichg == 14 ||ichg == 15)//plus,minus,mixed
                {
					dtc1etaphitpc[aniter]->SetPt(1,2);
					dtc2etaphitpc[aniter]->SetPt(1,2);
                }

               //**************** track Monitors ***************
               /*if(1)//ichg>8)
                 {
                   cutPass3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),PionMass);
                   cutFail3YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),PionMass);
                   if(ichg==0||ichg==3||ichg==6) dtc1etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
                   if(ichg==1||ichg==4||ichg==7) dtc2etaphitpc[aniter]->AddCutMonitor(cutPass3YPtetaphitpc[aniter], cutFail3YPtetaphitpc[aniter]);
                 }*/

               //******** Two - track cuts ************
				sqpcetaphitpc[aniter] = new AliFemtoPairCutAntiGamma();
               //sqpcetaphitpc[aniter] = new AliFemtoPairCutRadialDistance();
               sqpcetaphitpc[aniter]->SetDataType(AliFemtoPairCut::kKine);

               //***** Setting cuts ***********
               // setting event cut
               anetaphitpc[aniter]->SetEventCut(mecetaphitpc[aniter]);
               //setting single track cuts
               if(ichg == 0 || ichg == 3 || ichg == 6 || ichg == 9) //positive like-sign
               {
                  anetaphitpc[aniter]->SetFirstParticleCut(dtc1etaphitpc[aniter]);
                  anetaphitpc[aniter]->SetSecondParticleCut(dtc1etaphitpc[aniter]);
               }
               if(ichg == 1 || ichg == 4 || ichg == 7 || ichg == 10)//negative like-sign
               {
                  anetaphitpc[aniter]->SetFirstParticleCut(dtc2etaphitpc[aniter]);
                  anetaphitpc[aniter]->SetSecondParticleCut(dtc2etaphitpc[aniter]);
               }
               if(ichg == 2 || ichg == 5 || ichg == 8 || ichg == 11)//unlike-sign
               {
                  anetaphitpc[aniter]->SetFirstParticleCut(dtc1etaphitpc[aniter]);
                  anetaphitpc[aniter]->SetSecondParticleCut(dtc2etaphitpc[aniter]);
               }
				if(ichg==12) //all
               {
					  anetaphitpc[aniter]->SetFirstParticleCut(dtc3etaphitpc[aniter]);
					  anetaphitpc[aniter]->SetSecondParticleCut(dtc3etaphitpc[aniter]);
               }
               if(ichg==13) //positive like-sign
					{
						anetaphitpc[aniter]->SetFirstParticleCut(dtc1etaphitpc[aniter]);
						anetaphitpc[aniter]->SetSecondParticleCut(dtc1etaphitpc[aniter]);
					}
				if(ichg==14)//negative like-sign
				{
					anetaphitpc[aniter]->SetFirstParticleCut(dtc2etaphitpc[aniter]);
					anetaphitpc[aniter]->SetSecondParticleCut(dtc2etaphitpc[aniter]);
				}
				if(ichg==15)//unlike-sign
				{
					anetaphitpc[aniter]->SetFirstParticleCut(dtc1etaphitpc[aniter]);
					anetaphitpc[aniter]->SetSecondParticleCut(dtc2etaphitpc[aniter]);
				}

               //setting two-track cuts
               anetaphitpc[aniter]->SetPairCut(sqpcetaphitpc[aniter]);

               //**** Correlation functions *******

               cdedpetaphi[aniter] = new AliFemtoCorrFctnDEtaDPhi(Form("DEtaDPhi_%s_M%i", chrgs[ichg], imult),35, 35);// torzenie funkcji korelacji
               anetaphitpc[aniter]->AddCorrFctn(cdedpetaphi[aniter]);
               cqinvtpc[aniter] = new AliFemtoQinvCorrFctn(Form("Qinv_%s_M%i", chrgs[ichg], imult), 20, 0, 2);
               anetaphitpc[aniter]->AddCorrFctn(cqinvtpc[aniter]);

               if (runktdep)
               {
                  int ktm;
                  for (int ikt=0; ikt<numOfpTbins; ikt++)// dla kazdego przedzialu funkcje liczone oddzielnie
                  {
                     ktm = aniter * numOfpTbins + ikt;
                     ktpcuts[ktm] = new AliFemtoPairCutPt(ktrng[ikt], ktrng[ikt+1]);

                     cdedpetaphi[ktm] = new AliFemtoCorrFctnDEtaDPhi(Form("cdedp%stpcM%ipT%i", chrgs[ichg], imult,ikt),35, 35);
                     cdedpetaphi[ktm]->SetPairSelectionCut(ktpcuts[ktm]);
                     anetaphitpc[aniter]->AddCorrFctn(cdedpetaphi[ktm]);

                  }
               }
               Manager->AddAnalysis(anetaphitpc[aniter]);
            }
         }
      }
   }
   return Manager;// manager glowny program wykonujacy analize
}


text:
import { assert, expect } from 'chai';
import Vector3 from '../src/vector3';
import Matrix4 from '../src/matrix4.js';

describe('Vector3', function () {
  it('constructor, copy, clone', function () {
    // Testing the constructor
    const vector1 = new Vector3(1, 2, 3);
    const vector2 = new Vector3();

    assert.deepEqual([vector1.x, vector1.y, vector1.z], [1, 2, 3], 'Constructor works.');
    assert.deepEqual([vector2.x, vector2.y, vector2.z], [0, 0, 0], 'Constructor works.');
    // Testing copy
    vector1.copy(vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [0, 0, 0], 'Copy works.');
    // Testing clone
    const vector3 = vector2.clone();

    assert.deepEqual([vector3.x, vector3.y, vector3.z], [0, 0, 0], 'Constructor works.');
  });
  it('set, setX, setY, setZ, setComponent, getComponent', function () {
    // Initialzing
    const vector = new Vector3();

    // Testing set
    vector.set(3, 2, 1);
    assert.deepEqual([vector.x, vector.y, vector.z], [3, 2, 1], 'Set works.');
    // Testing setX
    vector.setX(0);
    assert.deepEqual([vector.x, vector.y, vector.z], [0, 2, 1], 'setX works.');
    // Testing setY
    vector.setY(0);
    assert.deepEqual([vector.x, vector.y, vector.z], [0, 0, 1], 'setY works.');
    // Testing setZ
    vector.setZ(0);
    assert.deepEqual([vector.x, vector.y, vector.z], [0, 0, 0], 'setZ works.');
    // Testing setComponent
    vector.setComponent(0, 2);
    vector.setComponent(1, 3);
    vector.setComponent(2, 4);
    const badFun1 = function () {
      vector.setComponent(3, 1);
    };

    expect(badFun1).to.throw(Error);
    assert.deepEqual([vector.x, vector.y, vector.z], [2, 3, 4], 'setComponent works.');
    // Testing getComponent
    const badFun2 = function () {
      vector.getComponent(5);
    };

    expect(badFun2).to.throw(Error);
    assert.deepEqual([vector.getComponent(0), vector.getComponent(2)], [2, 4], 'getComponent works.');
  });
  it('add, addScalar, addVectors', function () {
    // Testing add
    const vector1 = new Vector3();
    const vector2 = new Vector3(1, 2, 3);

    vector1.addVectors(vector2, vector1);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [1, 2, 3], 'add works.');
    // Testing addScalar
    vector1.addScalar(3);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [4, 5, 6], 'addScalar works.');
    // Testing addVectors
    vector1.addVectors(vector1, vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [5, 7, 9], 'addVectors works.');
  });
  it('sub, subVectors', function () {
    // Testing sub
    const vector1 = new Vector3(-1, -1, -1);
    const vector2 = new Vector3(-2, -3, -4);

    vector1.sub(vector2, vector1);
    vector2.sub(vector1);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [-1, -2, -3], 'sub works.');
    assert.deepEqual([vector2.x, vector2.y, vector2.z], [-1, -1, -1], 'sub works.');
    // Testing subVectors
    vector1.subVectors(vector1, vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [0, -1, -2], 'subVectors works.');
  });
  it('multiply, multiplyScalar, multiplyVectors', function () {
    // Testing multiply
    const vector1 = new Vector3(1, 1, 1);
    const vector2 = new Vector3(2, 3, 4);

    vector1.multiply(vector2, vector1);
    vector2.multiply(vector1);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [2, 3, 4], 'multiply works.');
    assert.deepEqual([vector2.x, vector2.y, vector2.z], [4, 9, 16], 'multiply works.');
    // Testing multiplyScalar
    vector1.multiplyScalar(2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [4, 6, 8], 'multiply works.');
    // Testing multiplyVectors
    vector1.multiplyVectors(vector1, vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [16, 54, 128], 'multiply works.');
  });
  it('applyMatrix3, applyMatrix4, applyProjection', function () {
    // Testing applyMatrix3
    // Using Matrix4 to simulate matrix3
    const matrix3 = new Matrix4();
    const vector = new Vector3(1, 1, 1);

    matrix3.elements = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    vector.applyMatrix3(matrix3);
    assert.deepEqual([vector.x, vector.y, vector.z], [12, 15, 18], 'applyMatrix3 works.');
    // Testing applyMatrix4
    const matrix4 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);

    vector.x = 1; vector.y = 1; vector.z = 1;
    vector.applyMatrix4(matrix4); // Gives translated (multiplied) vector.
    assert.deepEqual([vector.x, vector.y, vector.z], [10, 26, 42], 'applyMatrix4 works.');

    // Testing applyProjection
    vector.x = 1; vector.y = 1; vector.z = 1;
    vector.applyProjection(matrix4); // Applies perspective divide to normalize vector.
    assert.deepEqual([vector.x, vector.y, vector.z], [10 / 58, 26 / 58, 42 / 58], 'applyProjection works.');
  });
  it('applyAxisAngle, applyQuaternion, transformDirection', function () {
    // Testing applyAxisAngle and applyQuaternion
    const axis = new Vector3(1, 1, 1); // Vector to be used an axis for the quaternion
    const angle = Math.PI / 2;
    const vector = new Vector3(1, 1, 1);

    vector.applyAxisAngle(axis, angle); // Checks applyQuaternion by calling it internally
    assert.deepEqual([vector.x, vector.y, vector.z], [1, 1, 1], 'Vector rotated about itself.');
    vector.x = 1; vector.y = 1; vector.z = 1;
    axis.x = 0; axis.y = 1; axis.z = 0;
    const angle2 = Math.PI / 4;

    vector.applyAxisAngle(axis, angle2);
    // Application of quaternion returns a miniscule residual value in z
    assert.deepEqual([Math.round(vector.x * 1000) / 1000, vector.y, Math.round(vector.z)],
      [1.414, 1, -0], 'Vector rotated correctly.');
    vector.x = 2; vector.y = 2; vector.z = 3;
    axis.x = 1; axis.y = 1; axis.z = 0;
    const angle3 = 2 * Math.PI - Math.PI / 4;

    vector.applyAxisAngle(axis, angle3);
    assert.deepEqual([Math.round(vector.x * 1000) / 1000, Math.round(vector.y * 1000) / 1000,
      Math.round(vector.z * 1000) / 1000], [0.5, 3.5, 2.121], 'Vector rotated correctly.');
    // Testing transformDirection
    const transformMatrix = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);

    vector.x = 1; vector.y = 1; vector.z = 1;
    vector.transformDirection(transformMatrix); // Return z coordinate rounded down in the 16 decimal place
    assert.deepEqual([vector.x, vector.y, vector.z], [1 / Math.sqrt(35),
      3 / Math.sqrt(35), 0.8451542547285165], 'Transform Direction works.');
  });
  it('divide, divideScalar', function () {
    // Testing divide
    const vector1 = new Vector3(1, -1, 1);
    const vector2 = new Vector3(0, 2, Math.sqrt(2));

    vector1.divide(vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [Infinity, -0.5, 1 / Math.sqrt(2)], 'division works.');
    // Testing divideScalar
    vector1.divideScalar(2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [Infinity, -0.25, 1 / (2 * Math.sqrt(2))], 'divideScalar works.');
    vector1.divideScalar(0);
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [0, 0, 0], 'divideScalar works.');
  });
  it('min, max, clamp, clampScalar', function () {
    // Testing min
    const vector1 = new Vector3(-Infinity, -25, 121);
    const vector2 = new Vector3(20, 100, 1);

    vector1.min(vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [-Infinity, -25, 1], 'Min works.');
    // Testing max
    const vector3 = new Vector3(Infinity, -100, 1);

    vector1.max(vector3);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [Infinity, -25, 1], 'Max works.');
    // Testing clamp
    const min = new Vector3(-Infinity, 100, -2);
    const max = new Vector3(100, 200, Infinity);

    vector1.clamp(min, max);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [100, 100, 1], 'clamp works.');
    // Testing clampScalar
    vector1.clampScalar(50, 90);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [90, 90, 50], 'clampScalar works.');
  });
  it('floor, ceil, round, roundToZero', function () {
    // Testing floor
    const vector = new Vector3(25.32, Math.sqrt(2), -0);

    vector.floor();
    assert.deepEqual([vector.x, vector.y, vector.z], [25, 1, 0], 'floor works.');
    // Testing ceil
    vector.x = 25.32; vector.y = Math.sqrt(2); vector.z = -2;
    vector.ceil();
    assert.deepEqual([vector.x, vector.y, vector.z], [26, 2, -2], 'ceil works.');
    // Testing round
    vector.x = 25.62; vector.y = Math.sqrt(2); vector.z = -200;
    vector.round();
    assert.deepEqual([vector.x, vector.y, vector.z], [26, 1, -200], 'round works.');
    // Testing roundToZero
    vector.x = Infinity; vector.y = Math.sqrt(2); vector.z = -200.2;
    vector.roundToZero();
    assert.deepEqual([vector.x, vector.y, vector.z], [Infinity, 1, -200], 'roundToZero works.');
  });
  it('negate, dot, length, lengthSq, lengthManhattan', function () {
    // Testing negate
    const vector = new Vector3(2, 7, 16);

    vector.negate();
    assert.deepEqual([vector.x, vector.y, vector.z], [-2, -7, -16], 'negate works.');
    // Testing dot
    const newVector = new Vector3(-1, -2, -15);

    assert.equal(vector.dot(newVector), 256, 'dot product works.');
    // Testing length
    assert.equal(vector.length(), Math.sqrt(309), 'length works.');
    // Testing lengthSq
    assert.equal(vector.lengthSq(), 309, 'lengthSq works.');
    // Testing lengthManhattan
    assert.equal(newVector.lengthManhattan(), 18, 'lengthManhattan works.');
  });
  it('normalize, setLength, lerp', function () {
    // Testing normalize
    const vector = new Vector3(1, 2, 2);

    vector.normalize();
    assert.deepEqual([vector.x, vector.y, vector.z], [1 / 3, 2 / 3, 2 / 3], 'normalize works.');
    // Testing setLength
    vector.setLength(3);
    assert.deepEqual([vector.x, vector.y, vector.z], [1, 2, 2], 'setLength works.');
    // Testing lerp
    const newVector = new Vector3(1, 2, 3);

    vector.lerp(newVector, 0.5);
    assert.deepEqual([vector.x, vector.y, vector.z], [1, 2, 2.5], 'setLength works.');
  });
  it('cross, crossVectors', function () {
    // Testing crossVectors
    const vector1 = new Vector3(1, 2, 3);
    const vector2 = new Vector3(4, 5, 6);

    vector1.crossVectors(vector1, vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [-3, 6, -3], 'crossVectors works.');
    // Testing cross
    vector1.x = 0; vector1.y = 1; vector1.z = 2;
    vector1.cross(vector2);
    assert.deepEqual([vector1.x, vector1.y, vector1.z], [-4, 8, -4], 'cross works.');
  });
  it('projectOnVector, projectOnPlane, reflect', function () {
    // Testing projectOnVector
    const vector1 = new Vector3(1, 2, 6);
    const vector2 = new Vector3(-2, 3, 5);

    vector1.projectOnVector(vector2); // Returned values are off at the last decimal digit
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [-1.7894736842105268, 2.68421052631579, 4.473684210526317], 'projectOnVector works.');
    // Testing projectOnPlane
    const planeNormal = new Vector3(1, 0, 0);

    vector1.x = 1; vector1.y = 2; vector1.z = 3;
    vector1.projectOnPlane(planeNormal);
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [0, 2, 3], 'projectOnPlane works.');
    // Testing reflect
    const normal = new Vector3(0, 1, 0);

    vector1.x = 1; vector1.y = 2; vector1.z = 3;
    vector1.reflect(normal);
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [1, -2, 3], 'reflect works.');
  });
  it('angleTo, distanceTo, distanceToSquared', function () {
    // Testing angleTo
    const vector1 = new Vector3(1, 0, 0);
    const vector2 = new Vector3(0, 1, 0);

    assert.equal(vector1.angleTo(vector2), Math.PI / 2, 'angleTo works.');
    // Testing distanceToSquared
    assert.equal(vector1.distanceToSquared(vector2), 2, 'distanceToSquared works.');
    // Testing distanceTo
    assert.equal(vector1.distanceTo(vector2), Math.sqrt(2), 'distanceTo works.');
  });
  it('setFromMatrixPosition, setFromMatrixScale, setFromMatrixColumn', function () {
    // Testing setFromMatrixPosition
    const vector = new Vector3(1, 1, 1);
    const matrix = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);

    vector.setFromMatrixPosition(matrix);
    assert.deepEqual([vector.x, vector.y, vector.z],
      [4, 8, 12], 'setFromMatrixPosition works.');
    // Testing setFromMatrixScale
    vector.setFromMatrixScale(matrix);
    assert.deepEqual([vector.x, vector.y, vector.z],
      [Math.sqrt(107), Math.sqrt(140), Math.sqrt(179)], 'setFromMatrixScale works.');
    // Testing setFromMatrixColumn
    vector.setFromMatrixColumn(100, matrix);
    assert.deepEqual([vector.x, vector.y, vector.z],
      [undefined, undefined, undefined], 'setFromMatrixScale fails as expected.');
    vector.setFromMatrixColumn(3, matrix);
    assert.deepEqual([vector.x, vector.y, vector.z],
      [4, 8, 12], 'setFromMatrixScale works.');
  });
  it('equals, fromArray, toArray, clone', function () {
    // Testing equals
    const vector1 = new Vector3(1, 0, 0);
    const vector2 = new Vector3(0, 1, 0);

    assert.isFalse(vector1.equals(vector2), 'vectors not equal');
    vector2.x = 1; vector2.y = 0;
    assert.isOk(vector1.equals(vector2), 'vectors are equal.');
    // Testing fromArray
    vector1.fromArray([Infinity, -20.4343, 25]);
    assert.deepEqual([vector1.x, vector1.y, vector1.z],
      [Infinity, -20.4343, 25], 'fromArray works.');
    // Testing toArray
    assert.deepEqual(vector2.toArray(),
      [1, 0, 0], 'toArray works.');
    // Testing clone
    const clonedVector = vector1.clone();

    assert.deepEqual([clonedVector.x, clonedVector.y, clonedVector.z],
      [Infinity, -20.4343, 25], 'clone works.');
  });
});


text:
        Crafted with  by webonise

         © Kato


text:
namespace VkNet.Enums.SafetyEnums
{
	/// <summary>
	/// Сервисы
	/// </summary>
	public sealed class Services : SafetyEnum<Services>
	{
		/// <summary>
		/// The email
		/// </summary>
		public static readonly Services Email = RegisterPossibleValue("email");

		/// <summary>
		/// The phone
		/// </summary>
		public static readonly Services Phone = RegisterPossibleValue("phone");

		/// <summary>
		/// The twitter
		/// </summary>
		public static readonly Services Twitter = RegisterPossibleValue("twitter");

		/// <summary>
		/// The facebook
		/// </summary>
		public static readonly Services Facebook = RegisterPossibleValue("facebook");

		/// <summary>
		/// The odnoklassniki
		/// </summary>
		public static readonly Services Odnoklassniki = RegisterPossibleValue("odnoklassniki");

		/// <summary>
		/// The instagram
		/// </summary>
		public static readonly Services Instagram = RegisterPossibleValue("instagram");

		/// <summary>
		/// The google
		/// </summary>
		public static readonly Services Google = RegisterPossibleValue("google");
	}
}


text:
import stringcase

from generator.Field import Field

class OneOfField:

    def __init__(self, oneof_name, oneof_fields, context):
        self.name = oneof_name

        # Some booleans to describe the type
        self.one_of = True
        self.type = 'OneOf{}'.format(stringcase.pascalcase(self.name))
        self.fqn = '{}.{}'.format(context.fqn, self.type)
        self.default_value = '{}()'.format(self.type)

        self.map_type = False
        self.repeated = False
        self.pointer = False
        self.array_size = 0
        self.bytes_type = False
        self.basic = False

        self.oneof_fields = [Field(f, context) for f in oneof_fields]

        # Since our cpp_type is used a lot, precalculate it
        self.cpp_type = self.fqn.replace('.', '::')
        self.special_cpp_type = False

    def generate_cpp_header(self):
        return '{} {};'.format(self.cpp_type, self.name)


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The User Control item template is documented at http://go.microsoft.com/fwlink/?LinkId=234236

namespace PointOfSale.RT.Views
{
    public sealed partial class CashHomeView : UserControl
    {
        public CashHomeView()
        {
            this.InitializeComponent();
        }
    }
}


text:
package org.spongepowered.common.serialization;

import com.mojang.datafixers.util.Pair;
import com.mojang.serialization.Codec;
import com.mojang.serialization.DataResult;
import com.mojang.serialization.DynamicOps;

import java.util.Locale;

public final class EnumCodec<E extends Enum<E>> implements Codec<E> {

    public static <T extends Enum<T>> EnumCodec<T> create(final Class<T> type) {
        return new EnumCodec<>(type);
    }

    private final Class<E> type;

    public EnumCodec(final Class<E> type) {
        this.type = type;
    }

    @Override
    public <T> DataResult<Pair<E, T>> decode(final DynamicOps<T> ops, final T input) {
        return ops.getStringValue(input).map(v -> Pair.of(Enum.valueOf(this.type, v.toUpperCase(Locale.ROOT)), ops.empty()));
    }

    @Override
    public <T> DataResult<T> encode(final E input, final DynamicOps<T> ops, final T prefix) {
        return ops.mergeToPrimitive(prefix, ops.createString(input.name().toLowerCase(Locale.ROOT)));
    }
}


text:
(function(){
  window.Kirari.Views.ProductsListView = Backbone.View.extend({
    initialize: function() {
      if ( typeof this.collection != 'undefined' ) {
        this.collection.on('reset', this.render, this)
        this.collection.on('add', this.addOne, this)
      }
    }
  , render: function() {
      this.$el.hide().empty()

      if (this.collection.size() > 0)
        this.collection.each(_.bind(this.addOne, this))
      else
        this.$el.html('
該当する商品が見つかりませんでした。
')

      this.$el.fadeIn()
    }
  , addOne: function(model) {
      var newItemView = new Kirari.Views.ProductItemView({
        model: model
      })
      this.$el.append(newItemView.render().el)
    }
  })
}).call(this);


text:
@class OEXConfig;
@class OEXRouter;

@interface OEXEnvironment : NSObject

- (void)setConfigBuilder:(OEXConfig*(^)(void))config;
- (void)setRouterBuilder:(OEXRouter*(^)(void))router;

- (void)setupEnvironment;

@end


text:
?<?php
include_once($_SERVER['DOCUMENT_ROOT']."/eventconfig.php");
include_once(CLASSFOLDER . "/sendmail/Testsendmail.php");
/*$sendmail = new sendmailclass();

$from_address = "prabhakarindia2006@gmail.com";
$from_name = "Prabhakar";
$subject = "Test";
$html_message = "this is test mail";
$toname = "prabhakarindia2006";
$tomailid = "prabhakarindia2006@gmail";
$sendmail->sendHtmlEMail($from_address, $from_name, $toname, $tomailid, $subject, $html_message, $html_message);
*/

/* Instantiate Object
-------------------------------------------------------------------*/
	//$mailer = new SendMail ( MSG_TXT );
        $mailer = new SendMail ( MSG_HTML + MSG_TXT );
	$mailer->setSMTP ( 'smtp.gmail.com' , '465' , 'prabhakarindia2006@gmail.com' , 'prabhaprofit121085' ) ;

/* Set Basics, like sender, recipient (receiver), a CC, and the subject
-------------------------------------------------------------------*/
	$mailer->setSender('Prabhakar','prabhakarindia2006@gmail.com');
	$mailer->setReceiver('senthil','hariesh.air@gmail.com');
	//$mailer->addCC('you','pretendnamethatdoesntexist@hotmail.com');
	$mailer->subject = 'This is a test message.';
/* Set the actual message, both HTML and TXT
-------------------------------------------------------------------*/
	// Load the HTML template
	//$template_file = fopen ( 'mail_template.html' , 'r' );

	/*$template = '';
	while (!feof ($template_file)) {
		$template .= fgets ($template_file);
	}
	fclose ($template_file); */

	$msg = <<<MSG
this is text test mail in php
MSG;

	/*$mailer->reparseMail ( $template , array (
		'name'=>'Jason Vertucio',
		'email'=>'m@jasonvertucio.com',
		'phone'=>'(212) 555-1212',
		'message'=>$msg
	));*/

	//$mailer->setHtmlMessage($template);
	$mailer->setTextMessage(nl2br($msg));
		// Note that this will actually show you all the HTML
		// tags and is NOT a good way of performing the task
		echo "msg:::".var_dump($msg);
/* Actually send the message!
-------------------------------------------------------------------*/
	// Uncomment the following line and enter your information to send an email using SMTP.
	// $mailer->setSMTP( server , port (25 or 26) , username , password );
	$result = $mailer->send();

?>


text:
#ifndef IU_CORE_SCRIPTAPI_COMUTILS_H
#define IU_CORE_SCRIPTAPI_COMUTILS_H
#include "atlheaders.h"
#include <string>
#pragma once
namespace ScriptAPI {
    /* @cond PRIVATE */
    std::string ComVariantToString(const CComVariant& variant);
    /* @endcond */
}

#endif


text:
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

using System.Net.Http;
using FunctionalTests.Common;
using Microsoft.Owin;
using Microsoft.Owin.Security.Cookies;
using Owin;
using Xunit;
using Xunit.Extensions;

namespace FunctionalTests.Facts.Security.Cookies
{
    public class CookiesApplyRedirect
    {
        [Theory, Trait("FunctionalTests", "Security")]
        [InlineData(HostType.HttpListener)]
        public void Security_CookiesAuthDefaults(HostType hostType)
        {
            using (ApplicationDeployer deployer = new ApplicationDeployer())
            {
                string applicationUrl = deployer.Deploy(hostType, CookieApplyRedirectConfiguration);
                var httpClient = new HttpClient();

                // Unauthenticated request
                var response = httpClient.GetAsync(applicationUrl).Result;
                Assert.Equal<string>("custom", response.RequestMessage.RequestUri.ParseQueryString()["custom_redirect_uri"]);
            }
        }

        public void CookieApplyRedirectConfiguration(IAppBuilder app)
        {
            app.UseCookieAuthentication(new CookieAuthenticationOptions()
            {
                LoginPath = new PathString("/Auth/CookiesLogin"),
                Provider = new CookieAuthenticationProvider()
                {
                    OnApplyRedirect = context =>
                    {
                        context.Response.Redirect(context.RedirectUri + "&custom_redirect_uri=custom");
                    }
                }
            });

            app.UseProtectedResource();
        }
    }
}


text: Scratchpad for IPython notebooks.


text:
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

using System;
using System.Collections.Generic;

namespace Org.Apache.REEF.Driver.Bridge
{
    internal sealed class ClrSystemHandler<T> : IObserver<T>, IObservable<T>
    {
        readonly List<IObserver<T>> userHandlers = new List<IObserver<T>>();

        public void OnNext(T value)
        {
            foreach (var observer in userHandlers)
            {
                observer.OnNext(value);
            }
        }

        public void OnError(Exception error)
        {
            throw new NotImplementedException();
        }

        public void OnCompleted()
        {
            throw new NotImplementedException();
        }

        public IDisposable Subscribe(IObserver<T> observer)
        {
            userHandlers.Add(observer);
            return null;
        }
    }
}


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [puppeteer](./puppeteer.md) > [Protocol](./puppeteer.protocol.md) > [LayerTree](./puppeteer.protocol.layertree.md) > [Layer](./puppeteer.protocol.layertree.layer.md) > [paintCount](./puppeteer.protocol.layertree.layer.paintcount.md)

## Protocol.LayerTree.Layer.paintCount property

Indicates how many time this layer has painted.

<b>Signature:</b>

```typescript
paintCount: integer;
```


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AutoGetHashCode;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;

namespace TestAutoGetHashCode
{
    [TestClass]
    public class PointTester
    {
        private Point _point;
        [TestInitialize]
        public void SetUp()
        {
            _point = new Point(4, 4);
        }

        [TestMethod]
        public void TestGetHashCode()
        {
            AreEqual(9089, _point.GetHashCode());
        }
    }
}


text:
Log4Net - Links
***************

Alternatives
============

- Microsoft - Logging Application Block:
  :doc:`../microsoft/patterns-and-practices`

Article
=======

`Using log4net`_

.. _`Using log4net`: http://www.ondotnet.com/pub/a/dotnet/2003/06/16/log4net.html


text:
<?php

namespace Larasoft\Setting;

use Illuminate\Database\Eloquent\Model;

class SettingModel extends Model {

	/**
	 * The database table used by the model.
	 *
	 * @var string
	 */
	protected $table = 'settings';

}
?>