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

<title>FipsNodeReportType</title>
<meta name="date" content="2021-04-16">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

com.solidfire.element.api

Class FipsNodeReportType

java.lang.Object

com.solidfire.element.api.FipsNodeReportType

All Implemented Interfaces:

java.io.Serializable

public class FipsNodeReportType
extends java.lang.Object
implements java.io.Serializable

FipsNodeReportType
 FIPS related information for a node.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type
Class and Description

static class
FipsNodeReportType.Builder

Field Summary

Fields

Modifier and Type
Field and Description

static long
serialVersionUID

Constructor Summary

Constructors

Constructor and Description

FipsNodeReportType()

FipsNodeReportType(java.lang.Boolean httpsEnabled,
                  java.lang.Long nodeID)

FipsNodeReportType(java.lang.Boolean httpsEnabled,
                  java.lang.String fipsDrives,
                  java.lang.Long nodeID)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods

Modifier and Type
Method and Description

FipsNodeReportType.Builder
asBuilder()

static FipsNodeReportType.Builder
builder()

boolean
equals(java.lang.Object o)

java.lang.String
getFipsDrives()

Node's FipsDrives capability status.

java.lang.Boolean
getHttpsEnabled()

FIPS https feature status.

java.lang.Long
getNodeID()

Node ID.

int
hashCode()

void
setFipsDrives(java.lang.String fipsDrives)

void
setHttpsEnabled(java.lang.Boolean httpsEnabled)

void
setNodeID(java.lang.Long nodeID)

java.util.Map<java.lang.String,java.lang.Object>
toMap()

java.lang.String
toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

serialVersionUID

public static final long serialVersionUID

See Also:

Constant Field Values

Constructor Detail

FipsNodeReportType

@Since(value="7.0")
public FipsNodeReportType()

FipsNodeReportType

@Since(value="7.0")
public FipsNodeReportType(java.lang.Boolean httpsEnabled,
                                              java.lang.Long nodeID)

FipsNodeReportType

@Since(value="11.0")
public FipsNodeReportType(java.lang.Boolean httpsEnabled,
                                               java.lang.String fipsDrives,
                                               java.lang.Long nodeID)

Method Detail

getHttpsEnabled

public java.lang.Boolean getHttpsEnabled()

FIPS https feature status.

setHttpsEnabled

public void setHttpsEnabled(java.lang.Boolean httpsEnabled)

getFipsDrives

public java.lang.String getFipsDrives()

Node's FipsDrives capability status.

setFipsDrives

public void setFipsDrives(java.lang.String fipsDrives)

getNodeID

public java.lang.Long getNodeID()

Node ID.

setNodeID

public void setNodeID(java.lang.Long nodeID)

equals

public boolean equals(java.lang.Object o)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

toMap

public java.util.Map<java.lang.String,java.lang.Object> toMap()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

builder

public static FipsNodeReportType.Builder builder()

asBuilder

public final FipsNodeReportType.Builder asBuilder()

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
@extends('scaffold-interface.layouts.app')
@section('title','Index')
@section('content')

        Your CAD Models

    @can('upload stl')

        <form class = 'col s3' method = 'get' action = '{!!url("cadmodel")!!}/create'>
            <button class = 'btn btn-primary' type = 'submit'>Create New CAD Model</button>
        </form>

    @endcan()
    @can('view all prints')

            <form class='col s3' method='get' action='{!!url("cadmodelall")!!}'>
                <button class='btn btn-primary' type='submit'>Show All CAD Models</button>
                <input id="id" name="id" type="hidden" class="form-control">
            </form>

    @endcan

            Name
            Description
            {{--Material	--}}
            actions

            @foreach($cadmodels as $cadmodel)

                    id!!}/edit'>
                    {!!$cadmodel->Name!!}
                {!!$cadmodel->Description!!}
                {{--{!!$cadmodel->Material!!}	--}}

                    id!!}/deleteMsg" >delete
                    id!!}/edit'>edit
                    id!!}'>info

            @endforeach

    {!! $cadmodels->render() !!}

@endsection

redpajama_set_name: RedPajamaGithub


text:
package geojson

import (
	"errors"
	"fmt"
)

// lowest and highest values fo coordinates
type BoundingBox []float64

// A GeoJSON object with the type "Feature" is a feature object.
// - A feature object must have a member with the name "geometry".
//	 The value of the geometry member is a geometry object or a JSON null value.
// - A feature object must have a member with the name "properties".
//   The value of the properties member is an object (any JSON object
//   or a JSON null value).
// - If a feature has a commonly used identifier, that identifier should be
//   included as a member of the feature object with the name "id".
type Feature struct {
	Type       string                 `json:"type" bson:"type"`
	Id         interface{}            `json:"id,omitempty" bson:"id,omitempty"`
	Geometry   interface{}            `json:"geometry" bson:"geometry"`
	Properties map[string]interface{} `json:"properties" bson:"properties"`
	Bbox       BoundingBox            `json:"bbox,omitempty" bson:"bbox,omitempty"`
	Crs        *CRS                   `json:"crs,omitempty" bson:"crs,omitempty"`
}

func (t *Feature) GetGeometry() (Geometry, error) {
	gi := t.Geometry
	return parseGeometry(gi)
}

// Factory constructor method
func NewFeature(geom Geometry, properties map[string]interface{},
	id interface{}) *Feature {
	return &Feature{Type: "Feature",
		Geometry:   geom,
		Properties: properties,
		Id:         id}
}

// An object of type "FeatureCollection" must have a member with the name
// "features". The value corresponding to "features" is an array.
// Each element in the array is a Feature object.
type FeatureCollection struct {
	Type     string      `json:"type" bson:"type"`
	Features []*Feature  `json:"features" bson:"features"`
	Bbox     BoundingBox `json:"bbox,omitempty" bson:"bbox,omitempty"`
	Crs      *CRS        `json:"crs,omitempty" bson:"crs,omitempty"`
}

func (t *FeatureCollection) AddFeatures(f ...*Feature) {
	if f == nil {
		t.Features = make([]*Feature, 0, 100)
	}
	t.Features = append(t.Features, f...)
}

// factory funcion
func NewFeatureCollection(features []*Feature) *FeatureCollection {
	return &FeatureCollection{Type: "FeatureCollection", Features: features}
}

// The coordinate reference system (CRS) of a GeoJSON object
// is determined by its "crs" member.
type CRS struct {
	Type       string            `json:"type" bson:"type"`
	Properties map[string]string `json:"properties" bson:"properties"`
}

//Example:
//"crs": {
//  "type": "name",
//  "properties": {
//    "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
//    }
//  }
func NewNamedCRS(name string) *CRS {
	return &CRS{Type: "name", Properties: map[string]string{"name": name}}
}

// Exaples:
//"crs": {
//  "type": "link",
//  "properties": {
//    "href": "http://example.com/crs/42",
//    "type": "proj4"
//    }
//  }
//
//"crs": {
//  "type": "link",
//  "properties": {
//    "href": "data.crs",
//    "type": "ogcwkt"
//    }
//  }
func NewLinkedCRS(href, typ string) *CRS {
	return &CRS{Type: "link",
		Properties: map[string]string{"href": href, "type": typ}}
}

func parseCoordinate(c interface{}) (coord Coordinate, err error) {
	defer func() {
		if e := recover(); e != nil {
			err = errors.New(fmt.Sprintf("%v", e))
			return
		}
	}()
	coordinate, ok := c.([]interface{})
	if !ok || len(coordinate) != 2 {
		err = errors.New(fmt.Sprintf("Error unmarshal %v to coordinates", c))
		return
	}
	x := Coord(coordinate[0])
	y := Coord(coordinate[1])
	coord = Coordinate{x, y}
	return
}

func parseCoordinates(obj interface{}) (coords Coordinates, err error) {
	if c, ok := obj.([]interface{}); !ok || len(c) < 1 {
		err = errors.New(fmt.Sprintf("ParseErrr: Coordinates parse error, %v", obj))
		return
	} else {
		coords = make(Coordinates, len(c), len(c))
		for i, v := range c {
			if coords[i], err = parseCoordinate(v); err != nil {
				return
			}
		}
	}
	return
}

func parseMultiLine(obj interface{}) (coords MultiLine, err error) {
	if c, ok := obj.([]interface{}); !ok || len(c) < 1 {
		err = errors.New(fmt.Sprintf("ParseErrr: MultiLine parse error, %v", obj))
		return
	} else {
		coords = make(MultiLine, len(c), len(c))
		for i, v := range c {
			if coords[i], err = parseCoordinates(v); err != nil {
				return
			}
		}
	}
	return
}

func parsePoint(obj interface{}) (p *Point, err error) {
	var c Coordinate
	if c, err = parseCoordinate(obj); err != nil {
		return
	} else {
		p = NewPoint(c)
	}
	return
}

func parseLineString(obj interface{}) (ls *LineString, err error) {
	var cc Coordinates
	if cc, err = parseCoordinates(obj); err != nil {
		return
	}
	ls = NewLineString(cc)
	return
}

func parseMultiPoint(obj interface{}) (mp *MultiPoint, err error) {
	var cc Coordinates
	if cc, err = parseCoordinates(obj); err != nil {
		return
	}
	mp = NewMultiPoint(cc)
	return
}

func parseMultiLineString(obj interface{}) (mls *MultiLineString, err error) {
	var ml MultiLine
	if ml, err = parseMultiLine(obj); err != nil {
		return
	}
	mls = NewMultiLineString(ml)
	return
}

func parsePolygon(obj interface{}) (pol *Polygon, err error) {
	var pl MultiLine
	if pl, err = parseMultiLine(obj); err != nil {
		return
	}
	pol = NewPolygon(pl)
	return
}

