text:
<?php

namespace Propel\Common\Config\Loader;

use Propel\Common\Config\Exception\InvalidArgumentException;

/**
 * PhpFileLoader loads configuration values from a PHP file.
 *
 * The configuration values are expected to be in form of array. I.e.
 * <code>
 *     <?php
 *         return array(
 *                    'property1' => 'value1',
 *                    .......................
 *                );
 * </code>
 *
 * @author Cristiano Cinotti
 */
class PhpFileLoader extends FileLoader
{
    /**
     * Loads a PHP file.
     *
     * @param mixed  $file The resource
     * @param string $type The resource type
     *
     * @return array
     *
     * @throws \InvalidArgumentException                                if configuration file not found
     * @throws \Propel\Common\Config\Exception\InvalidArgumentException if invalid json file
     * @throws \Propel\Common\Config\Exception\InputOutputException     if configuration file is not readable
     */
    public function load($file, $type = null)
    {
        $path = $this->getPath($file);

        //Use output buffering because in case $file contains invalid non-php content (i.e. plain text), include() function
        //write it on stdoutput
        ob_start();
        $content = include $path;
        ob_end_clean();

        if (!is_array($content)) {
            throw new InvalidArgumentException("The configuration file '$file' has invalid content.");
        }

        $content = $this->resolveParams($content); //Resolve parameter placeholders (%name%)

        return $content;
    }

    /**
     * Returns true if this class supports the given resource.
     * It supports both .php and .inc extensions.
     *
     * @param mixed  $resource A resource
     * @param string $type     The resource type
     *
     * @return Boolean true if this class supports the given resource, false otherwise
     */
    public function supports($resource, $type = null)
    {
        return $this->checkSupports(['php', 'inc'], $resource);
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.maksim;

public class Doctor {
    private int id;
    private String firstname;
    private String lastname;
    private String[] specialization = new String[2];
    private int experience; //experience (years)

    // Constructor
    public Doctor(String firstname, String lastname, int experience, String[] specialization) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.experience = experience;
        this.specialization = specialization;
    }
    public Doctor(String firstname, String lastname, String[] specialization) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.specialization = specialization;
    }
    // Setter for experience
    public void experience(int experience) {
        this.experience = experience;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public void setSpecialization(String[] specialization) {
        this.specialization = specialization;
    }

    public int getExperience() {
        return experience;
    }

    public String[] getSpecialization() {
        return specialization;
    }

    public String getLastname() {
        return lastname;
    }

    public String getFirstname() {
        return firstname;
    }
    // Print doctor's card
    public void print(int number) {
        System.out.println("----------------------");
        System.out.println("Card of patient #" + number);
        String firstnameInfo = "Firstname: " + this.getFirstname();
        String lastnameInfo = "Lastname: " + this.getLastname();
        String experienceInfo = "Experience: " + this.getExperience();
        String specializationInfo = "Specialization: ";
        for (int i = 0; i < this.getSpecialization().length; i++) {
            specializationInfo += this.getSpecialization()[i];
            if (i < this.getSpecialization().length - 1) {
                specializationInfo += ", ";
            }
        }
        System.out.println(firstnameInfo);
        System.out.println(lastnameInfo);
        System.out.println(experienceInfo);
        System.out.println(specializationInfo);
    }

}


text:
namespace content {

bool IsPinchToZoomEnabled();
#if defined(OS_WIN)
// Disables Win32k Renderer lockdown for any future renderer child processes.
void DisableWin32kRendererLockdown();

// Returns whether Win32k Renderer lockdown is enabled or not.
bool IsWin32kRendererLockdownEnabled();
// Returns whether Win32k PPAPI lockdown is enabled for a specific mime type.
bool IsWin32kLockdownEnabledForMimeType(const std::string& mime_type);
#endif
V8CacheOptions GetV8CacheOptions();

bool IsUseZoomForDSFEnabled();

} // namespace content

#endif  // CONTENT_COMMON_CONTENT_SWITCHES_INTERNAL_H_


text:
<?php

require_once(sfConfig::get('sf_lib_dir').'/filter/base/BaseFormFilterPropel.class.php');

/**
 * SfGuardGroup filter form base class.
 *
 * @package    sf_sandbox
 * @subpackage filter
 * @author     Your name here
 * @version    SVN: $Id: sfPropelFormFilterGeneratedTemplate.php 16976 2009-04-04 12:47:44Z fabien $
 */
class BaseSfGuardGroupFormFilter extends BaseFormFilterPropel
{
  public function setup()
  {
    $this->setWidgets(array(
      'name'        => new sfWidgetFormFilterInput(),
      'description' => new sfWidgetFormFilterInput(),
    ));

    $this->setValidators(array(
      'name'        => new sfValidatorPass(array('required' => false)),
      'description' => new sfValidatorPass(array('required' => false)),
    ));

    $this->widgetSchema->setNameFormat('sf_guard_group_filters[%s]');

    $this->errorSchema = new sfValidatorErrorSchema($this->validatorSchema);

    parent::setup();
  }

  public function getModelName()
  {
    return 'SfGuardGroup';
  }

