text:
package org.valkyriercp.application.docking;

import com.vldocking.swing.docking.DockingContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.valkyriercp.application.*;
import org.valkyriercp.util.ValkyrieRepository;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * <tt>ApplicationPageFactory</tt> that creates instances of <tt>VLDockingApplicationPage</tt>.
 *
 * @author Rogan Dawes
 */
public class VLDockingApplicationPageFactory implements ApplicationPageFactory {

    private static final Log logger = LogFactory.getLog(VLDockingApplicationPageFactory.class);

    private boolean reusePages;
    private Map<Object, Map<Object, Object>> pageCache = new HashMap<Object, Map<Object, Object>>();
    /*
     * (non-Javadoc)
     *
     * @see org.springframework.richclient.application.ApplicationPageFactory#createApplicationPage(org.springframework.richclient.application.ApplicationWindow,
     *      org.springframework.richclient.application.PageDescriptor)
     */
    public ApplicationPage createApplicationPage(ApplicationWindow window, PageDescriptor descriptor) {
        if (reusePages) {
            VLDockingApplicationPage page = findPage(window, descriptor);
            if (page != null) {
                return page;
            }
        }
        VLDockingApplicationPage page = new VLDockingApplicationPage(window, descriptor);
        if (reusePages) {
            cachePage(page);
        }

        window.addPageListener(new PageListener() {
            public void pageOpened(ApplicationPage page) {
                // nothing to do here
            }

            public void pageClosed(ApplicationPage page) {
                VLDockingApplicationPage vlDockingApplicationPage = (VLDockingApplicationPage) page;
                saveDockingContext(vlDockingApplicationPage);
            }
        });

        return page;
    }

    /**
     * Saves the docking layout of a docking page fo the application
     *
     * @param dockingPage
     *            The application window (needed to hook in for the docking context)
     */
    private void saveDockingContext(VLDockingApplicationPage dockingPage) {
        DockingContext dockingContext = dockingPage.getDockingContext();

        // Page descriptor needed for config path
        VLDockingPageDescriptor vlDockingPageDescriptor = ValkyrieRepository.getInstance().getBean(dockingPage.getId(), VLDockingPageDescriptor.class);

        // Write docking context to file
        BufferedOutputStream buffOs = null;
        try {
            File desktopLayoutFile = vlDockingPageDescriptor.getInitialLayout().getFile();
            checkForConfigPath(desktopLayoutFile);

            buffOs = new BufferedOutputStream(new FileOutputStream(desktopLayoutFile));
            dockingContext.writeXML(buffOs);
            buffOs.close();
            logger.debug("Wrote docking context to config file " + desktopLayoutFile);

        }
        catch (IOException e) {
            logger.warn("Error writing VLDocking config", e);
        }
        finally {
            try {
                if(buffOs != null)
                    buffOs.close();
            }
            catch (Exception e) {
                logger.debug("Error closing layoutfile", e);
            }
        }
    }

    /**
     * Creates the config directory, if it doesn't exist already
     *
     * @param configFile
     *            The file for which to create the path
     */
    private void checkForConfigPath(File configFile) {
        String desktopLayoutFilePath = configFile.getAbsolutePath();
        String configDirPath = desktopLayoutFilePath.substring(0, desktopLayoutFilePath.lastIndexOf(System
                .getProperty("file.separator")));
        File configDir = new File(configDirPath);

        // create config dir if it does not exist
        if (!configDir.exists()) {
            boolean success = configDir.mkdirs();
            if(success)
                logger.debug("Newly created config directory");
            else
                logger.warn("Could not create config directory");
        }
    }

    protected VLDockingApplicationPage findPage(ApplicationWindow window, PageDescriptor descriptor) {
        Map<Object, Object> pages = pageCache.get(window);
        if (pages == null) {
            return null;
        }

        return (VLDockingApplicationPage) pages.get(descriptor.getId());
    }

    protected void cachePage(VLDockingApplicationPage page) {
        Map<Object, Object> pages = pageCache.get(page.getWindow());
        if (pages == null) {
            pages = new HashMap<Object, Object>();
            pageCache.put(page.getWindow(), pages);
        }
        pages.put(page.getId(), page);
    }

