text:
using org.xmlvm;
namespace java.util.regex {
public class SOLSet: global::java.util.regex.AbstractSet {
new public void @this(){
//XMLVM_BEGIN_WRAPPER[java.util.regex.SOLSet: void <init>()]
    global::System.Object _r0_o = null;
    _r0_o = this;
    ((global::java.util.regex.AbstractSet) _r0_o).@this();
    return;
//XMLVM_END_WRAPPER[java.util.regex.SOLSet: void <init>()]
}

public override int matches(int n1, global::java.lang.CharSequence n2, global::java.util.regex.MatchResultImpl n3){
//XMLVM_BEGIN_WRAPPER[java.util.regex.SOLSet: int matches(int, java.lang.CharSequence, java.util.regex.MatchResultImpl)]
    global::org.xmlvm._nElement _r0;
    global::System.Object _r0_o = null;
    global::System.Object _r1_o = null;
    global::org.xmlvm._nElement _r2;
    global::System.Object _r3_o = null;
    global::System.Object _r4_o = null;
    _r1_o = this;
    _r2.i = n1;
    _r3_o = n2;
    _r4_o = n3;
    if (_r2.i == 0) goto label14;
    _r0.i = ((global::java.util.regex.MatchResultImpl) _r4_o).hasAnchoringBounds() ? 1 : 0;
    if (_r0.i == 0) goto label21;
    _r0.i = ((global::java.util.regex.MatchResultImpl) _r4_o).getLeftBound();
    if (_r2.i != _r0.i) goto label21;
    label14:;
    _r0_o = ((global::java.util.regex.SOLSet) _r1_o)._fnext;
    _r0.i = ((global::java.util.regex.AbstractSet) _r0_o).matches((int) _r2.i, (global::java.lang.CharSequence) _r3_o, (global::java.util.regex.MatchResultImpl) _r4_o);
    label20:;
    return _r0.i;
    label21:;
    _r0.i = -1;
    goto label20;
//XMLVM_END_WRAPPER[java.util.regex.SOLSet: int matches(int, java.lang.CharSequence, java.util.regex.MatchResultImpl)]
}

public override bool hasConsumed(global::java.util.regex.MatchResultImpl n1){
//XMLVM_BEGIN_WRAPPER[java.util.regex.SOLSet: boolean hasConsumed(java.util.regex.MatchResultImpl)]
    global::org.xmlvm._nElement _r0;
    global::System.Object _r1_o = null;
    global::System.Object _r2_o = null;
    _r1_o = this;
    _r2_o = n1;
    _r0.i = 0;
    return _r0.i!=0;
//XMLVM_END_WRAPPER[java.util.regex.SOLSet: boolean hasConsumed(java.util.regex.MatchResultImpl)]
}

public override global::System.Object getName(){
//XMLVM_BEGIN_WRAPPER[java.util.regex.SOLSet: java.lang.String getName()]
    global::System.Object _r0_o = null;
    global::System.Object _r1_o = null;
    _r1_o = this;
    // Value=<SOL>
    _r0_o = new global::java.lang.String();
    ((global::java.lang.String)_r0_o).@this(new global::org.xmlvm._nArrayAdapter<char>(new char[] {unchecked((char) unchecked((uint)60)), unchecked((char) unchecked((uint) 83)), unchecked((char) unchecked((uint) 79)), unchecked((char) unchecked((uint) 76)), unchecked((char) unchecked((uint) 62))}));
    return (global::java.lang.String) _r0_o;
//XMLVM_END_WRAPPER[java.util.regex.SOLSet: java.lang.String getName()]
}

//XMLVM_BEGIN_WRAPPER[java.util.regex.SOLSet]
//XMLVM_END_WRAPPER[java.util.regex.SOLSet]

} // end of class: SOLSet

} // end of namespace: java.util.regex


text:
from django.forms import Form
from mongoengine.base import TopLevelDocumentMetaclass
from mongoengine.fields import EmbeddedDocumentField
from mongoengine.fields import ListField

from .form_mixins import MongoModelFormBaseMixin
from .form_utils import has_digit
from .form_utils import make_key
from .widgets import get_widget

class MongoModelForm(MongoModelFormBaseMixin, Form):
    """
    This class will take a model and generate a form for the model.
    Recommended use for this project only.

    Example:

    my_form = MongoModelForm(request.POST, model=self.document_type, instance=self.document).get_form()

    if self.form.is_valid():
        # Do your processing
    """

    def __init__(self, form_post_data=None, *args, **kwargs):
        """
        Overriding init so we can set the post vars like a normal form and generate
        the form the same way Django does.
        """
        kwargs.update({'form_post_data': form_post_data})
        super(MongoModelForm, self).__init__(*args, **kwargs)

    def set_fields(self):
        """Sets existing data to form fields."""

        # Get dictionary map of current model
        if self.is_initialized:
            self.model_map_dict = self.create_document_dictionary(self.model_instance)
        else:
            self.model_map_dict = self.create_document_dictionary(self.model)

        form_field_dict = self.get_form_field_dict(self.model_map_dict)
        self.set_form_fields(form_field_dict)

    def set_post_data(self):
        """
            Need to set form data so that validation on all post data occurs and
            places newly entered form data on the form object.
        """
        self.form.data = self.post_data_dict

        # Specifically adding list field keys to the form so they are included
        # in form.cleaned_data after the call to is_valid
        for field_key, field in self.form.fields.items():
            if has_digit(field_key):
                # We have a list field.
                base_key = make_key(field_key, exclude_last_string=True)

                # Add new key value with field to form fields so validation
                # will work correctly
                for key in self.post_data_dict.keys():
                    if base_key in key:
                        self.form.fields.update({key: field})

    def get_form(self):
        """
        Generate the form for view.
        """
        self.set_fields()
        if self.post_data_dict is not None:
            self.set_post_data()
        return self.form

    def create_doc_dict(self, document, doc_key=None, owner_document=None):
        """
        Generate a dictionary representation of the document.  (no recursion)

        DO NOT CALL DIRECTLY
        """
        # Get doc field for top level documents
        if owner_document:
            doc_field = owner_document._fields.get(doc_key, None) if doc_key else None
        else:
            doc_field = document._fields.get(doc_key, None) if doc_key else None

        # Generate the base fields for the document
        doc_dict = {"_document": document if owner_document is None else owner_document,
                    "_key": document.__class__.__name__.lower() if doc_key is None else doc_key,
                    "_document_field": doc_field}

        if not isinstance(document, TopLevelDocumentMetaclass) and doc_key:
            doc_dict.update({"_field_type": EmbeddedDocumentField})

        for key, field in document._fields.items():
            doc_dict[key] = field

        return doc_dict

    def create_list_dict(self, document, list_field, doc_key):
        """
        Genereates a dictionary representation of the list field. Document
        should be the document the list_field comes from.

        DO NOT CALL DIRECTLY
        """
        list_dict = {"_document": document}

        if isinstance(list_field.field, EmbeddedDocumentField):
            list_dict.update(self.create_document_dictionary(document=list_field.field.document_type_obj,
                                                             owner_document=document))

        # Set the list_dict after it may have been updated
        list_dict.update({"_document_field": list_field.field,
                          "_key": doc_key,
                          "_field_type": ListField,
                          "_widget": get_widget(list_field.field),
                          "_value": getattr(document, doc_key, None)})

        return list_dict

    def create_document_dictionary(self, document, document_key=None,
                                                        owner_document=None):
        """
        Given document generates a dictionary representation of the document.
        Includes the widget for each for each field in the document.
        """
        doc_dict = self.create_doc_dict(document, document_key, owner_document)

        for doc_key, doc_field in doc_dict.items():
            # Base fields should not be evaluated
            if doc_key.startswith("_"):
                continue

            if isinstance(doc_field, ListField):
                doc_dict[doc_key] = self.create_list_dict(document, doc_field, doc_key)

            elif isinstance(doc_field, EmbeddedDocumentField):
                doc_dict[doc_key] = self.create_document_dictionary(doc_dict[doc_key].document_type_obj,
                                                                    doc_key)
            else:
                doc_dict[doc_key] = {"_document": document,
                                     "_key": doc_key,
                                     "_document_field": doc_field,
                                     "_widget": get_widget(doc_dict[doc_key], getattr(doc_field, 'disabled', False))}

        return doc_dict