  public function getFields()
  {
    return array(
      'id'          => 'Number',
      'name'        => 'Text',
      'description' => 'Text',
    );
  }
}


text:
CREATE VCLASS StateCity(State CHAR(20), City CHAR(20));
CREATE VCLASS Company  (Name CHAR(20), Location StateCity, Budget FLOAT);
CREATE VCLASS Activity (Name CHAR(20), NumPlayers INTEGER);
CREATE VCLASS Employee (Name CHAR(20), Job CHAR(20), Salary FLOAT, Hobby Activity, WorksFor Company);

DROP VCLASS Employee;
drop VCLASS Activity;
drop VCLASS Company;
drop VCLASS StateCity;


text:
import { Combo } from "./base/combination/combo";
import { ButtonGroup } from "./base/combination/group.button";
import { Tab } from "./base/combination/tab";
import { Pane } from "./base/pane";
import { BasicButton } from "./base/single/button/button.basic";
import { NodeButton } from "./base/single/button/button.node";
import { Button } from "./base/single/button/buttons/button";
import { TextButton } from "./base/single/button/buttons/button.text";
import { IconTextItem } from "./base/single/button/listitem/icontextitem";
import { Editor } from "./base/single/editor/editor";
import { Iframe } from "./base/single/iframe/iframe";
import { Checkbox } from "./base/single/input/checkbox";
import { Input } from "./base/single/input/input";
import { AbstractLabel } from "./base/single/label/abstract.label";
import { Label } from "./base/single/label/label";
import { Single } from "./base/single/single";
import { Text } from "./base/single/text";
import { Trigger } from "./base/single/trigger/trigger";
import { IconChangeButton } from "./case/button/icon/icon.change";
import { MultiSelectItem } from "./case/button/item.multiselect";
import { BubbleCombo } from "./case/combo/bubblecombo/combo.bubble";
import { TextValueCombo } from "./case/combo/combo.textvalue";
import { SmallTextValueCombo } from './case/combo/combo.textvaluesmall';
import { SearchTextValueCombo } from "./case/combo/searchtextvaluecombo/combo.searchtextvalue";
import { SignEditor } from "./case/editor/editor.sign";
import { StateEditor } from './case/editor/editor.state';
import { AllValueMultiTextValueCombo } from "./component/allvaluemultitextvaluecombo/allvalue.multitextvalue.combo";
import { Form } from './component/form/form';
import { AbstractTreeValueChooser } from "./component/treevaluechooser/abstract.treevaluechooser";
import { AbstractListTreeValueChooser } from "./component/treevaluechooser/abstract.treevaluechooser.list";
import { Action, ActionFactory } from "./core/action/action";
import { ShowAction } from "./core/action/action.show";
import { _base } from "./core/base";
import { Behavior, BehaviorFactory } from "./core/behavior/behavior";
import { HighlightBehavior } from "./core/behavior/behavior.highlight";
import { RedMarkBehavior } from "./core/behavior/behavior.redmark";
import * as decorator from "./core/decorator/decorator";
import { _func } from "./core/func";
import { _i18n } from "./core/i18n";
import { _Plugin } from "./core/plugin";
import { _var } from "./core/var";
import { OB } from "./core/ob";
import { Widget } from "./core/widget";
import { _inject } from "./core/inject";
import { Layout } from "./core/wrapper/layout";
import { AbsoluteLayout } from "./core/wrapper/layout/layout.absolute";
import { HTapeLayout, VTapeLayout } from "./core/wrapper/layout/layout.tape";
import { HorizontalFillLayout } from "./core/wrapper/layout/fill/fill.horizontal";
import { VerticalFillLayout } from "./core/wrapper/layout/fill/fill.vertical";
import { VerticalLayout } from "./core/wrapper/layout/layout.vertical";
import { DefaultLayout } from "./core/wrapper/layout/layout.default";
import { DownListCombo } from "./widget/downlist/combo.downlist";
import { DownListPopup } from "./widget/downlist/popup.downlist";
import { Icon } from "./base/single/icon/icon";
import { LeftVerticalAdaptLayout } from "./core/wrapper/layout/adapt/adapt.leftvertical";
import { LeftRightVerticalAdaptLayout, RightVerticalAdaptLayout } from "./core/wrapper/layout/adapt/adapt.leftrightvertical";
import { IconTextIconItem } from "./base/single/button/listitem/icontexticonitem";
import { HorizontalAutoLayout } from "./core/wrapper/layout/adapt/auto.horizontal";
import { InlineVerticalAdaptLayout } from "./core/wrapper/layout/adapt/inline.vertical";
import { TableAdaptLayout } from "./core/wrapper/layout/adapt/adapt.table";
import { IconButton } from "./base/single/button/buttons/button.icon";
import { TextEditor } from "./widget/editor/editor.text";
import { IconLabel } from "./base/single/label/icon.label";
import { Popover, BarPopover } from "./base/layer/layer.popover";
import { IconCombo } from "./case/combo/iconcombo/combo.icon";
import { DynamicDateCombo } from "./widget/dynamicdate/dynamicdate.combo";
import { CustomTree } from "./base/tree/customtree";
import { ButtonTree } from "./base/combination/tree.button";
import { IconArrowNode } from "./case/button/node/node.icon.arrow";
import { MidTreeLeafItem } from "./case/button/treeitem/item.mid.treeleaf";
import { FirstTreeLeafItem } from "./case/button/treeitem/item.first.treeleaf";
import { LastTreeLeafItem } from "./case/button/treeitem/item.last.treeleaf";
import { SmallTextEditor } from "./widget/editor/editor.text.small";
import { MultifileEditor } from "./widget/editor/editor.multifile";
import { AbsoluteCenterLayout } from "./core/wrapper/layout/adapt/absolute.center";
import { HorizontalAdaptLayout } from "./core/wrapper/layout/adapt/adapt.horizontal";
import { FloatLeftLayout, FloatRightLayout } from "./core/wrapper/layout/layout.flow";
import { CenterAdaptLayout } from "./core/wrapper/layout/adapt/adapt.center";
import { VerticalAdaptLayout } from "./core/wrapper/layout/adapt/adapt.vertical";
import { MultiSelectInsertCombo } from "./widget/multiselect/multiselect.insert.combo";
import { MultiSelectCombo } from "./widget/multiselect/multiselect.combo";
import { SearchEditor } from "./widget/editor/editor.search";
import { MultiLayerSingleLevelTree } from "./widget/multilayersingletree/multilayersingletree.leveltree";
import { SimpleColorChooser } from "./case/colorchooser/colorchooser.simple";
import { A } from "./base/a/a";
import { Html } from "./base/single/html/html";
import { Switcher } from "./base/combination/switcher";
import { Expander } from './base/combination/expander';
import { Loader } from "./base/combination/loader";
import { ListPane } from "./case/layer/pane.list";
import { MultiPopupView } from './case/layer/layer.multipopup';
import { MultiSelectBar } from "./case/toolbar/toolbar.multiselect";
import { SelectList } from "./case/list/list.select";
import { AbstractAllValueChooser } from "./component/allvaluechooser/abstract.allvaluechooser";
import { AllValueChooserCombo } from "./component/allvaluechooser/combo.allvaluechooser";
import { TextAreaEditor } from "./base/single/editor/editor.textarea";
import { SingleSelectItem } from "./case/button/item.singleselect";
import { DynamicDateTimeCombo } from "./widget/dynamicdatetime/dynamicdatetime.combo";
import { MultiTreeCombo } from "./widget/multitree/multi.tree.combo";
import { CenterLayout } from "./core/wrapper/layout/middle/middle.center";
import { VirtualGroup } from "./base/combination/group.virtual";
import { GridLayout } from "./core/wrapper/layout/layout.grid";
import { TriggerIconButton } from "./case/button/icon/icon.trigger";
import { Searcher } from "./base/combination/searcher";
import { ListTreeValueChooserInsertCombo } from "./component/treevaluechooser/combo.listtreevaluechooser";
import { TreeValueChooserCombo } from "./component/treevaluechooser/combo.treevaluechooser";
import { TreeValueChooserInsertCombo } from "./component/treevaluechooser/combo.treevaluechooser.insert";
import { Radio } from "./base/single/input/radio/radio";
import { MultiLayerSelectTreePopup } from "./widget/multilayerselecttree/multilayerselecttree.popup";
import { MultiLayerSingleTreePopup } from "./widget/multilayersingletree/multilayersingletree.popup";
import { MultiLayerDownListPopup } from "./widget/multilayerdownlist/multilayerdownlist.popup";
import { TreeView } from "./base/tree/ztree/treeview";
import { MultiTreePopup } from "./widget/multitree/multi.tree.popup";
import { SingleSelectRadioItem } from "./case/button/item.singleselect.radio";
import { SingleSelectInsertCombo } from "./widget/singleselect/singleselect.insert.combo";
import { SingleSelectCombo } from "./widget/singleselect/singleselect.combo";
import { CardLayout } from "./core/wrapper/layout/layout.card";
import { DynamicYearMonthCombo } from "./widget/yearmonth/combo.yearmonth";
import { TimeCombo } from "./widget/time/time.combo";
import { ListTreeView } from "./base/tree/ztree/list/listtreeview";
import { ListAsyncTree } from "./base/tree/ztree/list/listasynctree";
import { AsyncTree } from "./base/tree/ztree/asynctree";
import { MultiLayerSingleTreeCombo } from "./widget/multilayersingletree/multilayersingletree.combo";
import { MultiLayerSelectTreeCombo } from "./widget/multilayerselecttree/multilayerselecttree.combo";
import { MultiLayerDownListCombo } from "./widget/multilayerdownlist/multilayerdownlist.combo";
import { MultiTreeListCombo } from "./widget/multitree/multi.tree.list.combo";
import { MultiTreeInsertCombo } from "./widget/multitree/multi.tree.insert.combo";
import { TextValueDownListCombo } from "./widget/textvaluedownlistcombo/combo.textvaluedownlist";
import { Switch } from "./case/button/switch";
import { HorizontalLayout } from "./core/wrapper/layout/layout.horizontal";
import { ShelterEditor } from "./case/editor/editor.shelter";
import { TextTrigger } from './case/trigger/trigger.text';
import { SelectTextTrigger } from "./case/trigger/trigger.text.select";
import { DateInterval } from "./widget/timeinterval/dateinterval";
import { DynamicDatePane } from "./widget/datepane/datepane";
import { AllCountPager } from "./case/pager/pager.all.count";
import { DirectionPager } from "./case/pager/pager.direction";
import { PopupView } from "./base/layer/layer.popup";
import { BubblePopupView, BubblePopupBarView, TextBubblePopupBarView } from "./case/combo/bubblecombo/popup.bubble";
import { ArrowTreeGroupNodeCheckbox } from "./case/checkbox/check.arrownode";
import { NumberInterval } from "./widget/numberinterval/numberinterval";
import { DynamicYearQuarterCombo } from "./widget/yearquarter/combo.yearquarter";
import { DynamicYearCombo } from "./widget/year/combo.year";
import { IntervalSlider } from "./widget/intervalslider/intervalslider";
import { MultiSelectInsertList } from "./widget/multiselectlist/multiselectlist.insert";
import { YearMonthInterval } from "./widget/yearmonthinterval/yearmonthinterval";
import { NumberEditor } from "./widget/numbereditor/numbereditor";
import { TextValueCheckCombo } from "./case/combo/textvaluecheckcombo/combo.textvaluecheck";
import { Segment } from "./case/segment/segment";
import { LinearSegment } from "./case/linersegment/linear.segment";
import { Img } from "./base/single/img/img";
import { EditorIconCheckCombo } from "./case/combo/editoriconcheckcombo/combo.editiconcheck";
import { IconTextValueCombo } from './case/combo/icontextvaluecombo/combo.icontextvalue';
import { ListView } from './base/list/listview';
import { FloatCenterLayout } from './core/wrapper/layout/middle/middle.float.center';
import { _msg } from './base/foundation/message';
import { _web } from './core/platform/web';
import { DynamicYearMonthPopup } from './widget/yearmonth/popup.yearmonth';
import { _utils } from './core/utils';
import { Controller } from "./core/controller/controller";
import { LayerController } from "./core/controller/controller.layer";
import { DateCalendarPopup } from "./widget/date/calendar/popup.calendar.date";
import { Tree, Node } from "./core/utils/tree";
import { TextNode } from "./base/single/button/node/textnode";
import { TextValueCheckComboPopup } from "./case/combo/textvaluecheckcombo/popup.textvaluecheck";
import { ImageButton } from './base/single/button/buttons/button.image';
import { History, Router } from "./router/router";
import { DateTimeCombo } from './widget/datetime/datetime.combo';
import { FloatHorizontalLayout } from "./core/wrapper/layout/adapt/float.horizontal";
import { AdaptiveLayout } from "./core/wrapper/layout/layout.adaptive";
import { HexColorChooserPopup } from './case/colorchooser/colorchooser.popup.hex';
import { BlankIconTextItem } from './base/single/button/listitem/blankicontextitem';
import { Broadcasts, Layers } from "./base/base";
import { BroadcastController } from "./core/controller/controller.broadcast";
import { Pager } from "./base/pager/pager";
import { TimeInterval } from './widget/timeinterval/timeinterval';
import { DynamicDateTimePane } from './widget/datetimepane/datetimepane';
import { SingleSelectInsertList } from './widget/singleselect/singleselectlist.insert';
import { MultiSelectTree } from './widget/multiselecttree/multiselecttree';
import { HtmlLabel } from "./base/single/label/html.label";
import { TreeValueChooserPane } from './component/treevaluechooser/pane.treevaluechooser';
import { TdLayout } from './core/wrapper/layout/layout.td';
import { MultiLayerSelectLevelTree } from './widget/multilayerselecttree/multilayerselecttree.leveltree';
import { SelectTreeExpander } from './widget/selecttree/selecttree.expander';
import { DownListGroupItem } from "./widget/downlist/item.downlistgroup";
import { VerticalStickyLayout } from "./core/wrapper/layout/sticky/sticky.vertical";
import { HorizontalStickyLayout } from "./core/wrapper/layout/sticky/sticky.horizontal";
import { TableLayout } from "./core/wrapper/layout/layout.table";
import './shims-tsx';

export interface BI extends _func, _i18n, _base, _inject, _var, _web, _utils {
    OB: typeof OB;
    Plugin: _Plugin;
    Widget: typeof Widget;
    Single: typeof Single;
    BasicButton: typeof BasicButton;
    NodeButton: typeof NodeButton;
    Checkbox: typeof Checkbox;
    Button: typeof Button;
    TextButton: typeof TextButton;
    IconChangeButton: typeof IconChangeButton;
    Trigger: typeof Trigger;
    Action: typeof Action;
    ActionFactory: typeof ActionFactory;
    ShowAction: typeof ShowAction;
    Controller: typeof Controller;
    Layers: Layers;
    LayerController: typeof LayerController;
    Broadcasts: Broadcasts;
    BroadcastController: typeof BroadcastController;
    Behavior: typeof Behavior;
    BehaviorFactory: typeof BehaviorFactory;
    HighlightBehavior: typeof HighlightBehavior;
    RedMarkBehavior: typeof RedMarkBehavior;
    Pane: typeof Pane;
    Tab: typeof Tab;
    ButtonGroup: typeof ButtonGroup;
    Combo: typeof Combo;
    TextValueCombo: typeof TextValueCombo;
    SmallTextValueCombo: typeof SmallTextValueCombo;
    BubbleCombo: typeof BubbleCombo;
    AllValueMultiTextValueCombo: typeof AllValueMultiTextValueCombo;
    Form: typeof Form;
    IconTextItem: typeof IconTextItem;
    MultiSelectItem: typeof MultiSelectItem;
    AbstractLabel: typeof AbstractLabel;
    Label: typeof Label;
    Text: typeof Text;
    Editor: typeof Editor;
    SignEditor: typeof SignEditor;
    StateEditor: typeof StateEditor;
    Layout: typeof Layout;
    HTapeLayout: typeof HTapeLayout;
    VTapeLayout: typeof VTapeLayout;
    AbstractTreeValueChooser: typeof AbstractTreeValueChooser;
    AbstractListTreeValueChooser: typeof AbstractListTreeValueChooser;
    ListTreeValueChooserInsertCombo: typeof ListTreeValueChooserInsertCombo;
    TreeValueChooserCombo: typeof TreeValueChooserCombo;
    TreeValueChooserInsertCombo: typeof TreeValueChooserInsertCombo;
    MultiLayerSelectTreePopup: typeof MultiLayerSelectTreePopup;
    MultiLayerSingleTreePopup: typeof MultiLayerSingleTreePopup;
    MultiLayerDownListPopup: typeof MultiLayerDownListPopup;
    TreeView: typeof TreeView;
    ListTreeView: typeof ListTreeView;
    ListAsyncTree: typeof ListAsyncTree;
    AsyncTree: typeof AsyncTree;
    MultiLayerSingleTreeCombo: typeof MultiLayerSingleTreeCombo;
    MultiLayerSelectTreeCombo: typeof MultiLayerSelectTreeCombo;
    MultiLayerDownListCombo: typeof MultiLayerDownListCombo;
    MultiTreeListCombo: typeof MultiTreeListCombo;
    MultiTreeInsertCombo: typeof MultiTreeInsertCombo;
    Decorators: typeof decorator;
    DownListCombo: typeof DownListCombo;
    DownListPopup: typeof DownListPopup;
    Iframe: typeof Iframe;
    AbsoluteLayout: typeof AbsoluteLayout;
    HorizontalFillLayout: typeof HorizontalFillLayout;
    VerticalFillLayout: typeof VerticalFillLayout;
    VerticalLayout: typeof VerticalLayout;
    DefaultLayout: typeof DefaultLayout;
    Input: typeof Input;
    SearchTextValueCombo: typeof SearchTextValueCombo;
    Icon: typeof Icon;
    LeftVerticalAdaptLayout: typeof LeftVerticalAdaptLayout;
    LeftRightVerticalAdaptLayout: typeof LeftRightVerticalAdaptLayout;
    IconTextIconItem: typeof IconTextIconItem;
    HorizontalAutoLayout: typeof HorizontalAutoLayout;
    InlineVerticalAdaptLayout: typeof InlineVerticalAdaptLayout;
    RightVerticalAdaptLayout: typeof RightVerticalAdaptLayout;
    TableAdaptLayout: typeof TableAdaptLayout;
    AbsoluteCenterLayout: typeof AbsoluteCenterLayout;
    HorizontalAdaptLayout: typeof HorizontalAdaptLayout;
    FloatLeftLayout: typeof FloatLeftLayout;
    FloatRightLayout: typeof FloatRightLayout;
    CenterAdaptLayout: typeof CenterAdaptLayout;
    VerticalAdaptLayout: typeof VerticalAdaptLayout;
    IconButton: typeof IconButton;
    TriggerIconButton: typeof TriggerIconButton;
    Searcher: typeof Searcher;
    TextEditor: typeof TextEditor;
    Radio: typeof Radio;
    A: typeof A;
    Html: typeof Html;
    Switcher: typeof Switcher;
    Expander: typeof Expander;
    Loader: typeof Loader;
    ListPane: typeof ListPane;
    MultiPopupView: typeof MultiPopupView;
    MultiSelectBar: typeof MultiSelectBar;
    SelectList: typeof SelectList;
    IconLabel: typeof IconLabel;
    Popover: typeof Popover;
    BarPopover: typeof BarPopover;
    IconCombo: typeof IconCombo;
    DynamicDateCombo: typeof DynamicDateCombo;
    CustomTree: typeof CustomTree;
    ButtonTree: typeof ButtonTree;
    IconArrowNode: typeof IconArrowNode;
    MidTreeLeafItem: typeof MidTreeLeafItem;
    FirstTreeLeafItem: typeof FirstTreeLeafItem;
    LastTreeLeafItem: typeof LastTreeLeafItem;
    SmallTextEditor: typeof SmallTextEditor;
    MultifileEditor: typeof MultifileEditor;
    MultiSelectInsertCombo: typeof MultiSelectInsertCombo;
    MultiSelectCombo: typeof MultiSelectCombo;
    SearchEditor: typeof SearchEditor;
    MultiLayerSingleLevelTree: typeof MultiLayerSingleLevelTree;
    SimpleColorChooser: typeof SimpleColorChooser;
    AbstractAllValueChooser: typeof AbstractAllValueChooser;
    AllValueChooserCombo: typeof AllValueChooserCombo;
    TextAreaEditor: typeof TextAreaEditor;
    SingleSelectItem: typeof SingleSelectItem;
    DynamicDateTimeCombo: typeof DynamicDateTimeCombo;
    MultiTreeCombo: typeof MultiTreeCombo;
    CenterLayout: typeof CenterLayout;
    VirtualGroup: typeof VirtualGroup;
    GridLayout: typeof GridLayout;
    MultiTreePopup: typeof MultiTreePopup;
    SingleSelectRadioItem: typeof SingleSelectRadioItem;
    SingleSelectInsertCombo: typeof SingleSelectInsertCombo;
    SingleSelectCombo: typeof SingleSelectCombo;
    CardLayout: typeof CardLayout;
    DynamicYearMonthCombo: typeof DynamicYearMonthCombo;
    TimeCombo: typeof TimeCombo;
    TextValueDownListCombo: typeof TextValueDownListCombo;
    Switch: typeof Switch;
    HorizontalLayout: typeof HorizontalLayout;
    ShelterEditor: typeof ShelterEditor;
    TextTrigger: typeof TextTrigger;
    SelectTextTrigger: typeof SelectTextTrigger;
    DateInterval: typeof DateInterval;
    DynamicDatePane: typeof DynamicDatePane;
    AllCountPager: typeof AllCountPager;
    DirectionPager: typeof DirectionPager;
    Pager: typeof Pager;
    PopupView: typeof PopupView;
    BubblePopupView: typeof BubblePopupView;
    BubblePopupBarView: typeof BubblePopupBarView;
    TextBubblePopupBarView: typeof TextBubblePopupBarView;
    ArrowTreeGroupNodeCheckbox: typeof ArrowTreeGroupNodeCheckbox;
    NumberInterval: typeof NumberInterval;
    DynamicYearQuarterCombo: typeof DynamicYearQuarterCombo;
    DynamicYearCombo: typeof DynamicYearCombo;
    IntervalSlider: typeof IntervalSlider;
    MultiSelectInsertList: typeof MultiSelectInsertList;
    YearMonthInterval: typeof YearMonthInterval;
    TextValueCheckCombo: typeof TextValueCheckCombo;
    NumberEditor: typeof NumberEditor;
    Segment: typeof Segment;
    LinearSegment: typeof LinearSegment;
    Img: typeof Img;
    EditorIconCheckCombo: typeof EditorIconCheckCombo;
    IconTextValueCombo: typeof IconTextValueCombo;
    ListView: typeof ListView;
    FloatCenterLayout: typeof FloatCenterLayout;
    Msg: _msg;
    DynamicYearMonthPopup: typeof DynamicYearMonthPopup;
    DateCalendarPopup: typeof DateCalendarPopup;
    TextNode: typeof TextNode;
    TextValueCheckComboPopup: typeof TextValueCheckComboPopup;
    ImageButton: typeof ImageButton;
    Router: typeof Router;
    history: History,
    DateTimeCombo: typeof DateTimeCombo;
    FloatHorizontalLayout: typeof FloatHorizontalLayout;
    AdaptiveLayout: typeof AdaptiveLayout;
    HexColorChooserPopup: typeof HexColorChooserPopup;
    BlankIconTextItem: typeof BlankIconTextItem;
    TimeInterval: typeof TimeInterval;
    DynamicDateTimePane: typeof DynamicDateTimePane;
    SingleSelectInsertList: typeof SingleSelectInsertList;
    MultiSelectTree: typeof MultiSelectTree;
    HtmlLabel: typeof HtmlLabel;
    TreeValueChooserPane: typeof TreeValueChooserPane;
    TdLayout: typeof TdLayout;
    MultiLayerSelectLevelTree: typeof MultiLayerSelectLevelTree;
    SelectTreeExpander: typeof SelectTreeExpander;
    DownListGroupItem: typeof DownListGroupItem;
    VerticalStickyLayout: typeof VerticalStickyLayout;
    HorizontalStickyLayout: typeof HorizontalStickyLayout;
    TableLayout: typeof TableLayout;
}

export default {
    Decorators: decorator,
};
export {
    OB,
    Widget,
    Single,
    BasicButton,
    Checkbox,
    Icon,
    LeftVerticalAdaptLayout,
    LeftRightVerticalAdaptLayout,
    SearchTextValueCombo,
    Input,
    IconTextItem,
    AllValueMultiTextValueCombo,
    IconTextIconItem,
    Layout,
    HorizontalAutoLayout,
    InlineVerticalAdaptLayout,
    RightVerticalAdaptLayout,
    TableAdaptLayout,
    AbsoluteCenterLayout,
    HorizontalAdaptLayout,
    FloatLeftLayout,
    FloatRightLayout,
    HorizontalFillLayout,
    VerticalFillLayout,
    VerticalLayout,
    AbsoluteLayout,
    DefaultLayout,
    HTapeLayout,
    CenterAdaptLayout,
    VTapeLayout,
    VerticalAdaptLayout,
    IconButton,
    Trigger,
    TriggerIconButton,
    Action,
    ActionFactory,
    ShowAction,
    Controller,
    LayerController,
    BroadcastController,
    Behavior,
    BehaviorFactory,
    RedMarkBehavior,
    HighlightBehavior,
    Searcher,
    AbstractLabel,
    Label,
    TextButton,
    DownListCombo,
    DownListPopup,
    IconChangeButton,
    Button,
    TextEditor,
    A,
    Html,
    Switcher,
    Expander,
    BubbleCombo,
    Loader,
    ListPane,
    MultiPopupView,
    MultiSelectBar,
    SelectList,
    TextValueCombo,
    SmallTextValueCombo,
    Editor,
    IconLabel,
    Popover,
    BarPopover,
    Tab,
    AbstractTreeValueChooser,
    AbstractListTreeValueChooser,
    ListTreeValueChooserInsertCombo,
    TreeValueChooserCombo,
    TreeValueChooserInsertCombo,
    MultiLayerSelectTreePopup,
    MultiLayerSingleTreePopup,
    MultiLayerDownListPopup,
    TreeView,
    ListTreeView,
    ListAsyncTree,
    AsyncTree,
    MultiLayerSingleTreeCombo,
    MultiLayerSelectTreeCombo,
    MultiLayerDownListCombo,
    MultiTreeListCombo,
    MultiTreeInsertCombo,
    Combo,
    IconCombo,
    DynamicDateCombo,
    Radio,
    MultiSelectItem,
    CustomTree,
    ButtonGroup,
    ButtonTree,
    NodeButton,
    IconArrowNode,
    MidTreeLeafItem,
    FirstTreeLeafItem,
    LastTreeLeafItem,
    SmallTextEditor,
    MultifileEditor,
    SignEditor,
    StateEditor,
    MultiSelectInsertCombo,
    MultiSelectCombo,
    SearchEditor,
    Text,
    Pane,
    MultiLayerSingleLevelTree,
    SimpleColorChooser,
    AbstractAllValueChooser,
    AllValueChooserCombo,
    TextAreaEditor,
    SingleSelectItem,
    DynamicDateTimeCombo,
    MultiTreeCombo,
    CenterLayout,
    VirtualGroup,
    GridLayout,
    MultiTreePopup,
    SingleSelectRadioItem,
    SingleSelectInsertCombo,
    SingleSelectCombo,
    CardLayout,
    DynamicYearMonthCombo,
    TimeCombo,
    Iframe,
    TextValueDownListCombo,
    Switch,
    HorizontalLayout,
    ShelterEditor,
    Form,
    TextTrigger,
    SelectTextTrigger,
    DateInterval,
    DynamicDatePane,
    AllCountPager,
    Pager,
    PopupView,
    BubblePopupView,
    BubblePopupBarView,
    TextBubblePopupBarView,
    ArrowTreeGroupNodeCheckbox,
    NumberInterval,
    DynamicYearQuarterCombo,
    DynamicYearCombo,
    IntervalSlider,
    MultiSelectInsertList,
    YearMonthInterval,
    TextValueCheckCombo,
    NumberEditor,
    Segment,
    LinearSegment,
    Img,
    EditorIconCheckCombo,
    IconTextValueCombo,
    ListView,
    FloatCenterLayout,
    DynamicYearMonthPopup,
    DateCalendarPopup,
    Tree,
    Node,
    TextNode,
    TextValueCheckComboPopup,
    ImageButton,
    Router,
    History,
    DateTimeCombo,
    FloatHorizontalLayout,
    AdaptiveLayout,
    HexColorChooserPopup,
    BlankIconTextItem,
    TimeInterval,
    DynamicDateTimePane,
    SingleSelectInsertList,
    MultiSelectTree,
    HtmlLabel,
    TreeValueChooserPane,
    TdLayout,
    MultiLayerSelectLevelTree,
    SelectTreeExpander,
    DirectionPager,
    DownListGroupItem,
    HorizontalStickyLayout,
    VerticalStickyLayout,
    TableLayout,
};


text:
import java.util.*;

/**
   This class implements a heap.
*/
public class MinHeap
{
   private ArrayList<Comparable> elements;