    /**
     * @param reusePages
     *            the reusePages to set
     */
    public void setReusePages(boolean reusePages) {
        this.reusePages = reusePages;
    }
}


text:
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.

package com.intellij.application.options.colors;

import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.options.colors.ColorSettingsPage;
import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NotNull;

/**
 * Generalises {@link ColorSettingsPage} in a way that allows to provide custom {@link PreviewPanel preview panel}.
 *
 * @author yole
 */
public interface ColorAndFontPanelFactory {

  ExtensionPointName<ColorAndFontPanelFactory> EP_NAME = ExtensionPointName.create("com.intellij.colorAndFontPanelFactory");

  @NotNull
  NewColorAndFontPanel createPanel(@NotNull ColorAndFontOptions options);

  @NotNull
  @Nls(capitalization = Nls.Capitalization.Title)
  String getPanelDisplayName();

  /**
   * @see {@link com.intellij.openapi.options.SearchableConfigurable#getOriginalClass()}
   */
  @NotNull
  default Class<?> getOriginalClass() {
    return this.getClass();
  }
}

redpajama_set_name: RedPajamaGithub


text:
package exercise.task3_customStack.commands;

import exercise.task3_customStack.Stack;

public interface Executable {

    void execute(Stack<Integer> stack, String... args);
}


text:
layout: default
title: Advanced usage
---

# Advanced usage

Once your Glide [server](/1.0/config/setup/) is configured, there are a number of methods available to interact with it. For basic setups you'll likely only need the `outputImage()` method. However, if you plan to use Glide with a queuing server or in other more complex configurations, these methods can be useful.

## Source

~~~ php
<?php

// Set the source file system
public function setSource(FilesystemOperator $source)

// Get the source file system
public function getSource()

// Set the source path prefix
public function setSourcePathPrefix($sourcePathPrefix)

// Get the source path prefix
public function getSourcePathPrefix()

// Get the source path for an image
public function getSourcePath($path)

// Check if a source file exists
public function sourceFileExists($path)
~~~

## Cache

~~~ php
<?php

// Set the cache file system
public function setCache(FilesystemOperator $cache)

// Get the cache file system
public function getCache()

// Set the cache path prefix
public function setCachePathPrefix($cachePathPrefix)

// Get the cache path prefix
public function getCachePathPrefix()

// Set the group cache in folders setting
public function setGroupCacheInFolders(true|false)

// Get the group cache in folders setting
public function getGroupCacheInFolders()

// Delete an image from the cache
public function deleteCache($path)

// Get the cache path for an image
public function getCachePath($path, array $params)

// Check if a cache file exists
public function cacheFileExists($path, array $params)

// Set the temporary directory that should be used to store EXIF data
public function setTempDir($tempDir)

// Get the current temporary directory
public function getTempDir()
~~~

## Api

~~~ php
<?php

// Set the image manipulation Api
public function setApi(ApiInterface $api)

// Get the image manipulation Api
public function getApi()
~~~

## Responses

~~~ php
<?php

// Set the response factory
public function setResponseFactory(ResponseFactoryInterface $responseFactory)

// Get the response factory
public function getResponseFactory()
~~~

## Default manipulations

~~~ php
<?php

// Set the default manipulators
public function setManipulators(array $manipulators)

// Get the default manipulators
public function getManipulators()
~~~

## Base URL

~~~ php
<?php

// Set the base url
public function setBaseUrl($baseUrl)

// Get the base url
public function getBaseUrl()
~~~

## Image generation

~~~ php
<?php

// Generates and outputs the image
$server->outputImage($path, array $params);

// Generates and returns the image reponse
$server->getImageResponse($path, array $params);

// Generates and returns the image Base64 encoded
$server->getImageAsBase64($path, array $params);

// Generates the image
$server->makeImage($path, array $params);
~~~


text:
This page was generated with Wiki Builder. Do not change the format!

## Acolyte's Eye
### Info
* **enemyId:** TakenTurret
* **enemyName:** ###TakenTurret###
* **raceName:** Taken