redpajama_set_name: RedPajamaGithub


text:
#include "../Partio.h"
#include "../core/ParticleHeaders.h"
#include "ZIP.h"

#include <iostream>
#include <fstream>
#include <string>
#include <cassert>
#include <memory>

ENTER_PARTIO_NAMESPACE

using namespace std;

// TODO: convert this to use iterators like the rest of the readers/writers

ParticlesDataMutable* readPDA(const char* filename,const bool headersOnly)
{
    auto_ptr<istream> input(Gzip_In(filename,ios::in|ios::binary));
    if(!*input){
        cerr<<"Partio: Can't open particle data file: "<<filename<<endl;
        return 0;
    }

    ParticlesDataMutable* simple=0;
    if(headersOnly) simple=new ParticleHeaders;
    else simple=create();

    // read NPoints and NPointAttrib
    string word;

    if(input->good()){
        *input>>word;
        if(word!="ATTRIBUTES"){simple->release();return 0;}
    }

    vector<string> attrNames;
    vector<ParticleAttribute> attrs;

    while(input->good()){
        *input>>word;
        if(word=="TYPES") break;;
        attrNames.push_back(word);
    }

    size_t index=0;
    while(input->good()){
        *input>>word;
        if(word=="NUMBER_OF_PARTICLES:") break;

        if(index>=attrNames.size()) continue;

        if(word=="V"){
            attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::VECTOR,3));
        }else if("R"){
            attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::FLOAT,1));
        }else if("I"){
            attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::INT,1));
        }

        index++;
    }

    unsigned int num=0;
    if(input->good()){
        *input>>num;
        simple->addParticles(num);
        if(headersOnly) return simple; // escape before we try to touch data
    }else{
        simple->release();
        return 0;
    }

    // look for beginning of header
    if(input->good()){
        *input>>word;
        if(word != "BEGIN"){simple->release();return 0;}
    }
    if(input->good()){
        *input>>word;
        if(word != "DATA"){simple->release();return 0;}
    }

    // Read actual particle data
    if(!input->good()){simple->release();return 0;}
    for(unsigned int particleIndex=0;input->good() && particleIndex<num; particleIndex++) {
        for(unsigned int attrIndex=0;attrIndex<attrs.size();attrIndex++){
            if(attrs[attrIndex].type==Partio::INT){
                int* data=simple->dataWrite<int>(attrs[attrIndex],particleIndex);
                for(int count=0;count<attrs[attrIndex].count;count++){
                    int ival;
                    *input>>ival;
                    data[count]=ival;
                }
            }else if(attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR){
                float* data=simple->dataWrite<float>(attrs[attrIndex],particleIndex);
                for(int count=0;count<attrs[attrIndex].count;count++){
                    float fval;
                    *input>>fval;
                    data[count]=fval;
                }
            }
        }
    }

    return simple;
}

bool writePDA(const char* filename,const ParticlesData& p,const bool compressed)
{
    auto_ptr<ostream> output(
        compressed ?
        Gzip_Out(filename,ios::out|ios::binary)
        :new ofstream(filename,ios::out|ios::binary));

    *output<<"ATTRIBUTES"<<endl;

    vector<ParticleAttribute> attrs;
    for (int aIndex=0;aIndex<p.numAttributes();aIndex++){
        attrs.push_back(ParticleAttribute());
        p.attributeInfo(aIndex,attrs[aIndex]);
        *output<<" "<<attrs[aIndex].name;
    }
    *output<<endl;

    // TODO: assert right count
    *output<<"TYPES"<<endl;
    for (int aIndex=0;aIndex<p.numAttributes();aIndex++){
        switch(attrs[aIndex].type){
            case FLOAT: *output<<" R";break;
            case VECTOR: *output<<" V";break;
            case INDEXEDSTR:
            case INT: *output<<" I";break;
            case NONE: assert(false); break; // TODO: more graceful
        }
    }
    *output<<endl;

    *output<<"NUMBER_OF_PARTICLES: "<<p.numParticles()<<endl;
    *output<<"BEGIN DATA"<<endl;

    for(int particleIndex=0;particleIndex<p.numParticles();particleIndex++){
        for(unsigned int attrIndex=0;attrIndex<attrs.size();attrIndex++){
            if(attrs[attrIndex].type==Partio::INT || attrs[attrIndex].type==Partio::INDEXEDSTR){
                const int* data=p.data<int>(attrs[attrIndex],particleIndex);
                for(int count=0;count<attrs[attrIndex].count;count++)
                    *output<<data[count]<<" ";
            }else if(attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR){
                const float* data=p.data<float>(attrs[attrIndex],particleIndex);
                for(int count=0;count<attrs[attrIndex].count;count++)
                    *output<<data[count]<<" ";
            }
        }
        *output<<endl;
    }
    return true;

}

EXIT_PARTIO_NAMESPACE


text:
<!DOCTYPE html>

    <meta charset="utf-8">

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

Access Alerts! Settings

            Domains or IP Addresses:

              <textarea id="domains" class="form-control" placeholder="example.com
127.0.0.1" rows="10"></textarea>

            <input type="button" id="save" class="btn btn-primary btn-lg" value="SAVE">


text:
CB=`which codeblocks`

# What is the project file called?
CBP=TraceMiner2.Linux.cbp

# What will the logfile be called?
LOG=TraceMiner2.release.log

# Rebuild all release targets
echo Rebuilding 32bit Release .... > ${LOG}
echo ============================= >> ${LOG}
echo >> ${LOG}
${CB} --rebuild --target="32bit Release" ${CBP} >>${LOG}

echo >> ${LOG}
echo Rebuilding 64bit Release .... >> ${LOG}
echo ============================= >> ${LOG}
echo >> ${LOG}
${CB} --rebuild --target="64bit Release" ${CBP} >>${LOG}

echo >> ${LOG}
echo Release Rebuild completed. See ${LOG} for details.


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

<TITLE>
Uses of Class net.authorize.arb.Transaction (Authorize.Net Java SDK)
</TITLE>

<META NAME="date" CONTENT="2011-07-18">

<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
net.authorize.arb.Transaction

Packages that use Transaction

net.authorize

net.authorize.arb

Uses of Transaction in net.authorize

Methods in net.authorize that return Transaction

 Transaction
Merchant.createARBTransaction(TransactionType transactionType,
                     Subscription subscription)

          Creates a new ARB Transaction.

Uses of Transaction in net.authorize.arb

Methods in net.authorize.arb that return Transaction

static Transaction
Transaction.createTransaction(Merchant merchant,
                  TransactionType transactionType,
                  Subscription subscription)

          Creates a transaction.

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes


text:
title: remove
page_title: ClientDataSource Object remove() - RadClientDataSource
description: Check our Web Forms article about remove.
slug: clientdatasource/client-side-programming/client-side-api/methods/remove
tags: remove
published: True
position: 2
---

# ClientDataSource Object - remove()

Removes the data item from the data source with the specified model ID.

|  **Parameters**  |  **Description**  |
| ------ | ------ |
| **ID** |The model ID of the data item which should be removed.|

````ASPNET
<telerik:RadClientDataSource runat="server" ID="RadClientDataSource1">
    <DataSource>
        <WebServiceDataSourceSettings ServiceType="OData">
            <Select Url="https://demos.telerik.com/aspnet-ajax/Services/SampleODataService.svc/Products" />
        </WebServiceDataSourceSettings>
    </DataSource>
    <Schema>
        <Model ID="ProductID"></Model>
    </Schema>
</telerik:RadClientDataSource>
<asp:Button ID="Button1" runat="server" Text="Button" OnClientClick="buttonClick(); return false;" />
````