   /**
      Constructs an empty heap.
   */
   public MinHeap()
   {
      elements = new ArrayList<>();
      elements.add(null);
   }

   /**
      Adds a new element to this heap.
      @param newElement the element to add
   */
   public void add(Comparable newElement)
   {
      // Add a new leaf
      elements.add(null);
      int index = elements.size() - 1;

      // Demote parents that are larger than the new element
      while (index > 1
            && getParent(index).compareTo(newElement) > 0)
      {
         elements.set(index, getParent(index));
         index = getParentIndex(index);
      }

      // Store the new element into the vacant slot
      elements.set(index, newElement);
   }

   /**
      Gets the minimum element stored in this heap.
      @return the minimum element
   */
   public Comparable peek()
   {
      return elements.get(1);
   }

   /**
      Removes the minimum element from this heap.
      @return the minimum element
   */
   public Comparable remove()
   {
      Comparable minimum = elements.get(1);

      // Remove last element
      int lastIndex = elements.size() - 1;
      Comparable last = elements.remove(lastIndex);

      if (lastIndex > 1)
      {
         elements.set(1, last);
         fixHeap();
      }

      return minimum;
   }

   /**
      Turns the tree back into a heap, provided only the root
      node violates the heap condition.
   */
   private void fixHeap()
   {
      Comparable root = elements.get(1);

      int lastIndex = elements.size() - 1;
      // Promote children of removed root while they are smaller than root

      int index = 1;
      boolean more = true;
      while (more)
      {
         int childIndex = getLeftChildIndex(index);
         if (childIndex <= lastIndex)
         {
            // Get smaller child

            // Get left child first
            Comparable child = getLeftChild(index);

            // Use right child instead if it is smaller
            if (getRightChildIndex(index) <= lastIndex
                  && getRightChild(index).compareTo(child) < 0)
            {
               childIndex = getRightChildIndex(index);
               child = getRightChild(index);
            }

            // Check if smaller child is smaller than root
            if (child.compareTo(root) < 0)
            {
               // Promote child
               elements.set(index, child);
               index = childIndex;
            }
            else
            {
               // Root is smaller than both children
               more = false;
            }
         }
         else
         {
            // No children
            more = false;
         }
      }

      // Store root element in vacant slot
      elements.set(index, root);
   }