### Overrides
key | value
--- | -----
enemyName | Acolyte's Eye

### Stats
statType | statId
-------- | ------
assistsAgainst | assistsAgainstTakenTurret
precisionKillsOf | precisionKillOfTakenTurret
deathsFrom | deathsFromTakenTurret
killsOf | killsOfTakenTurret


text:
class ErrorController < ApplicationController
  def index
  end

  def contact
  end
end


text:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Text;
using System.Windows.Forms;

namespace WinHtmlEditor
{
    public class ToolStripFontComboBox : ToolStripComboBox
    {
        #region  Private Member Declarations

        private readonly Dictionary<string, Font> _fontCache;
        private int _itemHeight;
        private int _previewFontSize;
        private StringFormat _stringFormat;

        #endregion  Private Member Declarations

        #region  Public Constructors

        public ToolStripFontComboBox()
        {
            _fontCache = new Dictionary<string, Font>();

            DrawMode = DrawMode.OwnerDrawVariable;
            if (!ComboBox.IsNull())
            {
                ComboBox.DrawItem += OnDrawItem;
                ComboBox.MeasureItem += OnMeasureItem;
            }
            Sorted = true;
            PreviewFontSize = 12;

            CalculateLayout();
            CreateStringFormat();
        }

        #endregion  Public Constructors

        #region  Events

        public event EventHandler PreviewFontSizeChanged;

        #endregion  Events

        #region  Protected Overridden Methods

        protected override void Dispose(bool disposing)
        {
            ClearFontCache();

            if (!_stringFormat.IsNull())
                _stringFormat.Dispose();

            base.Dispose(disposing);
        }

        protected void OnDrawItem(object sender, DrawItemEventArgs e)
        {
            if (e.Index <= -1 || e.Index >= Items.Count) return;
            e.DrawBackground();

            if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
                e.DrawFocusRectangle();

            using (var textBrush = new SolidBrush(e.ForeColor))
            {
                string fontFamilyName = Items[e.Index].ToString();
                e.Graphics.DrawString(fontFamilyName, GetFont(fontFamilyName), textBrush, e.Bounds, _stringFormat);
            }
        }

        protected override void OnClick(EventArgs e)
        {
            base.OnClick(e);
            _internalCall = false;
        }

        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            base.OnSelectedIndexChanged(e);
            _internalCall = false;
        }

        protected override void OnFontChanged(EventArgs e)
        {
            base.OnFontChanged(e);

            CalculateLayout();
        }

        protected override void OnGotFocus(EventArgs e)
        {
            LoadFontFamilies();

            base.OnGotFocus(e);
        }

        protected void OnMeasureItem(object sender, MeasureItemEventArgs e)
        {
            if (e.Index > -1 && e.Index < Items.Count)
            {
                e.ItemHeight = _itemHeight;
            }
        }

        protected override void OnRightToLeftChanged(EventArgs e)
        {
            base.OnRightToLeftChanged(e);

            CreateStringFormat();
        }

        protected override void OnTextChanged(EventArgs e)
        {
            base.OnTextChanged(e);

            if (Items.Count == 0)
            {
                LoadFontFamilies();

                int selectedIndex = FindStringExact(Text);
                if (selectedIndex != -1)
                    SelectedIndex = selectedIndex;
            }
        }

        protected override void OnDropDown(EventArgs e)
        {
            base.OnDropDown(e);
            AdjustComboBoxDropDownListWidth();  //调整comboBox的下拉列表的大小
        }

        private void AdjustComboBoxDropDownListWidth()
        {
            Graphics g = null;
            try
            {
                int width = Width;
                g = this.ComboBox.CreateGraphics();

                //checks if a scrollbar will be displayed.
                //If yes, then get its width to adjust the size of the drop down list.
                int vertScrollBarWidth =
                    (Items.Count > MaxDropDownItems)
                        ? SystemInformation.VerticalScrollBarWidth
                        : 0;

                int newWidth;
                foreach (object s in Items) //Loop through list items and check size of each items.
                {
                    if (s != null)
                    {
                        newWidth = (int)g.MeasureString(s.ToString().Trim(), GetFont(s.ToString())).Width
                                   + vertScrollBarWidth;
                        if (width < newWidth)
                            width = newWidth;
                        //set the width of the drop down list to the width of the largest item.
                    }
                }
                DropDownWidth = width;
            }
            catch
            { }
            finally
            {
                if (g != null)
                    g.Dispose();
            }
        }
        #endregion  Protected Overridden Methods