func parseMultiPolygon(obj interface{}) (mpol *MultiPolygon, err error) {
	var ml []MultiLine
	if si, ok := obj.([]interface{}); !ok {
		err = errors.New("Parse Error: parse multi polygon error")
		return
	} else {
		ml = make([]MultiLine, len(si), len(si))
		for i, slice := range si {
			if ml[i], err = parseMultiLine(slice); err != nil {
				return
			}
		}
	}
	mpol = NewMultiPolygon(ml)
	return
}

func parseGeometry(gi interface{}) (geom Geometry, err error) {
	switch g := gi.(type) {
	case map[string]interface{}:
		coord := g["coordinates"]
		switch typ := g["type"]; typ {
		case "Point":
			return parsePoint(coord)
		case "LineString":
			return parseLineString(coord)
		case "MultiPoint":
			return parseMultiPoint(coord)
		case "MultiLineString":
			return parseMultiLineString(coord)
		case "Polygon":
			return parsePolygon(coord)
		case "MultiPolygon":
			return parseMultiPolygon(coord)
		case "GeometryCollection":
			return parseGeometryCollection(coord)
		default:
			err = errors.New(fmt.Sprintf("ParseError: Unknown geometry type %s", typ))
			break
		}
	}
	return geom, err
}

func parseGeometryCollection(obj interface{}) (gc *GeometryCollection, err error) {
	gc = NewGeometryCollection([]interface{}{})
	if si, ok := obj.([]interface{}); !ok {
		err = errors.New("ParseError: Error durring parse geometry collection")
		return
	} else {
		for i := 0; i < len(si); i++ {
			gc.AddGeometry(si[i])
		}
	}
	return
}


text:
package br.net.meditec.controller.update;

import android.app.Activity;
import android.app.Dialog;
import android.os.AsyncTask;
import android.widget.Toast;
import br.net.meditec.R;
import br.net.meditec.controller.dao.DaoUser;
import br.net.meditec.controller.update.server.Connection;
import br.net.meditec.model.User;

public class LoginAsyncTask extends AsyncTask<String, Void, String> {
    private Activity f1a;
    private Dialog dialogProgress;
    private String login;
    private String senha;

    public LoginAsyncTask(Activity a) {
        this.f1a = a;
    }

    protected void onPreExecute() {
        this.dialogProgress = new Dialog(this.f1a);
        this.dialogProgress.setContentView(R.layout.dialog_progress);
        this.dialogProgress.setCancelable(true);
        this.dialogProgress.show();
        super.onPreExecute();
    }

    protected String doInBackground(String... str) {
        this.login = str[0];
        this.senha = str[1];
        Update.update(this.f1a);
        return Login.execute(this.login, this.senha, this.f1a);
    }

    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        this.dialogProgress.dismiss();
        if (result.equals(Connection.SERVER_LOGIN_STATUS_OK)) {
            DaoUser daoUser = new DaoUser(this.f1a);
            daoUser.delete();
            User user = new User();
            user.setLogin(this.login);
            user.setSenha(this.senha);
            daoUser.insert(user);
            Toast.makeText(this.f1a, R.string.text_update, 1).show();
        } else if (result.equals(Login.USER_INVALIDO)) {
            new DaoUser(this.f1a).delete();
            Toast.makeText(this.f1a, this.f1a.getString(R.string.toast_login_never), 0).show();
        } else if (result.equals(Connection.SERVER_LOGIN_STATUS_OK)) {
            Toast.makeText(this.f1a, this.f1a.getString(R.string.toast_server_never), 0).show();
        }
        this.f1a.startActivity(this.f1a.getIntent());
        this.f1a.finish();
    }
}


text:
using namespace llvm;

#define DEBUG_TYPE "wasm-frame-info"

// TODO: Implement a red zone?

/// Return true if the specified function should have a dedicated frame pointer
/// register.
bool WebAssemblyFrameLowering::hasFP(const MachineFunction &MF) const {
  llvm_unreachable("TODO: implement hasFP");
}

/// Under normal circumstances, when a frame pointer is not required, we reserve
/// argument space for call sites in the function immediately on entry to the
/// current function. This eliminates the need for add/sub sp brackets around
/// call sites. Returns true if the call frame is included as part of the stack
/// frame.
bool WebAssemblyFrameLowering::hasReservedCallFrame(
    const MachineFunction &MF) const {
  return !MF.getFrameInfo()->hasVarSizedObjects();
}

void WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
    MachineFunction &MF, MachineBasicBlock &MBB,
    MachineBasicBlock::iterator I) const {
  llvm_unreachable("TODO: implement eliminateCallFramePseudoInstr");
}

void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
                                            MachineBasicBlock &MBB) const {
  llvm_unreachable("TODO: implement emitPrologue");
}

void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
                                            MachineBasicBlock &MBB) const {
  llvm_unreachable("TODO: implement emitEpilogue");
}

void WebAssemblyFrameLowering::processFunctionBeforeCalleeSavedScan(
    MachineFunction &MF, RegScavenger *RS) const {
  llvm_unreachable("TODO: implement processFunctionBeforeCalleeSavedScan");
}


text:
"""
@author: Shimin
"""

from datetime import date, timedelta
import datetime
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import json

import ConfigParser

def json_to_dict(config_json):
        '''
        Read the configuration json file
        :param config_json : Path of the configuration file
        '''
        json_data = open(config_json)
        data = json.loads(json_data.read())
        json_data.close()

        return data

def send_email(TO, FROM, TEXT, SUB, smtp_server, CC=[]):
        '''
        Creates a HTML-based email with clickable link and send it out using sendmail
        '''

        ## make text MIME format
        msg = MIMEMultipart('alternative')
        body = MIMEText(TEXT, 'html')
        msg.attach(body)

        ## for displaying only
        msg['Subject'] = SUB
        msg['From'] = ','.join(FROM)

        ## list to string, check if its a string first
        msg['To'] = ','.join(TO)
        msg['Cc'] = ','.join(CC)

        email_addresses = TO + CC

        ## real address that sendmail module use shld be a list
        ## Send the message via our own SMTP server, but don't include the envelope header
        s = smtplib.SMTP( smtp_server )
        s.sendmail(msg['from'], email_addresses, msg.as_string())
        s.quit()

class custparser(ConfigParser.ConfigParser):
	'''
	Reads an .ini file using ConfigParser and transform it into a dictionary for easy reading
	'''
	def as_dict(self):

		d = dict(self._sections)
		for k in d:
			d[k] = dict(self._defaults, **d[k])
			d[k].pop('__name__', None)

		return d


text:
from elasticsearch_dsl import mapping

def test_mapping_can_has_fields():
    m = mapping.Mapping('article')
    m.field('name', 'string').field('tags', 'string', index='not_analyzed')

    assert {
        'article': {
            'properties': {
                'name': {'type': 'string'},
                'tags': {'index': 'not_analyzed', 'type': 'string'}
            }
        }
    } == m.to_dict()

def test_mapping_update_is_recursive():
    m1 = mapping.Mapping('article')
    m1.field('title', 'string')
    m1.field('author', 'object')
    m1['author'].property('name', 'string')
    m1.meta('_all', enabled=False)

    m2 = mapping.Mapping('article')
    m2.field('published_from', 'date')
    m2.field('author', 'object')
    m2.field('title', 'string')
    m2.field('lang', 'string', index='not_analyzed')
    m2.meta('_analyzer', path='lang')
    m2['author'].property('email', 'string')

    m1.update(m2, update_only=True)

    assert {
        'article': {
            '_all': {'enabled': False},
            '_analyzer': {'path': 'lang'},
            'properties': {
                'published_from': {'type': 'date'},
                'title': {'type': 'string'},
                'lang': {'type': 'string', 'index': 'not_analyzed'},
                'author': {
                    'type': 'object',
                    'properties': {
                        'name': {'type': 'string'},
                        'email': {'type': 'string'},
                    }
                }
            }
        }
    } == m1.to_dict()


text:
package br.edu.ladoss.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "periodo")
@Entity
@Table(name = "tb_periodo")
@NamedQuery(name = "Periodo.getAll", query = "from Periodo")
public class Periodo {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "id_periodo")
	private Integer id;

	@Column(name = "nm_periodo")
	private String nome;

	@XmlElement
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@XmlElement
	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	@Override
	public String toString() {
		return "Periodo [id=" + id
				+ ", nome=" + nome + "]";
	}
}


text:
package io.github.retz.protocol.data;

import com.fasterxml.jackson.annotation.JsonCreator;

public class MesosContainer extends Container {
    @JsonCreator
    public MesosContainer() {
    }
}


text:
package com.alipay.api.response;

import java.util.List;
import com.alipay.api.internal.mapping.ApiField;
import com.alipay.api.internal.mapping.ApiListField;
import com.alipay.api.domain.MpPrizeInfoModel;

import com.alipay.api.AlipayResponse;

/**
 * ALIPAY API: alipay.marketing.campaign.drawcamp.query response.
 *
 * @author auto create
 * @since 1.0, 2017-03-23 14:22:15
 */
public class AlipayMarketingCampaignDrawcampQueryResponse extends AlipayResponse {

	private static final long serialVersionUID = 7242561773797481557L;

	/**
	 * 单用户以支付宝账号维度可参与当前营销活动的总次数,由开发者自定义此数值
	 */
	@ApiField("account_count")
	private String accountCount;

	/**
	 * 以移动设备维度可参与当前营销活动的总次数,由开发者自定义此数值
	 */
	@ApiField("appid_count")
	private String appidCount;

	/**
	 * 单个用户当前活动允许中奖的最大次数,最大值999999
	 */
	@ApiField("award_count")
	private String awardCount;

	/**
	 * 活动奖品总中奖几率,开发者需传入整数值,如:传入99支付宝默认为99%
	 */
	@ApiField("award_rate")
	private String awardRate;

	/**
	 * 活动唯一标识,不能包含除中文、英文、数字以外的字符,创建后不能修改,需要保证在商户端不重复。
	 */
	@ApiField("camp_code")
	private String campCode;