   /**
      Checks whether this heap is empty.
   */
   public boolean empty()
   {
      return elements.size() == 1;
   }

   /**
      Returns the index of the left child.
      @param index the index of a node in this heap
      @return the index of the left child of the given node
   */
   private static int getLeftChildIndex(int index)
   {
      return 2 * index;
   }

   /**
      Returns the index of the right child.
      @param index the index of a node in this heap
      @return the index of the right child of the given node
   */
   private static int getRightChildIndex(int index)
   {
      return 2 * index + 1;
   }

   /**
      Returns the index of the parent.
      @param index the index of a node in this heap
      @return the index of the parent of the given node
   */
   private static int getParentIndex(int index)
   {
      return index / 2;
   }

   /**
      Returns the value of the left child.
      @param index the index of a node in this heap
      @return the value of the left child of the given node
   */
   private Comparable getLeftChild(int index)
   {
      return elements.get(2 * index);
   }

   /**
      Returns the value of the right child.
      @param index the index of a node in this heap
      @return the value of the right child of the given node
   */
   private Comparable getRightChild(int index)
   {
      return elements.get(2 * index + 1);
   }

   /**
      Returns the value of the parent.
      @param index the index of a node in this heap
      @return the value of the parent of the given node
   */
   private Comparable getParent(int index)
   {
      return elements.get(index / 2);
   }
}


text:
using System.Collections.Generic;
using System.Linq;
using Xunit;

namespace csharp
{
    /// <summary>
    /// Demonstrating little-known features of classes.
    /// </summary>
    public class Classes
    {
        class TestClass
        {
            private readonly IDictionary<string, int> _dictionary;

            public TestClass(IDictionary<string, int> dictionary)
                => _dictionary = dictionary;

            public int this[string key] => _dictionary[key];

            public IEnumerable<int> this[params string[] keys]
                => keys.Select(key => _dictionary[key]);

            public string this[int key]
                => _dictionary.First(kv => kv.Value == key).Key;
        }

        /// <summary>
        /// Shows how multiple array indexes can be accessed simultaneously.
        /// </summary>
        [Fact]
        public void MultipleIndexAccessors()
        {
            var testClass = new TestClass(new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 },
                { "c", 3 }
            });

            Assert.Equal(2, testClass["b"]);

            var actual = testClass["b", "c"];
            Assert.Equal(new[] { 2, 3 }, actual.ToArray());
        }

        /// <summary>
        /// Shows that different types can be accessed via the same syntax.
        /// </summary>
        [Fact]
        public void DifferentIndexAccessorTypes()
        {
            var testClass = new TestClass(new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 },
                { "c", 3 }
            });

            Assert.Equal(2, testClass["b"]);
            Assert.Equal("b", testClass[2]);
        }
    }
}


text:
package com.srotya.sidewinder.core.api.grafana;

import java.io.IOException;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TimeZone;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.ws.rs.BadRequestException;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.InternalServerErrorException;
import javax.ws.rs.NotFoundException;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.codahale.metrics.Timer.Context;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.srotya.sidewinder.core.api.DatabaseOpsApi;
import com.srotya.sidewinder.core.functions.list.FunctionTable;
import com.srotya.sidewinder.core.monitoring.MetricsRegistryService;
import com.srotya.sidewinder.core.storage.ItemNotFoundException;
import com.srotya.sidewinder.core.storage.RejectException;
import com.srotya.sidewinder.core.storage.StorageEngine;
import com.srotya.sidewinder.core.utils.InvalidFilterException;

/**
 * API specifically for designed for Grafana Sidewinder Datasource. This API is
 * currently NOT REST compliant and is designed to be purely functional.
 *
 * @author ambud
 */
@Path("/{" + DatabaseOpsApi.DB_NAME + "}")
public class GrafanaQueryApiv1 {

	private static final Logger logger = Logger.getLogger(GrafanaQueryApiv1.class.getName());
	private StorageEngine engine;
	private TimeZone tz;
	private Meter grafanaQueryCounter;
	private Timer grafanaQueryLatency;

	public GrafanaQueryApiv1(StorageEngine engine) throws SQLException {
		this.engine = engine;
		tz = TimeZone.getDefault();
		MetricRegistry registry = MetricsRegistryService.getInstance().getInstance("grafana");
		grafanaQueryCounter = registry.meter("queries");
		grafanaQueryLatency = registry.timer("latency");
	}

	@Path("/hc")
	@GET
	public String getHealth(@PathParam(DatabaseOpsApi.DB_NAME) String dbName) throws Exception {
		logger.fine("Checking db name:" + dbName);
		if (engine.checkIfExists(dbName)) {
			return "true";
		} else {
			throw new NotFoundException("Database:" + dbName + " doesn't exist");
		}
	}

	@Path("/query")
	@POST
	@Consumes({ MediaType.APPLICATION_JSON })
	@Produces({ MediaType.APPLICATION_JSON })
	public List<GrafanaOutput> queryData(@PathParam(DatabaseOpsApi.DB_NAME) String dbName, String queryString)
			throws ParseException {
		grafanaQueryCounter.mark();
		Context time = grafanaQueryLatency.time();
		Gson gson = new GsonBuilder().setPrettyPrinting().create();
		logger.log(Level.FINE,
				() -> "Grafana query:" + dbName + "\t" + gson.toJson(gson.fromJson(queryString, JsonObject.class)));
		JsonObject json = gson.fromJson(queryString, JsonObject.class);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
		JsonObject range = json.get("range").getAsJsonObject();
		long startTs = sdf.parse(range.get("from").getAsString()).getTime();
		long endTs = sdf.parse(range.get("to").getAsString()).getTime();

		startTs = tz.getOffset(startTs) + startTs;
		endTs = tz.getOffset(endTs) + endTs;

		List<TargetSeries> targetSeries = new ArrayList<>();
		try {
			GrafanaUtils.extractTargetsFromJson(json, targetSeries);
		} catch (InvalidFilterException e) {
			throw new BadRequestException(e.getMessage());
		}

		List<GrafanaOutput> output = new ArrayList<>();
		logger.log(Level.FINE,
				"Extracted targets from query json, target count:" + targetSeries.size() + " " + new Date(startTs));
		for (TargetSeries targetSeriesEntry : targetSeries) {
			logger.log(Level.FINE, () -> "Running grafana query fetch for:" + targetSeriesEntry);
			try {
				GrafanaUtils.queryAndGetData(engine, dbName, startTs, endTs, output, targetSeriesEntry);
			} catch (IOException e) {
				throw new InternalServerErrorException(e);
			}
		}
		time.stop();

		// Adding sorted output so series colors do not change in grafana
		Collections.sort(output);
		logger.log(Level.FINEST, () -> {
			StringBuilder builder = new StringBuilder();
			for (GrafanaOutput out : output) {
				builder.append(out.getTarget() + " " + out.getDatapoints().size() + "\n");
			}
			return builder.toString();
		});
		logger.log(Level.FINER, () -> "Grafana query result size:" + output.size());
		return output;
	}

	@Path("/query/measurements")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryMeasurementNames(@PathParam(DatabaseOpsApi.DB_NAME) String dbName, String queryString) {
		logger.log(Level.FINE, () -> "Query measurements for db:" + dbName + "\t" + queryString);
		try {
			if (queryString != null && !queryString.isEmpty()) {
				JsonObject query = new Gson().fromJson(queryString, JsonObject.class);
				if (query.has("target")) {
					String target = query.get("target").getAsString();
					if (target.startsWith("measurement:")) {
						return engine.getTagKeysForMeasurement(dbName, target.replace("measurement:", ""));
					} else if (target.contains("field:")) {
						return engine.getFieldsForMeasurement(dbName, target.replace("field:", ""));
					} else {
						return engine.getMeasurementsLike(dbName, target);
					}
				}
			}
			return engine.getMeasurementsLike(dbName, "");
		} catch (RejectException e) {
			throw new BadRequestException(e);
		} catch (Exception e) {
			e.printStackTrace();
			throw new InternalServerErrorException(e.getMessage());
		}
	}

	@Path("/query/tags")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryTagKeys(@PathParam(DatabaseOpsApi.DB_NAME) String dbName, String queryString) {
		logger.log(Level.FINE, () -> "Query tags for db:" + dbName + "\t" + queryString);
		if (queryString == null || queryString.trim().isEmpty()) {
			throw new BadRequestException();
		}
		try {
			Gson gson = new Gson();
			JsonObject measurement = gson.fromJson(queryString, JsonObject.class);
			if (measurement.has("target")) {
				return engine.getTagKeysForMeasurement(dbName, measurement.get("target").getAsString());
			} else {
				throw new ItemNotFoundException("Bad request");
			}
		} catch (ItemNotFoundException e) {
			throw new NotFoundException(e.getMessage());
		} catch (Exception e) {
			e.printStackTrace();
			throw new InternalServerErrorException(e.getMessage());
		}
	}

	@Path("/query/tagvs")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryTagValues(@PathParam(DatabaseOpsApi.DB_NAME) String dbName, String queryString) {
		logger.log(Level.FINE, () -> "Query tag values for db:" + dbName + "\t" + queryString);
		if (queryString == null || queryString.trim().isEmpty()) {
			throw new BadRequestException();
		}
		try {
			Gson gson = new Gson();
			JsonObject measurement = gson.fromJson(queryString, JsonObject.class);
			if (measurement.has("target")) {
				return engine.getTagValuesForMeasurement(dbName, measurement.get("target").getAsString(),
						measurement.get("tag").getAsString());
			} else {
				throw new ItemNotFoundException("Bad request");
			}
		} catch (ItemNotFoundException e) {
			throw new NotFoundException(e.getMessage());
		} catch (Exception e) {
			e.printStackTrace();
			throw new InternalServerErrorException(e.getMessage());
		}
	}

	@Path("/query/fields")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryFields(@PathParam(DatabaseOpsApi.DB_NAME) String dbName, String queryString) {
		try {
			Gson gson = new Gson();
			JsonObject measurement = gson.fromJson(queryString, JsonObject.class);
			if (measurement.has("target")) {
				Set<String> response = engine.getFieldsForMeasurement(dbName, measurement.get("target").getAsString());
				logger.log(Level.FINE, () -> "Query fields for db:" + dbName + "\t" + response + "\t" + queryString);
				return response;
			} else {
				throw new ItemNotFoundException("Bad request");
			}
		} catch (ItemNotFoundException e) {
			throw new NotFoundException(e.getMessage());
		} catch (Exception e) {
			throw new InternalServerErrorException(e.getMessage());
		}
	}

	@Path("/query/ctypes")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryConditionTypes() {
		return new HashSet<>(Arrays.asList("AND", "OR"));
	}

	@Path("/query/otypes")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryOperatorTypes() {
		return new HashSet<>(Arrays.asList("=", ">", "<", ">=", "<=", "~"));
	}

	@Path("/query/aggregators")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryAggregators() {
		return FunctionTable.get().listFunctions();
	}

	@Path("/query/units")
	@POST
	@Produces({ MediaType.APPLICATION_JSON })
	@Consumes({ MediaType.APPLICATION_JSON })
	public Set<String> queryTimeUnits() {
		return new HashSet<>(Arrays.asList("secs", "mins", "hours", "days", "weeks", "months", "years"));
	}

	// @Path("/rawquery")
	// @POST
	// @Produces({ MediaType.APPLICATION_JSON })
	// @Consumes({ MediaType.APPLICATION_JSON })
	// public List<Target> rawQuery(@PathParam(DatabaseOpsApi.DB_NAME) String
	// dbName, String query) throws ParseException {
	// grafanaQueryCounter.mark();
	// Context time = grafanaQueryLatency.time();
	// Gson gson = new GsonBuilder().create();
	// JsonObject json = gson.fromJson(query, JsonObject.class);
	// SimpleDateFormat sdf = new
	// SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
	// JsonObject range = json.get("range").getAsJsonObject();
	// long startTs = sdf.parse(range.get("from").getAsString()).getTime();
	// long endTs = sdf.parse(range.get("to").getAsString()).getTime();
	//
	// startTs = tz.getOffset(startTs) + startTs;
	// endTs = tz.getOffset(endTs) + endTs;
	//
	// List<TargetSeries> targetSeries = new ArrayList<>();
	//
	// List<Target> output = new ArrayList<>();
	// try {
	// for (TargetSeries targetSeriesEntry : targetSeries) {
	// GrafanaUtils.queryAndGetData(engine, dbName, startTs, endTs, output,
	// targetSeriesEntry);
	// }
	// } catch (Exception e) {
	// e.printStackTrace();
	// }
	// time.stop();
	// return output;
	// }

}


text:
投融资快报

            登录
            免费注册

            我的FT
            设置
            登出

<%include file="next/partials/login-overlay.html"%>


text:
/* rotate and fall */
@-webkit-keyframes rotateFall {
  0% {
    -moz-transform: rotateZ(0deg);
    -ms-transform: rotateZ(0deg);
    -o-transform: rotateZ(0deg);
    -webkit-transform: rotateZ(0deg);
    transform: rotateZ(0deg); }

  20% {
    -moz-transform: rotateZ(10deg);
    -ms-transform: rotateZ(10deg);
    -o-transform: rotateZ(10deg);
    -webkit-transform: rotateZ(10deg);
    transform: rotateZ(10deg);
    -moz-animation-timing-function: ease-out;
    -o-animation-timing-function: ease-out;
    -webkit-animation-timing-function: ease-out;
    animation-timing-function: ease-out; }

  40% {
    -moz-transform: rotateZ(17deg);
    -ms-transform: rotateZ(17deg);
    -o-transform: rotateZ(17deg);
    -webkit-transform: rotateZ(17deg);
    transform: rotateZ(17deg); }

  60% {
    -moz-transform: rotateZ(16deg);
    -ms-transform: rotateZ(16deg);
    -o-transform: rotateZ(16deg);
    -webkit-transform: rotateZ(16deg);
    transform: rotateZ(16deg); }

  100% {
    -moz-transform: translateY(100%) rotateZ(17deg);
    -ms-transform: translateY(100%) rotateZ(17deg);
    -o-transform: translateY(100%) rotateZ(17deg);
    -webkit-transform: translateY(100%) rotateZ(17deg);
    transform: translateY(100%) rotateZ(17deg); } }

@-moz-keyframes rotateFall {
  0% {
    -moz-transform: rotateZ(0deg);
    -ms-transform: rotateZ(0deg);
    -o-transform: rotateZ(0deg);
    -webkit-transform: rotateZ(0deg);
    transform: rotateZ(0deg); }

  20% {
    -moz-transform: rotateZ(10deg);
    -ms-transform: rotateZ(10deg);
    -o-transform: rotateZ(10deg);
    -webkit-transform: rotateZ(10deg);
    transform: rotateZ(10deg);
    -moz-animation-timing-function: ease-out;
    -o-animation-timing-function: ease-out;
    -webkit-animation-timing-function: ease-out;
    animation-timing-function: ease-out; }

  40% {
    -moz-transform: rotateZ(17deg);
    -ms-transform: rotateZ(17deg);
    -o-transform: rotateZ(17deg);
    -webkit-transform: rotateZ(17deg);
    transform: rotateZ(17deg); }

  60% {
    -moz-transform: rotateZ(16deg);
    -ms-transform: rotateZ(16deg);
    -o-transform: rotateZ(16deg);
    -webkit-transform: rotateZ(16deg);
    transform: rotateZ(16deg); }

  100% {
    -moz-transform: translateY(100%) rotateZ(17deg);
    -ms-transform: translateY(100%) rotateZ(17deg);
    -o-transform: translateY(100%) rotateZ(17deg);
    -webkit-transform: translateY(100%) rotateZ(17deg);
    transform: translateY(100%) rotateZ(17deg); } }

@keyframes rotateFall {
  0% {
    -moz-transform: rotateZ(0deg);
    -ms-transform: rotateZ(0deg);
    -o-transform: rotateZ(0deg);
    -webkit-transform: rotateZ(0deg);
    transform: rotateZ(0deg); }

  20% {
    -moz-transform: rotateZ(10deg);
    -ms-transform: rotateZ(10deg);
    -o-transform: rotateZ(10deg);
    -webkit-transform: rotateZ(10deg);
    transform: rotateZ(10deg);
    -moz-animation-timing-function: ease-out;
    -o-animation-timing-function: ease-out;
    -webkit-animation-timing-function: ease-out;
    animation-timing-function: ease-out; }

  40% {
    -moz-transform: rotateZ(17deg);
    -ms-transform: rotateZ(17deg);
    -o-transform: rotateZ(17deg);
    -webkit-transform: rotateZ(17deg);
    transform: rotateZ(17deg); }

  60% {
    -moz-transform: rotateZ(16deg);
    -ms-transform: rotateZ(16deg);
    -o-transform: rotateZ(16deg);
    -webkit-transform: rotateZ(16deg);
    transform: rotateZ(16deg); }

  100% {
    -moz-transform: translateY(100%) rotateZ(17deg);
    -ms-transform: translateY(100%) rotateZ(17deg);
    -o-transform: translateY(100%) rotateZ(17deg);
    -webkit-transform: translateY(100%) rotateZ(17deg);
    transform: translateY(100%) rotateZ(17deg); } }

/* scale up */
@keyframes scaleUp {
  from {
    opacity: 0.3;
    -moz-transform: scale(0.8);
    -ms-transform: scale(0.8);
    -o-transform: scale(0.8);
    -webkit-transform: scale(0.8);
    transform: scale(0.8); } }

@-moz-keyframes scaleUp {
  from {
    opacity: 0.3;
    -moz-transform: scale(0.8);
    -ms-transform: scale(0.8);
    -o-transform: scale(0.8);
    -webkit-transform: scale(0.8);
    transform: scale(0.8); } }

@-webkit-keyframes scaleUp {
  from {
    opacity: 0.3;
    -moz-transform: scale(0.8);
    -ms-transform: scale(0.8);
    -o-transform: scale(0.8);
    -webkit-transform: scale(0.8);
    transform: scale(0.8); } }

/* slide in from the right */
@keyframes slideInRight {
  from {
    -moz-transform: translateX(100%);
    -ms-transform: translateX(100%);
    -o-transform: translateX(100%);
    -webkit-transform: translateX(100%);
    transform: translateX(100%); }

  to {
    -moz-transform: translateX(0);
    -ms-transform: translateX(0);
    -o-transform: translateX(0);
    -webkit-transform: translateX(0);
    transform: translateX(0); } }

@-moz-keyframes slideInRight {
  from {
    -moz-transform: translateX(100%);
    -ms-transform: translateX(100%);
    -o-transform: translateX(100%);
    -webkit-transform: translateX(100%);
    transform: translateX(100%); }

  to {
    -moz-transform: translateX(0);
    -ms-transform: translateX(0);
    -o-transform: translateX(0);
    -webkit-transform: translateX(0);
    transform: translateX(0); } }

@-webkit-keyframes slideInRight {
  from {
    -moz-transform: translateX(100%);
    -ms-transform: translateX(100%);
    -o-transform: translateX(100%);
    -webkit-transform: translateX(100%);
    transform: translateX(100%); }

  to {
    -moz-transform: translateX(0);
    -ms-transform: translateX(0);
    -o-transform: translateX(0);
    -webkit-transform: translateX(0);
    transform: translateX(0); } }

/* slide in from the bottom */
@keyframes slideInUp {
  from {
    -moz-transform: translateY(100%);
    -ms-transform: translateY(100%);
    -o-transform: translateY(100%);
    -webkit-transform: translateY(100%);
    transform: translateY(100%); }

  to {
    -moz-transform: translateY(0);
    -ms-transform: translateY(0);
    -o-transform: translateY(0);
    -webkit-transform: translateY(0);
    transform: translateY(0); } }

@-moz-keyframes slideInUp {
  from {
    -moz-transform: translateY(100%);
    -ms-transform: translateY(100%);
    -o-transform: translateY(100%);
    -webkit-transform: translateY(100%);
    transform: translateY(100%); }

  to {
    -moz-transform: translateY(0);
    -ms-transform: translateY(0);
    -o-transform: translateY(0);
    -webkit-transform: translateY(0);
    transform: translateY(0); } }

@-webkit-keyframes slideInUp {
  from {
    -moz-transform: translateY(100%);
    -ms-transform: translateY(100%);
    -o-transform: translateY(100%);
    -webkit-transform: translateY(100%);
    transform: translateY(100%); }

  to {
    -moz-transform: translateY(0);
    -ms-transform: translateY(0);
    -o-transform: translateY(0);
    -webkit-transform: translateY(0);
    transform: translateY(0); } }

/* rotate out newspaper */
@-webkit-keyframes rotateOutNewspaper {
  to {
    opacity: 0;
    -moz-transform: translateZ(-3000px) rotateZ(360deg);
    -ms-transform: translateZ(-3000px) rotateZ(360deg);
    -o-transform: translateZ(-3000px) rotateZ(360deg);
    -webkit-transform: translateZ(-3000px) rotateZ(360deg);
    transform: translateZ(-3000px) rotateZ(360deg); } }

@-moz-keyframes rotateOutNewspaper {
  to {
    opacity: 0;
    -moz-transform: translateZ(-3000px) rotateZ(360deg);
    -ms-transform: translateZ(-3000px) rotateZ(360deg);
    -o-transform: translateZ(-3000px) rotateZ(360deg);
    -webkit-transform: translateZ(-3000px) rotateZ(360deg);
    transform: translateZ(-3000px) rotateZ(360deg); } }

@keyframes rotateOutNewspaper {
  to {
    opacity: 0;
    -moz-transform: translateZ(-3000px) rotateZ(360deg);
    -ms-transform: translateZ(-3000px) rotateZ(360deg);
    -o-transform: translateZ(-3000px) rotateZ(360deg);
    -webkit-transform: translateZ(-3000px) rotateZ(360deg);
    transform: translateZ(-3000px) rotateZ(360deg); } }

@-webkit-keyframes flipInY {
  0% {
    opacity: 0;
    -moz-transform: perspective(400px) rotateY(90deg);
    -ms-transform: perspective(400px) rotateY(90deg);
    -o-transform: perspective(400px) rotateY(90deg);
    -webkit-transform: perspective(400px) rotateY(90deg);
    transform: perspective(400px) rotateY(90deg); }

  40% {
    -moz-transform: perspective(400px) rotateY(-10deg);
    -ms-transform: perspective(400px) rotateY(-10deg);
    -o-transform: perspective(400px) rotateY(-10deg);
    -webkit-transform: perspective(400px) rotateY(-10deg);
    transform: perspective(400px) rotateY(-10deg); }

  70% {
    -moz-transform: perspective(400px) rotateY(10deg);
    -ms-transform: perspective(400px) rotateY(10deg);
    -o-transform: perspective(400px) rotateY(10deg);
    -webkit-transform: perspective(400px) rotateY(10deg);
    transform: perspective(400px) rotateY(10deg); }

  100% {
    opacity: 1;
    -moz-transform: perspective(400px) rotateY(0deg);
    -ms-transform: perspective(400px) rotateY(0deg);
    -o-transform: perspective(400px) rotateY(0deg);
    -webkit-transform: perspective(400px) rotateY(0deg);
    transform: perspective(400px) rotateY(0deg); } }

@-moz-keyframes flipInY {
  0% {
    opacity: 0;
    -moz-transform: perspective(400px) rotateY(90deg);
    -ms-transform: perspective(400px) rotateY(90deg);
    -o-transform: perspective(400px) rotateY(90deg);
    -webkit-transform: perspective(400px) rotateY(90deg);
    transform: perspective(400px) rotateY(90deg); }

  40% {
    -moz-transform: perspective(400px) rotateY(-10deg);
    -ms-transform: perspective(400px) rotateY(-10deg);
    -o-transform: perspective(400px) rotateY(-10deg);
    -webkit-transform: perspective(400px) rotateY(-10deg);
    transform: perspective(400px) rotateY(-10deg); }

  70% {
    -moz-transform: perspective(400px) rotateY(10deg);
    -ms-transform: perspective(400px) rotateY(10deg);
    -o-transform: perspective(400px) rotateY(10deg);
    -webkit-transform: perspective(400px) rotateY(10deg);
    transform: perspective(400px) rotateY(10deg); }

  100% {
    opacity: 1;
    -moz-transform: perspective(400px) rotateY(0deg);
    -ms-transform: perspective(400px) rotateY(0deg);
    -o-transform: perspective(400px) rotateY(0deg);
    -webkit-transform: perspective(400px) rotateY(0deg);
    transform: perspective(400px) rotateY(0deg); } }

@-o-keyframes flipInY {
  0% {
    opacity: 0;
    -moz-transform: perspective(400px) rotateY(90deg);
    -ms-transform: perspective(400px) rotateY(90deg);
    -o-transform: perspective(400px) rotateY(90deg);
    -webkit-transform: perspective(400px) rotateY(90deg);
    transform: perspective(400px) rotateY(90deg); }

  40% {
    -moz-transform: perspective(400px) rotateY(-10deg);
    -ms-transform: perspective(400px) rotateY(-10deg);
    -o-transform: perspective(400px) rotateY(-10deg);
    -webkit-transform: perspective(400px) rotateY(-10deg);
    transform: perspective(400px) rotateY(-10deg); }

  70% {
    -moz-transform: perspective(400px) rotateY(10deg);
    -ms-transform: perspective(400px) rotateY(10deg);
    -o-transform: perspective(400px) rotateY(10deg);
    -webkit-transform: perspective(400px) rotateY(10deg);
    transform: perspective(400px) rotateY(10deg); }

  100% {
    opacity: 1;
    -moz-transform: perspective(400px) rotateY(0deg);
    -ms-transform: perspective(400px) rotateY(0deg);
    -o-transform: perspective(400px) rotateY(0deg);
    -webkit-transform: perspective(400px) rotateY(0deg);
    transform: perspective(400px) rotateY(0deg); } }

@keyframes flipInY {
  0% {
    opacity: 0;
    -moz-transform: perspective(400px) rotateY(90deg);
    -ms-transform: perspective(400px) rotateY(90deg);
    -o-transform: perspective(400px) rotateY(90deg);
    -webkit-transform: perspective(400px) rotateY(90deg);
    transform: perspective(400px) rotateY(90deg); }

  40% {
    -moz-transform: perspective(400px) rotateY(-10deg);
    -ms-transform: perspective(400px) rotateY(-10deg);
    -o-transform: perspective(400px) rotateY(-10deg);
    -webkit-transform: perspective(400px) rotateY(-10deg);
    transform: perspective(400px) rotateY(-10deg); }

  70% {
    -moz-transform: perspective(400px) rotateY(10deg);
    -ms-transform: perspective(400px) rotateY(10deg);
    -o-transform: perspective(400px) rotateY(10deg);
    -webkit-transform: perspective(400px) rotateY(10deg);
    transform: perspective(400px) rotateY(10deg); }

  100% {
    opacity: 1;
    -moz-transform: perspective(400px) rotateY(0deg);
    -ms-transform: perspective(400px) rotateY(0deg);
    -o-transform: perspective(400px) rotateY(0deg);
    -webkit-transform: perspective(400px) rotateY(0deg);
    transform: perspective(400px) rotateY(0deg); } }

@keyframes fadein {
  from {
    opacity: 0; }

  to {
    opacity: 1; } }

/* Firefox < 16 */
@-moz-keyframes fadein {
  from {
    opacity: 0; }

  to {
    opacity: 1; } }

/* Safari, Chrome and Opera > 12.1 */
@-webkit-keyframes fadein {
  from {
    opacity: 0; }

  to {
    opacity: 1; } }

/* Internet Explorer */
@-ms-keyframes fadein {
  from {
    opacity: 0; }

  to {
    opacity: 1; } }

/* Opera < 12.1 */
@-o-keyframes fadein {
  from {
    opacity: 0; }

  to {
    opacity: 1; } }

@-webkit-keyframes fade-out {
  0% {
    opacity: 1;
    -webkit-transform: scale(1);
    -moz-transform: scale(1);
    -ms-transform: scale(1);
    -o-transform: scale(1);
    transform: scale(1); }

  85% {
    opacity: 1;
    -webkit-transform: scale(1.05);
    -moz-transform: scale(1.05);
    -ms-transform: scale(1.05);
    -o-transform: scale(1.05);
    transform: scale(1.05); }

  100% {
    -webkit-transform: scale(0.1);
    -moz-transform: scale(0.1);
    -ms-transform: scale(0.1);
    -o-transform: scale(0.1);
    transform: scale(0.1);
    opacity: 0; } }

@-moz-keyframes fade-out {
  0% {
    opacity: 1;
    -webkit-transform: scale(1);
    -moz-transform: scale(1);
    -ms-transform: scale(1);
    -o-transform: scale(1);
    transform: scale(1); }

  85% {
    opacity: 1;
    -webkit-transform: scale(1.05);
    -moz-transform: scale(1.05);
    -ms-transform: scale(1.05);
    -o-transform: scale(1.05);
    transform: scale(1.05); }

  100% {
    -webkit-transform: scale(0.1);
    -moz-transform: scale(0.1);
    -ms-transform: scale(0.1);
    -o-transform: scale(0.1);
    transform: scale(0.1);
    opacity: 0; } }

@keyframes fade-out {
  0% {
    opacity: 1;
    -webkit-transform: scale(1);
    -moz-transform: scale(1);
    -ms-transform: scale(1);
    -o-transform: scale(1);
    transform: scale(1); }

  85% {
    opacity: 1;
    -webkit-transform: scale(1.05);
    -moz-transform: scale(1.05);
    -ms-transform: scale(1.05);
    -o-transform: scale(1.05);
    transform: scale(1.05); }

  100% {
    -webkit-transform: scale(0.1);
    -moz-transform: scale(0.1);
    -ms-transform: scale(0.1);
    -o-transform: scale(0.1);
    transform: scale(0.1);
    opacity: 0; } }

@-ms-keyframes fade-out {
  0% {
    opacity: 1;
    -webkit-transform: scale(1);
    -moz-transform: scale(1);
    -ms-transform: scale(1);
    -o-transform: scale(1);
    transform: scale(1); }

  85% {
    opacity: 1;
    -webkit-transform: scale(1.05);
    -moz-transform: scale(1.05);
    -ms-transform: scale(1.05);
    -o-transform: scale(1.05);
    transform: scale(1.05); }

  100% {
    -webkit-transform: scale(0.1);
    -moz-transform: scale(0.1);
    -ms-transform: scale(0.1);
    -o-transform: scale(0.1);
    transform: scale(0.1);
    opacity: 0; } }

@-o-keyframes fade-out {
  0% {
    opacity: 1;
    -webkit-transform: scale(1);
    -moz-transform: scale(1);
    -ms-transform: scale(1);
    -o-transform: scale(1);
    transform: scale(1); }

  85% {
    opacity: 1;
    -webkit-transform: scale(1.05);
    -moz-transform: scale(1.05);
    -ms-transform: scale(1.05);
    -o-transform: scale(1.05);
    transform: scale(1.05); }

  100% {
    -webkit-transform: scale(0.1);
    -moz-transform: scale(0.1);
    -ms-transform: scale(0.1);
    -o-transform: scale(0.1);
    transform: scale(0.1);
    opacity: 0; } }

@-webkit-keyframes fadeInDown {
  0% {
    opacity: 0;
    -webkit-transform: translateY(-20px); }

  100% {
    opacity: 1;
    -webkit-transform: translateY(0); } }

@-moz-keyframes fadeInDown {
  0% {
    opacity: 0;
    -moz-transform: translateY(-20px); }

  100% {
    opacity: 1;
    -moz-transform: translateY(0); } }

@-o-keyframes fadeInDown {
  0% {
    opacity: 0;
    -o-transform: translateY(-20px); }

  100% {
    opacity: 1;
    -o-transform: translateY(0); } }

@keyframes fadeInDown {
  0% {
    opacity: 0;
    transform: translateY(-20px); }

  100% {
    opacity: 1;
    transform: translateY(0); } }

@-webkit-keyframes fadeInUp {
  0% {
    opacity: 0;
    -webkit-transform: translateY(20px); }

  100% {
    opacity: 1;
    -webkit-transform: translateY(0); } }

@-moz-keyframes fadeInUp {
  0% {
    opacity: 0;
    -moz-transform: translateY(20px); }

  100% {
    opacity: 1;
    -moz-transform: translateY(0); } }

@-o-keyframes fadeInUp {
  0% {
    opacity: 0;
    -o-transform: translateY(20px); }

  100% {
    opacity: 1;
    -o-transform: translateY(0); } }

@keyframes fadeInUp {
  0% {
    opacity: 0;
    transform: translateY(20px); }

  100% {
    opacity: 1;
    transform: translateY(0); } }

@-webkit-keyframes slideInLeft {
  0% {
    opacity: 0;
    -webkit-transform: translateX(-2000px); }

  100% {
    -webkit-transform: translateX(0); } }

@-moz-keyframes slideInLeft {
  0% {
    opacity: 0;
    -moz-transform: translateX(-2000px); }

  100% {
    -moz-transform: translateX(0); } }

@-o-keyframes slideInLeft {
  0% {
    opacity: 0;
    -o-transform: translateX(-2000px); }

  100% {
    -o-transform: translateX(0); } }

@keyframes slideInLeft {
  0% {
    opacity: 0;
    transform: translateX(-2000px); }

  100% {
    transform: translateX(0); } }

@-webkit-keyframes bounceIn {
  0% {
    opacity: 0;
    -webkit-transform: scale(0.3); }

  50% {
    opacity: 1;
    -webkit-transform: scale(1.05); }

  70% {
    -webkit-transform: scale(0.9); }

  100% {
    -webkit-transform: scale(1); } }

@-moz-keyframes bounceIn {
  0% {
    opacity: 0;
    -moz-transform: scale(0.3); }

  50% {
    opacity: 1;
    -moz-transform: scale(1.05); }

  70% {
    -moz-transform: scale(0.9); }

  100% {
    -moz-transform: scale(1); } }

@-o-keyframes bounceIn {
  0% {
    opacity: 0;
    -o-transform: scale(0.3); }

  50% {
    opacity: 1;
    -o-transform: scale(1.05); }

  70% {
    -o-transform: scale(0.9); }

  100% {
    -o-transform: scale(1); } }

@keyframes bounceIn {
  0% {
    opacity: 0;
    transform: scale(0.3); }

  50% {
    opacity: 1;
    transform: scale(1.05); }

  70% {
    transform: scale(0.9); }

  100% {
    transform: scale(1); } }

@-webkit-keyframes bounceInUp {
  0% {
    opacity: 0;
    -webkit-transform: translateY(2000px); }

  60% {
    opacity: 1;
    -webkit-transform: translateY(-30px); }

  80% {
    -webkit-transform: translateY(10px); }

  100% {
    -webkit-transform: translateY(0); } }

@-moz-keyframes bounceInUp {
  0% {
    opacity: 0;
    -moz-transform: translateY(2000px); }

  60% {
    opacity: 1;
    -moz-transform: translateY(-30px); }

  80% {
    -moz-transform: translateY(10px); }

  100% {
    -moz-transform: translateY(0); } }

@-o-keyframes bounceInUp {
  0% {
    opacity: 0;
    -o-transform: translateY(2000px); }

  60% {
    opacity: 1;
    -o-transform: translateY(-30px); }

  80% {
    -o-transform: translateY(10px); }

  100% {
    -o-transform: translateY(0); } }

@keyframes bounceInUp {
  0% {
    opacity: 0;
    transform: translateY(2000px); }

  60% {
    opacity: 1;
    transform: translateY(-30px); }

  80% {
    transform: translateY(10px); }

  100% {
    transform: translateY(0); } }

.animated {
  -webkit-animation-fill-mode: both;
  -moz-animation-fill-mode: both;
  -ms-animation-fill-mode: both;
  -o-animation-fill-mode: both;
  animation-fill-mode: both;
  -webkit-animation-duration: 1s;
  -moz-animation-duration: 1s;
  -ms-animation-duration: 1s;
  -o-animation-duration: 1s;
  animation-duration: 1s; }

.delay_0_2 {
  -moz-animation-delay: 0.2s;
  -webkit-animation-delay: 0.2s;
  -o-animation-delay: 0.2s;
  animation-delay: 0.2s; }

.delay_0_4 {
  -moz-animation-delay: 0.4s;
  -webkit-animation-delay: 0.4s;
  -o-animation-delay: 0.4s;
  animation-delay: 0.4s; }

.delay_0_6 {
  -moz-animation-delay: 0.6s;
  -webkit-animation-delay: 0.6s;
  -o-animation-delay: 0.6s;
  animation-delay: 0.6s; }

.delay_0_8 {
  -moz-animation-delay: 0.8s;
  -webkit-animation-delay: 0.8s;
  -o-animation-delay: 0.8s;
  animation-delay: 0.8s; }

.delay_1_0 {
  -moz-animation-delay: 1s;
  -webkit-animation-delay: 1s;
  -o-animation-delay: 1s;
  animation-delay: 1s; }

.delay_1_2 {
  -moz-animation-delay: 1.2s;
  -webkit-animation-delay: 1.2s;
  -o-animation-delay: 1.2s;
  animation-delay: 1.2s; }

.delay_1_4 {
  -moz-animation-delay: 1.4s;
  -webkit-animation-delay: 1.4s;
  -o-animation-delay: 1.4s;
  animation-delay: 1.4s; }

.delay_1_6 {
  -moz-animation-delay: 1.6s;
  -webkit-animation-delay: 1.6s;
  -o-animation-delay: 1.6s;
  animation-delay: 1.6s; }

.delay_1_8 {
  -moz-animation-delay: 1.8s;
  -webkit-animation-delay: 1.8s;
  -o-animation-delay: 1.8s;
  animation-delay: 1.8s; }

.delay_2_0 {
  -moz-animation-delay: 2s;
  -webkit-animation-delay: 2s;
  -o-animation-delay: 2s;
  animation-delay: 2s; }

.flipInY {
  -webkit-backface-visibility: visible !important;
  -webkit-animation-name: flipInY;
  -moz-backface-visibility: visible !important;
  -moz-animation-name: flipInY;
  -o-backface-visibility: visible !important;
  -o-animation-name: flipInY;
  backface-visibility: visible !important;
  animation-name: flipInY; }

.fadeIn {
  -webkit-animation-name: fadeIn;
  -moz-animation-name: fadeIn;
  -o-animation-name: fadeIn;
  animation-name: fadeIn; }

.fadeInUp {
  -webkit-animation-name: fadeInUp;
  -moz-animation-name: fadeInUp;
  -o-animation-name: fadeInUp;
  animation-name: fadeInUp; }

.fadeInDown {
  -webkit-animation-name: fadeInDown;
  -moz-animation-name: fadeInDown;
  -o-animation-name: fadeInDown;
  animation-name: fadeInDown; }

.slideInLeft {
  -webkit-animation-name: slideInLeft;
  -moz-animation-name: slideInLeft;
  -o-animation-name: slideInLeft;
  animation-name: slideInLeft; }

.bounceIn {
  -webkit-animation-name: bounceIn;
  -moz-animation-name: bounceIn;
  -o-animation-name: bounceIn;
  animation-name: bounceIn; }

.bounceInUp {
  -webkit-animation-name: bounceInUp;
  -moz-animation-name: bounceInUp;
  -o-animation-name: bounceInUp;
  animation-name: bounceInUp; }

