text:
#include "channel1.h"
#include "../savestate.h"
#include <algorithm>

namespace gambatte {

Channel1::SweepUnit::SweepUnit(MasterDisabler &disabler, DutyUnit &dutyUnit) :
	disableMaster(disabler),
	dutyUnit(dutyUnit),
	shadow(0),
	nr0(0),
	negging(false)
{}

unsigned Channel1::SweepUnit::calcFreq() {
	unsigned freq = shadow >> (nr0 & 0x07);

	if (nr0 & 0x08) {
		freq = shadow - freq;
		negging = true;
	} else
		freq = shadow + freq;

	if (freq & 2048)
		disableMaster();

	return freq;
}

void Channel1::SweepUnit::event() {
	const unsigned long period = nr0 >> 4 & 0x07;

	if (period) {
		const unsigned freq = calcFreq();

		if (!(freq & 2048) && (nr0 & 0x07)) {
			shadow = freq;
			dutyUnit.setFreq(freq, counter);
			calcFreq();
		}

		counter += period << 14;
	} else
		counter += 8ul << 14;
}

void Channel1::SweepUnit::nr0Change(const unsigned newNr0) {
	if (negging && !(newNr0 & 0x08))
		disableMaster();

	nr0 = newNr0;
}

void Channel1::SweepUnit::nr4Init(const unsigned long cc) {
	negging = false;
	shadow = dutyUnit.getFreq();

	const unsigned period = nr0 >> 4 & 0x07;
	const unsigned shift = nr0 & 0x07;

	if (period | shift)
		counter = ((cc >> 14) + (period ? period : 8)) << 14;
	else
		counter = COUNTER_DISABLED;

	if (shift)
		calcFreq();
}

void Channel1::SweepUnit::reset() {
	counter = COUNTER_DISABLED;
}

void Channel1::SweepUnit::loadState(const SaveState &state) {
	counter = std::max(state.spu.ch1.sweep.counter, state.spu.cycleCounter);
	shadow = state.spu.ch1.sweep.shadow;
	nr0 = state.spu.ch1.sweep.nr0;
	negging = state.spu.ch1.sweep.negging;
}

template<bool isReader>
void Channel1::SweepUnit::SyncState(NewState *ns)
{
	NSS(counter);
	NSS(shadow);
	NSS(nr0);
	NSS(negging);
}

Channel1::Channel1() :
	staticOutputTest(*this, dutyUnit),
	disableMaster(master, dutyUnit),
	lengthCounter(disableMaster, 0x3F),
	envelopeUnit(staticOutputTest),
	sweepUnit(disableMaster, dutyUnit),
	cycleCounter(0),
	soMask(0),
	prevOut(0),
	nr4(0),
	master(false)
{
	setEvent();
}

void Channel1::setEvent() {
// 	nextEventUnit = &dutyUnit;
// 	if (sweepUnit.getCounter() < nextEventUnit->getCounter())
		nextEventUnit = &sweepUnit;
	if (envelopeUnit.getCounter() < nextEventUnit->getCounter())
		nextEventUnit = &envelopeUnit;
	if (lengthCounter.getCounter() < nextEventUnit->getCounter())
		nextEventUnit = &lengthCounter;
}

void Channel1::setNr0(const unsigned data) {
	sweepUnit.nr0Change(data);
	setEvent();
}

void Channel1::setNr1(const unsigned data) {
	lengthCounter.nr1Change(data, nr4, cycleCounter);
	dutyUnit.nr1Change(data, cycleCounter);

	setEvent();
}

void Channel1::setNr2(const unsigned data) {
	if (envelopeUnit.nr2Change(data))
		disableMaster();
	else
		staticOutputTest(cycleCounter);

	setEvent();
}

void Channel1::setNr3(const unsigned data) {
	dutyUnit.nr3Change(data, cycleCounter);
	setEvent();
}

void Channel1::setNr4(const unsigned data) {
	lengthCounter.nr4Change(nr4, data, cycleCounter);

	nr4 = data;

	dutyUnit.nr4Change(data, cycleCounter);

	if (data & 0x80) { //init-bit
		nr4 &= 0x7F;
		master = !envelopeUnit.nr4Init(cycleCounter);
		sweepUnit.nr4Init(cycleCounter);
		staticOutputTest(cycleCounter);
	}

	setEvent();
}

void Channel1::setSo(const unsigned long soMask) {
	this->soMask = soMask;
	staticOutputTest(cycleCounter);
	setEvent();
}

void Channel1::reset() {
	cycleCounter = 0x1000 | (cycleCounter & 0xFFF); // cycleCounter >> 12 & 7 represents the frame sequencer position.

// 	lengthCounter.reset();
	dutyUnit.reset();
	envelopeUnit.reset();
	sweepUnit.reset();

	setEvent();
}

void Channel1::init(const bool cgb) {
	lengthCounter.init(cgb);
}

void Channel1::loadState(const SaveState &state) {
	sweepUnit.loadState(state);
	dutyUnit.loadState(state.spu.ch1.duty, state.mem.ioamhram.get()[0x111], state.spu.ch1.nr4, state.spu.cycleCounter);
	envelopeUnit.loadState(state.spu.ch1.env, state.mem.ioamhram.get()[0x112], state.spu.cycleCounter);
	lengthCounter.loadState(state.spu.ch1.lcounter, state.spu.cycleCounter);

	cycleCounter = state.spu.cycleCounter;
	nr4 = state.spu.ch1.nr4;
	master = state.spu.ch1.master;
}

void Channel1::update(uint_least32_t *buf, const unsigned long soBaseVol, unsigned long cycles) {
	const unsigned long outBase = envelopeUnit.dacIsOn() ? soBaseVol & soMask : 0;
	const unsigned long outLow = outBase * (0 - 15ul);
	const unsigned long endCycles = cycleCounter + cycles;

	for (;;) {
		const unsigned long outHigh = master ? outBase * (envelopeUnit.getVolume() * 2 - 15ul) : outLow;
		const unsigned long nextMajorEvent = nextEventUnit->getCounter() < endCycles ? nextEventUnit->getCounter() : endCycles;
		unsigned long out = dutyUnit.isHighState() ? outHigh : outLow;

		while (dutyUnit.getCounter() <= nextMajorEvent) {
			*buf = out - prevOut;
			prevOut = out;
			buf += dutyUnit.getCounter() - cycleCounter;
			cycleCounter = dutyUnit.getCounter();

			dutyUnit.event();
			out = dutyUnit.isHighState() ? outHigh : outLow;
		}

		if (cycleCounter < nextMajorEvent) {
			*buf = out - prevOut;
			prevOut = out;
			buf += nextMajorEvent - cycleCounter;
			cycleCounter = nextMajorEvent;
		}

		if (nextEventUnit->getCounter() == nextMajorEvent) {
			nextEventUnit->event();
			setEvent();
		} else
			break;
	}

	if (cycleCounter & SoundUnit::COUNTER_MAX) {
		dutyUnit.resetCounters(cycleCounter);
		lengthCounter.resetCounters(cycleCounter);
		envelopeUnit.resetCounters(cycleCounter);
		sweepUnit.resetCounters(cycleCounter);

		cycleCounter -= SoundUnit::COUNTER_MAX;
	}
}

SYNCFUNC(Channel1)
{
	SSS(lengthCounter);
	SSS(dutyUnit);
	SSS(envelopeUnit);
	SSS(sweepUnit);

	EBS(nextEventUnit, 0);
	EVS(nextEventUnit, &dutyUnit, 1);
	EVS(nextEventUnit, &sweepUnit, 2);
	EVS(nextEventUnit, &envelopeUnit, 3);
	EVS(nextEventUnit, &lengthCounter, 4);
	EES(nextEventUnit, NULL);

	NSS(cycleCounter);
	NSS(soMask);
	NSS(prevOut);

	NSS(nr4);
	NSS(master);
}

}


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>psidev.psi.mi.jami.analysis.graph.model (PSI :: JAMI - Java framework for molecular interactions 3.2.12 API)</title>
<meta name="date" content="2021-08-20">
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">

psidev.psi.mi.jami.analysis.graph.model

Interfaces

MIEdge

Classes

AbstractMIEdge

BindingFeatureGraph

BindingPair

redpajama_set_name: RedPajamaGithub


text:
/**
 * Message Driven Bean classes for the transport core.
 */
package energy.usef.core.service.mdb;


text:
from django.forms import ModelForm, Textarea

from .models import Record

class RecordForm(ModelForm):
    class Meta:
        model = Record
        fields = ['title', 'username', 'email', 'url',
                  'password', 'notes']
        widgets = {'notes': Textarea(
            attrs={'cols': 40, 'rows': 4})}


text:
package local

import (
	"fmt"
	"math/rand"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/coreos/mantle/Godeps/_workspace/src/github.com/vishvananda/netlink"
	"github.com/coreos/mantle/Godeps/_workspace/src/github.com/vishvananda/netns"
	"github.com/coreos/mantle/network"
	"github.com/coreos/mantle/network/ntp"
	"github.com/coreos/mantle/system/exec"
)

type LocalCluster struct {
	Dnsmasq    *Dnsmasq
	NTPServer  *ntp.Server
	SSHAgent   *network.SSHAgent
	SimpleEtcd *SimpleEtcd
	nshandle   netns.NsHandle
}

func NewLocalCluster() (*LocalCluster, error) {
	lc := &LocalCluster{}

	var err error
	lc.nshandle, err = NsCreate()
	if err != nil {
		return nil, err
	}

	dialer := NewNsDialer(lc.nshandle)
	lc.SSHAgent, err = network.NewSSHAgent(dialer)
	if err != nil {
		lc.nshandle.Close()
		return nil, err
	}

	// dnsmasq and etcd much be lunched in the new namespace
	nsExit, err := NsEnter(lc.nshandle)
	if err != nil {
		return nil, err
	}
	defer nsExit()

	lc.Dnsmasq, err = NewDnsmasq()
	if err != nil {
		lc.nshandle.Close()
		return nil, err
	}

	lc.SimpleEtcd, err = NewSimpleEtcd()
	if err != nil {
		lc.Dnsmasq.Destroy()
		lc.nshandle.Close()
		return nil, err
	}

	lc.NTPServer, err = ntp.NewServer(":123")
	if err != nil {
		lc.Dnsmasq.Destroy()
		lc.SimpleEtcd.Destroy()
		lc.nshandle.Close()
		return nil, err
	}
	go lc.NTPServer.Serve()

	return lc, nil
}

func (lc *LocalCluster) NewCommand(name string, arg ...string) exec.Cmd {
	cmd := NewNsCommand(lc.nshandle, name, arg...)
	sshEnv := fmt.Sprintf("SSH_AUTH_SOCK=%s", lc.SSHAgent.Socket)
	cmd.Env = append(cmd.Env, sshEnv)
	return cmd
}

func (lc *LocalCluster) EtcdEndpoint() string {
	// hackydoo
	bridge := "br0"
	for _, seg := range lc.Dnsmasq.Segments {
		if bridge == seg.BridgeName {
			return fmt.Sprintf("http://%s:%d", seg.BridgeIf.DHCPv4[0].IP, lc.SimpleEtcd.Port)
		}
	}
	panic("Not a valid bridge!")
}

func (lc *LocalCluster) GetDiscoveryURL(size int) (string, error) {
	baseURL := fmt.Sprintf("%v/v2/keys/discovery/%v", lc.EtcdEndpoint(), rand.Int())

	nsDialer := NewNsDialer(lc.nshandle)
	tr := &http.Transport{
		Dial: nsDialer.Dial,
	}
	client := &http.Client{Transport: tr}

	body := strings.NewReader(url.Values{"value": {strconv.Itoa(size)}}.Encode())
	req, err := http.NewRequest("PUT", baseURL+"/_config/size", body)
	if err != nil {
		return "", fmt.Errorf("setting discovery url failed: %v\n", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("setting discovery url failed: %v\n", err)
	}
	defer resp.Body.Close()

	return baseURL, nil
}

func (lc *LocalCluster) NewTap(bridge string) (*TunTap, error) {
	nsExit, err := NsEnter(lc.nshandle)
	if err != nil {
		return nil, err
	}
	defer nsExit()

	tap, err := AddLinkTap("")
	if err != nil {
		return nil, fmt.Errorf("tap failed: %v", err)
	}

	err = netlink.LinkSetUp(tap)
	if err != nil {
		return nil, fmt.Errorf("tap up failed: %v", err)
	}

	br, err := netlink.LinkByName(bridge)
	if err != nil {
		return nil, fmt.Errorf("bridge failed: %v", err)
	}

	err = netlink.LinkSetMaster(tap, br.(*netlink.Bridge))
	if err != nil {
		return nil, fmt.Errorf("set master failed: %v", err)
	}

	return tap, nil
}

func (lc *LocalCluster) Destroy() error {
	var err error
	firstErr := func(e error) {
		if e != nil && err == nil {
			err = e
		}
	}

	firstErr(lc.SimpleEtcd.Destroy())
	firstErr(lc.Dnsmasq.Destroy())
	firstErr(lc.SSHAgent.Close())
	firstErr(lc.nshandle.Close())
	return err
}


text:
#if !defined(AFX_IMAGEEDITDLG_H__07E27535_C6D9_11D1_A647_00A0C93A70EC__INCLUDED_)
#define AFX_IMAGEEDITDLG_H__07E27535_C6D9_11D1_A647_00A0C93A70EC__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
// BCGPImageEditDlg.h : header file
//

#include "BCGCBPro.h"
#include "BCGPDialog.h"
#include "BCGPColorBar.h"
#include "ImagePaintArea.h"
#include "BCGPToolBar.h"

class CBCGPImageEditorPaletteBar : public CBCGPToolBar
{
	virtual BOOL IsButtonExtraSizeAvailable () const
	{
		return FALSE;
	}

	virtual int GetRowHeight () const
	{
		return GetButtonSize ().cy;
	}

public:
	virtual BOOL IsDialogControl() const
	{
		return TRUE;
	}
};

/////////////////////////////////////////////////////////////////////////////
// CBCGPImageEditDlg dialog

class BCGCBPRODLLEXPORT CBCGPImageEditDlg : public CBCGPDialog
{
	friend CImagePaintArea;

// Construction
public:
	CBCGPImageEditDlg(CBitmap* pBitmap, CWnd* pParent = NULL,
					int nBitsPixel = -1);   // standard constructor

// Dialog Data
	//{{AFX_DATA(CBCGPImageEditDlg)
	enum { IDD = IDD_BCGBARRES_IMAGE_EDITOR };
	CStatic	m_wndColorPickerLocation;
	CStatic	m_wndPaletteBarLocation;
	CStatic	m_wndPreview;
	CImagePaintArea	m_wndLargeDrawArea;
	//}}AFX_DATA

// Operations:
protected:
	BOOL OnPickColor (COLORREF color);

	void SetMode (CImagePaintArea::IMAGE_EDIT_MODE mode)
	{
		m_wndLargeDrawArea.SetMode (mode);
	}

	CImagePaintArea::IMAGE_EDIT_MODE GetMode () const
	{
		return m_wndLargeDrawArea.GetMode ();
	}

protected:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CBCGPImageEditDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:

	// Generated message map functions
	//{{AFX_MSG(CBCGPImageEditDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnPaint();
	afx_msg void OnBcgToolClear();
	afx_msg void OnBcgToolCopy();
	afx_msg void OnBcgToolPaste();
	afx_msg void OnUpdateBcgToolPaste(CCmdUI* pCmdUI);
	afx_msg void OnBcgToolEllipse();
	afx_msg void OnBcgToolFill();
	afx_msg void OnBcgToolLine();
	afx_msg void OnBcgToolPen();
	afx_msg void OnBcgToolPick();
	afx_msg void OnBcgToolRect();
	afx_msg void OnUpdateBcgToolEllipse(CCmdUI* pCmdUI);
	afx_msg void OnUpdateBcgToolFill(CCmdUI* pCmdUI);
	afx_msg void OnUpdateBcgToolLine(CCmdUI* pCmdUI);
	afx_msg void OnUpdateBcgToolPen(CCmdUI* pCmdUI);
	afx_msg void OnUpdateBcgToolPick(CCmdUI* pCmdUI);
	afx_msg void OnUpdateBcgToolRect(CCmdUI* pCmdUI);
	//}}AFX_MSG
	afx_msg LRESULT OnKickIdle(WPARAM, LPARAM);
	afx_msg void OnColors();
	DECLARE_MESSAGE_MAP()

// Attributes:
	CBitmap*				m_pBitmap;
	CSize					m_sizeImage;
	int						m_nBitsPixel;

	CRect					m_rectPreviewFrame;
	CRect					m_rectPreviewImage;

	CBCGPImageEditorPaletteBar	m_wndPaletteBar;
	CBCGPColorBar			m_wndColorBar;
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_IMAGEEDITDLG_H__07E27535_C6D9_11D1_A647_00A0C93A70EC__INCLUDED_)


text:
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/**
* Admin User Services
* Admin
*  View list,
*  Add, Edit , Delete.
*
*/

class User_services extends MY_Controller {

    public function __construct()
    {
        parent::__construct();

        $this->load->model("user_service_model");
    }

    /**
    * View Listing
    */
	public function index()
	{
        user_access("administer user services");//access check

        $table=array();
        $table["header"]=array(
         array("title"=>"
User
",
                "attributes"=>array("class"=>"sortCol")
          ),
         array("title"=>"
Category
",
                "attributes"=>array("class"=>"sortCol")
          ),
         /*array("title"=>"
Sub Category
",
                "attributes"=>array("class"=>"sortCol")
          ),*/
         array("title"=>"
Service
",
                "attributes"=>array("class"=>"sortCol")
          ),
		 array("title"=>"Actions",
            "attributes"=>array("width"=>"100")
          ),
        );
        $table["no result text"]="No information found.";

        ////Auto Pagination
        $this->user_service_model->pager["base_url"]=admin_base_url("user_services/index");
        $this->user_service_model->pager["uri_segment"]=4;

        //////Filter/////
        $filter="";
        if($this->input->post("submit"))
        {
			$this->data["posted"]=$this->input->post();
           	if(!empty($this->data["posted"]["s_user_name"]))
		   		$filter="u.s_user_name LIKE '%".$this->data["posted"]["s_user_name"]."%'";

			/*if(!empty($this->data["posted"]["e_doc_type"]))
		   		$filter.=(!empty($filter)? " AND ":"")."e_doc_type ='".$this->data["posted"]["e_doc_type"]."'";*/

        }
        //pr($filter);
        //////end Filter/////

        $rec=$this->user_service_model->user_service_load(
                                  $filter,
                                  $this->noRecAdmin,
                                  $this->uri->segment(4,0)
                                );
        if(!empty($rec))
        {
            foreach($rec as $r)
            {
                $action="";

                $data = array(
                'name'        => 'i_active',
                'class'       => 'i_active',
                'value'       => $r->id,
                'checked'     => (bool)$r->i_active,
                );

                 $action.='
'.form_checkbox($data).'
';

                //$action.='
<input type="checkbox" id="check20" checked="checked" name="chbox" />
';

                //$action.='
'.form_checkbox('i_active['.$r->id.']',intval($r->i_active) , (bool)$r->i_active,'class=i_active').'
';

                $action.='id) ).'" >Delete';

                $table["rows"][]=array(
                      $r->s_user_name,
					  $r->s_category,
                      $r->s_service_name,
                      $action
                );

            }
        }
         //pr($table["rows"]);

        /**
        * Pager goes to the footer of the table
        */
        $table["footer"]=$this->user_service_model->get_pager();

        $this->data["page_title"]="Manage User Services";

        $this->data["table"]=theme_table($table);

        $this->render();
        ////end login form starts from here////
	}

    /**
    * Add edit form
    *
    * @param mixed $action
    * @param mixed $form_token
    */
    public function operation($action="add",$form_token="")
    {
        user_access("administer user services");//access check

        ////Inedit configuration////
        $id=0;
        if($action=="edit")
            $id=decrypt($form_token);

        $modify_data=$this->user_service_model->user_service_load(intval($id));

        $default_value[0]=json_encode(array(
                            "s_user_name"        => trim(@$modify_data->s_user_name),
							"s_email"            => trim(@$modify_data->s_email),
                            "action"             => $action,
                            ));
        $this->data["default_value"]= $default_value;

        $this->data["page_title"]="User ".ucwords($action);
        $this->render();
        ////end login form starts from here////
    }

    /**
    * Ajax add edit post
    */
    public function ajax_operation()
    {
        user_access("administer user services");//access check

        $ajx_ret=array(
            "mode" => "", //success|error
            "message"=>"",//html string
        );

        $posted=array();

        if(isset($_POST["s_user_name"]))
        {
            $posted["action"] 		        = trim($this->input->post("action"));
            $posted["s_user_name"]          = trim($this->input->post("s_user_name"));
			$posted["s_email"] 		        = trim($this->input->post("s_email"));
            $posted["s_password"]           = trim($this->input->post("s_password"));
            $posted["s_confirm_password"]   = trim($this->input->post("s_confirm_password"));
            ////rules
			$this->form_validation->set_rules('s_user_name', 'user name', 'required');
			$this->form_validation->set_rules('s_email', 'email', 'required');
            $this->form_validation->set_rules('s_password', 'new password', 'required|matches[s_confirm_password]');
            $this->form_validation->set_rules('s_confirm_password', 'confirm password', 'required');

            if($this->form_validation->run() == FALSE)/////invalid
            {
                $ajx_ret["mode"]="error";
                //$ajx_ret["message"]=form_error('s_admin_name');
                $ajx_ret["message"]= validation_errors();
                echo json_encode($ajx_ret);
                return FALSE;
            }
            else//valid, saving into db
            {
                $ret=FALSE;
                if($posted["action"]=="add")
                {

                    $ret=$this->user_service_model->add_user_service(array(
                                            "s_email"       =>$posted["s_email"],
											"s_user_name"	=>$posted["s_user_name"],
                                            "s_password"    =>md5($posted['s_password']),
                                        ));
                }

                if($ret)//success
                {

                    $ajx_ret["mode"]="success";
                    $ajx_ret["message"]= message_line("saved success");
                    if($posted["action"]=="add")
                        $ajx_ret["form_token"]=encrypt($ret);

                    echo json_encode($ajx_ret);
                    return TRUE;
                }
                else//error
                {
                    $ajx_ret["mode"]="error";
                    $ajx_ret["message"]= message_line("saved error");
                    echo json_encode($ajx_ret);
                    return TRUE;
                }
            }

        }//end if
    }

    /**
    * Delete
    *
    * @param mixed $form_token
    */
    public function delete($form_token)
    {
        user_access("administer user services");//access check
        $id=decrypt($form_token);

        $ret=$this->user_service_model->delete_user_service(array("id"=>$id));
        if($ret)//success
        {
            set_success_msg(message_line("delete success"));
            redirect(admin_base_url("user_services"));

        }
        else//error
        {
            set_error_msg(message_line("delete error"));
            redirect(admin_base_url("user_services"));
        }
    }

    /**
    * change the service status
    */
    public function changeStatus()
    {
        //pr($_POST);
        if(!empty($_POST))
        {
            foreach($_POST["i_active"] as $id=>$v )
            {
               $where="id=".intval($id);
               $ret=$this->user_service_model->update_user_service_status("",$where);
            }
            //redirect("admin/user_services");
        }
    }

     public function ajax_status_update(){

            $posted   = $this->input->post();
            foreach($posted as $id=>$value){
                $val=$value=='1'?array("i_active"=>'1'):array("i_active"=>'0');
                $condition=array('id'=>$id);
                $res=$this->user_service_model->update_user_service($val,$condition);

                if($res)
                    set_success_msg(message_line("status update success"));
                else
                    set_error_msg(message_line("status update error"));

            }

    }

     /**
    * Assigning permisions available
    */
    public function user_services_permission()
    {
        return array(
            "administer user services"=>array(
                "title"=>"Administer user services",
                "description"=>"Can view, add, delete User services.".message_line("security concern"),
            ),

        );
    }//end welcome_permission

}


text:
package main

import (
	"fmt"
)

func main() {

	things := map[string]interface{}{
		"string": "stringval",
		"bool":   true,
		"int":    5,
		"struct": struct{}{}, // inline declaration of a struct with no fields
	}

	for k, v := range things {
		thingType(k, v)
	}

}

func thingType(k string, v interface{}) {

	switch t := v.(type) {
	default:
		fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has
	case bool:
		fmt.Printf("boolean %t\n", t) // t has type bool
	case int:
		fmt.Printf("integer %d\n", t) // t has type int
	case string:
		fmt.Printf("string %s\n", t) // t has type string
	}
}


text:
package org.tomitribe.crest;

import junit.framework.TestCase;
import org.tomitribe.crest.api.Command;
import org.tomitribe.crest.api.Option;
import org.tomitribe.crest.api.Options;
import org.tomitribe.crest.cmds.Cmd;

import java.net.URI;
import java.util.Map;

public class OptionsObjectAdvancedArrayArgTest extends TestCase {

    private final Map<String, Cmd> commands = org.tomitribe.crest.cmds.processors.Commands.get(Commands.class);

    public void testSimple() throws Exception {
        assertArguments(commands.get("simple"));
    }

    public void testComplex() throws Exception {
        assertArguments(commands.get("complex"));
    }

    public void testComplex2() throws Exception {
        assertArguments(commands.get("complex2"));
    }

    public void testComplex3() throws Exception {
        assertArguments(commands.get("complex3"));
    }

    public void testComplex4() throws Exception {
        assertArguments(commands.get("complex4"));
    }

    public void testComplex5() throws Exception {
        assertArguments(commands.get("complex5"));
    }

    private void assertArguments(Cmd command) {
        {
            final Value exec = (Value) command.exec(null, "/tmp/dest1", "/tmp/dest2");
            assertEquals(0, exec.sources.length);
            assertEquals(URI.create("/tmp/dest1"), exec.dest1);
            assertEquals(URI.create("/tmp/dest2"), exec.dest2);
        }

        {
            final Value exec = (Value) command.exec(null, "/tmp/src", "/tmp/dest1", "/tmp/dest2");
            assertEquals(URI.create("/tmp/src"), exec.sources[0]);
            assertEquals(URI.create("/tmp/dest1"), exec.dest1);
            assertEquals(URI.create("/tmp/dest2"), exec.dest2);
        }

        {
            final Value exec = (Value) command.exec(null, "/tmp/src1", "/tmp/src2", "/tmp/dest1", "/tmp/dest2");
            assertEquals(URI.create("/tmp/src1"), exec.sources[0]);
            assertEquals(URI.create("/tmp/src2"), exec.sources[1]);
            assertEquals(URI.create("/tmp/dest1"), exec.dest1);
            assertEquals(URI.create("/tmp/dest2"), exec.dest2);
        }

        {
            final Value exec = (Value) command.exec(null, "/tmp/src1", "/tmp/src2", "/tmp/src3", "/tmp/dest1", "/tmp/dest2");
            assertEquals(URI.create("/tmp/src1"), exec.sources[0]);
            assertEquals(URI.create("/tmp/src2"), exec.sources[1]);
            assertEquals(URI.create("/tmp/src3"), exec.sources[2]);
            assertEquals(URI.create("/tmp/dest1"), exec.dest1);
            assertEquals(URI.create("/tmp/dest2"), exec.dest2);
        }
        {
            final Value exec = (Value) command.exec(null, "/tmp/src1", "/tmp/src2", "/tmp/src3", "/tmp/src4", "/tmp/dest1", "/tmp/dest2");
            assertEquals(URI.create("/tmp/src1"), exec.sources[0]);
            assertEquals(URI.create("/tmp/src2"), exec.sources[1]);
            assertEquals(URI.create("/tmp/src3"), exec.sources[2]);
            assertEquals(URI.create("/tmp/src4"), exec.sources[3]);
            assertEquals(URI.create("/tmp/dest1"), exec.dest1);
            assertEquals(URI.create("/tmp/dest2"), exec.dest2);
        }
    }

    public static class Commands {

        @Command
        public Value simple(final URI[] sources, @Option("foo") final URI uri, final URI dest1, final URI dest2) {
            return new Value(sources, dest1, dest2);
        }

        @Command
        public Value complex(Sources sources, @Option("foo") final URI uri, final URI dest1, final URI dest2) {
            return new Value(sources.sources, dest1, dest2);
        }

        @Command
        public Value complex2(Sources sources, @Option("foo") final URI uri, final Dest dest1, final URI dest2) {
            return new Value(sources.sources, dest1.dest, dest2);
        }

        @Command
        public Value complex3(Sources sources, @Option("foo") final URI uri, final Dest dest1, final Dest dest2) {
            return new Value(sources.sources, dest1.dest, dest2.dest);
        }

        @Command
        public Value complex4(Sources sources, @Option("foo") final URI uri, final URI dest1, final Dest dest2) {
            return new Value(sources.sources, dest1, dest2.dest);
        }

        @Command
        public Value complex5(final URI[] sources, @Option("foo") final URI uri, final Dest dest1, final Dest dest2) {
            return new Value(sources, dest1.dest, dest2.dest);
        }

        @Options
        public static class Sources {
            final URI[] sources;

            public Sources(final URI[] sources) {
                this.sources = sources;
            }
        }

        @Options
        public static class Dest {
            final URI dest;

            public Dest(URI dest) {
                this.dest = dest;
            }
        }

        @Command
        public void options(Bean bean) {
            assertNotNull(bean);

            assertEquals("color", bean.getKey());
            assertEquals("orange", bean.getValue());
        }

        @Command
        public void args(BeanWithArgs bean) {
            assertNotNull(bean);

            assertEquals("red", bean.getString());
            assertEquals(URI.create("blue://foo"), bean.getUri());
        }

        @Command
        public void optionsAndArgs(BeanWithArgsAndOptions bean) {
            assertNotNull(bean);

            assertEquals("color", bean.getKey());
            assertEquals("orange", bean.getValue());
            assertEquals("red", bean.getString());
            assertEquals(URI.create("blue://foo"), bean.getUri());
        }

        @Command
        public void twoBeans(Bean bean, BeanWithArgs beanWithArgs) {
            options(bean);
            args(beanWithArgs);
        }

        @Command
        public void mixed(@Option("size") int size, BeanWithArgs beanWithArgs, Shape shape, Bean bean, URI uri) {
            options(bean);
            args(beanWithArgs);

            assertEquals(Shape.CIRCLE, shape);
            assertEquals(4, size);
            assertEquals(URI.create("orange://fruit"), uri);
        }
    }

    public static enum Shape {
        SQUARE,
        CIRCLE,
        TRIANGLE;
    }

    @Options
    public static class Bean {

        private final String key;
        private final String value;

        public Bean(@Option("key") final String key, @Option("value") final String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    @Options
    public static class BeanWithArgs {

        private final String string;
        private final URI uri;

        public BeanWithArgs(String string, URI uri) {
            this.string = string;
            this.uri = uri;
        }

        public String getString() {
            return string;
        }

        public URI getUri() {
            return uri;
        }
    }

    @Options
    public static class BeanWithArgsAndOptions {

        private final String key;
        private final String value;
        private final String string;
        private final URI uri;

        public BeanWithArgsAndOptions(@Option("key") final String key, @Option("value") final String value, String string, URI uri) {
            this.key = key;
            this.value = value;
            this.string = string;
            this.uri = uri;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }

        public String getString() {
            return string;
        }

        public URI getUri() {
            return uri;
        }
    }

    public static class Value {
        private final URI[] sources;
        private final URI dest1;
        private final URI dest2;

        public Value(final URI[] sources, final URI dest1, final URI dest2) {
            this.sources = sources;
            this.dest1 = dest1;
            this.dest2 = dest2;
        }
    }
}


text:
(function ($, undefined) {
    "use strict";
    /*global document, window, jQuery, console */

    if (window.Select2 !== undefined) {
        return;
    }

    var KEY, AbstractSelect2, SingleSelect2, MultiSelect2;

    KEY = {
        TAB: 9,
        ENTER: 13,
        ESC: 27,
        SPACE: 32,
        LEFT: 37,
        UP: 38,
        RIGHT: 39,
        DOWN: 40,
        SHIFT: 16,
        CTRL: 17,
        ALT: 18,
        PAGE_UP: 33,
        PAGE_DOWN: 34,
        HOME: 36,
        END: 35,
        BACKSPACE: 8,
        DELETE: 46,
        isArrow: function (k) {
            k = k.which ? k.which : k;
            switch (k) {
            case KEY.LEFT:
            case KEY.RIGHT:
            case KEY.UP:
            case KEY.DOWN:
                return true;
            }
            return false;
        },
        isControl: function (k) {
            k = k.which ? k.which : k;
            switch (k) {
            case KEY.SHIFT:
            case KEY.CTRL:
            case KEY.ALT:
                return true;
            }
            return false;
        },
        isFunctionKey: function (k) {
            k = k.which ? k.which : k;
            return k >= 112 && k <= 123;
        }
    };

    function indexOf(value, array) {
        var i = 0, l = array.length, v;

        if (typeof value == 'undefined') {
          return -1;
        }

        if (value.constructor === String) {
            for (; i < l; i = i + 1) if (value.localeCompare(array[i]) === 0) return i;
        } else {
            for (; i < l; i = i + 1) {
                v = array[i];
                if (v.constructor === String) {
                    if (v.localeCompare(value) === 0) return i;
                } else {
                    if (v === value) return i;
                }
            }
        }
        return -1;
    }

    /**
     * Compares equality of a and b taking into account that a and b may be strings, in which case localCompare is used
     * @param a
     * @param b
     */
    function equal(a, b) {
        if (a === b) return true;
        if (a === undefined || b === undefined) return false;
        if (a === null || b === null) return false;
        if (a.constructor === String) return a.localeCompare(b) === 0;
        if (b.constructor === String) return b.localeCompare(a) === 0;
        return false;
    }

    /**
     * Splits the string into an array of values, trimming each value. An empty array is returned for nulls or empty
     * strings
     * @param string
     * @param separator
     */
    function splitVal(string, separator) {
        var val, i, l;
        if (string === null || string.length < 1) return [];
        val = string.split(separator);
        for (i = 0, l = val.length; i < l; i = i + 1) val[i] = $.trim(val[i]);
        return val;
    }

    function getSideBorderPadding(element) {
        return element.outerWidth() - element.width();
    }

    function installKeyUpChangeEvent(element) {
        element.bind("keydown", function () {
            element.data("keyup-change-value", element.val());
        });
        element.bind("keyup", function () {
            if (element.val() !== element.data("keyup-change-value")) {
                element.trigger("keyup-change");
            }
        });
    }

    /**
     * filters mouse events so an event is fired only if the mouse moved.
     *
     * filters out mouse events that occur when mouse is stationary but
     * the elements under the pointer are scrolled.
     */
    $(document).delegate("*", "mousemove", function (e) {
        $(document).data("select2-lastpos", {x: e.pageX, y: e.pageY});
    });
    function installFilteredMouseMove(element) {
        element.bind("mousemove", function (e) {
            var lastpos = $(document).data("select2-lastpos");
            if (lastpos === undefined || lastpos.x !== e.pageX || lastpos.y !== e.pageY) {
                $(e.target).trigger("mousemove-filtered", e);
            }
        });
    }

    /**
     * Debounces a function. Returns a function that calls the original fn function only if no invocations have been made
     * within the last quietMillis milliseconds.
     *
     * @param quietMillis number of milliseconds to wait before invoking fn
     * @param fn function to be debounced
     * @return debounced version of fn
     */
    function debounce(quietMillis, fn) {
        var timeout;
        return function () {
            window.clearTimeout(timeout);
            timeout = window.setTimeout(fn, quietMillis);
        };
    }

    function installDebouncedScroll(threshold, element) {
        var notify = debounce(threshold, function (e) { element.trigger("scroll-debounced", e);});
        element.bind("scroll", function (e) {
            if (indexOf(e.target, element.get()) >= 0) notify(e);
        });
    }

    function killEvent(event) {
        event.preventDefault();
        event.stopPropagation();
    }

    function measureTextWidth(e) {
        var sizer, width;
        sizer = $("

").css({
            position: "absolute",
            left: "-1000px",
            top: "-1000px",
            display: "none",
            fontSize: e.css("fontSize"),
            fontFamily: e.css("fontFamily"),
            fontStyle: e.css("fontStyle"),
            fontWeight: e.css("fontWeight"),
            letterSpacing: e.css("letterSpacing"),
            textTransform: e.css("textTransform"),
            whiteSpace: "nowrap"
        });
        sizer.text(e.val());
        $("body").append(sizer);
        width = sizer.width();
        sizer.remove();
        return width;
    }

    /**
     * Produces an ajax-based query function
     *
     * @param options object containing configuration paramters
     * @param options.transport function that will be used to execute the ajax request. must be compatible with parameters supported by $.ajax
     * @param options.url url for the data
     * @param options.data a function(searchTerm, pageNumber, context) that should return an object containing query string parameters for the above url.
     * @param options.dataType request data type: ajax, jsonp, other datatatypes supported by jQuery's $.ajax function or the transport function if specified
     * @param options.quietMillis (optional) milliseconds to wait before making the ajaxRequest, helps debounce the ajax function if invoked too often
     * @param options.results a function(remoteData, pageNumber) that converts data returned form the remote request to the format expected by Select2.
     *      The expected format is an object containing the following keys:
     *      results array of objects that will be used as choices
     *      more (optional) boolean indicating whether there are more results available
     *      Example: {results:[{id:1, text:'Red'},{id:2, text:'Blue'}], more:true}
     */
    function ajax(options) {
        var timeout, // current scheduled but not yet executed request
            requestSequence = 0, // sequence used to drop out-of-order responses
            handler = null,
            quietMillis = options.quietMillis || 100;

        return function (query) {
            window.clearTimeout(timeout);
            timeout = window.setTimeout(function () {
                requestSequence += 1; // increment the sequence
                var requestNumber = requestSequence, // this request's sequence number
                    data = options.data, // ajax data function
                    transport = options.transport || $.ajax;

                data = data.call(this, query.term, query.page, query.context);

                if( null !== handler){
                    handler.abort();
                }
                handler = transport.call(null, {
                    url: options.url,
                    dataType: options.dataType,
                    data: data,
                    success: function (data) {
                        if (requestNumber < requestSequence) {
                            return;
                        }
                        // TODO 3.0 - replace query.page with query so users have access to term, page, etc.
                        var results = options.results(data, query.page);
                        self.context = results.context;
                        query.callback(results);
                    }
                });
            }, quietMillis);
        };
    }

    /**
     * Produces a query function that works with a local array
     *
     * @param options object containing configuration parameters. The options parameter can either be an array or an
     * object.
     *
     * If the array form is used it is assumed that it contains objects with 'id' and 'text' keys.
     *
     * If the object form is used ti is assumed that it contains 'data' and 'text' keys. The 'data' key should contain
     * an array of objects that will be used as choices. These objects must contain at least an 'id' key. The 'text'
     * key can either be a String in which case it is expected that each element in the 'data' array has a key with the
     * value of 'text' which will be used to match choices. Alternatively, text can be a function(item) that can extract
     * the text.
     */
    function local(options) {
        var data = options, // data elements
            text = function (item) { return ""+item.text; }; // function used to retrieve the text portion of a data item that is matched against the search

        if (!$.isArray(data)) {
            text = data.text;
            // if text is not a function we assume it to be a key name
            if (!$.isFunction(text)) text = function (item) { return item[data.text]; };
            data = data.results;
        }

        return function (query) {
            var t = query.term, filtered = {};
            if (t === "") {
                query.callback({results: data});
                return;
            }
            filtered.results = $(data)
                .filter(function () {return query.matcher(t, text(this));})
                .get();
            query.callback(filtered);
        };
    }

    // TODO javadoc
    function tags(data) {
        // TODO even for a function we should probably return a wrapper that does the same object/string check as
        // the function for arrays. otherwise only functions that return objects are supported.
        if ($.isFunction(data)) {
            return data;
        }

        // if not a function we assume it to be an array

        return function (query) {
            var t = query.term, filtered = {results: []};
            $(data).each(function () {
                var isObject = this.text !== undefined,
                    text = isObject ? this.text : this;
                if (t === "" || query.matcher(t, text)) {
                    filtered.results.push(isObject ? this : {id: this, text: this});
                }
            });
            query.callback(filtered);
        };
    }

    /**
     * blurs any Select2 container that has focus when an element outside them was clicked or received focus
     */
    $(document).ready(function () {
        $(document).delegate("*", "mousedown focusin touchend", function (e) {
            var target = $(e.target).closest("div.select2-container").get(0);
            $(document).find("div.select2-container-active").each(function () {
                if (this !== target) $(this).data("select2").blur();
            });
        });
    });

    /**
     * Creates a new class
     *
     * @param superClass
     * @param methods
     */
    function clazz(SuperClass, methods) {
        var constructor = function () {};
        constructor.prototype = new SuperClass;
        constructor.prototype.constructor = constructor;
        constructor.prototype.parent = SuperClass.prototype;
        constructor.prototype = $.extend(constructor.prototype, methods);
        return constructor;
    }

    AbstractSelect2 = clazz(Object, {

        bind: function (func) {
            var self = this;
            return function () {
                func.apply(self, arguments);
            };
        },

        init: function (opts) {
            var results, search, resultsSelector = ".select2-results";

            // prepare options
            this.opts = opts = this.prepareOpts(opts);

            this.id=opts.id;

            // destroy if called on an existing component
            if (opts.element.data("select2") !== undefined &&
                opts.element.data("select2") !== null) {
                this.destroy();
            }

            this.enabled=true;
            this.container = this.createContainer();

            if (opts.element.attr("class") !== undefined) {
                this.container.addClass(opts.element.attr("class"));
            }

            // swap container for the element
            this.opts.element
                .data("select2", this)
                .hide()
                .after(this.container);
            this.container.data("select2", this);

            this.dropdown = this.container.find(".select2-drop");
            this.results = results = this.container.find(resultsSelector);
            this.search = search = this.container.find("input[type=text]");

            this.resultsPage = 0;
            this.context = null;

            // initialize the container
            this.initContainer();

            installFilteredMouseMove(this.results);
            this.container.delegate(resultsSelector, "mousemove-filtered", this.bind(this.highlightUnderEvent));

            installDebouncedScroll(80, this.results);
            this.container.delegate(resultsSelector, "scroll-debounced", this.bind(this.loadMoreIfNeeded));

            // if jquery.mousewheel plugin is installed we can prevent out-of-bounds scrolling of results via mousewheel
            if ($.fn.mousewheel) {
                results.mousewheel(function (e, delta, deltaX, deltaY) {
                    var top = results.scrollTop(), height;
                    if (deltaY > 0 && top - deltaY <= 0) {
                        results.scrollTop(0);
                        killEvent(e);
                    } else if (deltaY < 0 && results.get(0).scrollHeight - results.scrollTop() + deltaY <= results.height()) {
                        results.scrollTop(results.get(0).scrollHeight - results.height());
                        killEvent(e);
                    }
                });
            }

            installKeyUpChangeEvent(search);
            search.bind("keyup-change", this.bind(this.updateResults));
            search.bind("focus", function () { search.addClass("select2-focused");});
            search.bind("blur", function () { search.removeClass("select2-focused");});

            this.container.delegate(resultsSelector, "click", this.bind(function (e) {
                if ($(e.target).closest(".select2-result:not(.select2-disabled)").length > 0) {
                    this.highlightUnderEvent(e);
                    this.selectHighlighted(e);
                } else {
                    killEvent(e);
                    this.focusSearch();
                }
            }));

            if ($.isFunction(this.opts.initSelection)) {
                // initialize selection based on the current value of the source element
                this.initSelection();

                // if the user has provided a function that can set selection based on the value of the source element
                // we monitor the change event on the element and trigger it, allowing for two way synchronization
                this.monitorSource();
            }

            if (opts.element.is(":disabled")) this.disable();
        },

        destroy: function () {
            var select2 = this.opts.element.data("select2");
            if (select2 !== undefined) {
                select2.container.remove();
                select2.opts.element
                    .removeData("select2")
                    .unbind(".select2")
                    .show();
            }
        },

        prepareOpts: function (opts) {
            var element, select, idKey;

            element = opts.element;

            if (element.get(0).tagName.toLowerCase() === "select") {
                this.select = select = opts.element;
            }

            if (select) {
                // these options are not allowed when attached to a select because they are picked up off the element itself
                $.each(["id", "multiple", "ajax", "query", "createSearchChoice", "initSelection", "data", "tags"], function () {
                    if (this in opts) {
                        throw new Error("Option '" + this + "' is not allowed for Select2 when attached to a <select> element.");
                    }
                });
            }

            opts = $.extend({}, {
                formatResult: function (data) { return data.text; },
                formatSelection: function (data) { return data.text; },
                formatNoMatches: function () { return "No matches found"; },
                formatInputTooShort: function (input, min) { return "Please enter " + (min - input.length) + " more characters"; },
                minimumResultsForSearch: 0,
                minimumInputLength: 0,
                id: function (e) { return e.id; },
                matcher: function(term, text) {
                    return text.toUpperCase().indexOf(term.toUpperCase()) >= 0;
                }
            }, opts);

            if (typeof(opts.id) !== "function") {
                idKey = opts.id;
                opts.id = function (e) { return e[idKey]; };
            }

            if (select) {
                opts.query = this.bind(function (query) {
                    var data = {results: [], more: false},
                        term = query.term,
                        placeholder = this.getPlaceholder();
                    element.find("option").each(function (i) {
                        var e = $(this),
                            text = e.text();

                        if (i === 0 && placeholder !== undefined && text === "") return true;

                        if (query.matcher(term, text)) {
                            data.results.push({id: e.attr("value"), text: (e.attr("data-html") == undefined ? text : e.attr("data-html")) });
                        }
                    });
                    query.callback(data);
                });
                // this is needed because inside val() we construct choices from options and there id is hardcoded
                opts.id=function(e) { return e.id; };
            } else {
                if (!("query" in opts)) {
                    if ("ajax" in opts) {
                        opts.query = ajax(opts.ajax);
                    } else if ("data" in opts) {
                        opts.query = local(opts.data);
                    } else if ("tags" in opts) {
                        opts.query = tags(opts.tags);
                        opts.createSearchChoice = function (term) { return {id: term, text: term}; };
                        opts.initSelection = function (element) {
                            var data = [];
                            $(splitVal(element.val(), ",")).each(function () {
                                data.push({id: this, text: this});
                            });
                            return data;
                        };
                    }
                }
            }
            if (typeof(opts.query) !== "function") {
                throw "query function not defined for Select2 " + opts.element.attr("id");
            }

            return opts;
        },

        /**
         * Monitor the original element for changes and update select2 accordingly
         */
        monitorSource: function () {
            this.opts.element.bind("change.select2", this.bind(function (e) {
                if (this.opts.element.data("select2-change-triggered") !== true) {
                    this.initSelection();
                }
            }));
        },

        /**
         * Triggers the change event on the source element
         */
        triggerChange: function () {
            // Prevents recursive triggering
            this.opts.element.data("select2-change-triggered", true);
            this.opts.element.trigger("change");
            this.opts.element.data("select2-change-triggered", false);
        },

        enable: function() {
            if (this.enabled) return;

            this.enabled=true;
            this.container.removeClass("select2-container-disabled");
        },

        disable: function() {
            if (!this.enabled) return;

            this.close();

            this.enabled=false;
            this.container.addClass("select2-container-disabled");
        },

        opened: function () {
            return this.container.hasClass("select2-dropdown-open");
        },

        open: function () {
            if (this.opened()) return;

            this.container.addClass("select2-dropdown-open").addClass("select2-container-active");

            this.updateResults(true);
            this.dropdown.show();
            this.ensureHighlightVisible();
            this.focusSearch();
        },

        close: function () {
            if (!this.opened()) return;

            this.dropdown.hide();
            this.container.removeClass("select2-dropdown-open");
            this.results.empty();
            this.clearSearch();
        },

        clearSearch: function () {

        },

        ensureHighlightVisible: function () {
            var results = this.results, children, index, child, hb, rb, y, more;

            children = results.children(".select2-result");
            index = this.highlight();

            if (index < 0) return;

            child = $(children[index]);

            hb = child.offset().top + child.outerHeight();

            // if this is the last child lets also make sure select2-more-results is visible
            if (index === children.length - 1) {
                more = results.find("li.select2-more-results");
                if (more.length > 0) {
                    hb = more.offset().top + more.outerHeight();
                }
            }

            rb = results.offset().top + results.outerHeight();
            if (hb > rb) {
                results.scrollTop(results.scrollTop() + (hb - rb));
            }
            y = child.offset().top - results.offset().top;

            // make sure the top of the element is visible
            if (y < 0) {
                results.scrollTop(results.scrollTop() + y); // y is negative
            }
        },

        moveHighlight: function (delta) {
            var choices = this.results.children(".select2-result"),
                index = this.highlight();

            while (index > -1 && index < choices.length) {
                index += delta;
                if (!$(choices[index]).hasClass("select2-disabled")) {
                    this.highlight(index);
                    break;
                }
            }
        },

        highlight: function (index) {
            var choices = this.results.children(".select2-result");

            if (arguments.length === 0) {
                return indexOf(choices.filter(".select2-highlighted")[0], choices.get());
            }

            choices.removeClass("select2-highlighted");

            if (index >= choices.length) index = choices.length - 1;
            if (index < 0) index = 0;

            $(choices[index]).addClass("select2-highlighted");
            this.ensureHighlightVisible();

            if (this.opened()) this.focusSearch();
        },

        highlightUnderEvent: function (event) {
            var el = $(event.target).closest(".select2-result");
            if (el.length > 0) {
                this.highlight(el.index());
            }
        },

        loadMoreIfNeeded: function () {
            var results = this.results,
                more = results.find("li.select2-more-results"),
                below, // pixels the element is below the scroll fold, below==0 is when the element is starting to be visible
                offset = -1, // index of first element without data
                page = this.resultsPage + 1;

            if (more.length === 0) return;

            below = more.offset().top - results.offset().top - results.height();

            if (below <= 0) {
                more.addClass("select2-active");
                this.opts.query({
                        term: this.search.val(),
                        page: page,
                        context: self.context,
                        matcher: self.opts.matcher,
                        callback: this.bind(function (data) {
                    var parts = [], self = this;
                    $(data.results).each(function () {
                        parts.push("
");
                        parts.push(self.opts.formatResult(this));
                        parts.push("
");
                    });
                    more.before(parts.join(""));
                    results.find(".select2-result").each(function (i) {
                        var e = $(this);
                        if (e.data("select2-data") !== undefined) {
                            offset = i;
                        } else {
                            e.data("select2-data", data.results[i - offset - 1]);
                        }
                    });
                    if (data.more) {
                        more.removeClass("select2-active");
                    } else {
                        more.remove();
                    }
                    this.resultsPage = page;
                })});
            }
        },

        /**
         * @param initial whether or not this is the call to this method right after the dropdown has been opened
         */
        updateResults: function (initial) {
            var search = this.search, results = this.results, opts = this.opts, self=this;

            // if the search is currently hidden we do not alter the results
            if (initial !== true && this.showSearchInput === false) {
                return;
            }

            search.addClass("select2-active");

            function render(html) {
                results.html(html);
                results.scrollTop(0);
                search.removeClass("select2-active");
            }

            if (search.val().length < opts.minimumInputLength) {
                render("
" + opts.formatInputTooShort(search.val(), opts.minimumInputLength) + "
");
                return;
            }

            this.resultsPage = 1;
            opts.query({
                    term: search.val(),
                    page: this.resultsPage,
                    context: null,
                    matcher: opts.matcher,
                    callback: this.bind(function (data) {
                var parts = [], // html parts
                    def; // default choice

                // create a default choice and prepend it to the list
                if (this.opts.createSearchChoice && search.val() !== "") {
                    def = this.opts.createSearchChoice.call(null, search.val(), data.results);
                    if (def !== undefined && def !== null && self.id(def) !== undefined && self.id(def) !== null) {
                        if ($(data.results).filter(
                            function () {
                                return equal(self.id(this), self.id(def));
                            }).length === 0) {
                            data.results.unshift(def);
                        }
                    }
                }

                if (data.results.length === 0) {
                    render("
" + opts.formatNoMatches(search.val()) + "
");
                    return;
                }

                $(data.results).each(function () {
                    parts.push("
");
                    parts.push(opts.formatResult(this));
                    parts.push("
");
                });

                if (data.more === true) {
                    parts.push("
Loading more results...
");
                }

                render(parts.join(""));
                results.children(".select2-result").each(function (i) {
                    var d = data.results[i];
                    $(this).data("select2-data", d);
                });
                this.postprocessResults(data, initial);
            })});
        },

        cancel: function () {
            this.close();
        },

        blur: function () {
            /* we do this in a timeout so that current event processing can complete before this code is executed.
             this allows tab index to be preserved even if this code blurs the textfield */
            window.setTimeout(this.bind(function () {
                this.close();
                this.container.removeClass("select2-container-active");
                this.clearSearch();
                this.selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
                this.search.blur();
            }), 10);
        },

        focusSearch: function () {
            /* we do this in a timeout so that current event processing can complete before this code is executed.
             this makes sure the search field is focussed even if the current event would blur it */
            window.setTimeout(this.bind(function () {
                this.search.focus();
            }), 10);
        },

        selectHighlighted: function () {
            var data = this.results.find(".select2-highlighted:not(.select2-disabled)").data("select2-data");
            if (data) {
                this.onSelect(data);
            }
        },

        getPlaceholder: function () {
            return this.opts.element.attr("placeholder") || this.opts.element.data("placeholder") || this.opts.placeholder;
        },

        /**
         * Get the desired width for the container element.  This is
         * derived first from option `width` passed to select2, then
         * the inline 'style' on the original element, and finally
         * falls back to the jQuery calculated element width.
         *
         * @returns The width string (with units) for the container.
         */
        getContainerWidth: function () {
            var style, attrs, matches, i, l;
            if (this.opts.width !== undefined)
                return this.opts.width;

            style = this.opts.element.attr('style');
            if (style !== undefined) {
                attrs = style.split(';');
                for (i = 0, l = attrs.length; i < l; i = i + 1) {
                    matches = attrs[i].replace(/\s/g, '')
                        .match(/width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/);
                    if (matches !== null && matches.length >= 1)
                        return matches[1];
                }
            }
            return this.opts.element.width() + 'px';
        }
    });

    SingleSelect2 = clazz(AbstractSelect2, {

        createContainer: function () {
            return $("

", {
                "class": "select2-container",
                "style": "width: " + this.getContainerWidth()
            }).html([
                "    ",
                "   ",
                "

" ,
                "",
                "
" ,
                "
" ,
                "       <input type='text' autocomplete='off'/>" ,
                "
" ,
                "
" ,
                "
" ,
                "
"].join(""));
        },

        open: function () {

            if (this.opened()) return;

            this.parent.open.apply(this, arguments);

        },

        close: function () {
            if (!this.opened()) return;
            this.parent.close.apply(this, arguments);
        },

        focus: function () {
            this.close();
            this.selection.focus();
        },

        isFocused: function () {
            return this.selection.is(":focus");
        },

        cancel: function () {
            this.parent.cancel.apply(this, arguments);
            this.selection.focus();
        },

        initContainer: function () {

            var selection, container = this.container, clickingInside = false,
                selector = ".select2-choice";

            this.selection = selection = container.find(selector);

            this.search.bind("keydown", this.bind(function (e) {
                switch (e.which) {
                case KEY.UP:
                case KEY.DOWN:
                    this.moveHighlight((e.which === KEY.UP) ? -1 : 1);
                    killEvent(e);
                    return;
                case KEY.TAB:
                case KEY.ENTER:
                    this.selectHighlighted();
                    killEvent(e);
                    return;
                case KEY.ESC:
                    this.cancel(e);
                    e.preventDefault();
                    return;
                }
            }));

            container.delegate(selector, "click", this.bind(function (e) {
                clickingInside = true;

                if (this.opened()) {
                    this.close();
                    selection.focus();
                } else if (this.enabled) {
                    this.open();
                }
                e.preventDefault();

                clickingInside = false;
            }));
            container.delegate(selector, "keydown", this.bind(function (e) {
                if (!this.enabled || e.which === KEY.TAB || KEY.isControl(e) || KEY.isFunctionKey(e) || e.which === KEY.ESC) {
                    return;
                }
                this.open();
                if (e.which === KEY.PAGE_UP || e.which === KEY.PAGE_DOWN || e.which === KEY.SPACE) {
                    // prevent the page from scrolling
                    killEvent(e);
                }
                if (e.which === KEY.ENTER) {
                    // do not propagate the event otherwise we open, and propagate enter which closes
                    killEvent(e);
                }
            }));
            container.delegate(selector, "focus", function () { if (this.enabled) container.addClass("select2-container-active"); });
            container.delegate(selector, "blur", this.bind(function () {
                if (clickingInside) return;
                if (!this.opened()) this.blur();
            }));

            selection.delegate("abbr", "click", this.bind(function (e) {
                if (!this.enabled) return;
                this.val("");
                killEvent(e);
                this.close();
                this.triggerChange();
            }));

            this.setPlaceholder();
        },

        /**
         * Sets selection based on source element's value
         */
        initSelection: function () {
            var selected;
            if (this.opts.element.val() === "") {
                this.updateSelection({id: "", text: ""});
            } else {
                selected = this.opts.initSelection.call(null, this.opts.element);
                if (selected !== undefined && selected !== null) {
                    this.updateSelection(selected);
                }
            }

            this.close();
            this.setPlaceholder();
        },

        prepareOpts: function () {
            var opts = this.parent.prepareOpts.apply(this, arguments);

            if (opts.element.get(0).tagName.toLowerCase() === "select") {
                // install sthe selection initializer
                opts.initSelection = function (element) {
                    var selected = element.find(":selected");
                    // a single select box always has a value, no need to null check 'selected'
                    return {id: selected.attr("value"), text: selected.text()};
                };
            }

            return opts;
        },

        setPlaceholder: function () {
            var placeholder = this.getPlaceholder();

            if (this.opts.element.val() === "" && placeholder !== undefined) {

                // check for a first blank option if attached to a select
                if (this.select && this.select.find("option:first").text() !== "") return;

                if (typeof(placeholder) === "object") {
                    this.updateSelection(placeholder);
                } else {
                    this.selection.find("span").html(placeholder);
                }
                this.selection.addClass("select2-default");

                this.selection.find("abbr").hide();
            }
        },

        postprocessResults: function (data, initial) {
            var selected = 0, self = this, showSearchInput = true;

            // find the selected element in the result list

            this.results.find(".select2-result").each(function (i) {
                if (equal(self.id($(this).data("select2-data")), self.opts.element.val())) {
                    selected = i;
                    return false;
                }
            });

            // and highlight it

            this.highlight(selected);

            // hide the search box if this is the first we got the results and there are a few of them

            if (initial === true) {
                showSearchInput = this.showSearchInput = data.results.length >= this.opts.minimumResultsForSearch;
                this.container.find(".select2-search")[showSearchInput ? "removeClass" : "addClass"]("select2-search-hidden");

                //add "select2-with-searchbox" to the container if search box is shown
                this.container[showSearchInput ? "addClass" : "removeClass"]("select2-with-searchbox");
            }

        },

        onSelect: function (data) {
            var old = this.opts.element.val();

            this.opts.element.val(this.id(data));
            this.updateSelection(data);
            this.close();
            this.selection.focus();

            if (!equal(old, this.id(data))) { this.triggerChange(); }
        },

        updateSelection: function (data) {
            this.selection
                .find("span")
                .html(this.opts.formatSelection(data));

            this.selection.removeClass("select2-default");

            if (this.opts.allowClear && this.getPlaceholder() !== undefined) {
                this.selection.find("abbr").show();
            }
        },

        val: function () {
            var val, data = null;

            if (arguments.length === 0) {
                return this.opts.element.val();
            }

            val = arguments[0];

            if (this.select) {
                // val is an id
                this.select
                    .val(val)
                    .find(":selected").each(function () {
                        data = {id: $(this).attr("value"), text: $(this).text()};
                        return false;
                    });
                this.updateSelection(data);
            } else {
                // val is an object. !val is true for [undefined,null,'']
                this.opts.element.val(!val ? "" : this.id(val));
                this.updateSelection(val);
            }
            this.setPlaceholder();

        },

        clearSearch: function () {
            this.search.val("");
        }
    });

    MultiSelect2 = clazz(AbstractSelect2, {

        createContainer: function () {
            return $("

", {
                "class": "select2-container select2-container-multi ",
                "style": "width: 100%" + this.getContainerWidth()}).html([
                "
",
                //"
California
" ,
                "
" ,
                "    <input type='text' autocomplete='off' " ,
                "
" ,
                "
" ,
                "
" ,
                "
" ,
                "
" ,
                "
"].join(""));
        },

        prepareOpts: function () {
            var opts = this.parent.prepareOpts.apply(this, arguments);

            opts = $.extend({}, {
                closeOnSelect: true
            }, opts);

            // TODO validate placeholder is a string if specified

            if (opts.element.get(0).tagName.toLowerCase() === "select") {
                // install sthe selection initializer
                opts.initSelection = function (element) {
                    var data = [];
                    element.find(":selected").each(function () {
                        data.push({id: $(this).attr("value"), text: $(this).text()});
                    });
                    return data;
                };
            }

            return opts;
        },

        initContainer: function () {

            var selector = ".select2-choices", selection;

            this.searchContainer = this.container.find(".select2-search-field");
            this.selection = selection = this.container.find(selector);

            this.search.bind("keydown", this.bind(function (e) {
                if (!this.enabled) return;

                if (e.which === KEY.BACKSPACE && this.search.val() === "") {
                    this.close();

                    var choices,
                        selected = selection.find(".select2-search-choice-focus");
                    if (selected.length > 0) {
                        this.unselect(selected.first());
                        this.search.width(10);
                        killEvent(e);
                        return;
                    }

                    choices = selection.find(".select2-search-choice");
                    if (choices.length > 0) {
                        choices.last().addClass("select2-search-choice-focus");
                    }
                } else {
                    selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
                }

                if (this.opened()) {
                    switch (e.which) {
                    case KEY.UP:
                    case KEY.DOWN:
                        this.moveHighlight((e.which === KEY.UP) ? -1 : 1);
                        killEvent(e);
                        return;
                    case KEY.ENTER:
                    case KEY.TAB:
                        this.selectHighlighted();
                        killEvent(e);
                        return;
                    case KEY.ESC:
                        this.cancel(e);
                        e.preventDefault();
                        return;
                    }
                }

                if (e.which === KEY.TAB || KEY.isControl(e) || KEY.isFunctionKey(e) || e.which === KEY.BACKSPACE || e.which === KEY.ESC) {
                    return;
                }

                this.open();

                if (e.which === KEY.PAGE_UP || e.which === KEY.PAGE_DOWN) {
                    // prevent the page from scrolling
                    killEvent(e);
                }
            }));

            this.search.bind("keyup", this.bind(this.resizeSearch));

            this.container.delegate(selector, "click", this.bind(function (e) {
                if (!this.enabled) return;
                this.open();
                this.focusSearch();
                e.preventDefault();
            }));

            this.container.delegate(selector, "focus", this.bind(function () {
                if (!this.enabled) return;
                this.container.addClass("select2-container-active");
                this.clearPlaceholder();
            }));

            // set the placeholder if necessary
            this.clearSearch();
        },

        enable: function() {
            if (this.enabled) return;

            this.parent.enable.apply(this, arguments);

            this.search.show();
        },

        disable: function() {
            if (!this.enabled) return;

            this.parent.disable.apply(this, arguments);

            this.search.hide();
        },

        initSelection: function () {
            var data;
            if (this.opts.element.val() === "") {
                this.updateSelection([]);
            }
            if (this.select || this.opts.element.val() !== "") {
                data = this.opts.initSelection.call(null, this.opts.element);
                if (data !== undefined && data !== null) {
                    this.updateSelection(data);
                }
            }

            this.close();

            // set the placeholder if necessary
            this.clearSearch();
        },

        clearSearch: function () {
            var placeholder = this.getPlaceholder();

            if (placeholder !== undefined
                && this.getVal().length === 0
                && this.search.hasClass("select2-focused") === false) {

                this.search.val(placeholder).addClass("select2-default");
                // stretch the search box to full width of the container so as much of the placeholder is visible as possible
                this.search.width(this.getContainerWidth());
            } else {
                this.search.val("").width(10);
            }
        },

        clearPlaceholder: function () {
            if (this.search.hasClass("select2-default")) {
                this.search.val("").removeClass("select2-default");
            }
        },

        open: function () {
            if (this.opened()) return;
            this.parent.open.apply(this, arguments);
            this.resizeSearch();
            this.focusSearch();
        },

        close: function () {
            if (!this.opened()) return;
            this.parent.close.apply(this, arguments);
        },

        focus: function () {
            this.close();
            this.search.focus();
        },

        isFocused: function () {
            return this.search.hasClass("select2-focused");
        },

        updateSelection: function (data) {
            var ids = [], filtered = [], self = this;

            // filter out duplicates
            $(data).each(function () {
                if (indexOf(self.id(this), ids) < 0) {
                    ids.push(self.id(this));
                    filtered.push(this);
                }
            });
            data = filtered;

            this.selection.find(".select2-search-choice").remove();
            $(data).each(function () {
                self.addSelectedChoice(this);
            });
            self.postprocessResults();
        },

        onSelect: function (data) {
            this.addSelectedChoice(data);
            if (this.select) { this.postprocessResults(); }

            if (this.opts.closeOnSelect) {
                this.close();
                this.search.width(10);
            } else {
                this.search.width(10);
                this.resizeSearch();
            }

            // since its not possible to select an element that has already been
            // added we do not need to check if this is a new element before firing change
            this.triggerChange();

            this.focusSearch();
        },

        cancel: function () {
            this.close();
            this.focusSearch();
        },

        addSelectedChoice: function (data) {
            var choice,
                id = this.id(data),
                parts,
                val = this.getVal();

            parts = ["
",
                this.opts.formatSelection(data),
                "",
                "
"
            ];

            choice = $(parts.join(""));
            choice.find("a")
                .bind("click dblclick", this.bind(function (e) {
                if (!this.enabled) return;

                this.unselect($(e.target));
                this.selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
                killEvent(e);
                this.close();
                this.focusSearch();
            })).bind("focus", this.bind(function () {
                if (!this.enabled) return;
                this.container.addClass("select2-container-active");
            }));

            choice.data("select2-data", data);
            choice.insertBefore(this.searchContainer);

            val.push(id);
            this.setVal(val);
        },

        unselect: function (selected) {
            var val = this.getVal(),
                index;

            selected = selected.closest(".select2-search-choice");

            if (selected.length === 0) {
                throw "Invalid argument: " + selected + ". Must be .select2-search-choice";
            }

            index = indexOf(this.id(selected.data("select2-data")), val);

            if (index >= 0) {
                val.splice(index, 1);
                this.setVal(val);
                if (this.select) this.postprocessResults();
            }
            selected.remove();
            this.triggerChange();
        },

        postprocessResults: function () {
            var val = this.getVal(),
                choices = this.results.find(".select2-result"),
                self = this;

            choices.each(function () {
                var choice = $(this), id = self.id(choice.data("select2-data"));
                if (indexOf(id, val) >= 0) {
                    choice.addClass("select2-disabled");
                } else {
                    choice.removeClass("select2-disabled");
                }
            });

            choices.each(function (i) {
                if (!$(this).hasClass("select2-disabled")) {
                    self.highlight(i);
                    return false;
                }
            });

        },

        resizeSearch: function () {

            var minimumWidth, left, maxWidth, containerLeft, searchWidth;

            minimumWidth = measureTextWidth(this.search) + 10;

            left = this.search.offset().left;

            maxWidth = this.selection.width();
            containerLeft = this.selection.offset().left;

            searchWidth = maxWidth - (left - containerLeft) - getSideBorderPadding(this.search);

            if (searchWidth < minimumWidth) {
                searchWidth = maxWidth - getSideBorderPadding(this.search);
            }

            if (searchWidth < 40) {
                searchWidth = maxWidth - getSideBorderPadding(this.search);
            }
            this.search.width(searchWidth);
        },

        getVal: function () {
            var val;
            if (this.select) {
                val = this.select.val();
                return val === null ? [] : val;
            } else {
                val = this.opts.element.val();
                return splitVal(val, ",");
            }
        },

        setVal: function (val) {
            var unique;
            if (this.select) {
                this.select.val(val);
            } else {
                unique = [];
                // filter out duplicates
                $(val).each(function () {
                    if (indexOf(this, unique) < 0) unique.push(this);
                });
                this.opts.element.val(unique.length === 0 ? "" : unique.join(","));
            }
        },

        val: function () {
            var val, data = [], self=this;

            if (arguments.length === 0) {
                return this.getVal();
            }

            val = arguments[0];

            if (this.select) {
                // val is a list of ids
                this.setVal(val);
                this.select.find(":selected").each(function () {
                    data.push({id: $(this).attr("value"), text: $(this).text()});
                });
                this.updateSelection(data);
            } else {
                val = (val === null) ? [] : val;
                this.setVal(val);
                // val is a list of objects
                $(val).each(function () { data.push(self.id(this)); });
                this.setVal(data);
                this.updateSelection(val);
            }

            this.clearSearch();
        },
        onSortStart: function() {
            if (this.select) {
                throw new Error("Sorting of elements is not supported when attached to <select>. Attach to <input type='hidden'/> instead.");
            }

            // collapse search field into 0 width so its container can be collapsed as well
            this.search.width(0);
            // hide the container
            this.searchContainer.hide();
        },
        onSortEnd:function() {

            var val=[], self=this;

            // show search and move it to the end of the list
            this.searchContainer.show();
            // make sure the search container is the last item in the list
            this.searchContainer.appendTo(this.searchContainer.parent());
            // since we collapsed the width in dragStarteed, we resize it here
            this.resizeSearch();

            // update selection

            this.selection.find(".select2-search-choice").each(function() {
                val.push(self.opts.id($(this).data("select2-data")));
            });
            this.setVal(val);
            this.triggerChange();
        }
    });

    $.fn.select2 = function () {

        var args = Array.prototype.slice.call(arguments, 0),
            opts,
            select2,
            value, multiple, allowedMethods = ["val", "destroy", "open", "close", "focus", "isFocused", "container", "onSortStart", "onSortEnd", "enable", "disable"];

        this.each(function () {
            if (args.length === 0 || typeof(args[0]) === "object") {
                opts = args.length === 0 ? {} : $.extend({}, args[0]);
                opts.element = $(this);

                if (opts.element.get(0).tagName.toLowerCase() === "select") {
                    multiple = opts.element.attr("multiple");
                } else {
                    multiple = opts.multiple || false;
                    if ("tags" in opts) {opts.multiple = multiple = true;}
                }

                select2 = multiple ? new MultiSelect2() : new SingleSelect2();
                select2.init(opts);
            } else if (typeof(args[0]) === "string") {

                if (indexOf(args[0], allowedMethods) < 0) {
                    throw "Unknown method: " + args[0];
                }

                value = undefined;
                select2 = $(this).data("select2");
                if (select2 === undefined) return;
                if (args[0] === "container") {
                    value=select2.container;
                } else {
                    value = select2[args[0]].apply(select2, args.slice(1));
                }
                if (value !== undefined) {return false;}
            } else {
                throw "Invalid arguments to select2 plugin: " + args;
            }
        });
        return (value === undefined) ? this : value;
    };

    // exports
    window.Select2 = {
        query: {
            ajax: ajax,
            local: local,
            tags: tags
        }, util: {
            debounce: debounce
        }, "class": {
            "abstract": AbstractSelect2,
            "single": SingleSelect2,
            "multi": MultiSelect2
        }
    };

}(jQuery));


text:
package android.provider;

public final class AlarmClock
{
  // Fields

  public static final java.lang.String ACTION_SET_ALARM = "android.intent.action.SET_ALARM";

  public static final java.lang.String EXTRA_MESSAGE = "android.intent.extra.alarm.MESSAGE";

  public static final java.lang.String EXTRA_HOUR = "android.intent.extra.alarm.HOUR";

  public static final java.lang.String EXTRA_MINUTES = "android.intent.extra.alarm.MINUTES";

  public static final java.lang.String EXTRA_SKIP_UI = "android.intent.extra.alarm.SKIP_UI";

  // Constructors

  public AlarmClock(){
  }
}


text:
layout: attachment
title: FirefoxOS-Marketplace-280x341
date: 2014-06-28 11:08:36.000000000 -03:00
categories: []
tags: []
status: inherit
type: attachment
published: false
meta: {}
author:
  login: aronbbordin
  email: aron.bordin@gmail.com
  display_name: aron.bordin
  first_name: ''
  last_name: ''
excerpt: !ruby/object:Hpricot::Doc
  options: {}
---


text:
<?xml version="1.0" encoding="UTF-8"?>
<config xmlns="http://www.knime.org/2008/09/XMLConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.knime.org/2008/09/XMLConfig http://www.knime.org/XMLConfig_2008_09.xsd" key="settings.xml">
<entry key="node_file" type="xstring" value="settings.xml"/>
<config key="flow_stack"/>
<config key="internal_node_subsettings">
<entry key="memory_policy" type="xstring" value="CacheSmallInMemory"/>
</config>
<config key="model">
<config key="Base path_Internals">
<entry key="SettingsModelID" type="xstring" value="SMID_string"/>
<entry key="EnabledStatus" type="xboolean" value="true"/>
</config>
<entry key="Base path" type="xstring" value="https://gpcrdb.org/"/>
<config key="Timeout_Internals">
<entry key="SettingsModelID" type="xstring" value="SMID_integer"/>
<entry key="EnabledStatus" type="xboolean" value="true"/>
</config>
<entry key="Timeout" type="xint" value="10"/>
<config key="In Column_Internals">
<entry key="SettingsModelID" type="xstring" value="SMID_string"/>
<entry key="EnabledStatus" type="xboolean" value="true"/>
</config>
<entry key="In Column" type="xstring" value="uniprot_acc"/>
<config key="In column type_Internals">
<entry key="SettingsModelID" type="xstring" value="SMID_string"/>
<entry key="EnabledStatus" type="xboolean" value="true"/>
</config>
<entry key="In column type" type="xstring" value="Uniprot accesion"/>
</config>
<config key="nodeAnnotation">
<entry key="text" type="xstring" value="Expected from real server"/>
<entry key="bgcolor" type="xint" value="16777215"/>
<entry key="x-coordinate" type="xint" value="271"/>
<entry key="y-coordinate" type="xint" value="839"/>
<entry key="width" type="xint" value="139"/>
<entry key="height" type="xint" value="16"/>
<entry key="alignment" type="xstring" value="CENTER"/>
<entry key="borderSize" type="xint" value="0"/>
<entry key="borderColor" type="xint" value="16777215"/>
<entry key="defFontSize" type="xint" value="9"/>
<entry key="annotation-version" type="xint" value="20151123"/>
<config key="styles"/>
</config>
<entry key="customDescription" type="xstring" isnull="true" value=""/>
<entry key="state" type="xstring" value="EXECUTED"/>
<entry key="factory" type="xstring" value="nl.esciencecenter.e3dchem.gpcrdb.proteins.ProteinInfoNodeFactory"/>
<entry key="node-name" type="xstring" value="GPCRDB Protein information"/>
<entry key="node-bundle-name" type="xstring" value="GPCRDB Nodes"/>
<entry key="node-bundle-symbolic-name" type="xstring" value="nl.esciencecenter.e3dchem.gpcrdb"/>
<entry key="node-bundle-vendor" type="xstring" value="Netherlands eScience Center"/>
<entry key="node-bundle-version" type="xstring" value="1.1.0"/>
<entry key="node-feature-name" type="xstring" value="GPCRDB Nodes for Knime"/>
<entry key="node-feature-symbolic-name" type="xstring" value="nl.esciencecenter.e3dchem.gpcrdb.feature.feature.group"/>
<entry key="node-feature-vendor" type="xstring" value="Netherlands eScience Center"/>
<entry key="node-feature-version" type="xstring" value="1.1.0"/>
<config key="factory_settings"/>
<entry key="name" type="xstring" value="GPCRDB Protein information"/>
<entry key="hasContent" type="xboolean" value="true"/>
<entry key="isInactive" type="xboolean" value="false"/>
<config key="ports">
<config key="port_1">
<entry key="index" type="xint" value="1"/>
<entry key="port_spec_class" type="xstring" value="org.knime.core.data.DataTableSpec"/>
<entry key="port_object_class" type="xstring" value="org.knime.core.node.BufferedDataTable"/>
<entry key="port_object_summary" type="xstring" value="Rows: 1, Cols: 8"/>
<entry key="port_dir_location" type="xstring" value="port_1"/>
</config>
</config>
<config key="filestores">
<entry key="file_store_location" type="xstring" isnull="true" value=""/>
<entry key="file_store_id" type="xstring" value="e9bcf279-20a6-4124-a9ed-9c23dd1eee32"/>
</config>
</config>


text:
import { B as Behavior, n as query, m as generateId } from './index-1e8b6f76.js';

let counter = 0;

class DebugBehavior extends Behavior {
  constructor(host, value) {
    super(host, value);

    this.debuggerId = value;
  }

  connected() {
    this.connect();

    this.log('connected');
  }

  changed(name, value) {
    this.log('changed', { name, value });
  }

  disconnected() {
    this.log('disconnected');
  }

  connect() {
    const debugEl = this.getDebugger();

    if (!debugEl) return;

    debugEl.use('debugger').then(Debug => {
      Debug.componentPromise.then(() => {
        const { host } = this;

        if (!host.nuDebugId) {
          const debugId = ++counter;

          window[`el${debugId}`] = host;

          Object.keys(host.nuBehaviors || {})
            .forEach(name => {
              window[`${name}${counter}`] = host.nuBehaviors[name];
            });

          host.nuDebugId = debugId;
        }

        Debug.set({ target: host });
      });
    });
  }

  getDebugger() {
    const { host } = this;
    let id = this.debuggerId.trim();

    if (this.debugger && this.debugger.nuId === id) {
      return this.debugger;
    }

    if (!id) {
      const debugEl = query(host, 'nu-debug');

      if (debugEl) {
        generateId(debugEl);

        this.debuggerId = debugEl.nuId;

        this.debugger = debugEl;

        return debugEl;
      } else {
        return;
      }
    }

    const debugEl = query(host, `#${id.trim()}`);

    if (debugEl && debugEl.nu) {
      this.debugger = debugEl;

      return debugEl;
    }
  }

  log(event, detail) {
    const debugEl = this.getDebugger();

    if (!debugEl) return;

    debugEl.use('debugger').then(Debug => {
      Debug.componentPromise.then(() => {
        Debug.component.log(event, detail);
      });
    });
  }
}

export default DebugBehavior;


text:
package org.wso2.carbon.bpel.ui.fileupload;

import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.client.Options;
import org.apache.axis2.context.ConfigurationContext;
import org.wso2.carbon.bpel.stub.upload.types.UploadedFileItem;
import org.wso2.carbon.bpel.stub.upload.BPELUploaderStub;

import javax.activation.DataHandler;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.List;

/**
 * Client handle the process archive uploading
 */
public class BPELUploaderClient {
    private List<UploadedFileItem> uploadServiceTypeList;
    private BPELUploaderStub stub;

    public BPELUploaderClient(ConfigurationContext ctx, String serviceURL, String cookie) throws AxisFault {
        stub = new BPELUploaderStub(ctx, serviceURL);
        Options options =  stub._getServiceClient().getOptions();
        options.setManageSession(true);
        options.setProperty(Constants.Configuration.ENABLE_MTOM, Constants.VALUE_TRUE);
        options.setProperty(org.apache.axis2.transport.http.HTTPConstants.COOKIE_STRING, cookie);
        //Increase the time out when sending large attachments
        options.setTimeOutInMilliSeconds(60*1000);
        uploadServiceTypeList = new ArrayList<UploadedFileItem>();

    }

    public void addUploadedFileItem(DataHandler dataHandler, String fileName, String fileType) {
        UploadedFileItem uploadedFileItem = new UploadedFileItem();
        uploadedFileItem.setDataHandler(dataHandler);
        uploadedFileItem.setFileName(fileName);
        uploadedFileItem.setFileType(fileType);
        uploadServiceTypeList.add(uploadedFileItem);
    }

    public void uploadFileItems() throws RemoteException {
        UploadedFileItem[] uploadServiceTypes = new UploadedFileItem[uploadServiceTypeList.size()];
        uploadServiceTypes = uploadServiceTypeList.toArray(uploadServiceTypes);
        stub.uploadService(uploadServiceTypes);
    }
}


text:
#include <gtest/gtest.h>
#include <string>
#include <vector>
#include "vsfs/ui/cli/commands.h"

using std::string;
using std::vector;

namespace vsfs {
namespace ui {
namespace cli {

vector<char*> create_args(const vector<string>& args) {
  vector<char*> ret;
  for (const auto& arg : args) {
    ret.push_back(const_cast<char*>(arg.c_str()));
  }
  return ret;
}

TEST(IndexUpdateCommandTest, TestParseArgs) {
  IndexUpdateCommand cmd(IndexUpdateCommand::IndexOp::UPDATE);
  vector<string> strargs = {"insert", "--stdin", "energy"};
  auto args = create_args(strargs);
  EXPECT_EQ(0, cmd.parse_args(args.size(), &args[0]));
  EXPECT_TRUE(cmd.use_stdin_);
  EXPECT_EQ("energy", cmd.name_);
  EXPECT_EQ(IndexUpdateCommand::IndexOp::UPDATE, cmd.op_);

  IndexUpdateCommand cmd1(IndexUpdateCommand::IndexOp::UPDATE);
  strargs = {"insert", "energy", "file0", "key0", "file1", "key1"};
  args = create_args(strargs);
  EXPECT_EQ(0, cmd1.parse_args(args.size(), &args[0]));
  EXPECT_EQ("energy", cmd1.name_);
  EXPECT_EQ(2, cmd1.index_data_.size());

  // Missing file,key pair.
  IndexUpdateCommand cmd2(IndexUpdateCommand::IndexOp::UPDATE);
  strargs = {"insert", "energy", "file0", "key0", "file1", "key1", "file2"};
  args = create_args(strargs);
  EXPECT_EQ(-1, cmd2.parse_args(args.size(), &args[0]));
}

TEST(IndexUpdateCommandTest, TestParseRecordFromStdin) {
  IndexUpdateCommand cmd(IndexUpdateCommand::IndexOp::UPDATE);
  string path, key;
  EXPECT_TRUE(cmd.parse_record("/foo/bar/zoo key", &path, &key));
  EXPECT_EQ("/foo/bar/zoo", path);
  EXPECT_EQ("key", key);

  path.clear();
  key.clear();
  EXPECT_TRUE(cmd.parse_record(" /foo/bar/zoo key ", &path, &key));
  EXPECT_EQ("/foo/bar/zoo", path);
  EXPECT_EQ("key", key);

  path.clear();
  key.clear();
  EXPECT_TRUE(cmd.parse_record("'/foo/bar/zoo' 'key'", &path, &key));
  EXPECT_EQ("/foo/bar/zoo", path);
  EXPECT_EQ("key", key);

  path.clear();
  key.clear();
  EXPECT_TRUE(cmd.parse_record("'/foo/bar zoo' 'key'", &path, &key));
  EXPECT_EQ("/foo/bar zoo", path);
  EXPECT_EQ("key", key);
}

}  // namespace cli
}  // namespace ui
}  // namespace vsfs


text:
// Code generated by applyconfiguration-gen. DO NOT EDIT.

package v1

// GlusterfsVolumeSourceApplyConfiguration represents an declarative configuration of the GlusterfsVolumeSource type for use
// with apply.
type GlusterfsVolumeSourceApplyConfiguration struct {
	EndpointsName *string `json:"endpoints,omitempty"`
	Path          *string `json:"path,omitempty"`
	ReadOnly      *bool   `json:"readOnly,omitempty"`
}

// GlusterfsVolumeSourceApplyConfiguration constructs an declarative configuration of the GlusterfsVolumeSource type for use with
// apply.
func GlusterfsVolumeSource() *GlusterfsVolumeSourceApplyConfiguration {
	return &GlusterfsVolumeSourceApplyConfiguration{}
}

// WithEndpointsName sets the EndpointsName field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the EndpointsName field is set to the value of the last call.
func (b *GlusterfsVolumeSourceApplyConfiguration) WithEndpointsName(value string) *GlusterfsVolumeSourceApplyConfiguration {
	b.EndpointsName = &value
	return b
}

// WithPath sets the Path field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Path field is set to the value of the last call.
func (b *GlusterfsVolumeSourceApplyConfiguration) WithPath(value string) *GlusterfsVolumeSourceApplyConfiguration {
	b.Path = &value
	return b
}

// WithReadOnly sets the ReadOnly field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ReadOnly field is set to the value of the last call.
func (b *GlusterfsVolumeSourceApplyConfiguration) WithReadOnly(value bool) *GlusterfsVolumeSourceApplyConfiguration {
	b.ReadOnly = &value
	return b
}