        #region  Public Methods

        public void LoadFontFamilies()
        {
            if (Items.Count == 0)
            {
                Cursor.Current = Cursors.WaitCursor;
                foreach (FontFamily fontFamily in FontFamily.Families)
                    Items.Add(fontFamily.Name);

                Cursor.Current = Cursors.Default;
            }
        }

        #endregion  Public Methods

        #region  Public Properties

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public DrawMode DrawMode
        {
            get
            {
                if (!ComboBox.IsNull()) return ComboBox.DrawMode;
                return DrawMode.Normal;
            }
            set { if (!ComboBox.IsNull()) ComboBox.DrawMode = value; }
        }

        [Category("Appearance"), DefaultValue(12)]
        public int PreviewFontSize
        {
            get { return _previewFontSize; }
            set
            {
                _previewFontSize = value;

                OnPreviewFontSizeChanged(EventArgs.Empty);
            }
        }

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public new bool Sorted
        {
            get { return base.Sorted; }
            set { base.Sorted = value; }
        }

        private bool _internalCall;

        public bool InternalCall
        {
            get { return _internalCall; }
            set { _internalCall = value; }
        }

        private int _count;
        private bool _gotit;

        public string SelectedFontNameItem
        {
            get
            {
                if (SelectedIndex > -1)
                    return ((Font)SelectedItem).Name;
                return string.Empty;
            }

            set
            {
                _gotit = false;
                _count = 0;
                foreach (object item in Items)
                {
                    if (((Font)item).Name == value)
                    {
                        _gotit = true;
                        break;
                    }
                    _count++;
                }
                if (_gotit)
                {
                    _internalCall = true;
                    SelectedIndex = _count;
                }
            }
        }

        public Font SelectedFontItem
        {
            get
            {
                if (SelectedIndex > -1)
                    return (Font)SelectedItem;
                return null;
            }

            set
            {
                _gotit = false;
                _count = 0;
                foreach (object item in Items)
                {
                    if (((Font)item).Name == value.Name)
                    {
                        _gotit = true;
                        break;
                    }
                    _count++;
                }
                if (_gotit)
                {
                    _internalCall = true;
                    SelectedIndex = _count;
                }
            }
        }

        #endregion  Public Properties

        #region  Private Methods

        private void CalculateLayout()
        {
            ClearFontCache();

            using (var font = new Font(Font.FontFamily, PreviewFontSize))
            {
                Size textSize = TextRenderer.MeasureText("yY", font);
                _itemHeight = textSize.Height + 2;
            }
        }

        private bool IsUsingRTL(Control control)
        {
            bool result;

            if (control.RightToLeft == RightToLeft.Yes)
                result = true;
            else if (control.RightToLeft == RightToLeft.Inherit && !control.Parent.IsNull())
                result = IsUsingRTL(control.Parent);
            else
                result = false;

            return result;
        }

        #endregion  Private Methods

        #region  Protected Methods

        private void ClearFontCache()
        {
            if (!_fontCache.IsNull())
            {
                foreach (string key in _fontCache.Keys)
                    _fontCache[key].Dispose();
                _fontCache.Clear();
            }
        }

        private void CreateStringFormat()
        {
            if (!_stringFormat.IsNull())
                _stringFormat.Dispose();

            _stringFormat = new StringFormat(StringFormatFlags.NoWrap)
            {
                Trimming = StringTrimming.EllipsisCharacter,
                HotkeyPrefix = HotkeyPrefix.None,
                Alignment = StringAlignment.Near,
                LineAlignment = StringAlignment.Center
            };

            if (IsUsingRTL(ComboBox))
                _stringFormat.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
        }