````JavaScript
<script type="text/javascript">
    var dataSource;
    function pageLoad() {
        dataSource = $find('<%= RadClientDataSource1.ClientID %>');
        dataSource.fetch();
    }
    function buttonClick() {
        var data = dataSource.view();
        alert(data.length);  // displays "12"
        alert(data[0].ProductName); // displays "Chai"

        dataSource.remove("1");

        data = dataSource.view();
        alert(data.length);  // displays "11"
        alert(data[0].ProductName); // displays "Chang"
    }
</script>
````


text:
Selection
=========

.. automodule:: pybel_tools.selection
    :members:


text:
        <ng-include src="'pxform-layout'" class="pxrecord"></ng-include>

        <ng-include src="'pxform-layout'"></ng-include>

  <px-pagination
    options="vm.paginationOptions"
    ng-attr-on-pagination-change="vm.paginationChangeHandler({newPage: newPage, newPageSize: newPageSize})">
  </px-pagination>

        <button class="btn btn-primary submit-button" type="submit"
            ng-disabled="vm.isSubmitDisabled()">

          Save
        </button>

        <button class="btn btn-primary submit-button" type="submit">

          Filter
        </button>


text:
#region License Information (GPL v3)

#endregion License Information (GPL v3)

using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace ShareX.HelpersLib
{
    public partial class TabToListView : UserControl
    {
        private TabControl mainTabControl;

        [Browsable(false)]
        public TabControl MainTabControl
        {
            get
            {
                return mainTabControl;
            }
            set
            {
                mainTabControl = value;
                FillListView(mainTabControl);
            }
        }

        private int listViewSize;

        public int ListViewSize
        {
            get
            {
                return listViewSize;
            }
            set
            {
                listViewSize = value;
                scMain.SplitterDistance = listViewSize;
            }
        }

        public ImageList ImageList
        {
            get
            {
                return lvMain.SmallImageList;
            }
            set
            {
                lvMain.SmallImageList = tcMain.ImageList = value;
            }
        }

        public TabToListView()
        {
            InitializeComponent();
            ListViewSize = 150;
        }

        private void FillListView(TabControl tab)
        {
            if (tab != null)
            {
                foreach (TabPage tabPage in tab.TabPages)
                {
                    ListViewGroup lvg = new ListViewGroup(tabPage.Text);
                    lvMain.Groups.Add(lvg);

                    foreach (Control control in tabPage.Controls)
                    {
                        if (control is TabControl)
                        {
                            TabControl tab2 = control as TabControl;

                            foreach (TabPage tabPage2 in tab2.TabPages)
                            {
                                ListViewItem lvi = new ListViewItem(tabPage2.Text);
                                lvi.ImageKey = tabPage2.ImageKey;
                                lvi.Tag = tabPage2;
                                lvi.Group = lvg;
                                lvMain.Items.Add(lvi);
                            }

                            tab2.TabPages.Clear();
                        }
                    }
                }

                if (lvMain.Items.Count > 0)
                {
                    lvMain.Items[0].Selected = true;
                }
            }
        }

        private void lvMain_MouseUp(object sender, MouseEventArgs e)
        {
            if (lvMain.SelectedItems.Count == 0 && (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right))
            {
                ListViewItem lvi = lvMain.GetItemAt(e.X, e.Y);

                if (lvi == null)
                {
                    // Workaround for 1px space between items
                    lvi = lvMain.GetItemAt(e.X, e.Y - 1);
                }

                if (lvi != null)
                {
                    lvi.Selected = true;
                }
            }
        }

        private void lvMain_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lvMain.SelectedItems.Count > 0)
            {
                ListViewItem lvi = lvMain.SelectedItems[0];
                TabPage tabPage = lvi.Tag as TabPage;

                if (tabPage != null && !tcMain.TabPages.Contains(tabPage))
                {
                    tcMain.TabPages.Clear();
                    tcMain.TabPages.Add(tabPage);
                    // Need to set ImageKey again otherwise icon not show up
                    tabPage.ImageKey = lvi.ImageKey;
                    lvMain.Focus();
                }
            }
        }

        public void FocusListView()
        {
            lvMain.Focus();
        }
    }
}


text:
#include "config.h"
#include "B3PatchpointSpecial.h"

#if ENABLE(B3_JIT)

#include "AirGenerationContext.h"
#include "B3StackmapGenerationParams.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 {

using namespace Air;

PatchpointSpecial::PatchpointSpecial()
{
}

PatchpointSpecial::~PatchpointSpecial()
{
}

void PatchpointSpecial::forEachArg(Inst& inst, const ScopedLambda<Inst::EachArgCallback>& callback)
{
    PatchpointValue* patchpoint = inst.origin->as<PatchpointValue>();
    unsigned argIndex = 1;

    if (patchpoint->type() != Void) {
        Arg::Role role;
        if (patchpoint->resultConstraint.kind() == ValueRep::SomeEarlyRegister)
            role = Arg::EarlyDef;
        else
            role = Arg::Def;

        callback(inst.args[argIndex++], role, inst.origin->resultBank(), inst.origin->resultWidth());
    }

    forEachArgImpl(0, argIndex, inst, SameAsRep, std::nullopt, callback, std::nullopt);
    argIndex += inst.origin->numChildren();

    for (unsigned i = patchpoint->numGPScratchRegisters; i--;)
        callback(inst.args[argIndex++], Arg::Scratch, GP, conservativeWidth(GP));
    for (unsigned i = patchpoint->numFPScratchRegisters; i--;)
        callback(inst.args[argIndex++], Arg::Scratch, FP, conservativeWidth(FP));
}

bool PatchpointSpecial::isValid(Inst& inst)
{
    PatchpointValue* patchpoint = inst.origin->as<PatchpointValue>();
    unsigned argIndex = 1;

    if (inst.origin->type() != Void) {
        if (argIndex >= inst.args.size())
            return false;

        if (!isArgValidForValue(inst.args[argIndex], patchpoint))
            return false;
        if (!isArgValidForRep(code(), inst.args[argIndex], patchpoint->resultConstraint))
            return false;
        argIndex++;
    }

    if (!isValidImpl(0, argIndex, inst))
        return false;
    argIndex += patchpoint->numChildren();

    if (argIndex + patchpoint->numGPScratchRegisters + patchpoint->numFPScratchRegisters
        != inst.args.size())
        return false;

    for (unsigned i = patchpoint->numGPScratchRegisters; i--;) {
        Arg arg = inst.args[argIndex++];
        if (!arg.isGPTmp())
            return false;
    }
    for (unsigned i = patchpoint->numFPScratchRegisters; i--;) {
        Arg arg = inst.args[argIndex++];
        if (!arg.isFPTmp())
            return false;
    }

    return true;
}

bool PatchpointSpecial::admitsStack(Inst& inst, unsigned argIndex)
{
    if (inst.origin->type() == Void)
        return admitsStackImpl(0, 1, inst, argIndex);

    if (argIndex == 1) {
        switch (inst.origin->as<PatchpointValue>()->resultConstraint.kind()) {
        case ValueRep::WarmAny:
        case ValueRep::StackArgument:
            return true;
        case ValueRep::SomeRegister:
        case ValueRep::SomeEarlyRegister:
        case ValueRep::Register:
        case ValueRep::LateRegister:
            return false;
        default:
            RELEASE_ASSERT_NOT_REACHED();
            return false;
        }
    }

    return admitsStackImpl(0, 2, inst, argIndex);
}

CCallHelpers::Jump PatchpointSpecial::generate(
    Inst& inst, CCallHelpers& jit, GenerationContext& context)
{
    PatchpointValue* value = inst.origin->as<PatchpointValue>();
    ASSERT(value);

    Vector<ValueRep> reps;
    unsigned offset = 1;
    if (inst.origin->type() != Void)
        reps.append(repForArg(*context.code, inst.args[offset++]));
    reps.appendVector(repsImpl(context, 0, offset, inst));
    offset += value->numChildren();

    StackmapGenerationParams params(value, reps, context);

    for (unsigned i = value->numGPScratchRegisters; i--;)
        params.m_gpScratch.append(inst.args[offset++].gpr());
    for (unsigned i = value->numFPScratchRegisters; i--;)
        params.m_fpScratch.append(inst.args[offset++].fpr());

    value->m_generator->run(jit, params);

    return CCallHelpers::Jump();
}