	/**
	 * 活动结束时间,yyyy-MM-dd HH:00:00格式(到小时),需要大于活动开始时间
	 */
	@ApiField("camp_end_time")
	private String campEndTime;

	/**
	 * 抽奖活动id
	 */
	@ApiField("camp_id")
	private String campId;

	/**
	 * 活动名称,开发者自定义
	 */
	@ApiField("camp_name")
	private String campName;

	/**
	 * 活动开始时间,yyyy-MM-dd HH:00:00格式(到小时),时间不能早于当前日期的0点
	 */
	@ApiField("camp_start_time")
	private String campStartTime;

	/**
	 * 活动状态,CAMP_CREATED(已创建状态),CAMP_PAUSED(暂停状态),CAMP_ENDED(结束状态),CAMP_GOING(启动状态),可由alipay.marketing.campaign.drawcamp.status.update 接口将已创建状态改为启动状态,将启动状态改为暂停/结束状态,将暂停状态置为结束状态
	 */
	@ApiField("camp_status")
	private String campStatus;

	/**
	 * 凭证验证规则id,通过alipay.marketing.campaign.cert.create 接口创建的凭证id
	 */
	@ApiField("cert_rule_id")
	private String certRuleId;

	/**
	 * 单用户以账户证件号(如身份证号、护照、军官证等)维度可参与当前营销活动的总次数,由开发者自定义此数值
	 */
	@ApiField("certification_count")
	private String certificationCount;

	/**
	 * 签约商户的pid,系统默认获取当前接口调用者的签约pid
	 */
	@ApiField("creator")
	private String creator;

	/**
	 * 圈人规则id,通过alipay.marketing.campaign.rule.crowd.create 接口创建的规则id
	 */
	@ApiField("crowd_rule_id")
	private String crowdRuleId;

	/**
	 * 以认证手机号(与支付宝账号绑定的手机号)维度的可参与当前营销活动的总次数,由开发者自定义此数值
	 */
	@ApiField("mobile_count")
	private String mobileCount;

	/**
	 * 奖品模型,至少有一个奖品模型
	 */
	@ApiListField("prize_list")
	@ApiField("mp_prize_info_model")
	private List<MpPrizeInfoModel> prizeList;

	/**
	 * 营销验证规则id,由支付宝配置
	 */
	@ApiField("promo_rule_id")
	private String promoRuleId;

	/**
	 * 活动触发类型,目前支持
CAMP_USER_TRIGGER:用户触发(开发者调用alipay.marketing.campaign.drawcamp.trigger 接口触发);
CAMP_SYS_TRIGGER:系统触发,必须配置实时人群验证规则(如:配置了监听用户支付事件,支付宝会根据活动规则自动发奖,无需用户手动触发)。
	 */
	@ApiField("trigger_type")
	private String triggerType;

	/**
	 * 实时人群验证规则id,由支付宝配置
	 */
	@ApiField("trigger_user_rule_id")
	private String triggerUserRuleId;

	/**
	 * 人群验证规则id,由支付宝配置
	 */
	@ApiField("user_rule_id")
	private String userRuleId;

	public void setAccountCount(String accountCount) {
		this.accountCount = accountCount;
	}
	public String getAccountCount( ) {
		return this.accountCount;
	}

	public void setAppidCount(String appidCount) {
		this.appidCount = appidCount;
	}
	public String getAppidCount( ) {
		return this.appidCount;
	}

	public void setAwardCount(String awardCount) {
		this.awardCount = awardCount;
	}
	public String getAwardCount( ) {
		return this.awardCount;
	}

	public void setAwardRate(String awardRate) {
		this.awardRate = awardRate;
	}
	public String getAwardRate( ) {
		return this.awardRate;
	}

	public void setCampCode(String campCode) {
		this.campCode = campCode;
	}
	public String getCampCode( ) {
		return this.campCode;
	}

	public void setCampEndTime(String campEndTime) {
		this.campEndTime = campEndTime;
	}
	public String getCampEndTime( ) {
		return this.campEndTime;
	}

	public void setCampId(String campId) {
		this.campId = campId;
	}
	public String getCampId( ) {
		return this.campId;
	}

	public void setCampName(String campName) {
		this.campName = campName;
	}
	public String getCampName( ) {
		return this.campName;
	}

	public void setCampStartTime(String campStartTime) {
		this.campStartTime = campStartTime;
	}
	public String getCampStartTime( ) {
		return this.campStartTime;
	}

	public void setCampStatus(String campStatus) {
		this.campStatus = campStatus;
	}
	public String getCampStatus( ) {
		return this.campStatus;
	}

	public void setCertRuleId(String certRuleId) {
		this.certRuleId = certRuleId;
	}
	public String getCertRuleId( ) {
		return this.certRuleId;
	}

	public void setCertificationCount(String certificationCount) {
		this.certificationCount = certificationCount;
	}
	public String getCertificationCount( ) {
		return this.certificationCount;
	}

	public void setCreator(String creator) {
		this.creator = creator;
	}
	public String getCreator( ) {
		return this.creator;
	}

	public void setCrowdRuleId(String crowdRuleId) {
		this.crowdRuleId = crowdRuleId;
	}
	public String getCrowdRuleId( ) {
		return this.crowdRuleId;
	}

	public void setMobileCount(String mobileCount) {
		this.mobileCount = mobileCount;
	}
	public String getMobileCount( ) {
		return this.mobileCount;
	}

	public void setPrizeList(List<MpPrizeInfoModel> prizeList) {
		this.prizeList = prizeList;
	}
	public List<MpPrizeInfoModel> getPrizeList( ) {
		return this.prizeList;
	}

	public void setPromoRuleId(String promoRuleId) {
		this.promoRuleId = promoRuleId;
	}
	public String getPromoRuleId( ) {
		return this.promoRuleId;
	}

	public void setTriggerType(String triggerType) {
		this.triggerType = triggerType;
	}
	public String getTriggerType( ) {
		return this.triggerType;
	}

	public void setTriggerUserRuleId(String triggerUserRuleId) {
		this.triggerUserRuleId = triggerUserRuleId;
	}
	public String getTriggerUserRuleId( ) {
		return this.triggerUserRuleId;
	}

	public void setUserRuleId(String userRuleId) {
		this.userRuleId = userRuleId;
	}
	public String getUserRuleId( ) {
		return this.userRuleId;
	}

}


text:
export interface IAfterGuiAttachedParams {
    hidePopup?: (event?: any)=> void
}

export interface IComponent<T> {

    /** Return the DOM element of your editor, this is what the grid puts into the DOM */
    getGui(): HTMLElement;

    /** Gets called once by grid after editing is finished - if your editor needs to do any cleanup, do it here */
    destroy?(): void;

    /** A hook to perform any necessary operation just after the gui for this component has been renderer
     in the screen.
     If the filter popup is closed and reopened, this method is called each time the filter is shown.
     This is useful for any
     logic that requires attachment before executing, such as putting focus on a particular DOM
     element. The params has one callback method 'hidePopup', which you can call at any later
     point to hide the popup - good if you have an 'Apply' button and you want to hide the popup
     after it is pressed. */
    afterGuiAttached?(params?: IAfterGuiAttachedParams): void;

    /** The init(params) method is called on the filter once. See below for details on the parameters. */
    init?(params: T): void;

}


text:
namespace Clutter {

    //
    // Clutter command line parser class
    //
    class Clutter {
        public:
            Clutter( int argc, const char* argv[] );
            virtual ~Clutter() { }

        private:
            // Define internal aliases
            typedef std::string string;
            typedef std::map<string, CommandBlock>::iterator MapIterator;

        public:
            // Declare public functions
            template <typename T>
                void require( string tag, string label, T& value, string help );

            template <typename T>
                void request( string tag, string label, T& value, string help );

            template <typename T>
                void request( string tag, string label, bool& toggle, T& value, string help );

            void end_parse();

            void redial( std::string filename="redial" );

        private:
            // Declare internal functions
            template <typename T>
                void parse( T& value, CommandBlock &block );

            template <typename T>
                void parse( std::vector<T>& value, CommandBlock &block );

            void print_help();

            bool has_flag( std::string flag );

            bool help_has_flag( string, string );

            MapIterator find_flag( string, string );

        private:
            // Help members
            bool                    mHelpFlag = false;
            std::vector<HelpBlock>  mHelpTree_required;
            std::vector<HelpBlock>  mHelpTree_requested;

            // Redial members
            std::string mExecutable;

            // Command map
            std::map<string, CommandBlock> mCommandMap;

            // Redial member
            std::vector<string> mRedial;
    };

    //
    // Template functions
    //
    template <typename T>
        void Clutter::require( string tag, string label, T& value, string help )
        {
            // Safeguard: test require against the help tree
            if ( help_has_flag( tag, label ) )
                throw std::logic_error("logic error: duplicate flag in parse tree: " + tag + "/" + label);

            // Store the require in the help tree
            mHelpTree_required.emplace_back( tag, label, help );

            // Check for help request
            if ( mHelpFlag ) return;

            // Find the flag position in the Command Map
            auto it = this->find_flag( tag, label );

            // Test if the flag is found
            if ( it == mCommandMap.end() )
                throw std::runtime_error("parse error: required flag is missing: " + tag + "/" + label);

            // Process the flag
            try {
                parse( value, (it->second) );
            }
            catch( const std::exception& e ) {
                throw std::runtime_error("parse error: could not parse: " + tag + "/" + label + ": " + e.what() );
            }

            return;
        }

    template <typename T>
        void Clutter::request( string tag, string label, T& value, string help )
        {
            // Safeguard: test require against the help tree
            if ( help_has_flag( tag, label ) )
                throw std::logic_error("logic error: duplicate flag in parse tree: " + tag + "/" + label);

            // Store the require in the help tree
            mHelpTree_requested.emplace_back( tag, label, help );

            // Check for help request
            if ( mHelpFlag ) return;

            // Find the flag position in the Command Map
            auto it = this->find_flag( tag, label );

            // Test if the flag is found
            if ( it == mCommandMap.end() )
                return;

            // Process the flag
            try {
                parse( value, (it->second) );
            }
            catch( const std::exception& e ) {
                throw std::runtime_error("parse error: could not parse: " + tag + "/" + label + ": " + e.what() );
            }

            return;
        }

    template <typename T>
        void Clutter::request( string tag, string label, bool& toggle, T& value, string help )
        {
            // Safeguard: test require against the help tree
            if ( help_has_flag( tag, label ) )
                throw std::logic_error("logic error: duplicate flag in parse tree");

            // Store the require in the help tree
            mHelpTree_requested.emplace_back( tag, label, help );

            // Check for help request
            if ( mHelpFlag ) return;

            // Find the flag position in the Command Map
            auto it = this->find_flag( tag, label );

            // Test if the flag is found
            if ( it == mCommandMap.end() )
                return;

            // If found: toggle the boolian
            toggle = !toggle;

            try {
                if (it->second.size() > 0)
                    // If there is an argument in the block: parse to value
                    parse( value, (it->second) );
                else
                    // Manually set processed flagelse
                    it->second.processed = true;
            }
            catch( const std::exception& e ) {
                throw std::runtime_error("parse error: could not parse: " + tag + "/" + label + ": " + e.what() );
            }

            return;
        }

    template <typename T>
        void Clutter::parse( T& value, CommandBlock& block )
        {
            // Test block size
            if ( block.size() == 0 )
                throw std::runtime_error("flag argument missing");
            if ( block.size() > 1 )
                throw std::runtime_error("orphan argument: " + block.values[1] );

            // Convert string to template type
            // value = fromString<T>( block.values[0] );
            value = sto<T>( block.values[0] );

            // Mark block as processed
            block.processed = true;
        }

    // Vector specialization
    template <typename T>
        void Clutter::parse( std::vector<T>& value, CommandBlock& block )
        {
            // Clear the values
            value.clear();

            // Test block size
            if ( block.size() == 0 )
                throw std::runtime_error("flag argument missing");

            // Convert string to template type
            for ( auto& e : block.values ) {
                value.push_back( fromString<T>( e ) );
            }

            // Mark as processed
            block.processed = true;
        }

    // Forward declare other specializations
    template <> void Clutter::parse<bool>( bool& value, CommandBlock& block );
    template <> void Clutter::parse<std::string>( std::string& value, CommandBlock& block );
}


text:
A very thin wrapper client around [S3 Storer](https://github.com/Skalar/s3_storer)'s API
Please see the documentation for S3 Storer's API on [their page](https://github.com/Skalar/s3_storer).

## Usage

```ruby
# Set up config

S3StorerClient::Api.config = S3StorerClient::Config.new(
  api_endpoint: 'https://s3-storer.herokuapp.com',
  basic_auth_user: "xxx",
  basic_auth_pass: "xxx",
  aws_access_key_id: "xxx",
  aws_secret_access_key: "xxx",
  s3_bucket: "xxx",
  s3_region: "xxx"
)

# Make requests to store

urls = {
  my: 'http://www.example.com/urls'
  urls: 'http://www.example.com/i/want/stored'
}
response = S3StorerClient.store urls
response.ok?
response.json['urls']['my'] # => returns url where example.com/i/want/stored now is coped to S3.

# Delete urls

urls = [
  'http://www.s3.com/urls', 'http://www.se.com/i/want/deleted'
]

response = S3StorerClient.delete urls
response.ok?

```

## Installation

Add this line to your application's Gemfile:

```ruby
gem 's3_storer_client'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install s3_storer_client

## Usage

TODO: Write usage instructions here

## Contributing

1. Fork it ( https://github.com/[my-github-username]/s3_storer_client/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
using System.ComponentModel;
using ACBr.Net.Core.Generics;

namespace ACBr.Net.NFSe.Nota
{
    public sealed class Deducao : GenericClone<Deducao>, INotifyPropertyChanged
    {
        #region Events

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion Events

        #region Constructors

        internal Deducao()
        {
        }

        #endregion Constructors

        #region Propriedades

        /// <summary>
        /// Gets or sets the deducao por.
        /// </summary>
        /// <value>The deducao por.</value>
        public DeducaoPor DeducaoPor { get; set; }

        /// <summary>
        /// Gets or sets the tipo deducao.
        /// </summary>
        /// <value>The tipo deducao.</value>
        public TipoDeducao TipoDeducao { get; set; }

        /// <summary>
        /// Gets or sets the CPFCNPJ referencia.
        /// </summary>
        /// <value>The CPFCNPJ referencia.</value>
        public string CPFCNPJReferencia { get; set; }

        /// <summary>
        /// Gets or sets the numero nf referencia.
        /// </summary>
        /// <value>The numero nf referencia.</value>
        public int? NumeroNFReferencia { get; set; }

        /// <summary>
        /// Gets or sets the valor total referencia.
        /// </summary>
        /// <value>The valor total referencia.</value>
        public decimal ValorTotalReferencia { get; set; }

        /// <summary>
        /// Gets or sets the percentual deduzir.
        /// </summary>
        /// <value>The percentual deduzir.</value>
        public decimal PercentualDeduzir { get; set; }

        /// <summary>
        /// Gets or sets the valor deduzir.
        /// </summary>
        /// <value>The valor deduzir.</value>
        public decimal ValorDeduzir { get; set; }

        #endregion Propriedades
    }
}


text:
<!DOCTYPE frameset SYSTEM "frameset.dtd">
<frameset>
    <predicate lemma="institute">
        <note>
            Frames file for 'institute' based on sentences in financial
            subcorpus.  No verbnet entry.  Comparison with 'establish' roleset
            of 'set'.
        </note>

        <roleset id="institute.01" name="establish" vncls="55.5-1">
            <roles>
                <role descr="agent, setter" n="0">
                    <vnrole vncls="55.5-1" vntheta="Agent"/>
                </role>
                <role descr="thing set" n="1">
                    <vnrole vncls="55.5-1" vntheta="Theme"/>
                </role>
                <role descr="attribute" n="2"/>
            </roles>

            <example name="transitive">
                <text>
                    Joseph Riccardo, an analyst with Bear, Stearns & Co., said
                    that over the past few years most drug makers have shed their
                    slow-growing businesses and instituted other cost savings, such as
                    consolidating manufacturing plants and administrative staffs.
                </text>
                <arg f="TMP" n="M">over the past few years</arg>
                <arg n="0">most drug makers</arg>
                <rel>instituted</rel>
                <arg n="1">other cost savings, such as consolidating
                    manufacturing plants and administrative staffs
                </arg>
            </example>

            <example name="with attribute">
                <text>
                    Mary instituted a curfew as a means of getting John home at a
                    reasonable hour.
                </text>
                <arg n="0">Mary</arg>
                <rel>instituted</rel>
                <arg n="1">a curfew</arg>
                <arg n="2">as a means of getting John home at a
                    reasonable hour.
                </arg>
            </example>

            <note>
                Not sure the latter is entirely good.
            </note>

        </roleset>
    </predicate>
</frameset>


text:
function BookingCtrl ($log, $location, $window, $scope, $timeout, $filter, BasketService, NEXT_URL, BOAT_ID, MESSAGES, datalayers) {

    var vm = this;
    var queryParams = $location.search();
    vm.isDataLoaded = true;
    vm.data = {};
    vm.data.booking_basket = {};
    vm.data.booking_basket.boat = BOAT_ID;
    vm.data.skipper = false;
    window.vm = vm;

    function applyQueryParams() {
        var dateFormat = new RegExp('^[0-9]{4}-[0-9]{2}-[0-9]{2}$');

        if (queryParams.date_from && dateFormat.test(queryParams.date_from)) {
            vm.data.booking_basket.checkin = queryParams.date_from;
        }

        if (queryParams.date_to && dateFormat.test(queryParams.date_to)) {
            vm.data.booking_basket.checkout = queryParams.date_to;
        }

        if (queryParams.nr_guests) {
            queryParams.nr_guests = parseInt(queryParams.nr_guests, 10);
            vm.data.booking_basket.guest_count = isNaN(queryParams.nr_guests) ? 1 : queryParams.nr_guests;
        } else {
            vm.data.booking_basket.guest_count = 1;
        }

        if (queryParams.skipper === '1') {
            vm.data.skipper = true;
        }
    }

    function handleCheckout() {
        $location.search('basket', vm.data.booking_basket.id);
        $window.location.href = NEXT_URL + vm.data.booking_basket.id;
    }

    function triggerGlobalEvent(type, data) {
        if (type) {
            jQuery(document).trigger(type, data);
            radio(type).broadcast(data);
        }
    }

    function formatCurrency(amount) {
        return $filter('currency')(amount, '', 2);
    }

    function pushEcommerceDataLayer() {
        function eventExists(event) {
            var bool = false;
            window.dataLayer.forEach(function(el) { if (el.event === event) bool = true; });
            return bool;
        }

        if (typeof window.dataLayer === 'object' && typeof datalayers.booking === 'object') {
            // add and format price
            datalayers.booking.eventValue = formatCurrency(vm.data.booking_basket.basket_total);
            datalayers.booking.ecommerce.add.products[0].price = formatCurrency(vm.data.booking_basket.basket_total);
            // because the create basket sometimes fires twice, check first if the datalayer has already been pushed to
            if (!eventExists(datalayers.booking.event)) {
                window.dataLayer.push(datalayers.booking);
            }
        }
    }

    function lockUi() {
        vm.isDataLoaded = false;
        window.ajaxProcessFlag = 0;
    }

    function unlockUi() {
        vm.isDataLoaded = true;
        window.ajaxProcessFlag = 1;
    }

    function shouldShowMmkDiscountMessage() {
        var checkinDay = $filter('date')(vm.data.booking_basket.checkin, 'EEE');
        var checkoutDay = $filter('date')(vm.data.booking_basket.checkout, 'EEE');

        if (checkinDay === 'Sat' && checkoutDay === 'Sat') {
            vm.showMmkDiscountMessage = false;
        } else {
            vm.showMmkDiscountMessage = true;
        }
    }

    function syncSkipperState() {
        if (vm.data.booking_basket.basket_items.length) {
            if (vm.data.booking_basket.basket_items[0].product_id === 'skipper') {
                vm.data.skipper = true;
            } else {
                vm.data.skipper = false;
            }
        }
        triggerGlobalEvent('skipperChange', vm.data.skipper);
    }

    function getPayload() {
        var payload = {
            booking_basket: {
                checkin: vm.data.booking_basket.checkin,
                checkout: vm.data.booking_basket.checkout,
                boat: vm.data.booking_basket.boat,
                guest_count: vm.data.booking_basket.guest_count
            }
        };

        if (vm.data.booking_basket.basket_items) {
            payload.booking_basket.basket_items = vm.data.booking_basket.basket_items;
        } else if (vm.data.skipper) {
            payload.booking_basket.basket_items = [{ product_id: 'skipper' }];
        }

        return payload;
    }

    function handleError(response) {
        var errorObj;

        if (response.data.errors) {
            // symfony form error structure :(
            errorObj = response.data.errors.children;
            Object.keys(errorObj).forEach(function (prop) {
                if (errorObj[prop].errors) {
                    vm.data.formError = errorObj[prop].errors[0];
                }
            });
            vm.data.formError = vm.data.formError ? vm.data.formError : response.data.message;
        } else if (response.data.message) {
            vm.data.formError = response.data.message;
        } else {
            vm.data.formError = MESSAGES.errors.general;
        }
        throw new Error(response.statusText);
    }

    function setBasketId(id) {
        vm.data.booking_basket.id = id;
        // hack to notify other js modules of basketId
        triggerGlobalEvent('basketId', id);
    }

    function createBasket() {
        return BasketService
            .create(getPayload())
            .then(function (response) {
                vm.data.formError = false;
                setBasketId(response.id);
            })
            .catch(handleError);
    }

    function updateBasket() {
        return BasketService
            .update(vm.data.booking_basket.id, getPayload())
            .then(function (response) {
                vm.data.formError = false;
            })
            .catch(handleError);
    }

    function getBasket() {
        return BasketService
            .get(vm.data.booking_basket.id)
            .then(function (response) {
                vm.data.booking_basket = response.data.booking_basket;
                if (!vm.data.booking_basket.basket_total) {
                    vm.data.formError = MESSAGES.errors.no_price;
                } else {
                    vm.data.formError = false;
                    triggerGlobalEvent('boatPrice', formatCurrency(vm.data.booking_basket.basket_total));
                }
                syncSkipperState();
                triggerGlobalEvent('nr_guestsDropdownChange', vm.data.booking_basket.guest_count);
            })
            .catch(handleError);
    }

    function addSkipper() {
        return BasketService
            .createItem(vm.data.booking_basket.id, {
                'basket_item': {
                    'product_id': 'skipper'
                }
            })
            .then(function (response) {
                vm.data.formError = false;
            })
            .catch(handleError);
    }

    function removeSkipper() {
        var items = vm.data.booking_basket.basket_items;
        var itemId;

        if (items.length) itemId = items[0].id;

        return BasketService
            .removeItem(vm.data.booking_basket.id, itemId)
            .then(function (response) {
                vm.data.formError = false;
            })
            .catch(handleError);
    }

    // add/replace dates and guest num in url params
    // so booking widget state is persisted when going back and forth
    function updateUrlParams() {
        if (vm.data.booking_basket.checkin && vm.data.booking_basket.checkout) {
            $location.search('date_from', vm.data.booking_basket.checkin.split('T')[0]);
            $location.search('date_to', vm.data.booking_basket.checkout.split('T')[0]);
            $location.search('nr_guests', vm.data.booking_basket.guest_count);
            $location.search('skipper', vm.data.skipper ? '1' : '0');
            $location.replace();
        }
    }

    vm.resolveBasket = function () {
        $timeout(function() {
            if (vm.form.$valid) {
                lockUi();
                if (vm.data.booking_basket.id) {
                    updateBasket()
                        .then(getBasket)
                        .finally(unlockUi);
                } else {
                    createBasket()
                        .then(getBasket)
                        .then(pushEcommerceDataLayer)
                        .finally(unlockUi);
                }
                shouldShowMmkDiscountMessage();
                updateUrlParams();
            }
        }, 100);
    };

    vm.resolveSkipper = function () {
        lockUi();
        updateUrlParams();

        if (!vm.data.booking_basket.basket_items.length) {
            addSkipper()
                .then(getBasket)
                .finally(unlockUi);
        } else {
            removeSkipper()
                .then(getBasket)
                .finally(unlockUi);
        }
    };

    vm.handleOfferCheckout = function() {
        lockUi();
        $window.location.href = NEXT_URL + vm.data.booking_basket.id;
    };

    vm.processForm = function () {
        if (vm.form.$valid && vm.data.booking_basket.basket_total) {
            lockUi();
            handleCheckout();
        }
    };

    if (typeof datalayers.offer === 'object' && queryParams.offer) {
        window.dataLayer.push(datalayers.offer);
    }

    if (queryParams.basket) {
        setBasketId(queryParams.basket);
        lockUi();
        getBasket()
            .catch(function (error) {
                setBasketId(null);
            })
            .finally(unlockUi);
    } else {
        applyQueryParams();
        // wait for the form to become available in the controller
        $scope.$watch('vm.form', function (form) {
            // now wait for the form to validate itself :(
            $timeout(vm.resolveBasket, 500);
        });
    }

}
BookingCtrl.$inject = ['$log', '$location', '$window', '$scope', '$timeout', '$filter', 'BasketService', 'NEXT_URL', 'BOAT_ID', 'MESSAGES', 'datalayers'];

angular
    .module('BookingApp')
    .controller('BookingCtrl', BookingCtrl);


text:
JavaScript control base class for both server and client side GUI development. Control is the opposite of templating. Currently the API is not stable.

Control.js is for people who prefer their HTML / DOM generating user interface code (server and client) completely written in JavaScript.
Control.js aims to be small. Control.js is used extensively by Framework.js that aims to be large.

Installation

	npm install controljs

Example usage:

	new control({
		  tag: 'html',
		  isRootControl: true,
		  items : [
		      {tag: 'head', items: [{tag: 'title', controlValue: 'Hello world app.'}]},
		      {tag: 'body', items: [{tag: 'h1', controlValue: 'Hello world!'}]}
		  ]
	}).render()

Resulting HTML:

			<title>Hello world app.</title>

Hello world!


text:
package com.zu.sweetalbum.swiftp.server;

import net.vrallev.android.cat.Cat;

public class CmdRANG extends FtpCmd implements Runnable {

    private String input;

    public CmdRANG(SessionThread sessionThread, String input) {
        super(sessionThread);
        this.input = input;
    }

    @Override
    public void run() {
        Cat.d("RANG executing");
        String param = getParameter(input);
        String splits[] = param.split(" ");
        String errString = null;

        mainblock:
        {
            if (splits.length != 2) {
                errString = "500 Malformed RANG command\r\n";
                break mainblock;
            } else if (!sessionThread.isBinaryMode()) {
                errString = "551 Server is not in binary mode\r\n";
                break mainblock;
            }

            long startPosition = 0L, endPosition = 0L;
            try {
                startPosition = Long.parseLong(splits[0]);
                endPosition = Long.parseLong(splits[1]);
            } catch (NumberFormatException e) {
                errString = "500 Invalid start and end position\r\n";
                break mainblock;
            }

            if (startPosition == 1 && endPosition == 0) {
                sessionThread.writeString("350 Resetting start and end positions\r\n");
                sessionThread.offset = -1L; // reset start position
                sessionThread.endPosition = -1L; //reset end position
                break mainblock;
            } else if (startPosition > endPosition) {
                errString = "500 Invalid start and end position\r\n";
                break mainblock;
            }

            sessionThread.offset = startPosition;
            sessionThread.endPosition = endPosition;
            sessionThread.writeString("350 Restarting at "
                    + startPosition + ". End Byte range at " + endPosition + ".\r\n");
        }

        if (errString != null) {
            sessionThread.writeString(errString);
        }
    }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no, minimal-ui">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <title>Omega Inc - Delivery</title>

    <link rel="stylesheet" href="css/framework7.material.min.css">
    <link rel="stylesheet" href="css/framework7.material.colors.min.css">

    <link rel="stylesheet" href="css/delivery.css">

    <link href="https://cdnjs.cloudflare.com/ajax/libs/toastr.js/latest/css/toastr.min.css" rel="stylesheet"/>

    <link href="http://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">

    <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" integrity="sha384-T8Gy5hrqNKT+hzMclPo118YTQO6cYprQmhrYwIiQ/3axmI1hQomh7Ud2hPOy8SP1" crossorigin="anonymous">

Delivery

 Estamos Fechados

                      Horário de Atendimento: Ter. à Dom. das 18h as 00h.

                      Telefone:

                      Email:


text:
package org.apache.hc.core5.http.impl.nio;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.apache.hc.core5.annotation.Internal;
import org.apache.hc.core5.http.ConnectionClosedException;
import org.apache.hc.core5.http.ConnectionReuseStrategy;
import org.apache.hc.core5.http.ContentLengthStrategy;
import org.apache.hc.core5.http.EntityDetails;
import org.apache.hc.core5.http.Header;
import org.apache.hc.core5.http.HttpException;
import org.apache.hc.core5.http.HttpRequest;
import org.apache.hc.core5.http.HttpResponse;
import org.apache.hc.core5.http.HttpStatus;
import org.apache.hc.core5.http.config.CharCodingConfig;
import org.apache.hc.core5.http.config.Http1Config;
import org.apache.hc.core5.http.impl.BasicHttpConnectionMetrics;
import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics;
import org.apache.hc.core5.http.impl.DefaultConnectionReuseStrategy;
import org.apache.hc.core5.http.impl.Http1StreamListener;
import org.apache.hc.core5.http.nio.AsyncServerExchangeHandler;
import org.apache.hc.core5.http.nio.CapacityChannel;
import org.apache.hc.core5.http.nio.ContentDecoder;
import org.apache.hc.core5.http.nio.ContentEncoder;
import org.apache.hc.core5.http.nio.HandlerFactory;
import org.apache.hc.core5.http.nio.NHttpMessageParser;
import org.apache.hc.core5.http.nio.NHttpMessageWriter;
import org.apache.hc.core5.http.nio.SessionInputBuffer;
import org.apache.hc.core5.http.nio.SessionOutputBuffer;
import org.apache.hc.core5.http.nio.command.RequestExecutionCommand;
import org.apache.hc.core5.http.protocol.HttpCoreContext;
import org.apache.hc.core5.http.protocol.HttpProcessor;
import org.apache.hc.core5.io.CloseMode;
import org.apache.hc.core5.reactor.ProtocolIOSession;
import org.apache.hc.core5.util.Args;
import org.apache.hc.core5.util.Asserts;
import org.apache.hc.core5.util.Timeout;

/**
 * I/O event handler for events fired by {@link ProtocolIOSession} that implements
 * server side HTTP/1.1 messaging protocol with full support for
 * duplexed message transmission and message pipelining.
 *
 * @since 5.0
 */
@Internal
public class ServerHttp1StreamDuplexer extends AbstractHttp1StreamDuplexer<HttpRequest, HttpResponse> {

    private final String scheme;
    private final HttpProcessor httpProcessor;
    private final HandlerFactory<AsyncServerExchangeHandler> exchangeHandlerFactory;
    private final Http1Config http1Config;
    private final ConnectionReuseStrategy connectionReuseStrategy;
    private final Http1StreamListener streamListener;
    private final Queue<ServerHttp1StreamHandler> pipeline;
    private final Http1StreamChannel<HttpResponse> outputChannel;

    private volatile ServerHttp1StreamHandler outgoing;
    private volatile ServerHttp1StreamHandler incoming;

    public ServerHttp1StreamDuplexer(
            final ProtocolIOSession ioSession,
            final HttpProcessor httpProcessor,
            final HandlerFactory<AsyncServerExchangeHandler> exchangeHandlerFactory,
            final String scheme,
            final Http1Config http1Config,
            final CharCodingConfig charCodingConfig,
            final ConnectionReuseStrategy connectionReuseStrategy,
            final NHttpMessageParser<HttpRequest> incomingMessageParser,
            final NHttpMessageWriter<HttpResponse> outgoingMessageWriter,
            final ContentLengthStrategy incomingContentStrategy,
            final ContentLengthStrategy outgoingContentStrategy,
            final Http1StreamListener streamListener) {
        super(ioSession, http1Config, charCodingConfig, incomingMessageParser, outgoingMessageWriter,
                incomingContentStrategy, outgoingContentStrategy);
        this.httpProcessor = Args.notNull(httpProcessor, "HTTP processor");
        this.exchangeHandlerFactory = Args.notNull(exchangeHandlerFactory, "Exchange handler factory");
        this.scheme = scheme;
        this.http1Config = http1Config != null ? http1Config : Http1Config.DEFAULT;
        this.connectionReuseStrategy = connectionReuseStrategy != null ? connectionReuseStrategy :
                DefaultConnectionReuseStrategy.INSTANCE;
        this.streamListener = streamListener;
        this.pipeline = new ConcurrentLinkedQueue<>();
        this.outputChannel = new Http1StreamChannel<HttpResponse>() {

            @Override
            public void close() {
                ServerHttp1StreamDuplexer.this.close(CloseMode.GRACEFUL);
            }

            @Override
            public void submit(
                    final HttpResponse response,
                    final boolean endStream,
                    final FlushMode flushMode) throws HttpException, IOException {
                if (streamListener != null) {
                    streamListener.onResponseHead(ServerHttp1StreamDuplexer.this, response);
                }
                commitMessageHead(response, endStream, flushMode);
            }

            @Override
            public void requestOutput() {
                requestSessionOutput();
            }

            @Override
            public void suspendOutput() throws IOException {
                suspendSessionOutput();
            }

            @Override
            public Timeout getSocketTimeout() {
                return getSessionTimeout();
            }

            @Override
            public void setSocketTimeout(final Timeout timeout) {
                setSessionTimeout(timeout);
            }

            @Override
            public int write(final ByteBuffer src) throws IOException {
                return streamOutput(src);
            }

            @Override
            public void complete(final List<? extends Header> trailers) throws IOException {
                endOutputStream(trailers);
            }

            @Override
            public boolean isCompleted() {
                return isOutputCompleted();
            }

            @Override
            public boolean abortGracefully() throws IOException {
                final MessageDelineation messageDelineation = endOutputStream(null);
                return messageDelineation != MessageDelineation.MESSAGE_HEAD;
            }

            @Override
            public void activate() throws HttpException, IOException {
                // empty
            }

            @Override
            public String toString() {
                return "Http1StreamChannel[" + ServerHttp1StreamDuplexer.this + "]";
            }

        };
    }

    @Override
    void terminate(final Exception exception) {
        if (incoming != null) {
            incoming.failed(exception);
            incoming.releaseResources();
            incoming = null;
        }
        if (outgoing != null) {
            outgoing.failed(exception);
            outgoing.releaseResources();
            outgoing = null;
        }
        for (;;) {
            final ServerHttp1StreamHandler handler = pipeline.poll();
            if (handler != null) {
                handler.failed(exception);
                handler.releaseResources();
            } else {
                break;
            }
        }
    }

    @Override
    void disconnected() {
        if (incoming != null) {
            if (!incoming.isCompleted()) {
                incoming.failed(new ConnectionClosedException());
            }
            incoming.releaseResources();
            incoming = null;
        }
        if (outgoing != null) {
            if (!outgoing.isCompleted()) {
                outgoing.failed(new ConnectionClosedException());
            }
            outgoing.releaseResources();
            outgoing = null;
        }
        for (;;) {
            final ServerHttp1StreamHandler handler = pipeline.poll();
            if (handler != null) {
                handler.failed(new ConnectionClosedException());
                handler.releaseResources();
            } else {
                break;
            }
        }
    }

    @Override
    void updateInputMetrics(final HttpRequest request, final BasicHttpConnectionMetrics connMetrics) {
        connMetrics.incrementRequestCount();
    }

    @Override
    void updateOutputMetrics(final HttpResponse response, final BasicHttpConnectionMetrics connMetrics) {
        if (response.getCode() >= HttpStatus.SC_OK) {
            connMetrics.incrementRequestCount();
        }
    }

    @Override
    protected boolean handleIncomingMessage(final HttpRequest request) throws HttpException {
        return true;
    }

    @Override
    protected ContentDecoder createContentDecoder(
            final long len,
            final ReadableByteChannel channel,
            final SessionInputBuffer buffer,
            final BasicHttpTransportMetrics metrics) throws HttpException {
        if (len >= 0) {
            return new LengthDelimitedDecoder(channel, buffer, metrics, len);
        } else if (len == ContentLengthStrategy.CHUNKED) {
            return new ChunkDecoder(channel, buffer, http1Config, metrics);
        } else {
            return null;
        }
    }

    @Override
    protected boolean handleOutgoingMessage(final HttpResponse response) throws HttpException {
        return true;
    }

    @Override
    protected ContentEncoder createContentEncoder(
            final long len,
            final WritableByteChannel channel,
            final SessionOutputBuffer buffer,
            final BasicHttpTransportMetrics metrics) throws HttpException {
        final int chunkSizeHint = http1Config.getChunkSizeHint() >= 0 ? http1Config.getChunkSizeHint() : 2048;
        if (len >= 0) {
            return new LengthDelimitedEncoder(channel, buffer, metrics, len, chunkSizeHint);
        } else if (len == ContentLengthStrategy.CHUNKED) {
            return new ChunkEncoder(channel, buffer, metrics, chunkSizeHint);
        } else {
            return new IdentityEncoder(channel, buffer, metrics, chunkSizeHint);
        }
    }

    @Override
    boolean inputIdle() {
        return incoming == null;
    }

    @Override
    boolean outputIdle() {
        return outgoing == null && pipeline.isEmpty();
    }

    @Override
    HttpRequest parseMessageHead(final boolean endOfStream) throws IOException, HttpException {
        try {
            return super.parseMessageHead(endOfStream);
        } catch (final HttpException ex) {
            terminateExchange(ex);
            return null;
        }
    }

    void terminateExchange(final HttpException ex) throws HttpException, IOException {
        suspendSessionInput();
        final ServerHttp1StreamHandler streamHandler;
        final HttpCoreContext context = HttpCoreContext.create();
        context.setAttribute(HttpCoreContext.SSL_SESSION, getSSLSession());
        context.setAttribute(HttpCoreContext.CONNECTION_ENDPOINT, getEndpointDetails());
        if (outgoing == null) {
            streamHandler = new ServerHttp1StreamHandler(
                    outputChannel,
                    httpProcessor,
                    connectionReuseStrategy,
                    exchangeHandlerFactory,
                    context);
            outgoing = streamHandler;
        } else {
            streamHandler = new ServerHttp1StreamHandler(
                    new DelayedOutputChannel(outputChannel),
                    httpProcessor,
                    connectionReuseStrategy,
                    exchangeHandlerFactory,
                    context);
            pipeline.add(streamHandler);
        }
        streamHandler.terminateExchange(ex);
        incoming = null;
    }

    @Override
    void consumeHeader(final HttpRequest request, final EntityDetails entityDetails) throws HttpException, IOException {
        if (streamListener != null) {
            streamListener.onRequestHead(this, request);
        }
        final ServerHttp1StreamHandler streamHandler;
        final HttpCoreContext context = HttpCoreContext.create();
        context.setAttribute(HttpCoreContext.SSL_SESSION, getSSLSession());
        context.setAttribute(HttpCoreContext.CONNECTION_ENDPOINT, getEndpointDetails());
        if (outgoing == null) {
            streamHandler = new ServerHttp1StreamHandler(
                    outputChannel,
                    httpProcessor,
                    connectionReuseStrategy,
                    exchangeHandlerFactory,
                    context);
            outgoing = streamHandler;
        } else {
            streamHandler = new ServerHttp1StreamHandler(
                    new DelayedOutputChannel(outputChannel),
                    httpProcessor,
                    connectionReuseStrategy,
                    exchangeHandlerFactory,
                    context);
            pipeline.add(streamHandler);
        }
        request.setScheme(scheme);
        streamHandler.consumeHeader(request, entityDetails);
        incoming = streamHandler;
    }

    @Override
    void consumeData(final ByteBuffer src) throws HttpException, IOException {
        Asserts.notNull(incoming, "Request stream handler");
        incoming.consumeData(src);
    }

    @Override
    void updateCapacity(final CapacityChannel capacityChannel) throws HttpException, IOException {
        Asserts.notNull(incoming, "Request stream handler");
        incoming.updateCapacity(capacityChannel);
    }

    @Override
    void dataEnd(final List<? extends Header> trailers) throws HttpException, IOException {
        Asserts.notNull(incoming, "Request stream handler");
        incoming.dataEnd(trailers);
    }

    @Override
    void inputEnd() throws HttpException, IOException {
        if (incoming != null) {
            if (incoming.isCompleted()) {
                incoming.releaseResources();
            }
            incoming = null;
        }
        if (isShuttingDown() && outputIdle() && inputIdle()) {
            shutdownSession(CloseMode.IMMEDIATE);
        }
    }

    @Override
    void execute(final RequestExecutionCommand executionCommand) throws HttpException {
        throw new HttpException("Illegal command: " + executionCommand.getClass());
    }

    @Override
    boolean isOutputReady() {
        return outgoing != null && outgoing.isOutputReady();
    }

    @Override
    void produceOutput() throws HttpException, IOException {
        if (outgoing != null) {
            outgoing.produceOutput();
        }
    }

    @Override
    void outputEnd() throws HttpException, IOException {
        if (outgoing != null && outgoing.isResponseFinal()) {
            if (streamListener != null) {
                streamListener.onExchangeComplete(this, outgoing.keepAlive());
            }
            if (outgoing.isCompleted()) {
                outgoing.releaseResources();
            }
            outgoing = null;
        }
        if (outgoing == null && isActive()) {
            final ServerHttp1StreamHandler handler = pipeline.poll();
            if (handler != null) {
                outgoing = handler;
                handler.activateChannel();
                if (handler.isOutputReady()) {
                    handler.produceOutput();
                }
            }
        }
        if (isShuttingDown() && outputIdle() && inputIdle()) {
            shutdownSession(CloseMode.IMMEDIATE);
        }
    }

    @Override
    boolean handleTimeout() {
        return false;
    }

    @Override
    void appendState(final StringBuilder buf) {
        super.appendState(buf);
        buf.append(", incoming=[");
        if (incoming != null) {
            incoming.appendState(buf);
        }
        buf.append("], outgoing=[");
        if (outgoing != null) {
            outgoing.appendState(buf);
        }
        buf.append("], pipeline=");
        buf.append(pipeline.size());
    }

    @Override
    public String toString() {
        final StringBuilder buf = new StringBuilder();
        buf.append("[");
        appendState(buf);
        buf.append("]");
        return buf.toString();
    }

    private static class DelayedOutputChannel implements Http1StreamChannel<HttpResponse> {

        private final Http1StreamChannel<HttpResponse> channel;

        private volatile boolean direct;
        private volatile HttpResponse delayedResponse;
        private volatile boolean completed;

        private DelayedOutputChannel(final Http1StreamChannel<HttpResponse> channel) {
            this.channel = channel;
        }

        @Override
        public void close() {
            channel.close();
        }

        @Override
        public void submit(
                final HttpResponse response,
                final boolean endStream,
                final FlushMode flushMode) throws HttpException, IOException {
            synchronized (this) {
                if (direct) {
                    channel.submit(response, endStream, flushMode);
                } else {
                    delayedResponse = response;
                    completed = endStream;
                }
            }
        }

        @Override
        public void suspendOutput() throws IOException {
            channel.suspendOutput();
        }

        @Override
        public void requestOutput() {
            channel.requestOutput();
        }

        @Override
        public Timeout getSocketTimeout() {
            return channel.getSocketTimeout();
        }

        @Override
        public void setSocketTimeout(final Timeout timeout) {
            channel.setSocketTimeout(timeout);
        }

        @Override
        public int write(final ByteBuffer src) throws IOException {
            synchronized (this) {
                return direct ? channel.write(src) : 0;
            }
        }

        @Override
        public void complete(final List<? extends Header> trailers) throws IOException {
            synchronized (this) {
                if (direct) {
                    channel.complete(trailers);
                } else {
                    completed = true;
                }
            }
        }

        @Override
        public boolean abortGracefully() throws IOException {
            synchronized (this) {
                if (direct) {
                    return channel.abortGracefully();
                }
                completed = true;
                return true;
            }
        }

        @Override
        public boolean isCompleted() {
            synchronized (this) {
                return direct ? channel.isCompleted() : completed;
            }
        }

        @Override
        public void activate() throws IOException, HttpException {
            synchronized (this) {
                direct = true;
                if (delayedResponse != null) {
                    channel.submit(delayedResponse, completed, completed ? FlushMode.IMMEDIATE : FlushMode.BUFFER);
                    delayedResponse = null;
                }
            }
        }

    }

}


text:
(function(){

var log = Log.forModule("CacheManager");

/**
 * @namespace {Jaxer.Cache}
 * A namespace object holding functions and members for in-memory caches
 * @advanced
 */
var CacheManager = {};

CacheManager.callbackPages = {};

CacheManager.autoloadScripts = {};

frameworkGlobal.CacheManager = Jaxer.CacheManager = CacheManager;

Log.trace("*** CacheManager.js loaded");

})();


text:
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.compositor.bottombar.contextualsearch;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.widget.ImageView;

import androidx.appcompat.content.res.AppCompatResources;

import org.chromium.chrome.R;
import org.chromium.ui.resources.dynamics.DynamicResourceLoader;
import org.chromium.ui.resources.dynamics.ViewResourceInflater;

/**
 * Manages an icon to display in the {@link ContextualSearchBarControl} in a non-action card
 * returned by the server. A Card is a structured result from the CoCa backend that can
 * be rendered directly in the Bar. Action cards have associated intents, like dialing
 * a phone number. This class handles some special cases for the general
 * {@link ContextualSearchImageControl} that is responsible for any image that is rendered
 * in the Bar.
 */
public class ContextualSearchCardIconControl extends ViewResourceInflater {
    private final Context mContext;
    private boolean mHasIcon;

    /**
     * @param context The Android Context used to inflate the View.
     * @param resourceLoader The resource loader that will handle the snapshot capturing.
     */
    public ContextualSearchCardIconControl(Context context, DynamicResourceLoader resourceLoader) {
        super(R.layout.contextual_search_card_icon_view, R.id.contextual_search_card_icon_view,
                context, null, resourceLoader);
        mContext = context;
    }

    /**
     * Sets the icon to a vector drawable dictionary definition image.
     */
    void setVectorDrawableDefinitionIcon() {
        setVectorDrawableResourceId(R.drawable.ic_book_round);
    }

    /**
     * Sets this view to display the icon from the given vector drawable resource.
     * @param resId The resource ID of a drawable.
     */
    private void setVectorDrawableResourceId(int resId) {
        Drawable drawable = AppCompatResources.getDrawable(mContext, resId);
        if (drawable != null) {
            inflate();
            ((ImageView) getView()).setImageDrawable(drawable);
            invalidate();
            mHasIcon = true;
        }
    }

    /**
     * @return The resource id for the icon associated with the card, if present.
     */
    private int getIconResId() {
        return mHasIcon ? getViewId() : 0;
    }

    @Override
    protected boolean shouldAttachView() {
        return false;
    }
}


text:
package me.aliceq.garbler.analyzer;

import java.util.HashMap;
import java.util.Map;
import me.aliceq.garbler.GarblerAnalyzer;
import me.aliceq.heatmap.HeatMap;

/**
 * Analyzer which keeps track of the correlation between the first letter in a
 * word and its length
 *
 * @author Alice Quiros <email@aliceq.me>
 */
public class WordLengthCorrelationAnalyzer implements GarblerAnalyzer<Integer> {

    private final Map<Character, HeatMap<Integer>> map = new HashMap();

    @Override
    public void analyze(String word) {
        if (word.isEmpty()) {
            return;
        }

        char first = word.charAt(0);
        int length = word.length();

        HeatMap<Integer> heatmap = map.get(first);
        if (heatmap == null) {
            heatmap = new HeatMap();
            map.put(first, heatmap);
        }
        heatmap.increment(length);
    }

    @Override
    public HeatMap<Integer> next(String context, String wordPrefix) {
        if (wordPrefix.length() < 1) {
            return null;
        }
        char c = wordPrefix.charAt(0);
        HeatMap<Integer> heatmap = map.get(c);
        return heatmap;
    }

    @Override
    public void clear() {
        map.clear();
    }

}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.consciencemobilesafe.app"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="17" />

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <uses-permission android:name="android.permission.SEND_SMS" />
    <uses-permission android:name="android.permission.RECEIVE_SMS" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.VIBRATE" />
    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />

    <instrumentation
        android:name="android.test.InstrumentationTestRunner"
        android:targetPackage="com.consciencemobilesafe.app" />

    <uses-permission android:name="android.permission.CALL_PHONE" />
    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
    <uses-permission android:name="android.permission.READ_LOGS" />
    <uses-permission android:name="android.permission.READ_SMS" />
    <uses-permission android:name="android.permission.WRITE_SMS" />
    <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES" />
    <uses-permission android:name="android.permission.GET_TASKS" />
    <uses-permission android:name="android.permission.GET_PACKAGE_SIZE"/>
    <uses-permission android:name="android.permission.CLEAR_APP_CACHE"/>

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.consciencemobilesafe.SplashActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="com.consciencemobilesafe.HomeActivity" />
        <activity android:name="com.consciencemobilesafe.SettingActivity" />
        <activity android:name="com.consciencemobilesafe.SetupActivity1" />
        <activity android:name="com.consciencemobilesafe.LostFindActivity" />
        <activity android:name="com.consciencemobilesafe.SetupActivity2" />
        <activity android:name="com.consciencemobilesafe.SetupActivity3" />
        <activity android:name="com.consciencemobilesafe.SetupActivity4" />
        <activity android:name="com.consciencemobilesafe.SelectContactActivity" />
        <activity android:name="com.consciencemobilesafe.AtoolActivity" />
        <activity android:name="com.consciencemobilesafe.NumberQueryActivity" />
        <activity android:name="com.consciencemobilesafe.NumberSmsSafeActivity" />
        <activity android:name="com.consciencemobilesafe.APPManagerActivity" />
        <activity android:name="com.consciencemobilesafe.TaskManagerActivity" />
        <activity android:name="com.consciencemobilesafe.TaskManagerSettingActivity" />
        <activity
            android:name="com.consciencemobilesafe.WatchDogItemActivity"
            android:launchMode="singleInstance" />
        <activity android:name="com.consciencemobilesafe.AntiVirusActivity" />
        <activity android:name="com.consciencemobilesafe.CleanCacheActivity" />
        <activity android:name="com.consciencemobilesafe.TrafficManagerActivity" />

        <uses-library android:name="android.test.runner" />

        <service android:name="com.consciencemobilesafe.service.GPSService" />
        <service android:name="com.consciencemobilesafe.service.NumberQueryService" />
        <service android:name="com.consciencemobilesafe.service.BlackSmsService" />
        <service android:name="com.consciencemobilesafe.service.TaskManagerLockCleanService" />
        <service android:name="com.consciencemobilesafe.service.UpdateWidgetService" />
        <service android:name="com.consciencemobilesafe.service.WatchDogService" />

        <receiver android:name="com.consciencemobilesafe.receiver.BootCompleteReceiver" >
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <receiver android:name="com.consciencemobilesafe.receiver.SmsReceiver" >
            <intent-filter android:priority="1000" >
                <action android:name="android.provider.Telephony.SMS_RECEIVED" />
            </intent-filter>
        </receiver>
        <receiver
            android:name="com.consciencemobilesafe.receiver.MyAdmin"
            android:description="@string/sample_device_admin_description"
            android:label="@string/sample_device_admin"
            android:permission="android.permission.BIND_DEVICE_ADMIN" >
            <meta-data
                android:name="android.app.device_admin"
                android:resource="@xml/device_admin_sample" />

            <intent-filter>
                <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
            </intent-filter>
        </receiver>
        <receiver android:name="com.consciencemobilesafe.receiver.MyWidget" >
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
            </intent-filter>

            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/process_widget_provider" />
        </receiver>
        <receiver android:name="com.consciencemobilesafe.receiver.WidgetCleanReceiver" >
            <intent-filter>
                <action android:name="com.consciencemobilesafe.clean" />
            </intent-filter>
        </receiver>
    </application>

</manifest>


text:
package com.netflix.spinnaker.clouddriver.cloudfoundry.deploy.ops;

import com.netflix.spinnaker.clouddriver.cloudfoundry.client.CloudFoundryApiException;
import com.netflix.spinnaker.clouddriver.cloudfoundry.client.CloudFoundryClient;
import com.netflix.spinnaker.clouddriver.cloudfoundry.client.Routes;
import com.netflix.spinnaker.clouddriver.cloudfoundry.deploy.description.LoadBalancersDescription;
import com.netflix.spinnaker.clouddriver.cloudfoundry.model.CloudFoundryLoadBalancer;
import com.netflix.spinnaker.clouddriver.data.task.Task;
import com.netflix.spinnaker.clouddriver.data.task.TaskRepository;
import com.netflix.spinnaker.clouddriver.orchestration.AtomicOperation;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class UnmapLoadBalancersAtomicOperation implements AtomicOperation<Void> {
  public static final String PHASE = "UNMAP_LOAD_BALANCERS";

  private final LoadBalancersDescription description;

  private static Task getTask() {
    return TaskRepository.threadLocalTask.get();
  }

  @Override
  public Void operate(List priorOutputs) {
    getTask()
        .updateStatus(
            PHASE, "Unmapping '" + description.getServerGroupName() + "' from load balancer(s).");

    List<String> routeList = description.getRoutes();
    if (routeList == null || routeList.size() == 0) {
      throw new CloudFoundryApiException("No load balancer specified");
    } else {
      Routes routes = description.getClient().getRoutes();
      Map<String, Optional<CloudFoundryLoadBalancer>> lbMap =
          routeList.stream()
              .collect(
                  Collectors.toMap(
                      uri -> uri,
                      uri ->
                          Optional.ofNullable(
                              routes.find(routes.toRouteId(uri), description.getSpace().getId()))));
      routeList.forEach(
          uri -> {
            if (!Routes.isValidRouteFormat(uri)) {
              throw new CloudFoundryApiException("Invalid format for load balancer '" + uri + "'");
            } else if (!lbMap.get(uri).isPresent()) {
              throw new CloudFoundryApiException("Load balancer '" + uri + "' does not exist");
            }
          });

      CloudFoundryClient client = description.getClient();
      lbMap.forEach(
          (uri, o) -> {
            getTask().updateStatus(PHASE, "Unmapping load balancer '" + uri + "'");
            o.ifPresent(
                lb ->
                    client
                        .getApplications()
                        .unmapRoute(description.getServerGroupId(), lb.getId()));
            getTask().updateStatus(PHASE, "Unmapped load balancer '" + uri + "'");
          });
    }

    return null;
  }
}


text:
var
    use_db          = false,
    gameport        = 8000,
    app             = require('express')(),
    server          = app.listen(gameport),
    io              = require('socket.io')(server),
    _               = require('underscore'),
    fs              = require('fs');

if (use_db) {
    database        = require(__dirname + "/database"),
    connection      = database.getConnection();
}

game_server = require('./game.server.js');
utils = require('./utils.js');

global_player_set = {}

// Log something so we know that server-side setup succeeded
console.log("info  - socket.io started");
console.log('\t :: Express :: Listening on port ' + gameport );

//  This handler will listen for requests on /*, any file from the
//  root of our server. See expressjs documentation for more info
app.get( '/*' , function( req, res ) {
    // this is the current file they have requested
    var file = req.params[0];
    console.log('\t :: Express :: file requested: ' + file);

    if(req.query.id && !valid_id(req.query.id)) {
	res.redirect('http://projects.csail.mit.edu/ci/turk/forms/invalid.html')
    } else {
	if(req.query.id && req.query.id in global_player_set) {
	    res.redirect('http://projects.csail.mit.edu/ci/turk/forms/duplicate.html')
	} else {
	    // give them what they want
	    res.sendfile("./" + file);
	}
    }
});

// Socket.io will call this function when a client connects. We check
// to see if the client supplied a id. If so, we distinguish them by
// that, otherwise we assign them one at random
io.on('connection', function (client) {
    // Recover query string information and set condition
    var hs = client.handshake;
    var query = require('url').parse(client.handshake.headers.referer, true).query;
    if( !(query.id && query.id in global_player_set) ) {
	if(query.id) {
	    global_player_set[query.id] = true
	    var id = query.id; // use id from query string if exists
	} else {
	    var id = utils.UUID();
	}
	if(valid_id(id)) {
	    console.log("user connecting...")
	    initialize(query, client, id);
	}
    }
});

var valid_id = function(id) {
    return id.length == 41;
}

var initialize = function(query, client, id) {
    client.userid = id;
    client.emit('onconnected', { id: client.userid } );

    // Good to know when they connected
    console.log('\t socket.io:: player ' + client.userid + ' connected');

    //Pass off to game.server.js code
    game_server.findGame(client);

    // Now we want set up some callbacks to handle messages that clients will send.
    // We'll just pass messages off to the server_onMessage function for now.
    client.on('message', function(m) {
        game_server.server_onMessage(client, m);
    });

    // When this client disconnects, we want to tell the game server
    // about that as well, so it can remove them from the game they are
    // in, and make sure the other player knows that they left and so on.
    client.on('disconnect', function () {
        console.log('\t socket.io:: client id ' + client.userid
                    + ' disconnected from game id ' + client.game.id);

        //If the client was in a game set by game_server.findGame,
        //we can tell the game server to update that game state.
        if(client.userid && client.game && client.game.id)
	    console.log("calling end game...")
            //player leaving a game should change that game
            game_server.endGame(client.game.id, client.userid);
    });
};


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

namespace D3Demos.Models
{
    public class TagDataPoint
    {
        public string TagName { get; set; }
        public int Rate { get; set; }
        public int MonthAsked { get; set; }
        public int YearAsked { get; set; }

        public DateTime DateAsked
        {
            get
            {
                return new DateTime(YearAsked, MonthAsked, 1);
            }
            set { }
        }
    }
}