        private Font GetFont(string fontFamilyName)
        {
            lock (_fontCache)
            {
                if (!_fontCache.ContainsKey(fontFamilyName))
                {
                    Font font = (((GetFont(fontFamilyName, FontStyle.Regular) ??
                                   GetFont(fontFamilyName, FontStyle.Bold)) ??
                                  GetFont(fontFamilyName, FontStyle.Italic)) ??
                                 GetFont(fontFamilyName, FontStyle.Bold | FontStyle.Italic)) ??
                                (Font)Font.Clone();

                    _fontCache.Add(fontFamilyName, font);
                }
            }

            return _fontCache[fontFamilyName];
        }

        private Font GetFont(string fontFamilyName, FontStyle fontStyle)
        {
            Font font;

            try
            {
                font = new Font(fontFamilyName, PreviewFontSize, fontStyle);
            }
            catch
            {
                font = null;
            }

            return font;
        }

        private void OnPreviewFontSizeChanged(EventArgs e)
        {
            if (!PreviewFontSizeChanged.IsNull())
                PreviewFontSizeChanged(this, e);

            CalculateLayout();
        }

        #endregion  Protected Methods
    }
}


text:
"use strict";

const synchronizer = require('../../');
const ChatPage = require('./chat_page');

describe('test for socket.io chat example.', function() {
    const chatPage = new ChatPage();

    beforeEach(function() {
        synchronizer.run({wait: true}, function() {
            chatPage.get();
        });
        synchronizer.run({only: 'client_1'}, function() {
            chatPage.login('client_1');
        });
        synchronizer.run({only: 'client_2'}, function() {
            chatPage.login('client_2');
        });
        synchronizer.run({only: 'client_3'}, function() {
            chatPage.login('client_3');
        });
    });

    it('real-time chat.', function() {
        synchronizer.run({wait: true}, function() {
            expect(browser.getTitle()).toEqual('Socket.IO Chat Example');
            expect(chatPage.getLastLogMessage()).toEqual('there are 3 participants');
        });
        synchronizer.run({only: 'client_1'}, function() {
            chatPage.postMessage('Hello!');
        });
        synchronizer.run({only: ['client_2', 'client_3'], wait: true}, function() {
            expect(chatPage.getLastChatMessageUser()).toEqual('client_1');
            expect(chatPage.getLastChatMessageBody()).toEqual('Hello!');
        });
        synchronizer.run({only: 'client_2'}, function() {
            chatPage.postMessage('Hi!');
        });
        synchronizer.run({wait: true}, function() {
            expect(chatPage.getLastChatMessageUser()).toEqual('client_2');
            expect(chatPage.getLastChatMessageBody()).toEqual('Hi!');
        });
    });
});


text:
package com.zxytech.designpatterns.gof.behavioralpatterns.commandpattern;

/**
 * Created by ryan on 2016/12/18.
 * 使用 Broker 类来接受并执行命令。
 */
public class CommandPatternDemo {
    public static void main(String[] args) {
        Stock abcStock = new Stock();

        BuyStock buyStockOrder = new BuyStock(abcStock);
        SellStock sellStockOrder = new SellStock(abcStock);

        Broker broker = new Broker();
        broker.takeOrder(buyStockOrder);
        broker.takeOrder(sellStockOrder);

        broker.placeOrders();
    }
}


text:
package gin

import (
	"encoding/json"
	"encoding/xml"
	"github.com/julienschmidt/httprouter"
	"html/template"
	"log"
	"math"
	"net/http"
	"path"
)

const (
	AbortIndex = math.MaxInt8 / 2
)

type (
	HandlerFunc func(*Context)

	H map[string]interface{}

	// Used internally to collect a error ocurred during a http request.
	ErrorMsg struct {
		Message string      `json:"msg"`
		Meta    interface{} `json:"meta"`
	}

	// Context is the most important part of gin. It allows us to pass variables between middleware,
	// manage the flow, validate the JSON of a request and render a JSON response for example.
	Context struct {
		Req      *http.Request
		Writer   http.ResponseWriter
		Keys     map[string]interface{}
		Errors   []ErrorMsg
		Params   httprouter.Params
		handlers []HandlerFunc
		engine   *Engine
		index    int8
	}

	// Used internally to configure router, a RouterGroup is associated with a prefix
	// and an array of handlers (middlewares)
	RouterGroup struct {
		Handlers []HandlerFunc
		prefix   string
		parent   *RouterGroup
		engine   *Engine
	}

	// Represents the web framework, it wrappers the blazing fast httprouter multiplexer and a list of global middlewares.
	Engine struct {
		*RouterGroup
		handlers404   []HandlerFunc
		router        *httprouter.Router
		HTMLTemplates *template.Template
	}
)

// Returns a new blank Engine instance without any middleware attached.
// The most basic configuration
func New() *Engine {
	engine := &Engine{}
	engine.RouterGroup = &RouterGroup{nil, "", nil, engine}
	engine.router = httprouter.New()
	engine.router.NotFound = engine.handle404
	return engine
}

// Returns a Engine instance with the Logger and Recovery already attached.
func Default() *Engine {
	engine := New()
	engine.Use(Recovery(), Logger())
	return engine
}

func (engine *Engine) LoadHTMLTemplates(pattern string) {
	engine.HTMLTemplates = template.Must(template.ParseGlob(pattern))
}

// Adds handlers for NotFound. It return a 404 code by default.
func (engine *Engine) NotFound404(handlers ...HandlerFunc) {
	engine.handlers404 = handlers
}

func (engine *Engine) handle404(w http.ResponseWriter, req *http.Request) {
	handlers := engine.combineHandlers(engine.handlers404)
	c := engine.createContext(w, req, nil, handlers)
	if engine.handlers404 == nil {
		http.NotFound(c.Writer, c.Req)
	} else {
		c.Writer.WriteHeader(404)
	}

	c.Next()
}

// ServeFiles serves files from the given file system root.
// The path must end with "/*filepath", files are then served from the local
// path /defined/root/dir/*filepath.
// For example if root is "/etc" and *filepath is "passwd", the local file
// "/etc/passwd" would be served.
// Internally a http.FileServer is used, therefore http.NotFound is used instead
// of the Router's NotFound handler.
// To use the operating system's file system implementation,
// use http.Dir:
//     router.ServeFiles("/src/*filepath", http.Dir("/var/www"))
func (engine *Engine) ServeFiles(path string, root http.FileSystem) {
	engine.router.ServeFiles(path, root)
}

// ServeHTTP makes the router implement the http.Handler interface.
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	engine.router.ServeHTTP(w, req)
}

func (engine *Engine) Run(addr string) {
	http.ListenAndServe(addr, engine)
}

/************************************/
/********** ROUTES GROUPING *********/
/************************************/

func (group *RouterGroup) createContext(w http.ResponseWriter, req *http.Request, params httprouter.Params, handlers []HandlerFunc) *Context {
	return &Context{
		Writer:   w,
		Req:      req,
		index:    -1,
		engine:   group.engine,
		Params:   params,
		handlers: handlers,
	}
}

// Adds middlewares to the group, see example code in github.
func (group *RouterGroup) Use(middlewares ...HandlerFunc) {
	group.Handlers = append(group.Handlers, middlewares...)
}

// Greates a new router group. You should create add all the routes that share that have common middlwares or same path prefix.
// For example, all the routes that use a common middlware for authorization could be grouped.
func (group *RouterGroup) Group(component string, handlers ...HandlerFunc) *RouterGroup {
	prefix := path.Join(group.prefix, component)
	return &RouterGroup{
		Handlers: group.combineHandlers(handlers),
		parent:   group,
		prefix:   prefix,
		engine:   group.engine,
	}
}

// Handle registers a new request handle and middlewares with the given path and method.
// The last handler should be the real handler, the other ones should be middlewares that can and should be shared among different routes.
// See the example code in github.
//
// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
// functions can be used.
//
// This function is intended for bulk loading and to allow the usage of less
// frequently used, non-standardized or custom methods (e.g. for internal
// communication with a proxy).
func (group *RouterGroup) Handle(method, p string, handlers []HandlerFunc) {
	p = path.Join(group.prefix, p)
	handlers = group.combineHandlers(handlers)
	group.engine.router.Handle(method, p, func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
		group.createContext(w, req, params, handlers).Next()
	})
}