.header {
  background: #E23337; }

.navbar {
  margin-bottom: 0;
  border-radius: 0; }

/* BASE STYLES
============================================================================= */
html {
  overflow-x: hidden; }

body {
  -webkit-backface-visibility: hidden;
  -moz-backface-visibility: hidden;
  backface-visibility: hidden;
  /*background: url(/images/grey_wash_wall.png);*/
  font-family: 'Open Sans', sans-serif !important;
  min-width: 320px;
  width: auto !important;
  overflow-x: hidden !important;
  overflow: hidden; }

.page {
  position: relative;
  top: 0;
  bottom: 0;
  padding-top: 20px;
  width: 100%;
  text-align: center; }

.page h1 {
  font-size: 60px;
  font-family: 'Open Sans', sans-serif; }

.page a {
  margin-top: 50px; }

/* PAGES
============================================================================= */

.page-preview {
  -webkit-transition: height 0.8s;
  -moz-transition: height 0.8s;
  transition: height 0.8s; }
  .page-preview .view-prev {
    display: block;
    font-size: 12px; }
  .page-preview.pprev-img img {
    width: 65%;
    margin: 0 auto; }

.project-preview h1 {
  margin-bottom: 20px; }

.preview-play, .preview-stop {
  font-size: 50px;
  cursor: pointer; }

.stop-prev {
  display: none; }

/* ANIMATIONS
============================================================================= */

.page.ng-leave {
  z-index: 99; }

.page.ng-enter {
  z-index: 100; }

/* page specific animations ------------------------ */
.thumbnail {
  background: #333;
  padding: 0;
  border: none; }
  .thumbnail .caption {
    padding: 10px;
    color: #fff;
    min-height: 115px;
    vertical-align: bottom;
    display: table;
    height: 115px;
    text-align: center;
    width: 100%; }
    .thumbnail .caption div {
      display: table-cell;
      vertical-align: bottom; }
      .thumbnail .caption div h2 {
        margin: 0 0 10px;
        text-transform: uppercase;
        font-size: 20px; }
      .thumbnail .caption div a {
        margin-top: 0; }

h2 > small {
  display: block;
  margin-top: 5px; }

.btn-xs {
  padding: 1px 5px;
  font-size: 12px;
  line-height: 1.5;
  border-radius: 3px; }

.btn-primary {
  color: #fff;
  background-color: #c0392a;
  border-color: #ab3325; }

.btn-primary:hover, .btn-primary:focus, .btn-primary:active, .btn-primary.active, .open .dropdown-toggle.btn-primary {
  color: #fff;
  background-color: #9f2f23;
  border-color: #79241a; }

.project-info {
  text-align: left; }
  .project-info .checkedList, .project-info ul {
    list-style-type: none;
    padding-left: 0; }
    .project-info .checkedList li, .project-info ul li {
      padding-left: 14px;
      margin-bottom: 5px;
      color: #666; }
      .project-info .checkedList li .checked, .project-info ul li .checked {
        margin-right: 15px; }

/*# sourceMappingURL=C:\Users\Chris\Documents\GitHub\angular-seed\app\assets\scss\base.css.map */


text:
@echo off

reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0" /v MSBuildToolsPath > nul 2>&1
if ERRORLEVEL 1 goto MissingMSBuildRegistry

for /f "skip=2 tokens=2,*" %%A in ('reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0" /v MSBuildToolsPath') do SET MSBUILDDIR=%%B

IF NOT EXIST %MSBUILDDIR%nul goto MissingMSBuildToolsPath
IF NOT EXIST %MSBUILDDIR%msbuild.exe goto MissingMSBuildExe

::BUILD
"tools\nuget.exe" restore Newtonsoft.Json.DependencyInjection.sln
"%MSBUILDDIR%msbuild.exe" "Newtonsoft.Json.Ninject\Newtonsoft.Json.Ninject.csproj" /t:ReBuild /p:Configuration=Release;TargetFrameworkVersion=v4.5;DefineConstants="TRACE;NET45";OutPutPath=bin\Release\net45\;DocumentationFile=bin\Release\net45\Newtonsoft.Json.Ninject.xml

mkdir build
del "build\*.nupkg"

::PACK
"tools\nuget.exe" pack "Newtonsoft.Json.Ninject\Newtonsoft.Json.Ninject.nuspec" -OutputDirectory build

::DEPLOY
"tools\nuget.exe" push "build\*.nupkg"

goto:eof
::ERRORS
::---------------------
:MissingMSBuildRegistry
echo Cannot obtain path to MSBuild tools from registry
goto:eof
:MissingMSBuildToolsPath
echo The MSBuild tools path from the registry '%MSBUILDDIR%' does not exist
goto:eof
:MissingMSBuildExe
echo The MSBuild executable could not be found at '%MSBUILDDIR%'
goto:eof


text:
package dict

import (
	"io/ioutil"
	"os"
	"runtime"
	"strings"
	"testing"
)

func TestNewDictionaryCustom(t *testing.T) {
	words := []string{"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"}
	data := strings.Join(words, "\n")
	err := ioutil.WriteFile(customDictPath, []byte(data), 0644)
	if err != nil {
		t.Errorf("write dictionary err (%s) != nil", err)
	}
	defer os.Remove(customDictPath)

	dict, err := newDictionaryFile(customDictPath)
	if err != nil {
		t.Errorf("err (%s) != nil", err)
	}

	if !testSlicesEqual(words, dict.words) {
		t.Error("words != dict.words")
	}
}

func TestNewDictionarySystem(t *testing.T) {
	if runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
		t.Logf("OS %s may not have system dictionary, so test skipped")
		return
	}

	dict, err := newDictionaryFile(systemDictPath)
	if err != nil {
		t.Errorf("err (%s) != nil", err)
	}

	if len(dict.words) == 0 {
		t.Error("len(dict.words) == 0")
	}
}

func TestNewDictionaryDownload(t *testing.T) {
	// Make sure custom dict doesn't already exist
	os.Remove(customDictPath)

	dict, err := newDictionaryDownload()
	if err != nil {
		t.Errorf("err (%s) != nil", err)
	}

	if len(dict.words) == 0 {
		t.Error("len(dict.words) == 0")
	}

	customDict, err := newDictionaryFile(customDictPath)
	if err != nil {
		t.Errorf("custom err (%s) != nil", err)
	}
	defer os.Remove(customDictPath)

	if !testSlicesEqual(dict.words, customDict.words) {
		t.Error("downloaded dict != saved dict")
	}
}


text:
using base::StringPiece;
using std::min;
using testing::_;
using testing::InSequence;
using testing::Return;
using testing::SaveArg;
using testing::StrEq;
using testing::StrictMock;

namespace net {
namespace test {
namespace {

const char kData1[] = "FooAndBar";
const char kData2[] = "EepAndBaz";
const size_t kDataLen = 9;
const QuicGuid kGuid = 42;
const QuicGuid kStreamId = 3;
const bool kIsServer = true;
const bool kShouldProcessData = true;

class TestStream : public ReliableQuicStream {
 public:
  TestStream(QuicStreamId id,
                         QuicSession* session,
                         bool should_process_data)
      : ReliableQuicStream(id, session),
        should_process_data_(should_process_data) {
  }

  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
    DVLOG(1) << "ProcessData data_len: " << data_len;
    data_ += string(data, data_len);
    return should_process_data_ ? data_len : 0;
  }

  using ReliableQuicStream::WriteData;
  using ReliableQuicStream::CloseReadSide;
  using ReliableQuicStream::CloseWriteSide;

  const string& data() const { return data_; }

 private:
  bool should_process_data_;
  string data_;
};

class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
 public:
  ReliableQuicStreamTest() {
    headers_[":host"] = "www.google.com";
    headers_[":path"] = "/index.hml";
    headers_[":scheme"] = "https";
  }

  void Initialize(bool stream_should_process_data) {
    connection_ = new testing::StrictMock<MockConnection>(
        kGuid, IPEndPoint(), kIsServer);
    session_.reset(new testing::StrictMock<MockSession>(
        connection_, kIsServer));
    stream_.reset(new TestStream(kStreamId, session_.get(),
                                 stream_should_process_data));
    stream2_.reset(new TestStream(kStreamId + 2, session_.get(),
                                 stream_should_process_data));
    compressor_.reset(new QuicSpdyCompressor());
    decompressor_.reset(new QuicSpdyDecompressor);
  }

 protected:
  MockConnection* connection_;
  scoped_ptr<MockSession> session_;
  scoped_ptr<TestStream> stream_;
  scoped_ptr<TestStream> stream2_;
  scoped_ptr<QuicSpdyCompressor> compressor_;
  scoped_ptr<QuicSpdyDecompressor> decompressor_;
  SpdyHeaderBlock headers_;
};

TEST_F(ReliableQuicStreamTest, WriteAllData) {
  Initialize(kShouldProcessData);

  connection_->options()->max_packet_length =
      1 + QuicPacketCreator::StreamFramePacketOverhead(1, !kIncludeVersion);
  // TODO(rch): figure out how to get StrEq working here.
  //EXPECT_CALL(*session_, WriteData(kStreamId, StrEq(kData1), _, _)).WillOnce(
  EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
      Return(QuicConsumedData(kDataLen, true)));
  EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
}

TEST_F(ReliableQuicStreamTest, WriteData) {
  Initialize(kShouldProcessData);

  connection_->options()->max_packet_length =
      1 + QuicPacketCreator::StreamFramePacketOverhead(1, !kIncludeVersion);
  // TODO(rch): figure out how to get StrEq working here.
  //EXPECT_CALL(*session_, WriteData(_, StrEq(kData1), _, _)).WillOnce(
  EXPECT_CALL(*session_, WriteData(_, _, _, _)).WillOnce(
      Return(QuicConsumedData(kDataLen - 1, false)));
  // The return will be kDataLen, because the last byte gets buffered.
  EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);

  // Queue a bytes_consumed write.
  EXPECT_EQ(kDataLen, stream_->WriteData(kData2, false).bytes_consumed);

  // Make sure we get the tail of the first write followed by the bytes_consumed
  InSequence s;
  //EXPECT_CALL(*session_, WriteData(_, StrEq(&kData1[kDataLen - 1]), _, _)).
  EXPECT_CALL(*session_, WriteData(_, _, _, _)).
      WillOnce(Return(QuicConsumedData(1, false)));
  //EXPECT_CALL(*session_, WriteData(_, StrEq(kData2), _, _)).
  EXPECT_CALL(*session_, WriteData(_, _, _, _)).
      WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
  stream_->OnCanWrite();

  // And finally the end of the bytes_consumed
  //EXPECT_CALL(*session_, WriteData(_, StrEq(&kData2[kDataLen - 2]), _, _)).
  EXPECT_CALL(*session_, WriteData(_, _, _, _)).
      WillOnce(Return(QuicConsumedData(2, true)));
  stream_->OnCanWrite();
}

TEST_F(ReliableQuicStreamTest, ConnectionCloseAfterStreamClose) {
  Initialize(kShouldProcessData);

  stream_->CloseReadSide();
  stream_->CloseWriteSide();
  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
  stream_->ConnectionClose(QUIC_INTERNAL_ERROR, false);
  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
}

TEST_F(ReliableQuicStreamTest, ProcessHeaders) {
  Initialize(kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  QuicStreamFrame frame(kStreamId, false, 0, compressed_headers);

  stream_->OnStreamFrame(frame);
  EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_), stream_->data());
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidHeaderId) {
  Initialize(kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  compressed_headers.replace(0, 1, 1, '\xFF');  // Illegal header id.
  QuicStreamFrame frame(kStreamId, false, 0, compressed_headers);

  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID));
  stream_->OnStreamFrame(frame);
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBody) {
  Initialize(kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  string body = "this is the body";
  string data = compressed_headers + body;
  QuicStreamFrame frame(kStreamId, false, 0, data);

  stream_->OnStreamFrame(frame);
  EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
            stream_->data());
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyFragments) {
  Initialize(kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  string body = "this is the body";
  string data = compressed_headers + body;

  for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) {
    Initialize(kShouldProcessData);
    for (size_t offset = 0; offset < data.size(); offset += fragment_size) {
      size_t remaining_data = data.length() - offset;
      StringPiece fragment(data.data() + offset,
                           min(fragment_size, remaining_data));
      QuicStreamFrame frame(kStreamId, false, offset, fragment);

      stream_->OnStreamFrame(frame);
    }
    ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
              stream_->data()) << "fragment_size: " << fragment_size;
  }
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyReadv) {
  Initialize(!kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  string body = "this is the body";
  string data = compressed_headers + body;
  QuicStreamFrame frame(kStreamId, false, 0, data);
  string uncompressed_headers =
      SpdyUtils::SerializeUncompressedHeaders(headers_);
  string uncompressed_data = uncompressed_headers + body;

  stream_->OnStreamFrame(frame);
  EXPECT_EQ(uncompressed_data, stream_->data());

  char buffer[1024];
  ASSERT_LT(data.length(), arraysize(buffer));
  struct iovec vec;
  vec.iov_base = buffer;
  vec.iov_len = arraysize(buffer);

  size_t bytes_read = stream_->Readv(&vec, 1);
  EXPECT_EQ(uncompressed_headers.length(), bytes_read);
  EXPECT_EQ(uncompressed_headers, string(buffer, bytes_read));

  bytes_read = stream_->Readv(&vec, 1);
  EXPECT_EQ(body.length(), bytes_read);
  EXPECT_EQ(body, string(buffer, bytes_read));
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
  Initialize(!kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  string body = "this is the body";
  string data = compressed_headers + body;
  QuicStreamFrame frame(kStreamId, false, 0, data);
  string uncompressed_headers =
      SpdyUtils::SerializeUncompressedHeaders(headers_);
  string uncompressed_data = uncompressed_headers + body;

  stream_->OnStreamFrame(frame);
  EXPECT_EQ(uncompressed_data, stream_->data());

  char buffer[1];
  struct iovec vec;
  vec.iov_base = buffer;
  vec.iov_len = arraysize(buffer);
  for (size_t i = 0; i < uncompressed_data.length(); ++i) {
    size_t bytes_read = stream_->Readv(&vec, 1);
    ASSERT_EQ(1u, bytes_read);
    EXPECT_EQ(uncompressed_data.data()[i], buffer[0]);
  }
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
  Initialize(!kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  string body = "this is the body";
  string data = compressed_headers + body;
  QuicStreamFrame frame(kStreamId, false, 0, data);
  string uncompressed_headers =
      SpdyUtils::SerializeUncompressedHeaders(headers_);
  string uncompressed_data = uncompressed_headers + body;

  stream_->OnStreamFrame(frame);
  EXPECT_EQ(uncompressed_data, stream_->data());

  char buffer1[1];
  char buffer2[1];
  struct iovec vec[2];
  vec[0].iov_base = buffer1;
  vec[0].iov_len = arraysize(buffer1);
  vec[1].iov_base = buffer2;
  vec[1].iov_len = arraysize(buffer2);
  for (size_t i = 0; i < uncompressed_data.length(); i += 2) {
    size_t bytes_read = stream_->Readv(vec, 2);
    ASSERT_EQ(2u, bytes_read) << i;
    ASSERT_EQ(uncompressed_data.data()[i], buffer1[0]) << i;
    ASSERT_EQ(uncompressed_data.data()[i + 1], buffer2[0]) << i;
  }
}

TEST_F(ReliableQuicStreamTest, ProcessHeadersEarly) {
  Initialize(kShouldProcessData);

  string compressed_headers1 = compressor_->CompressHeaders(headers_);
  QuicStreamFrame frame1(stream_->id(), false, 0, compressed_headers1);
  string decompressed_headers1 =
      SpdyUtils::SerializeUncompressedHeaders(headers_);

  headers_["content-type"] = "text/plain";
  string compressed_headers2 = compressor_->CompressHeaders(headers_);
  QuicStreamFrame frame2(stream2_->id(), false, 0, compressed_headers2);
  string decompressed_headers2 =
      SpdyUtils::SerializeUncompressedHeaders(headers_);

  stream2_->OnStreamFrame(frame2);
  EXPECT_EQ("", stream_->data());

  stream_->OnStreamFrame(frame1);
  EXPECT_EQ(decompressed_headers1, stream_->data());

  EXPECT_EQ(2u, session_->decompressor()->current_header_id());
  stream2_->OnDecompressorAvailable();
  EXPECT_EQ(decompressed_headers2, stream2_->data());
}
TEST_F(ReliableQuicStreamTest, ProcessHeadersDelay) {
  Initialize(!kShouldProcessData);

  string compressed_headers = compressor_->CompressHeaders(headers_);
  QuicStreamFrame frame1(stream_->id(), false, 0, compressed_headers);
  string decompressed_headers =
      SpdyUtils::SerializeUncompressedHeaders(headers_);

  // Send the headers to the stream and verify they were decompressed.
  stream_->OnStreamFrame(frame1);
  EXPECT_EQ(2u, session_->decompressor()->current_header_id());

  // Verify that we are now able to handle the body data,
  // even though the stream has not processed the headers.
  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
      .Times(0);
  QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
                         "body data");
  stream_->OnStreamFrame(frame2);
}

}  // namespace
}  // namespace test
}  // namespace net


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Bulletin de la Société des Sciences naturelles et d'Archéologie de Toulon et du Var 195: 7 (1971)

#### Original name
Bitunicostilbe M. Morelet

### Remarks
null