bool PatchpointSpecial::isTerminal(Inst& inst)
{
    return inst.origin->as<PatchpointValue>()->effects.terminal;
}

void PatchpointSpecial::dumpImpl(PrintStream& out) const
{
    out.print("Patchpoint");
}

void PatchpointSpecial::deepDumpImpl(PrintStream& out) const
{
    out.print("Lowered B3::PatchpointValue.");
}

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)


text:
{{ site.title }}

          {% if site.github_username %}

            {% include icon-github.html username=site.github_username %}

          {% endif %}
          {% if site.linkedin_url %}

            {% include icon-linkedin.html name=site.name url=site.linkedin_url %}

          {% endif%}

{{ site.description }}


text:
<!DOCTYPE html>

    <link rel="stylesheet" href="bundle.css">


text:
define([
    'generics/labels',
    'models/stack'
], function (Labels, Stack) {
    'use strict';

    return Labels.extend({
        breadcrumbs: [
            {
                active: false,
                title: 'Stacks',
                href: '/stacks/'
            },
            {
                active: false,
                title: window.stackdio.stackTitle,
                href: '/stacks/' + window.stackdio.stackId + '/'
            },
            {
                active: true,
                title: 'Labels'
            }
        ],
        parentModel: Stack,
        parentId: window.stackdio.stackId,
        baseUrl: '/stacks/',
        initialUrl: '/api/stacks/' + window.stackdio.stackId + '/labels/'
    });
});


text:
# Desenvolvimento de Pacotes