// POST is a shortcut for router.Handle("POST", path, handle)
func (group *RouterGroup) POST(path string, handlers ...HandlerFunc) {
	group.Handle("POST", path, handlers)
}

// GET is a shortcut for router.Handle("GET", path, handle)
func (group *RouterGroup) GET(path string, handlers ...HandlerFunc) {
	group.Handle("GET", path, handlers)
}

// DELETE is a shortcut for router.Handle("DELETE", path, handle)
func (group *RouterGroup) DELETE(path string, handlers ...HandlerFunc) {
	group.Handle("DELETE", path, handlers)
}

// PATCH is a shortcut for router.Handle("PATCH", path, handle)
func (group *RouterGroup) PATCH(path string, handlers ...HandlerFunc) {
	group.Handle("PATCH", path, handlers)
}

// PUT is a shortcut for router.Handle("PUT", path, handle)
func (group *RouterGroup) PUT(path string, handlers ...HandlerFunc) {
	group.Handle("PUT", path, handlers)
}

func (group *RouterGroup) combineHandlers(handlers []HandlerFunc) []HandlerFunc {
	s := len(group.Handlers) + len(handlers)
	h := make([]HandlerFunc, 0, s)
	h = append(h, group.Handlers...)
	h = append(h, handlers...)
	return h
}

/************************************/
/****** FLOW AND ERROR MANAGEMENT****/
/************************************/

// Next should be used only in the middlewares.
// It executes the pending handlers in the chain inside the calling handler.
// See example in github.
func (c *Context) Next() {
	c.index++
	s := int8(len(c.handlers))
	for ; c.index < s; c.index++ {
		c.handlers[c.index](c)
	}
}

// Forces the system to do not continue calling the pending handlers.
// For example, the first handler checks if the request is authorized. If it's not, context.Abort(401) should be called.
// The rest of pending handlers would never be called for that request.
func (c *Context) Abort(code int) {
	c.Writer.WriteHeader(code)
	c.index = AbortIndex
}

// Fail is the same than Abort plus an error message.
// Calling `context.Fail(500, err)` is equivalent to:
// ```
// context.Error("Operation aborted", err)
// context.Abort(500)
// ```
func (c *Context) Fail(code int, err error) {
	c.Error(err, "Operation aborted")
	c.Abort(code)
}

// Attachs an error to the current context. The error is pushed to a list of errors.
// It's a gooc idea to call Error for each error ocurred during the resolution of a request.
// A middleware can be used to collect all the errors and push them to a database together, print a log, or append it in the HTTP response.
func (c *Context) Error(err error, meta interface{}) {
	c.Errors = append(c.Errors, ErrorMsg{
		Message: err.Error(),
		Meta:    meta,
	})
}

/************************************/
/******** METADATA MANAGEMENT********/
/************************************/

// Sets a new pair key/value just for the specefied context.
// It also lazy initializes the hashmap
func (c *Context) Set(key string, item interface{}) {
	if c.Keys == nil {
		c.Keys = make(map[string]interface{})
	}
	c.Keys[key] = item
}

// Returns the value for the given key.
// It panics if the value doesn't exist.
func (c *Context) Get(key string) interface{} {
	var ok bool
	var item interface{}
	if c.Keys != nil {
		item, ok = c.Keys[key]
	} else {
		item, ok = nil, false
	}
	if !ok || item == nil {
		log.Panicf("Key %s doesn't exist", key)
	}
	return item
}

/************************************/
/******** ENCOGING MANAGEMENT********/
/************************************/

// Like ParseBody() but this method also writes a 400 error if the json is not valid.
func (c *Context) EnsureBody(item interface{}) bool {
	if err := c.ParseBody(item); err != nil {
		c.Fail(400, err)
		return false
	}
	return true
}

// Parses the body content as a JSON input. It decodes the json payload into the struct specified as a pointer.
func (c *Context) ParseBody(item interface{}) error {
	decoder := json.NewDecoder(c.Req.Body)
	if err := decoder.Decode(&item); err == nil {
		return Validate(c, item)
	} else {
		return err
	}
}

// Serializes the given struct as a JSON into the response body in a fast and efficient way.
// It also sets the Content-Type as "application/json"
func (c *Context) JSON(code int, obj interface{}) {
	c.Writer.Header().Set("Content-Type", "application/json")
	if code >= 0 {
		c.Writer.WriteHeader(code)
	}
	encoder := json.NewEncoder(c.Writer)
	if err := encoder.Encode(obj); err != nil {
		c.Error(err, obj)
		http.Error(c.Writer, err.Error(), 500)
	}
}

// Serializes the given struct as a XML into the response body in a fast and efficient way.
// It also sets the Content-Type as "application/xml"
func (c *Context) XML(code int, obj interface{}) {
	c.Writer.Header().Set("Content-Type", "application/xml")
	if code >= 0 {
		c.Writer.WriteHeader(code)
	}
	encoder := xml.NewEncoder(c.Writer)
	if err := encoder.Encode(obj); err != nil {
		c.Error(err, obj)
		http.Error(c.Writer, err.Error(), 500)
	}
}

// Renders the HTTP template specified by his file name.
// It also update the HTTP code and sets the Content-Type as "text/html".
// See http://golang.org/doc/articles/wiki/
func (c *Context) HTML(code int, name string, data interface{}) {
	c.Writer.Header().Set("Content-Type", "text/html")
	if code >= 0 {
		c.Writer.WriteHeader(code)
	}
	if err := c.engine.HTMLTemplates.ExecuteTemplate(c.Writer, name, data); err != nil {
		c.Error(err, map[string]interface{}{
			"name": name,
			"data": data,
		})
		http.Error(c.Writer, err.Error(), 500)
	}
}

// Writes the given string into the response body and sets the Content-Type to "text/plain"
func (c *Context) String(code int, msg string) {
	c.Writer.Header().Set("Content-Type", "text/plain")
	c.Writer.WriteHeader(code)
	c.Writer.Write([]byte(msg))
}

// Writes some data into the body stream and updates the HTTP code
func (c *Context) Data(code int, data []byte) {
	c.Writer.WriteHeader(code)
	c.Writer.Write(data)
}


text:
/* main.cpp from QTau http://github.com/qtau-devgroup/editor by digited, BSD license */

#include <QApplication>
#include "Controller.h"
#include <QIcon>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    app.setWindowIcon(QIcon(":/images/appicon_ouka_alice.png"));

    qtauController c;
    c.run(); // create UI that can immediately call back, thus requires already created & inited controller

    return app.exec();
}


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

<TITLE>
Uses of Class org.hibernate.ejb.criteria.predicate.InPredicate (Hibernate JavaDocs)
</TITLE>

<META NAME="date" CONTENT="2013-10-23">

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

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Uses of Class
org.hibernate.ejb.criteria.predicate.InPredicate

Packages that use InPredicate

org.hibernate.ejb.criteria.predicate

Uses of InPredicate in org.hibernate.ejb.criteria.predicate

Methods in org.hibernate.ejb.criteria.predicate that return InPredicate

 InPredicate<T>
InPredicate.value(Expression<? extends T> value)

 InPredicate<T>
InPredicate.value(T value)

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Copyright © 2001-2013 Red Hat, Inc.  All Rights Reserved.


text:
<?php
    namespace CuEx\Console;

    use CuEx\CuEx;
    use Illuminate\Console\Command;

    class BestRateCommand
        extends Command
    {
        protected $name = 'rate:best';
        protected $description = 'Gives the best exchange rate for a given currency pair. (ex. EUR/LTL)';
        protected $cuex;

        public function __construct(Cuex $cuex)
        {
            $this->cuex = $cuex;

            parent::__construct();
        }

        public function fire()
        {
            $currencyPair = $this->ask('What currency, exchange rate you wish to see (ex. EUR/LTL) ?');
            $rate = $this->cuex->getRate($currencyPair)->getValue();
            $this->info('There is you best exchange rate: '.$rate);

        }
    }