- [Introdução](#introduction)
- [Service Providers](#service-providers)
- [Rotas](#routing)
- [Recursos](#resources)
	- [Views](#views)
	- [Traduções](#translations)
	- [Configurações](#configuration)
- [Assets públicos](#public-assets)
- [Publicando Grupos de Arquivos](#publishing-file-groups)

## Introdução

Pacotes são um modo primário de adicionar funcionalidades ao Laravel. Eles podem fazer coisas excelentes, como o [Carbon](https://github.com/briannesbitt/Carbon), ou o framework de testes BDD [Behat](https://github.com/Behat/Behat).

E é claro, existem diferentes tipos de pacotes. Alguns deles são agnósticos, isso significa que funcionam em qualquer framework, não somente Laravel. Carbon e Behat são exemplos de pacotes agnósticos. Qualquer um desses pacotes podem ser usados com o Laravel simplemente requerindo-os no arquivo `composer.json`.

Por outro lado, existem pacotes que são para uso específico no Laravel. Esses pacotes podem ter rotas, controllers, views e configurações específicas para melhor entrosamento com a aplicação Laravel. Esse artigo lhe instruirá a construir pacotes que serão específicos para Laravel.

## Service Providers

[Service providers](/docs/{{version}}/providers) são o ponto de conexão entre seu pacote e o Laravel. Um service provider é responsável por atrelar coisas no [service container](/docs/{{version}}/container) do Laravel e informá-lo onde estão os recursos como views, configurações, e arquivos de localização.

Um service provider deve estender a classe `Illuminate\Support\ServiceProvider` e conter dois métodos: `register` e `boot`. A classe base `ServiceProvider` está localizada no pacote Composer `illuminate/support`, que você deve adicionar nas dependências do seu pacote.

Para aprender mais sobre a estrutura do service provider, leia [sua documentação](/docs/{{version}}/providers).

## Rotas

Para definir rotas para seu pacote, simplesmente `require` o arquivo de rotas dentro do método `boot` do service provider. Dentro do seu arquivo de rotas você pode usar o facade `Route` para [registrar rotas](/docs/{{version}}/routing) como você quiser dentro de uma aplicação Laravel típica:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		if (! $this->app->routesAreCached()) {
			require __DIR__.'/../../routes.php';
		}
	}

## Recursos

### Views

Para registrar [views](/docs/{{version}}/views)  do seu pacote com Laravel, você precisa dizer ao Laravel onde as views estão localizadas. Você pode fazer isso usando o método do service provider `loadViewsFrom`. Esse método aceita dois argumentos: o caminho para o diretório das suas views e o nome do seu pacote. Por exemplo, se o nome do seu pacote é `courier`, adicione o seguinte trecho ao método `boot` do service provider:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->loadViewsFrom(__DIR__.'/path/to/views', 'courier');
	}

As views do pacote serão referenciadas usando a sintaxe dois-pontos-duplos `package::view`. Então, você pode carregar uma view `admin` do seu pacote `courier` da seguinte maneira:

	Route::get('admin', function () {
		return view('courier::admin');
	});

#### Sobrescrevendo as Views do Pacote

Quando você usa o método `loadViewsFrom`, o Laravel na realidade registra **duas** localizações para suas views: Uma no diretório da sua aplicação `resources/views/vendor` e outra no diretório que você especificou. Então, usando o exemplo `courier`: Quando você requerer uma view do pacote, o Laravel irá primeiro checar se existe uma versão dessa view gerada pelo desenvolvedor que está usando seu pacote em `resources/views/vendor/courier`. Então, se não há uma versão dessa view, o Laravel irá procurar a view no diretório que você especificou na chamada ao método `loadViewsFrom`. Isso torna fácil para o usuário final (desenvolvedor que está usando seu pacote) customizar ou sobrescrevê-las.

#### Publicando Views

Se você gostaria de disponibilizar suas views para o diretório da aplicação `resources/views/vendor`, você pode usar o método `publishes` do service provider. Esse método aceita um array cujos índices são caminho principal de cada diretório de views do seu pacote e valor é o local de sua publicação, neste caso `resources/views/vendor/courier`:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->loadViewsFrom(__DIR__.'/path/to/views', 'courier');

		$this->publishes([
			__DIR__.'/path/to/views' => base_path('resources/views/vendor/courier'),
		]);
	}

Agora, quando os desenvolvedores que usam seu pacote executarem o comando Artisan `vendor:publish`, as views do seu pacote serão copiadas para o local que você especificou.

### Traduções

Se seu pacote contiver [arquivos de tradução](/docs/{{version}}/localization), você pode usar o método `loadTranslationsFrom` para informar ao Laravel como carregá-las. Por exemplo, se o nome do seu pacote é "courier", você pode adicionar o seguinte trecho ao método `boot` do service provider:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->loadTranslationsFrom(__DIR__.'/path/to/translations', 'courier');
	}

As traduções de pacotes são referenciadas usando a sintaxe dois-pontos-duplos. Então, se você quiser carregar a linha `welcome` do arquivo `messages` do pacote `courier`, seria assim:

	echo trans('courier::messages.welcome');

### Configuração

Usualmente, você pode querer publicar os arquivos de configuração do seu pacote para o diretório `config` da aplicação. Isso permitirá que desenvolvedores que usam seu pacote possam facilmente sobrescrever suas configurações padrão. Para publicar um arquivo de configuração, use o método `publishes` do service provider dentro do método `boot`:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->publishes([
			__DIR__.'/path/to/config/courier.php' => config_path('courier.php'),
		]);
	}

Agora, quando o desenvolvedor que usa seu pacote executar o comando Artisan `vendor:publish`, seu arquivo de configuração será copiado para o diretório que você especificou. E é claro, uma vez que seu arquivo foi publicado, ele pode ser acessado como qualquer outro arquivo de configuração:

	$value = config('courier.option');

#### Configuração Padrão do Pacote

Você pode escolher fundir as configurações do seu pacote com a cópia das configurações da aplicação. Isso permitira que os desenvolvedores incluam somente as opções que eles querem sobrescrever na cópia do seu arquivo de configuração. Para fundir as configurações, no método `register` do seu service provider use  `mergeConfigFrom`:

	/**
	 * Register bindings in the container.
	 *
	 * @return void
	 */
	public function register()
	{
		$this->mergeConfigFrom(
			__DIR__.'/path/to/config/courier.php', 'courier'
		);
	}

## Assets Públicos

Você pode ter assets como JavaScript, CSS e imagens. Para publicar esses assets no diretório `public` da aplicação, use o método `publishes` do service provider. No exemplo a seguir, nós vamos também adicionar uma tag de grupo `public`, que pode ser usada para publicar grupos de assets:

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->publishes([
			__DIR__.'/path/to/assets' => public_path('vendor/courier'),
		], 'public');
	}

Agora, quando o desenvolvedor que usa seu pacote executar o comando Artisan `vendor:publish`, seus assets serão copiados para o local especificado. Se você precisar sobrescrever os assets toda vez que seu pacote for atualizado, você pode usar a flag `--force`.

	php artisan vendor:publish --tag=public --force

Caso queira se certificar que os assets serão sempre atualizados, você pode adicionar esse comando na lista de comandos `post-update-cmd` no seu arquivo `composer.json`.

## Publicando Grupos de Arquivos

Você pode publicar grupos de assets e recursos separadamente. Por exemplo, se quiser que seus usuários possam publicar os arquivos configuração do seu pacote sem forçá-lo a publicar também os assets ao mesmo tempo. Para evitar isso, use tags quando chamar o método `publishes`. Por exemplo, vamos definir dois grupos de publicação no método `boot` do service provider do pacote.

	/**
	 * Perform post-registration booting of services.
	 *
	 * @return void
	 */
	public function boot()
	{
		$this->publishes([
			__DIR__.'/../config/package.php' => config_path('package.php')
		], 'config');

		$this->publishes([
			__DIR__.'/../database/migrations/' => database_path('/migrations')
		], 'migrations');
	}

Agora os usuários poderão publicar esses grupos separadamente, referenciado o nome da tag quando usar o comando Artisan `vendor:publish`:

	php artisan vendor:publish --provider="Vendor\Providers\PackageServiceProvider" --tag="config"


text:
package br.com.senai.stayFilm.vizualizacao.viewModel;

import java.util.Date;

import com.auth0.jwt.internal.com.fasterxml.jackson.annotation.JsonFormat;

import br.com.senai.stayFilm.model.EscalaBloqueioEspecifico;

public class EscalaBloqueioEspecificoVisualizacaoViewModel {

	private Date data;
	private String horario;

	public Date getData() {
		return data;
	}
	public void setData(Date data) {
		this.data = data;
	}
	public String getHorario() {
		return horario;
	}
	public void setHorario(String horario) {
		this.horario = horario+"h";
	}

	/*public String converteData(Date data){
	SimpleDateFormat sdf= new SimpleDateFormat("dd/MM/yyyy");
	String dataToString=sdf.format(new Date());
	return dataToString;
	}*/

	public EscalaBloqueioEspecificoVisualizacaoViewModel(EscalaBloqueioEspecifico escala){
		String horario = escala.getHoraInicio()+ " - "+ escala.getHoraFim();
		setData(escala.getData());
		setHorario(horario);
	}

}


text:
package bankdroid.soda;

import java.io.Serializable;
import java.util.Date;

import bankdroid.soda.bank.Bank;

public class Message implements Serializable
{
	private static final long serialVersionUID = 2119110172022224864L;

	private Bank bank;
	private String code;
	private String message;
	private String originatingAddress;
	private Date timestamp;

	public Message()
	{
		super();
	}

	public Message( final Bank bank, final String message, final Date timestamp, final String originatingAddress,
			final String code )
	{
		super();
		this.bank = bank;
		this.message = message;
		this.timestamp = timestamp;
		this.originatingAddress = originatingAddress;
		this.code = code;
	}

	public Bank getBank()
	{
		return bank;
	}

	public String getCode()
	{
		return code;
	}

	public String getMessage()
	{
		return message;
	}

	public String getOriginatingAddress()
	{
		return originatingAddress;
	}

	public Date getTimestamp()
	{
		return timestamp;
	}

	public void setBank( final Bank bank )
	{
		this.bank = bank;
	}

	public void setCode( final String code )
	{
		this.code = code;
	}

	public void setMessage( final String message )
	{
		this.message = message;
	}

	public void setOriginatingAddress( final String originatingAddress )
	{
		this.originatingAddress = originatingAddress;
	}

	public void setTimestamp( final Date timestamp )
	{
		this.timestamp = timestamp;
	}

}


text:
package ca.xvx.tracks;

public class DuplicateContextException extends Exception {
	private static final long serialVersionUID = 1L;
}


text:
using Esri.ArcGISRuntime.Geometry;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace Ellipsoidus
{

    public class LineLineIntersectionPresenter : GeodesicPresenter
    {

        public LineLineIntersectionPresenter()
        {
            IntersectionPoint = new GeodesicPointPresenter();

            FirstLine = new GeodesicLineSegmentPresenter();
            FirstLine.PropertyChanged += LineChanged;

            SecondLine = new GeodesicLineSegmentPresenter();
            SecondLine.PropertyChanged += LineChanged;

            Init();
        }

        private bool _disableLineChanged = false;
        void LineChanged(object sender, PropertyChangedEventArgs e)
        {
            if (_disableLineChanged)
                return;

            var pt = FirstLine.Line.IntersectionPoint(SecondLine.Line);
            IntersectionPoint.Point = pt.Cast("IntersectionPoint");
            NotifyPropertyChanged("IntersectionPoint");
        }

        public GeodesicLineSegmentPresenter FirstLine { get; private set; }
        public GeodesicLineSegmentPresenter SecondLine { get; private set; }
        public GeodesicPointPresenter IntersectionPoint { get; private set; }

        public Envelope Extent()
        {
            var res = FirstLine.Line.Extent;
            res = res.Union(SecondLine.Line.Extent);
            res = res.Union(IntersectionPoint.Point);

            return res;
        }

        internal void Init()
        {
            _disableLineChanged = true;

            FirstLine.StartPoint.Point = Presenter.RandomPoint("L1.Start");
            FirstLine.EndPoint.Point = Presenter.RandomPoint("L1.End");

            SecondLine.StartPoint.Point = Presenter.RandomPoint("L2.Start");
            SecondLine.EndPoint.Point = Presenter.RandomPoint("L2.End");

            _disableLineChanged = false;
            LineChanged(this, null);
        }
    }
}


text:
define({
  "chartTasks": "Diagrammi toimingud",
  "addNew": "Lisa uus",
  "addNewTip": "Lisa uus diagrammi toiming",
  "name": "Nimi",
  "set": "Määra",
  "setDataSource": "Määra andmeallikas",
  "generalSettingsTip": "Saate määrata diagrammide andmeallikad, pealkirjad ja kirjeldused.",
  "chartModeSettingTip": "Saate valida andmete analüüsimise ja diagrammina kuvamise viisi.",
  "detailsSettingTip": "Saate muuta diagrammi tüüpi, värvi ja valida kuvatavad väärtused:",
  "symbolSettingTip": "Saate määrata diagrammile kantud andmete kaardil esitamise viisi.",
  "addFilterTip": "Saate lisada nendele andmetele filtri.",
  "dataSource": "Andmeallikas",
  "noResults": "Objekte ei leitud.",
  "chartTitle": "Diagrammi pealkiri",
  "description": "Kirjeldus",
  "chartingMode": "Diagrammi kuva",
  "featureOption": "Kuva väärtused objektide kaupa",
  "categoryOption": "Kuva väärtused kategooriate kaupa",
  "countOption": "Kuva objektide kogused kategooriate kaupa",
  "fieldOption": "Kuva atribuutide väärtused diagrammidena",
  "category": "Kategooria",
  "axisLabel": "Kategooria märgis",
  "categoryField": "Kategooria väli",
  "operation": "Toiming",
  "originalOption": "Kasuta algväärtusi",
  "sumOption": "Summa",
  "averageOption": "Keskmine",
  "minOption": "Miinimum",
  "maxOption": "Maksimaalne",
  "valueFields": "Väärtuste väljad",
  "moveUp": "Liiguta ülespoole",
  "moveDown": "Liiguta allapoole",
  "sortOrder": "Sordi diagrammid kategooria märgiste põhjal",
  "ascending": "Kasvav",
  "descending": "Kahanev",
  "chartType": "Diagrammi tüüp",
  "column": "Tulpdiagramm",
  "bar": "Lintdiagramm",
  "line": "Joondiagramm",
  "pie": "Sektordiagramm",
  "chartColor": "Diagrammi värv",
  "showDataLabels": "Kuva andmete märgised",
  "setSymbol": "Valiku sümbol",
  "setHighLightColor": "Esiletõstmise värv",
  "settings": "Seaded",
  "mapInterationOptions": "Kaardi interaktsiooni valikud",
  "preview": "Eelvaade",
  "ok": "OK",
  "cancel": "Tühista",
  "close": "Sulge",
  "setFilterTip": "Määrake filter õigesti. ",
  "setChartTitleTip": "Määrake diagrammi pealkiri.",
  "setChartTypeTip": "Valige vähemalt üks diagrammitüüp.",
  "setDataFieldTip": "Valige vähemalt üks väärtuse väli.",
  "setOutputFieldTip": "Määrake väljundi väljad.",
  "count": "Kogus",
  "label": "Märgis",
  "horizontalAxis": "Horisontaaltelg",
  "verticalAxis": "Vertikaaltelg",
  "dataLabels": "Andmete märgised",
  "color": "Värv",
  "colorful": "Värviline",
  "monochromatic": "Ühevärviline",
  "noTaskTip": "Uue diagrammitoimingu lisamiseks klõpsake käsku Lisa uus",
  "info": "Teave",
  "charts": "Graafikud",
  "options": "Seaded",
  "taskName": "Ülesande nimi",
  "summary": "Kokkuvõte",
  "resultDescription": "Tulemuse kirjeldus",
  "spatialFilterTip": "Valige vidinas tulemuste piiramiseks ruumiline filter (filtrid).",
  "defaultOption": "Vaikimisi",
  "useCurrentExtentTip": "Osaliselt või täielikult praeguses kaardi kuvaulatuses",
  "useDrawGraphicTip": "Osaliselt või täielikult kaardile joonistatud kujundis",
  "useFeaturesTip": "Vastavalt nende asukohale teise kihi objektide suhtes",
  "noSpatialLimitTip": "Ära piira tulemusi ruumiliselt",
  "drawingTools": "Joonistamise töövahendid",
  "bufferSettings": "Puhvri seaded",
  "defaultDistance": "Vaike-vahemaa",
  "bufferDistance": "Puhvri ulatus",
  "defaultUnit": "Vaikeühik",
  "miles": "Miilid",
  "kilometers": "Kilomeetrid",
  "feet": "Jalad",
  "meters": "Meetrid",
  "yards": "Jardid",
  "nauticalMiles": "Meremiilid",
  "availableSpatialRelationships": "Saadaolevad ruumilised seosed",
  "setSpatialRelationships": "Määra ruumilised seosed",
  "availability": "Saadavus",
  "relationship": "Seos",
  "actions": "Toimingud",
  "intersect": "lõikuvad",
  "contain": "sisaldavad",
  "areContainedIn": "sisalduvad",
  "cross": "rist",
  "envelopeIntersect": "lõikuvad ümbrisega",
  "overlap": "kattuvad",
  "areOverlapped": "kaetakse",
  "touche": "puutuvad kokku",
  "within": "vahemikus",
  "areWithin": "on vahemikus",
  "indexIntersect": "lõikuvad indeksiga"
});


text:
@class AMContentDescription;
@class AMPeer;

@interface AMNotification : NSObject

#pragma mark Public

- (instancetype)initWithAMPeer:(AMPeer *)peer
                       withInt:(jint)sender
      withAMContentDescription:(AMContentDescription *)contentDescription;

- (AMContentDescription *)getContentDescription;

- (AMPeer *)getPeer;

- (jint)getSender;

@end

J2OBJC_EMPTY_STATIC_INIT(AMNotification)

FOUNDATION_EXPORT void AMNotification_initWithAMPeer_withInt_withAMContentDescription_(AMNotification *self, AMPeer *peer, jint sender, AMContentDescription *contentDescription);

FOUNDATION_EXPORT AMNotification *new_AMNotification_initWithAMPeer_withInt_withAMContentDescription_(AMPeer *peer, jint sender, AMContentDescription *contentDescription) NS_RETURNS_RETAINED;

J2OBJC_TYPE_LITERAL_HEADER(AMNotification)

typedef AMNotification ImActorModelEntityNotification;

#endif // _AMNotification_H_


text:
package org.whale.system.api;

import java.util.List;
import java.util.Map;

import org.whale.system.domain.Dict;
import org.whale.system.domain.DictItem;

/**
 * 字典接口
 *
 * @author wjs
 *
 */
public interface IDictIntf {

	public Dict getDict(String dictCode);

	public List<DictItem> getItemsByDictCode(String dictCode, boolean noDisabled);

	public DictItem getByDictCodeAndItemCode(String dictCode, String itemCode);

	public String getItemValue(String dictCode, String itemCode);

	public String getItemValueExt(String dictCode, String itemCode);

	public Integer getItemIntValue(String dictCode, String itemCode);

	public String getItemLabel(String dictCode, String itemCode);

	public boolean hasItemValue(String dictCode, String value);

	public boolean isValue(String dictCode, String itemCode, String value);

	public Map<String, Object> getMap(String dictCode);

	public String getMapJson(String dictCode);
}


text:
package org.votesmart.classes;

import org.votesmart.api.*;
import org.votesmart.data.AddressAddress;
import org.votesmart.data.AddressOffice;
import org.votesmart.data.WebAddress;

/**
 *

 * Address Class
 * * - Required
 * * - Multiple rows
 *
 * Address.getCampaign
 * This method grabs campaign office(s) and basic candidate information for the specified candidate.
 * Input: candidateId*
 * Output: {@link AddressOffice}
 *
 * Address.getCampaignWebAddress
 * This method grabs the campaign office's Web address(es) and basic candidate information for the specified candidate.
 * Input: candidateId*
 * Output: {@link WebAddress}
 *
 * Address.getCampaignByElection
 * This method grabs campaign office(s) and basic candidate information for the specified election.
 * Input: electionId*
 * Output: {@link AddressOffice}
 *
 * Address.getOffice
 * This method grabs office(s) and basic candidate information for the specified candidate.
 * Input: candidateId*
 * Output: {@link AddressOffice}
 *
 * Address.getOfficeWebAddress
 * This method grabs office's Web address(es) and basic candidate information for the specified candidate.
 * Input: candidateId*
 * Output: {@link WebAddress}
 *
 * Address.getOfficeByOfficeState
 * This method grabs office address and basic candidate information according to the officeId and state.
 * Input: officeId*, stateId (Default: 'NA')
 * Output: {@link AddressAddress}
 *
 * ==== EXAMPLE USAGE =====
 *
 * AddressClass addressClass = new AddressClass();
 *
 * // address of Office (State Assembly)
 * AddressAddress addressOffice = addressClass.getOfficeByOfficeState(office.officeId, state.stateId);
 *
 * // address of Official
 * AddressOffice addressOffical = addressClass.getOffice(candidate.candidateId)
 *
 * // WebAddress of Official
 * WebAddress webAddressOffical = addressClass.getOfficeWebAddress(candidate.candidateId);
 *

 */
public class AddressClass extends ClassesBase {

	/**
	 * Constructor for testing purposes.
	 *
	 * @param api
	 */
	public AddressClass(VoteSmartAPI api) {
		super(api);
	}

	/**
	 * Default constructor
	 */
	public AddressClass() throws VoteSmartException {
		super();
	}

	/**
	 * This method grabs campaign office(s) and basic candidate information for the specified candidate.
	 *
	 * @param candidateId
	 * @return {@link AddressOffice}: address and list of office addresses.
	 */
	public AddressOffice getCampaign(String candidateId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getCampaign", new ArgMap("candidateId", candidateId), AddressOffice.class );
	}

	/**
	 * This method grabs the campaign office's Web address(es) and basic candidate information for the specified candidate.
	 *
	 * @param candidateId
	 * @return {@link WebAddress}: Candidate name and URL's
	 */
	public WebAddress getCampaignWebAddress(String candidateId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getCampaignWebAddress", new ArgMap("candidateId", candidateId), WebAddress.class );
	}

	/**
	 * This method grabs campaign office(s) and basic candidate information for the specified election.
	 *
	 * @param electionId
	 * @return {@link AddressOffice}: Candidate name and list of office addresses
	 */
	public AddressOffice getCampaignByElection(String electionId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getCampaignByElection", new ArgMap("electionId", electionId), AddressOffice.class );
	}

	/**
	 * This method grabs office(s) and basic candidate information for the specified candidate.
	 *
	 * @param candidateId
	 * @return {@link AddressOffice}: Candidate name and list of office addresses
	 */
	public AddressOffice getOffice(String candidateId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getOffice", new ArgMap("candidateId", candidateId), AddressOffice.class );
	}

	/**
	 * This method grabs office's Web address(es) and basic candidate information for the specified candidate.
	 *
	 * @param candidateId
	 * @return {@link WebAddress}: Candidate name and list of URL's
	 */
	public WebAddress getOfficeWebAddress(String candidateId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getOfficeWebAddress", new ArgMap("candidateId", candidateId), WebAddress.class );
	}

	/**
	 * This method grabs office address and basic candidate information according to the officeId and state.
	 *
	 * @param officeId
	 * @return {@link AddressAddress}: Candidate name and list of offices
	 */
	public AddressAddress getOfficeByOfficeState(String officeId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getOfficeByOfficeState", new ArgMap("officeId", officeId), AddressAddress.class );
	}

	/**
	 * This method grabs office address and basic candidate information according to the officeId and state.
	 *
	 * @param officeId
	 * @param stateId
	 * @return {@link AddressAddress}: Candidate name and list of offices
	 */
	public AddressAddress getOfficeByOfficeState(String officeId, String stateId) throws VoteSmartException, VoteSmartErrorException {
		return api.query("Address.getOfficeByOfficeState", new ArgMap("officeId", officeId, "stateId", stateId), AddressAddress.class );
	}

}


text:
import re

try:
    from _scss import Scanner, NoMoreTokens
except ImportError:
    Scanner = None

################################################################################
# Parser

if not Scanner:
    class NoMoreTokens(Exception):
        """
        Another exception object, for when we run out of tokens
        """
        pass

    class Scanner(object):
        def __init__(self, patterns, ignore, input=None):
            """
            Patterns is [(terminal,regex)...]
            Ignore is [terminal,...];
            Input is a string
            """
            self.reset(input)
            self.ignore = ignore
            # The stored patterns are a pair (compiled regex,source
            # regex).  If the patterns variable passed in to the
            # constructor is None, we assume that the class already has a
            # proper .patterns list constructed
            if patterns is not None:
                self.patterns = []
                for k, r in patterns:
                    self.patterns.append((k, re.compile(r)))

        def reset(self, input):
            self.tokens = []
            self.restrictions = []
            self.input = input
            self.pos = 0

        def __repr__(self):
            """
            Print the last 10 tokens that have been scanned in
            """
            output = ''
            for t in self.tokens[-10:]:
                output = "%s\n  (@%s)  %s  =  %s" % (output, t[0], t[2], repr(t[3]))
            return output

        def _scan(self, restrict):
            """
            Should scan another token and add it to the list, self.tokens,
            and add the restriction to self.restrictions
            """
            # Keep looking for a token, ignoring any in self.ignore
            token = None
            while True:
                best_pat = None
                # Search the patterns for a match, with earlier
                # tokens in the list having preference
                best_pat_len = 0
                for p, regexp in self.patterns:
                    # First check to see if we're restricting to this token
                    if restrict and p not in restrict and p not in self.ignore:
                        continue
                    m = regexp.match(self.input, self.pos)
                    if m:
                        # We got a match
                        best_pat = p
                        best_pat_len = len(m.group(0))
                        break

                # If we didn't find anything, raise an error
                if best_pat is None:
                    msg = "Bad Token"
                    if restrict:
                        msg = "Trying to find one of " + ", ".join(restrict)
                    raise SyntaxError("SyntaxError[@ char %s: %s]" % (repr(self.pos), msg))

                # If we found something that isn't to be ignored, return it
                if best_pat in self.ignore:
                    # This token should be ignored...
                    self.pos += best_pat_len
                else:
                    end_pos = self.pos + best_pat_len
                    # Create a token with this data
                    token = (
                        self.pos,
                        end_pos,
                        best_pat,
                        self.input[self.pos:end_pos]
                    )
                    break
            if token is not None:
                self.pos = token[1]
                # Only add this token if it's not in the list
                # (to prevent looping)
                if not self.tokens or token != self.tokens[-1]:
                    self.tokens.append(token)
                    self.restrictions.append(restrict)
                    return 1
            return 0

        def token(self, i, restrict=None):
            """
            Get the i'th token, and if i is one past the end, then scan
            for another token; restrict is a list of tokens that
            are allowed, or 0 for any token.
            """
            tokens_len = len(self.tokens)
            if i == tokens_len:  # We are at the end, get the next...
                tokens_len += self._scan(restrict)
            if i < tokens_len:
                if restrict and self.restrictions[i] and restrict > self.restrictions[i]:
                    raise NotImplementedError("Unimplemented: restriction set changed")
                return self.tokens[i]
            raise NoMoreTokens

        def rewind(self, i):
            tokens_len = len(self.tokens)
            if i <= tokens_len:
                token = self.tokens[i]
                self.tokens = self.tokens[:i]
                self.restrictions = self.restrictions[:i]
                self.pos = token[0]

class CachedScanner(Scanner):
    """
    Same as Scanner, but keeps cached tokens for any given input
    """
    _cache_ = {}
    _goals_ = ['END']

    @classmethod
    def cleanup(cls):
        cls._cache_ = {}

    def __init__(self, patterns, ignore, input=None):
        try:
            self._tokens = self._cache_[input]
        except KeyError:
            self._tokens = None
            self.__tokens = {}
            self.__input = input
            super(CachedScanner, self).__init__(patterns, ignore, input)

    def reset(self, input):
        try:
            self._tokens = self._cache_[input]
        except KeyError:
            self._tokens = None
            self.__tokens = {}
            self.__input = input
            super(CachedScanner, self).reset(input)

    def __repr__(self):
        if self._tokens is None:
            return super(CachedScanner, self).__repr__()
        output = ''
        for t in self._tokens[-10:]:
            output = "%s\n  (@%s)  %s  =  %s" % (output, t[0], t[2], repr(t[3]))
        return output

    def token(self, i, restrict=None):
        if self._tokens is None:
            token = super(CachedScanner, self).token(i, restrict)
            self.__tokens[i] = token
            if token[2] in self._goals_:  # goal tokens
                self._cache_[self.__input] = self._tokens = self.__tokens
            return token
        else:
            token = self._tokens.get(i)
            if token is None:
                raise NoMoreTokens
            return token

    def rewind(self, i):
        if self._tokens is None:
            super(CachedScanner, self).rewind(i)

class Parser(object):
    def __init__(self, scanner):
        self._scanner = scanner
        self._pos = 0

    def reset(self, input):
        self._scanner.reset(input)
        self._pos = 0

    def _peek(self, types):
        """
        Returns the token type for lookahead; if there are any args
        then the list of args is the set of token types to allow
        """
        tok = self._scanner.token(self._pos, types)
        return tok[2]

    def _scan(self, type):
        """
        Returns the matched text, and moves to the next token
        """
        tok = self._scanner.token(self._pos, set([type]))
        if tok[2] != type:
            raise SyntaxError("SyntaxError[@ char %s: %s]" % (repr(tok[0]), "Trying to find " + type))
        self._pos += 1
        return tok[3]

    def _rewind(self, n=1):
        self._pos -= min(n, self._pos)
        self._scanner.rewind(self._pos)

################################################################################

def print_error(input, err, scanner):
    """This is a really dumb long function to print error messages nicely."""
    p = err.pos
    # Figure out the line number
    line = input[:p].count('\n')
    print err.msg + " on line " + repr(line + 1) + ":"
    # Now try printing part of the line
    text = input[max(p - 80, 0):
        p + 80]
    p = p - max(p - 80, 0)

    # Strip to the left
    i = text[:p].rfind('\n')
    j = text[:p].rfind('\r')
    if i < 0 or (0 <= j < i):
        i = j
    if 0 <= i < p:
        p = p - i - 1
        text = text[i + 1:]

    # Strip to the right
    i = text.find('\n', p)
    j = text.find('\r', p)
    if i < 0 or (0 <= j < i):
        i = j
    if i >= 0:
        text = text[:i]

    # Now shorten the text
    while len(text) > 70 and p > 60:
        # Cut off 10 chars
        text = "..." + text[10:]
        p = p - 7

    # Now print the string, along with an indicator
    print '> ', text
    print '> ', ' ' * p + '^'
    print 'List of nearby tokens:', scanner

def wrap_error_reporter(parser, rule, *args):
    try:
        return getattr(parser, rule)(*args)
    except SyntaxError, s:
        input = parser._scanner.input
        try:
            print_error(input, s, parser._scanner)
            raise
        except ImportError:
            print "Syntax Error %s on line %d" % (s.msg, input[:s.pos].count('\n') + 1)
    except NoMoreTokens:
        print "Could not complete parsing; stopped around here:"
        print parser._scanner


text:
package org.apache.xalan.transformer;

public class MsgMgr
{
  // Constructors

  public MsgMgr(TransformerImpl arg1){
  }
  // Methods

  public void error(javax.xml.transform.SourceLocator arg1, java.lang.String arg2) throws javax.xml.transform.TransformerException{
  }
  public void error(javax.xml.transform.SourceLocator arg1, java.lang.String arg2, java.lang.Object [] arg3) throws javax.xml.transform.TransformerException{
  }
  public void error(javax.xml.transform.SourceLocator arg1, java.lang.String arg2, java.lang.Exception arg3) throws javax.xml.transform.TransformerException{
  }
  public void error(javax.xml.transform.SourceLocator arg1, java.lang.String arg2, java.lang.Object [] arg3, java.lang.Exception arg4) throws javax.xml.transform.TransformerException{
  }
  public void error(javax.xml.transform.SourceLocator arg1, org.w3c.dom.Node arg2, org.w3c.dom.Node arg3, java.lang.String arg4) throws javax.xml.transform.TransformerException{
  }
  public void error(javax.xml.transform.SourceLocator arg1, org.w3c.dom.Node arg2, org.w3c.dom.Node arg3, java.lang.String arg4, java.lang.Object [] arg5) throws javax.xml.transform.TransformerException{
  }
  public void warn(javax.xml.transform.SourceLocator arg1, java.lang.String arg2) throws javax.xml.transform.TransformerException{
  }
  public void warn(javax.xml.transform.SourceLocator arg1, java.lang.String arg2, java.lang.Object [] arg3) throws javax.xml.transform.TransformerException{
  }
  public void warn(javax.xml.transform.SourceLocator arg1, org.w3c.dom.Node arg2, org.w3c.dom.Node arg3, java.lang.String arg4) throws javax.xml.transform.TransformerException{
  }
  public void warn(javax.xml.transform.SourceLocator arg1, org.w3c.dom.Node arg2, org.w3c.dom.Node arg3, java.lang.String arg4, java.lang.Object [] arg5) throws javax.xml.transform.TransformerException{
  }
  public void message(javax.xml.transform.SourceLocator arg1, java.lang.String arg2, boolean arg3) throws javax.xml.transform.TransformerException{
  }
}


text:
#include "WProgram.h"
#include "FreeMemory.h"

extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;
extern unsigned int __data_start;

/// return available RAM
int freeMemory1()
{
	/// copy from http://arduino.cc/playground/Code/AvailableMemory
	int free_memory;

	if ((int) __brkval == 0)
		free_memory = ((int) &free_memory) - ((int) &__bss_end);
	else
		free_memory = ((int) &free_memory) - ((int) __brkval);

	return free_memory;
}

/// return available RAM
/*! This function places the current value of the heap and stack pointers in the
 * variables. You can call it from any place in your code and save the data for
 * outputting or displaying later. This allows you to check at different parts of
 * your program flow.
 * The stack pointer starts at the top of RAM and grows downwards. The heap pointer
 * starts just above the static variables etc. and grows upwards. SP should always
 * be larger than HP or you'll be in big trouble! The smaller the gap, the more
 * careful you need to be. Julian Gall 6-Feb-2009.
 */
int freeMemory2()
{
	/// copy from http://arduino.cc/playground/Code/AvailableMemory
	uint8_t * heapptr, *stackptr;

	stackptr = (uint8_t *) malloc(4); // use stackptr temporarily
	heapptr = stackptr; // save value of heap pointer
	free(stackptr); // free up the memory again (sets stackptr to 0)
	stackptr = (uint8_t *) (SP); // save value of stack pointer
	return (int) (stackptr - heapptr);
}

/// return available RAM

/// this function will return the number of bytes currently free in RAM
/// written by David A. Mellis
/// based on code by Rob Faludi http://www.faludi.com
int freeMemory3()
{
	/// copy from http://arduino.cc/playground/Code/AvailableMemory
	int size = (int) RAMEND - (int) &__data_start;
	byte *buf;

	while ((buf = (byte *) malloc(--size)) == NULL)
		;

	free(buf);

	return size;
}


text:
package org.springframework.boot.actuate.endpoint.invoke.reflect;

import java.lang.reflect.Method;

import org.junit.Test;

import org.springframework.boot.actuate.endpoint.OperationType;
import org.springframework.boot.actuate.endpoint.invoke.OperationParameters;
import org.springframework.util.ReflectionUtils;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;

/**
 * Tests for {@link OperationMethod}.
 *
 * @author Phillip Webb
 */
public class OperationMethodTests {

	private Method exampleMethod = ReflectionUtils.findMethod(getClass(), "example",
			String.class);

	@Test
	public void createWhenMethodIsNullShouldThrowException() {
		assertThatIllegalArgumentException()
				.isThrownBy(() -> new OperationMethod(null, OperationType.READ))
				.withMessageContaining("Method must not be null");
	}

	@Test
	public void createWhenOperationTypeIsNullShouldThrowException() {
		assertThatIllegalArgumentException()
				.isThrownBy(() -> new OperationMethod(this.exampleMethod, null))
				.withMessageContaining("OperationType must not be null");
	}

	@Test
	public void getMethodShouldReturnMethod() {
		OperationMethod operationMethod = new OperationMethod(this.exampleMethod,
				OperationType.READ);
		assertThat(operationMethod.getMethod()).isEqualTo(this.exampleMethod);
	}

	@Test
	public void getOperationTypeShouldReturnOperationType() {
		OperationMethod operationMethod = new OperationMethod(this.exampleMethod,
				OperationType.READ);
		assertThat(operationMethod.getOperationType()).isEqualTo(OperationType.READ);
	}

	@Test
	public void getParametersShouldReturnParameters() {
		OperationMethod operationMethod = new OperationMethod(this.exampleMethod,
				OperationType.READ);
		OperationParameters parameters = operationMethod.getParameters();
		assertThat(parameters.getParameterCount()).isEqualTo(1);
		assertThat(parameters.iterator().next().getName()).isEqualTo("name");
	}

	String example(String name) {
		return name;
	}

}


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

<TITLE>
Uses of Class com.google.flightmap.common.db.AbstractAirportDirectory (Flight Map common)
</TITLE>

<META NAME="date" CONTENT="2011-02-02">

<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
com.google.flightmap.common.db.AbstractAirportDirectory

Packages that use AbstractAirportDirectory

com.google.flightmap.common.db

Uses of AbstractAirportDirectory in com.google.flightmap.common.db

Subclasses of AbstractAirportDirectory in com.google.flightmap.common.db

 class
CachedAirportDirectory

          Caches access to AirportDirectory for improved performance.

 class
CustomGridAirportDirectory

          High level interface to the aviation database based on the spatial indexing methods in
 CustomGridUtil.

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes