text:
/* These styles are used by both reset_profile_settings_banner.html and
 * automatic_settings_reset_banner.html. */

.settings-banner {
  background-color: #f5f5f5;
  border-color: #c8c8c8;
  border-radius: 3px;
  border-style: solid;
  border-width: 1px;
  margin-bottom: 24px;
  margin-top: 20px;
  max-width: 716px;
  position: relative;
}

.settings-banner > .close-button {
  background-image: url('chrome://theme/IDR_CLOSE_DIALOG');
  background-position: center;
  background-repeat: no-repeat;
  height: 14px;
  opacity: 0.5;
  position: absolute;
  right: 4px;
  top: 4px;
  width: 14px;
}

html[dir='rtl'] .settings-banner > .close-button {
  left: 4px;
  right: auto;
}

.settings-banner > .close-button:hover {
  background-image: url('chrome://theme/IDR_CLOSE_DIALOG_H');
}

.settings-banner > .close-button:active {
  background-image: url('chrome://theme/IDR_CLOSE_DIALOG_P');
}

.settings-banner .content-area {
  -webkit-box-align: center;
  display: -webkit-box;
  padding: 17px;
}

.settings-banner .content-area .badge {
  background-image: url(yellow_gear.png);
  background-position: center;
  background-repeat: no-repeat;
  height: 55px;
  width: 58px;
}

.settings-banner .content-area .text {
  -webkit-box-flex: 1.0;
  -webkit-margin-start: 18px;
}

.settings-banner .content-area .text p {
  -webkit-margin-after: 0;
  -webkit-margin-before: 0;
}

.settings-banner .content-area .button-area  {
  -webkit-margin-start: 54px;
}

.settings-banner .nowrap  {
  white-space: nowrap;
}

.settings-banner button {
  margin-bottom: 1px;
  margin-right: 0;
}

#secondary-user-banner .content-area .badge {
  background-color: rgb(210, 210, 212);
  background-image: url(chrome://theme/IDR_SECONDARY_USER_SETTINGS);
}


text:
namespace Ogre {
	class Matrix4;
}

namespace XE {

	class GraphicsManager;
	class ImgGuiMovableObject;

	///lives in Rendererthread
	class EditorUIRenderer
	{

	public:
		EditorUIRenderer(GraphicsManager& graphicsManager, Ogre::Camera* camera);

		~EditorUIRenderer();

		void init();

		void Render(const Ogre::Matrix4& projMatrix, const sf::Vector2f& viewportSize, const float delta);

		static bool ProcessSDLEvent(SDL_Event* event);

		IEditorUIState& createUIState(std::unique_ptr<IEditorUIState> uiState);

		IEditorUIState* getUIState(int ID);

		std::atomic<bool> IsGizmoEnabled;

	private:

		Ogre::Camera* m_camera;

		void _t_createFontTexture();

		GraphicsManager& m_graphicsManager;

		Ogre::TexturePtr mFontTex;

		std::vector<ImgGuiMovableObject*> _t_ImgGuiMovableObject;

		std::vector<std::unique_ptr<IEditorUIState>> m_EditorUIStates;
	};

}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

    <meta content="text/html; charset=utf-8" http-equiv="content-type">
    <meta property="og:title" content="">
    <meta property="og:description" content="">
    <meta property="og:site_name" content="http://www.picfil.tk">

    <title></title><link href="assets/css/style.css" rel="stylesheet">

    <link href="http://fonts.googleapis.com/css?family=Yanone+Kaffeesatz:400,200" rel="stylesheet">

PicFil

        Use filters for your Pictures

 Download
        Image

 Normal

 Vintage

 Lomo

 Clarity

 Sin City

 Sunrise

 Cross Process

 Orange Peel

 Love

 Grungy

 Jarques

 Pinhole

 Old Boot

 Glowing Sun

 Hazy Days

 Her Majesty

 Nostalgia

 Hemingway

 Concentrate

    Fusion Apps © - Vikhyat Chaudhry


text:
(function( $, undefined ) {

$.KBWidget({
    name: "ContigSetUploadWidget",
    parent: "kbaseAuthenticatedWidget",
    version: "1.0.0",
	token: null,
	ws_name: null,
	contig_set: null,
    options: {
    	ws_name: null,
    	contig_set: null
    },

    wsUrl: window.kbconfig.urls.workspace,
    uploadUrl: "https://kbase.us/services/xxx/uploader",

    init: function(options) {
        this._super(options);
        this.ws_name = options.ws_name;
        this.contig_set = options.contig_set;
        return this;
    },

    render: function() {
        var self = this;
        var container = this.$elem;
    	container.empty();
        if (self.token == null) {
        	container.append("
[Error] You're not logged in
");
        	return;
        }
    	var pref = this.uuid();
        var kbws = new Workspace(this.wsUrl, {'token': self.token});
    	var panel = $('
'+
    			'Contig Set Target ID: ' + self.contig_set + '

' +
    			'<form id="'+pref+'form" action="' + self.uploadUrl + '" enctype="multipart/form-data" method="post" target="'+pref+'hidden-iframe">'+
    			'<input type="hidden" name="token" value="' + self.token + '">'+
    			'<input type="hidden" name="ws" value="' + self.ws_name + '">'+
    			'<input type="hidden" name="id" value="' + self.contig_set + '">'+
    			'<input type="hidden" name="type" value="contigfasta">'+
    			'<input type="file" name="file">
'+
    			'<input type="submit" value="Upload">'+
    			'</form>
'+
    			''+
    			'
');
    	container.append(panel);
    	var ifrm = document.getElementById(pref+'frm');
    	ifrm = (ifrm.contentWindow) ? ifrm.contentWindow : (ifrm.contentDocument.document) ? ifrm.contentDocument.document : ifrm.contentDocument;
    	ifrm.document.open();
    	ifrm.document.write("Please wait...");
    	ifrm.document.close();
    	$('#'+pref+'form').submit(function( event ) {
    		$('#'+pref+'frm').show();
    	});
        return this;
    },

    loggedInCallback: function(event, auth) {
        this.token = auth.token;
        this.render();
        return this;
    },

    loggedOutCallback: function(event, auth) {
        this.token = null;
        this.render();
        return this;
    },

    uuid: function() {
        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,
            function(c) {
                var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
                return v.toString(16);
            });
    }
})
}( jQuery ) );


text:
set -o errexit
set -o nounset
set -o pipefail

OS_ROOT=$(dirname "${BASH_SOURCE}")/..
source "${OS_ROOT}/hack/common.sh"

# Go to the top of the tree.
cd "${OS_ROOT}"

# Get the latest Linux release
if [[ ! -d _output/local/releases ]]; then
  echo "No release has been built. Run hack/build-release.sh"
  exit 1
fi
releases=$(find _output/local/releases/ -print | grep 'openshift-origin-.*-linux-' --color=never)
if [[ $(echo $releases | wc -l) -ne 1 ]]; then
  echo "There must be exactly one Linux release tar in _output/local/releases"
  exit 1
fi
echo "Building images from ${releases}"

imagedir="_output/imagecontext"
rm -rf "${imagedir}"
mkdir -p "${imagedir}"
tar xzf "${releases}" -C "${imagedir}"

# copy build artifacts to the appropriate locations
cp -f "${imagedir}/openshift" images/origin/bin
cp -f "${imagedir}/openshift" images/router/haproxy/bin

# build hello-openshift binary
"${OS_ROOT}/hack/build-go.sh" examples/hello-openshift

# images that depend on openshift/origin-base
echo "--- openshift/origin ---"
docker build -t openshift/origin                images/origin
echo "--- openshift/origin-haproxy-router ---"
docker build -t openshift/origin-haproxy-router images/router/haproxy
echo "--- openshift/hello-openshift ---"
docker build -t openshift/hello-openshift       examples/hello-openshift

# images that depend on openshift/origin
echo "--- openshift/origin-deployer ---"
docker build -t openshift/origin-deployer       images/deployer
echo "--- openshift/origin-docker-builder ---"
docker build -t openshift/origin-docker-builder images/builder/docker/docker-builder
echo "--- openshift/origin-custom-docker-builder ---"
docker build -t openshift/origin-custom-docker-builder images/builder/docker/custom-docker-builder
echo "--- openshift/origin-sti-builder ---"
docker build -t openshift/origin-sti-builder    images/builder/docker/sti-builder
echo "--- openshift/sti-image-builder ---"
docker build -t openshift/sti-image-builder     images/builder/docker/sti-image-builder


text:
/**
 * Service which defines the Error class.
 */
angular.module('rest').factory('Error', [function defineError() {

    /**
     * The object returned by REST API calls when an error occurs.
     *
     * @constructor
     * @param {Error|Object} [template={}]
     *     The object whose properties should be copied within the new
     *     Error.
     */
    var Error = function Error(template) {

        // Use empty object by default
        template = template || {};

        /**
         * A human-readable message describing the error that occurred.
         *
         * @type String
         */
        this.message = template.message;

        /**
         * A message which can be translated using the translation service,
         * consisting of a translation key and optional set of substitution
         * variables.
         *
         * @type TranslatableMessage
         */
        this.translatableMessage = template.translatableMessage;

        /**
         * The Guacamole protocol status code associated with the error that
         * occurred. This is only valid for errors of type STREAM_ERROR.
         *
         * @type Number
         */
        this.statusCode = template.statusCode;

        /**
         * The type string defining which values this parameter may contain,
         * as well as what properties are applicable. Valid types are listed
         * within Error.Type.
         *
         * @type String
         * @default Error.Type.INTERNAL_ERROR
         */
        this.type = template.type || Error.Type.INTERNAL_ERROR;

        /**
         * Any parameters which were expected in the original request, or are
         * now expected as a result of the original request, if any. If no
         * such information is available, this will be null.
         *
         * @type Field[]
         */
        this.expected = template.expected;

    };

    /**
     * All valid field types.
     */
    Error.Type = {

        /**
         * The requested operation could not be performed because the request
         * itself was malformed.
         *
         * @type String
         */
        BAD_REQUEST : 'BAD_REQUEST',

        /**
         * The credentials provided were invalid.
         *
         * @type String
         */
        INVALID_CREDENTIALS : 'INVALID_CREDENTIALS',

        /**
         * The credentials provided were not necessarily invalid, but were not
         * sufficient to determine validity.
         *
         * @type String
         */
        INSUFFICIENT_CREDENTIALS : 'INSUFFICIENT_CREDENTIALS',

        /**
         * An internal server error has occurred.
         *
         * @type String
         */
        INTERNAL_ERROR : 'INTERNAL_ERROR',

        /**
         * An object related to the request does not exist.
         *
         * @type String
         */
        NOT_FOUND : 'NOT_FOUND',

        /**
         * Permission was denied to perform the requested operation.
         *
         * @type String
         */
        PERMISSION_DENIED : 'PERMISSION_DENIED',

        /**
         * An error occurred within an intercepted stream, terminating that
         * stream. The Guacamole protocol status code of that error will be
         * stored within statusCode.
         *
         * @type String
         */
        STREAM_ERROR : 'STREAM_ERROR'

    };

    return Error;

}]);


text:
package com.caspar.caswechat.start.service;

import com.caspar.caswechat.start.entity.AccessToken;

/**
 * AccessToken服务
 *
 * @author caspar.chen
 * @date 2017-5-12
 */
public interface AccessTokenService {

	/**
	 * 获取access_token对象
	 *
	 */
	public AccessToken getAccessToken();

	/**
	 * 获取token值
	 *
	 * @return token值
	 */
	public String getAccessTokenStr();
}


text:
define([
    "usr/extend",
    "usr/draw/drawable",
    "usr/draw/point",
    "usr/utils/arrays"
], function(
    Extend,
    Drawable,
    Point,
    Arrays) {
    'use strict';

    /**
     * Creates a new _c.draw.FrameSet
     * @constructor
     * @member {_c.draw.Image[]} frames - sequence of images to draw
     * @member {number} index - index of current frame
     * @member {_c.draw.Point} corner - point on the canvas where the image
     * will be drawn
     * @member {_c.draw.Vector} offset - offset to be applied to the frame's
     * corner (this.frames[this.index].corner as opposed to this.corner).
     * @member {boolean[]} loaded - set to false until the corresponding
     * frame has loaded, at which point the corresponding index is set to true.
     * @member {function} advance - advances the current frame, reverting
     * back to 0 when all frames have been traversed.
     * @member {function} draw - draws the current frame onto the canvas,
     * offsetting the corner maintained by the image by this.offset
     * @member {function} contains - specifies whether the current image,
     * including the currently specified offset, contains a particular point.
     */
    var FrameSet = Drawable.extend({

        /**
         * @constructs _c.draw.FrameSet
         * @param {object} params
         * @param {_c.draw.Image[]} params.frames
         * @param {_c.draw.Vector} [params.offset]
         * @default new _c.draw.Vector(0, 0)
         */
        init: function(params) {
            var _this = this,
                fn;

            // each frame is an object of type _c.draw.Image
            this.frames = params.frames;
            this.index = 0;
            // temporary variable for holding the corner where the image will be drawn
            this.corner = new _c.draw.Point(0, 0);
            // offset to be applied to the frame's corner
            this.offset = params.offset || new _c.draw.Vector(0, 0);
            this.loaded = _c.utils.fill(this.frames.length, false);
            // the onload callback for each image should normally call
            // FrameSet#draw()
            // The following ensures that all frames have been loaded
            this.frames.forEach(function(frame, i) {
                fn = frame.image.onload;
                frame.image.onload = function(event) {
                    _this.loaded[i] = true;
                    if (_.reduce(_this.loaded,
                            function(memo, value) { return memo && value; }, true)) {
                        return fn(event);
                    }
                };
            });
        },

        advance: function() {
            this.index = (this.index + 1) % this.frames.length;
        },

        draw: function(context) {
            var frame = this.frames[this.index];

            frame.corner.offset(this.offset, this.corner);
            context.drawImage(frame.image,
                this.corner.x, this.corner.y,
                frame.width, frame.height);
        },

        contains: function(point) {
            return this.frames[this.index].contains(point.offset(this.offset,
                this.corner));
        }
    });

    return FrameSet;
});


text:
class TicketsController < ApplicationController
	  def new
	    @ticket = Ticket.new
  	end

  	def create
  	  @ticket = Ticket.new(ticket_params)
  	  if @ticket.save
	      render json: @ticket
	    end
    end

    def destroy
      @ticket = Ticket.find(params[:id])
      @ticket.destroy
      render json: @ticket
    end

    def update
      @ticket = Ticket.find(params[:id])
      @ticket.update_attributes(ticket_params)
      render nothing: true
    end

    def index
      if params[:customer_id]
        @ticket = Ticket.where(:customer_id => "#{params[:customer_id]}")
      else
        @ticket = Ticket.all
      end
      render json: @ticket
    end

    def ticket_params
        params.require(:ticket).permit(:number, :customer_id, :completed, :description)
    end
end


text:
\documentclass{article}
\usepackage{amsmath}

\title{Metrizability in generalized inverse limits}
\author{Steven Clontz}
\date{2016 March 3rd}

\begin{document}
\maketitle
\abstract{
  For the metric arc \(I=[0,1]\) and continuum-valued bonding relation
  \(f\subseteq_{\operatorname{cl}} I^2\),
  the inverse limit \(\varprojlim\{I,f,\omega\}\)
  is the subspace of the countable
  power \(I^\omega\) containing sequences \(\vec x\) satisfying
  \(\vec x(n)\in f(\vec x(n+1))\). A recent trend in continuum theory is
  to generalize this notion to \(\varprojlim\{I,f,L\}\), where \(L\) is
  an arbitrary linear order. When \(L=\omega\), the inverse limit is a
  subspace of the metrizable space \(I^\omega\); however, we will show that
  when \(L\) is uncountable, the inverse limit cannot be metrizable unless
  \(f\) is trivial. Furthermore, when \(L\) is an uncountable well
  order, it will be shown that the inverse limit is not even Corson compact.
}
\end{document}


text:
//
//  File: AdMoGoAdNetworkRegistry.h
//  Project: AdsMOGO iOS SDK
//  Version: 1.1.7
//
//  Copyright 2011 AdsMogo.com. All rights reserved.
//

/*
    反射工具类 old code
 */
#import <Foundation/Foundation.h>

@class AdMoGoAdNetworkAdapter;
@class AdMoGoClassWrapper;

@interface AdMoGoAdNetworkRegistry : NSObject {
	NSMutableDictionary *adapterDict;
}

+ (AdMoGoAdNetworkRegistry *)sharedRegistry;
- (void)registerClass:(Class)adapterClass;
- (NSArray *)adapterClassFor:(NSInteger)adNetworkType;

@end


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/cloud/compute/v1/compute.proto

namespace Google\Cloud\Compute\V1;

use Google\Protobuf\Internal\GPBType;
use Google\Protobuf\Internal\RepeatedField;
use Google\Protobuf\Internal\GPBUtil;

/**
 * Commitment for a particular license resource.
 *
 * Generated from protobuf message google.cloud.compute.v1.LicenseResourceCommitment
 */
class LicenseResourceCommitment extends \Google\Protobuf\Internal\Message
{
    /**
     * The number of licenses purchased.
     *
     * Generated from protobuf field optional int64 amount = 196759640;
     */
    private $amount = null;
    /**
     * Specifies the core range of the instance for which this license applies.
     *
     * Generated from protobuf field optional string cores_per_license = 32482324;
     */
    private $cores_per_license = null;
    /**
     * Any applicable license URI.
     *
     * Generated from protobuf field optional string license = 166757441;
     */
    private $license = null;

    /**
     * Constructor.
     *
     * @param array $data {
     *     Optional. Data for populating the Message object.
     *
     *     @type int|string $amount
     *           The number of licenses purchased.
     *     @type string $cores_per_license
     *           Specifies the core range of the instance for which this license applies.
     *     @type string $license
     *           Any applicable license URI.
     * }
     */
    public function __construct($data = NULL) {
        \GPBMetadata\Google\Cloud\Compute\V1\Compute::initOnce();
        parent::__construct($data);
    }

    /**
     * The number of licenses purchased.
     *
     * Generated from protobuf field optional int64 amount = 196759640;
     * @return int|string
     */
    public function getAmount()
    {
        return isset($this->amount) ? $this->amount : 0;
    }

    public function hasAmount()
    {
        return isset($this->amount);
    }

    public function clearAmount()
    {
        unset($this->amount);
    }

    /**
     * The number of licenses purchased.
     *
     * Generated from protobuf field optional int64 amount = 196759640;
     * @param int|string $var
     * @return $this
     */
    public function setAmount($var)
    {
        GPBUtil::checkInt64($var);
        $this->amount = $var;

        return $this;
    }

    /**
     * Specifies the core range of the instance for which this license applies.
     *
     * Generated from protobuf field optional string cores_per_license = 32482324;
     * @return string
     */
    public function getCoresPerLicense()
    {
        return isset($this->cores_per_license) ? $this->cores_per_license : '';
    }

    public function hasCoresPerLicense()
    {
        return isset($this->cores_per_license);
    }

    public function clearCoresPerLicense()
    {
        unset($this->cores_per_license);
    }

    /**
     * Specifies the core range of the instance for which this license applies.
     *
     * Generated from protobuf field optional string cores_per_license = 32482324;
     * @param string $var
     * @return $this
     */
    public function setCoresPerLicense($var)
    {
        GPBUtil::checkString($var, True);
        $this->cores_per_license = $var;

        return $this;
    }

    /**
     * Any applicable license URI.
     *
     * Generated from protobuf field optional string license = 166757441;
     * @return string
     */
    public function getLicense()
    {
        return isset($this->license) ? $this->license : '';
    }

    public function hasLicense()
    {
        return isset($this->license);
    }

    public function clearLicense()
    {
        unset($this->license);
    }

    /**
     * Any applicable license URI.
     *
     * Generated from protobuf field optional string license = 166757441;
     * @param string $var
     * @return $this
     */
    public function setLicense($var)
    {
        GPBUtil::checkString($var, True);
        $this->license = $var;

        return $this;
    }

}


text:
module ITSF::FundReports
  class Trades::Trade < ActiveRecord::Base
    self.table_name = 'itsf_fund_reports_trades_trades'

    # associations
    belongs_to :account
    belongs_to :action
    belongs_to :currency
    belongs_to :asset_category
    belongs_to :symbol
    belongs_to :security
    belongs_to :transaction_type
    belongs_to :exchange
    belongs_to :ib_commission_currency, :class_name => Currency
    belongs_to :order, :class_name => ITSF::FundReports::Trades::Order
    belongs_to :order_type
    belongs_to :flex_query_run, :class_name => ITSF::FundReports::FlexQuery::Run,
                                :foreign_key => 'flex_query_run_id'
    belongs_to :underlying_symbol, :class_name => Underlying
    belongs_to :trade_group

    # attributes
    attr_accessible :account,
                    :action,
                    :asset_category,
                    :brokerage_order_ifentifier,
                    :change_in_price,
                    :change_in_quantity,
                    :clearing_firm_identifier,
                    :close_price,
                    :con_identifier,
                    :cost,
                    :currency,
                    :cusip,
                    :description,
                    :exch_order_identifier,
                    :exchange,
                    :expiry,
                    :ext_exec_identifier,
                    :fifo_pnl_realized,
                    :fx_rate_to_base,
                    :holding_period_date_time,
                    :ib_commission,
                    :ib_commission_currency,
                    :ib_exec_identifier,
                    :ib_order_identifier,
                    :issuer,
                    :level_of_detail,
                    :mtm_pnl,
                    :multiplier,
                    :net_cash,
                    :notes,
                    :open_close_indicator,
                    :open_date_time,
                    :order_placement_time,
                    :order_reference,
                    :order,
                    :order_time,
                    :order_type,
                    :orig_order_identifier,
                    :orig_trade_date,
                    :orig_trade_identifier,
                    :orig_trade_price,
                    :proceeds,
                    :put_call,
                    :quantity,
                    :report_date,
                    :security,
                    :security_id_type,
                    :security_indentifier,
                    :settle_date_target,
                    :strike,
                    :symbol,
                    :taxes,
                    :trade_identifier,
                    :trade_money,
                    :trade_price,
                    :trade_time,
                    :transaction_type,
                    :underlying_con_identifier,
                    :underlying_symbol,
                    :volatility_order_link,
                    :when_realized,
                    :when_reopened
    attr_accessible :exchange_id,
                    :underlying_symbol_id,
                    :order_id,
                    :transaction_type_id,
                    :asset_category_id,
                    :action_id,
                    :account_id,
                    :ib_commission_currency_id,
                    :order_type_id,
                    :currency_id,
                    :flex_query_run_id,
                    :symbol_id,
                    :security_id
    # callbacks
    before_validation :discover_source_order, :if => Proc.new { |trade| trade.order.blank? }

    # validations
    validates :account, :presence => true
    validates :action, :presence => true
    validates :asset_category, :presence => true
    validates :currency, :presence => true
    validates :exchange, :presence => true
    validates :ib_commission_currency, :presence => true
    validates :ib_order_identifier, :presence => true # ,
#                                     :uniqueness => true
#    validates :ib_exec_identifier, :presence => true,
#                                    :uniqueness => true
#    validates :order, :presence => true
    validates :order_type, :presence => true
    validates :quantity, :presence => true
    validates :symbol, :presence => true
    validates :trade_time, :presence => true
    validates :transaction_type, :presence => true

    def buy?
      action_name == 'BUY'
    end # def

    def discover_source_order
      self.order = ITSF::FundReports::Trades::Order.where(:ib_order_identifier => ib_order_identifier).first
    end # def

    def sell?
      action_name == 'SELL'
    end # def

    private

    def action_name
      action.name
    end # def
  end # class Trades::Trade < ActiveRecord::Base
end # module ITSF::FundReports


text:
/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#pragma once

#include <folly/futures/Future.h>
#include <thrift/lib/cpp/TApplicationException.h>
#include <thrift/lib/cpp2/ServiceIncludes.h>
#include <thrift/lib/cpp2/async/FutureRequest.h>
#include <thrift/lib/cpp2/async/HeaderChannel.h>
#include "src/gen-cpp2/module_types.h"

namespace folly {
  class IOBuf;
  class IOBufQueue;
}
namespace apache { namespace thrift {
  class Cpp2RequestContext;
  class BinaryProtocolReader;
  class CompactProtocolReader;
  namespace transport { class THeader; }
}}

namespace cpp2 {

class RaiserSvAsyncIf {
 public:
  virtual ~RaiserSvAsyncIf() {}
  virtual void async_tm_doBland(std::unique_ptr<apache::thrift::HandlerCallback<void>> callback) = 0;
  virtual folly::Future<folly::Unit> future_doBland() = 0;
  virtual void async_tm_doRaise(std::unique_ptr<apache::thrift::HandlerCallback<void>> callback) = 0;
  virtual folly::Future<folly::Unit> future_doRaise() = 0;
  virtual void async_tm_get200(std::unique_ptr<apache::thrift::HandlerCallback<std::unique_ptr<std::string>>> callback) = 0;
  virtual folly::Future<std::unique_ptr<std::string>> future_get200() = 0;
  virtual void async_tm_get500(std::unique_ptr<apache::thrift::HandlerCallback<std::unique_ptr<std::string>>> callback) = 0;
  virtual folly::Future<std::unique_ptr<std::string>> future_get500() = 0;
};

class RaiserAsyncProcessor;

class RaiserSvIf : public RaiserSvAsyncIf, public apache::thrift::ServerInterface {
 public:
  typedef RaiserAsyncProcessor ProcessorType;
  std::unique_ptr<apache::thrift::AsyncProcessor> getProcessor() override;
  virtual void doBland();
  folly::Future<folly::Unit> future_doBland() override;
  void async_tm_doBland(std::unique_ptr<apache::thrift::HandlerCallback<void>> callback) override;
  virtual void doRaise();
  folly::Future<folly::Unit> future_doRaise() override;
  void async_tm_doRaise(std::unique_ptr<apache::thrift::HandlerCallback<void>> callback) override;
  virtual void get200(std::string& /*_return*/);
  folly::Future<std::unique_ptr<std::string>> future_get200() override;
  void async_tm_get200(std::unique_ptr<apache::thrift::HandlerCallback<std::unique_ptr<std::string>>> callback) override;
  virtual void get500(std::string& /*_return*/);
  folly::Future<std::unique_ptr<std::string>> future_get500() override;
  void async_tm_get500(std::unique_ptr<apache::thrift::HandlerCallback<std::unique_ptr<std::string>>> callback) override;
};

class RaiserSvNull : public RaiserSvIf {
 public:
  void doBland() override;
  void doRaise() override;
  void get200(std::string& /*_return*/) override;
  void get500(std::string& /*_return*/) override;
};

class RaiserAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor {
 public:
  const char* getServiceName() override;
  using BaseAsyncProcessor = void;
  using HasFrozen2 = std::false_type;
 protected:
  RaiserSvIf* iface_;
  folly::Optional<std::string> getCacheKey(folly::IOBuf* buf, apache::thrift::protocol::PROTOCOL_TYPES protType) override;
 public:
  void process(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override;
 protected:
  bool isOnewayMethod(const folly::IOBuf* buf, const apache::thrift::transport::THeader* header) override;
 private:
  static std::unordered_set<std::string> onewayMethods_;
  static std::unordered_map<std::string, int16_t> cacheKeyMap_;
 public:
  using BinaryProtocolProcessFunc = ProcessFunc<RaiserAsyncProcessor, apache::thrift::BinaryProtocolReader>;
  using BinaryProtocolProcessMap = ProcessMap<BinaryProtocolProcessFunc>;
  static const RaiserAsyncProcessor::BinaryProtocolProcessMap& getBinaryProtocolProcessMap();
 private:
  static const RaiserAsyncProcessor::BinaryProtocolProcessMap binaryProcessMap_;
 public:
  using CompactProtocolProcessFunc = ProcessFunc<RaiserAsyncProcessor, apache::thrift::CompactProtocolReader>;
  using CompactProtocolProcessMap = ProcessMap<CompactProtocolProcessFunc>;
  static const RaiserAsyncProcessor::CompactProtocolProcessMap& getCompactProtocolProcessMap();
 private:
  static const RaiserAsyncProcessor::CompactProtocolProcessMap compactProcessMap_;
 private:
  template <typename ProtocolIn_, typename ProtocolOut_>
  void _processInThread_doBland(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void process_doBland(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot,apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <class ProtocolIn_, class ProtocolOut_>
  static folly::IOBufQueue return_doBland(int32_t protoSeqId, apache::thrift::ContextStack* ctx);
  template <class ProtocolIn_, class ProtocolOut_>
  static void throw_wrapped_doBland(std::unique_ptr<apache::thrift::ResponseChannel::Request> req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void _processInThread_doRaise(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void process_doRaise(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot,apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <class ProtocolIn_, class ProtocolOut_>
  static folly::IOBufQueue return_doRaise(int32_t protoSeqId, apache::thrift::ContextStack* ctx);
  template <class ProtocolIn_, class ProtocolOut_>
  static void throw_wrapped_doRaise(std::unique_ptr<apache::thrift::ResponseChannel::Request> req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void _processInThread_get200(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void process_get200(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot,apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <class ProtocolIn_, class ProtocolOut_>
  static folly::IOBufQueue return_get200(int32_t protoSeqId, apache::thrift::ContextStack* ctx, std::string const& _return);
  template <class ProtocolIn_, class ProtocolOut_>
  static void throw_wrapped_get200(std::unique_ptr<apache::thrift::ResponseChannel::Request> req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void _processInThread_get500(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <typename ProtocolIn_, typename ProtocolOut_>
  void process_get500(std::unique_ptr<apache::thrift::ResponseChannel::Request> req, std::unique_ptr<folly::IOBuf> buf, std::unique_ptr<ProtocolIn_> iprot,apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm);
  template <class ProtocolIn_, class ProtocolOut_>
  static folly::IOBufQueue return_get500(int32_t protoSeqId, apache::thrift::ContextStack* ctx, std::string const& _return);
  template <class ProtocolIn_, class ProtocolOut_>
  static void throw_wrapped_get500(std::unique_ptr<apache::thrift::ResponseChannel::Request> req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx);
 public:
  RaiserAsyncProcessor(RaiserSvIf* iface) :
      iface_(iface) {}

  virtual ~RaiserAsyncProcessor() {}
};

class RaiserAsyncClient : public apache::thrift::TClientBase {
 public:
  virtual const char* getServiceName();
  typedef std::unique_ptr<apache::thrift::RequestChannel, folly::DelayedDestruction::Destructor> channel_ptr;

  virtual ~RaiserAsyncClient() {}

  RaiserAsyncClient(std::shared_ptr<apache::thrift::RequestChannel> channel) :
      channel_(channel) {
    connectionContext_.reset(new apache::thrift::Cpp2ConnContext);
  }

  apache::thrift::RequestChannel*  getChannel() {
    return this->channel_.get();
  }

  apache::thrift::HeaderChannel*  getHeaderChannel() {
    return dynamic_cast<apache::thrift::HeaderChannel*>(this->channel_.get());
  }
  virtual void doBland(std::unique_ptr<apache::thrift::RequestCallback> callback);
  virtual void doBland(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 private:
  virtual void doBlandImpl(bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 public:
  virtual void sync_doBland();
  virtual void sync_doBland(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<folly::Unit> future_doBland();
  virtual folly::Future<folly::Unit> future_doBland(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_doBland(apache::thrift::RpcOptions& rpcOptions);
  virtual void doBland(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback);
  static folly::exception_wrapper recv_wrapped_doBland(::apache::thrift::ClientReceiveState& state);
  static void recv_doBland(::apache::thrift::ClientReceiveState& state);
  // Mock friendly virtual instance method
  virtual void recv_instance_doBland(::apache::thrift::ClientReceiveState& state);
  virtual folly::exception_wrapper recv_instance_wrapped_doBland(::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  void doBlandT(Protocol_* prot, bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
  template <typename Protocol_>
  static folly::exception_wrapper recv_wrapped_doBlandT(Protocol_* prot, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  static void recv_doBlandT(Protocol_* prot, ::apache::thrift::ClientReceiveState& state);
  virtual void doRaise(std::unique_ptr<apache::thrift::RequestCallback> callback);
  virtual void doRaise(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 private:
  virtual void doRaiseImpl(bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 public:
  virtual void sync_doRaise();
  virtual void sync_doRaise(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<folly::Unit> future_doRaise();
  virtual folly::Future<folly::Unit> future_doRaise(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_doRaise(apache::thrift::RpcOptions& rpcOptions);
  virtual void doRaise(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback);
  static folly::exception_wrapper recv_wrapped_doRaise(::apache::thrift::ClientReceiveState& state);
  static void recv_doRaise(::apache::thrift::ClientReceiveState& state);
  // Mock friendly virtual instance method
  virtual void recv_instance_doRaise(::apache::thrift::ClientReceiveState& state);
  virtual folly::exception_wrapper recv_instance_wrapped_doRaise(::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  void doRaiseT(Protocol_* prot, bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
  template <typename Protocol_>
  static folly::exception_wrapper recv_wrapped_doRaiseT(Protocol_* prot, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  static void recv_doRaiseT(Protocol_* prot, ::apache::thrift::ClientReceiveState& state);
  virtual void get200(std::unique_ptr<apache::thrift::RequestCallback> callback);
  virtual void get200(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 private:
  virtual void get200Impl(bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 public:
  virtual void sync_get200(std::string& _return);
  virtual void sync_get200(apache::thrift::RpcOptions& rpcOptions, std::string& _return);
  virtual folly::Future<std::string> future_get200();
  virtual folly::Future<std::string> future_get200(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<std::pair<std::string, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_get200(apache::thrift::RpcOptions& rpcOptions);
  virtual void get200(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback);
  static folly::exception_wrapper recv_wrapped_get200(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  static void recv_get200(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  // Mock friendly virtual instance method
  virtual void recv_instance_get200(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  virtual folly::exception_wrapper recv_instance_wrapped_get200(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  void get200T(Protocol_* prot, bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
  template <typename Protocol_>
  static folly::exception_wrapper recv_wrapped_get200T(Protocol_* prot, std::string& _return, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  static void recv_get200T(Protocol_* prot, std::string& _return, ::apache::thrift::ClientReceiveState& state);
  virtual void get500(std::unique_ptr<apache::thrift::RequestCallback> callback);
  virtual void get500(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 private:
  virtual void get500Impl(bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
 public:
  virtual void sync_get500(std::string& _return);
  virtual void sync_get500(apache::thrift::RpcOptions& rpcOptions, std::string& _return);
  virtual folly::Future<std::string> future_get500();
  virtual folly::Future<std::string> future_get500(apache::thrift::RpcOptions& rpcOptions);
  virtual folly::Future<std::pair<std::string, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_get500(apache::thrift::RpcOptions& rpcOptions);
  virtual void get500(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback);
  static folly::exception_wrapper recv_wrapped_get500(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  static void recv_get500(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  // Mock friendly virtual instance method
  virtual void recv_instance_get500(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  virtual folly::exception_wrapper recv_instance_wrapped_get500(std::string& _return, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  void get500T(Protocol_* prot, bool useSync, apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback);
  template <typename Protocol_>
  static folly::exception_wrapper recv_wrapped_get500T(Protocol_* prot, std::string& _return, ::apache::thrift::ClientReceiveState& state);
  template <typename Protocol_>
  static void recv_get500T(Protocol_* prot, std::string& _return, ::apache::thrift::ClientReceiveState& state);
 protected:
  std::unique_ptr<apache::thrift::Cpp2ConnContext> connectionContext_;
  std::shared_ptr<apache::thrift::RequestChannel> channel_;
};

} // cpp2
namespace apache { namespace thrift {

}} // apache::thrift


text:
package org.n52.sos.ogc.swe;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Test;
import org.n52.sos.ogc.swe.simpleType.SweBoolean;

/**
 * @author Eike Hinderk
 *         Jürrens
 *
 * @since 4.0.0
 */
public class SweDataRecordTest {

    @Test
    public final void getFieldIndexByIdentifier_should_return_negativeValue_if_not_found_or_empty() throws Exception {
        assertThat(new SweDataRecord().getFieldIndexByIdentifier("test-identifier"), is(-1));
    }

    @Test
    public void getFieldIndexByIdentifier_should_not_fail_on_bad_input() {
        final SweDataRecord dataRecord = new SweDataRecord();
        dataRecord.addField(new SweField("identifier", new SweBoolean()));
        final SweBoolean b = new SweBoolean();
        b.setDefinition("test-element-definition");
        dataRecord.addField(new SweField("test-field-name", b));

        assertThat(dataRecord.getFieldIndexByIdentifier(null), is(-1));
        assertThat(dataRecord.getFieldIndexByIdentifier(""), is(-1));
    }

    @Test
    public void getFieldIndexByIdentifier_should_return_one() {
        final SweDataRecord dataRecord = new SweDataRecord();
        dataRecord.addField(new SweField("identifier", new SweBoolean()));
        final SweBoolean b = new SweBoolean();
        final String definition = "test-element-definition";
        b.setDefinition(definition);
        final String name = "test-field-name";
        dataRecord.addField(new SweField(name, b));

        assertThat(dataRecord.getFieldIndexByIdentifier(definition), is(1));
        assertThat(dataRecord.getFieldIndexByIdentifier(name), is(1));
    }

}


text:
<?php

//@require 'Swift/Mime/Attachment.php';
//@require 'Swift/Mime/ContentEncoder.php';
//@require 'Swift/KeyCache.php';
//@require

/**
 * An embedded file, in a multipart message.
 * @package Swift
 * @subpackage Mime
 * @author Chris Corbyn
 */
class Swift_Mime_EmbeddedFile extends Swift_Mime_Attachment
{

  /**
   * Creates a new Attachment with $headers and $encoder.
   * @param Swift_Mime_HeaderSet $headers
   * @param Swift_Mime_ContentEncoder $encoder
   * @param Swift_KeyCache $cache
   * @param array $mimeTypes optional
   */
  public function __construct(Swift_Mime_HeaderSet $headers,
    Swift_Mime_ContentEncoder $encoder, Swift_KeyCache $cache,
    $mimeTypes = array())
  {
    parent::__construct($headers, $encoder, $cache, $mimeTypes);
    $this->setDisposition('inline');
    $this->setId($this->getId());
  }

  /**
   * Get the nesting level of this EmbeddedFile.
   * Returns {@link LEVEL_RELATED}.
   * @return int
   */
  public function getNestingLevel()
  {
    return self::LEVEL_RELATED;
  }

}


text:
title: "Why Us"
bg: blue
color: white
fa-icon: toggle-on
---

#### Basically...

# Chattahoochee Hills Charter School Rocks

We are a startup charter school located in [Chattahoochee Hills, Georgia](https://www.google.com/maps/place/Chattahoochee+Hills+Charter+School/@33.581361,-84.697708,9z/data=!4m2!3m1!1s0x88f4dadf5845cb05:0xad17349679d749f4). We have a committed board, standing-room-only PTO meetings, and a campus that's committed to nature and the outdoors.

## Our Mission

Our mission is to inspire all of our children to the highest levels of academic achievement through a rigorous curriculum that integrates the wonders of the natural world. CHCS's goal is for our students to cultivate the capacity to achieve a meaningful, healthy, and flourishing life that embodies responsibility, stewardship, and experiential engagement with the arts, agriculture and environment in informed, imaginative, and rigorous ways.

### Some quick facts

- We are currently a K-6 School, with 7th & 8th Grades coming in the next two years.
- Enrollment of about 360 for the 2015/16 year. We saw a 300 kid waiting list this year.
- An Environmentally Integrated Curriculum dedicated to Arts, Agriculture, and the Environment
- A campus featuring several, independent indoor classrooms, and a planned outdoor classroom environment where children can learn in nature.
- Completely engaged parents: standing-room-only PTO meetings.
- A diverse and cohesive board ready to help you lead.
- A racially, economically diverse and committed student population.

## **Ready? [Start The Application](https://screendoor.dobt.co/chattahoochee-hills-charter-school/principal-application)**

<img class="row full column"  src="chcs-buildings.jpg" alt="Our Campus" title="Our Campus" />


text:
@extends('frontend.layouts.default')

{{-- Page Content --}}
@section('page_body')

@include('frontend.elements.navigation_main')
@include('frontend.elements.navigation_secondary')
@include('frontend.elements.promoted_posts')

Search Results

                You searched for: “{{ $searchTerm }}” and found {{ count( $searchResults ) }} results.

Related search terms.

@stop


text:
package org.maneau.maventools.batch;

import junit.framework.TestCase;

/**
 * Created by maneau on 05/07/2014.
 * Test class for ArtifactImporter
 */
public class ArtifactImporterTest extends TestCase {

    public void testSimpleResolveArtifact() throws Exception {
        String[] args = {"org.codehaus.mojo:xdoclet-maven-plugin:1.0"};

        ArtifactImporter.main(args);
        assertEquals(1, ArtifactImporter.getArtifacts().size());
        assertEquals(1, ArtifactImporter.getResults().size());
    }

    public void testMultipleResolveArtifact() throws Exception {
        String[] args = {"-f", "src/test/resources/local_repo.list"};

        ArtifactImporter.main(args);
        assertEquals(132, ArtifactImporter.getArtifacts().size());
        assertEquals(132, ArtifactImporter.getResults().size());
    }

}


text:
package com.zby.chest.view;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.widget.TextView;

import com.zby.chest.utils.Tools;

public class MyTextView2 extends TextView{
	private final String namespace = "http://www.angellecho.com/";
	private String text;
	private float textSize;
	private float paddingLeft;
	private float paddingRight;
	private float marginLeft;
	private float marginRight;
	private int textColor;

	private float density;
	//private float singleWordWidth;
	private Context mContext;

	private Paint paint1 = new Paint();
	private float textShowWidth;
	public MyTextView2(Context context, AttributeSet attrs) {
		super(context, attrs);
		this.mContext = context;
		text = attrs.getAttributeValue(
				"http://schemas.android.com/apk/res/android", "text");
		density = getResources().getDisplayMetrics().density;

		textSize = attrs.getAttributeIntValue(namespace, "textSize", 18) *density;
		textColor = attrs.getAttributeIntValue(namespace, "textColor",Color.BLACK);
		paint1.setColor(textColor);
		paint1.setAntiAlias(true);

		paint1.setTextSize(textSize);
		paddingLeft = attrs.getAttributeIntValue(namespace, "paddingLeft", 0) *density;
		paddingRight = attrs.getAttributeIntValue(namespace, "paddingRight", 0) * density;
		marginLeft = attrs.getAttributeIntValue(namespace, "marginLeft", 0) * density;
		marginRight = attrs.getAttributeIntValue(namespace, "marginRight", 0) *density;
	}
	@Override
	protected void onDraw(Canvas canvas) {
//	    if(Tools.isLocalLanguageChina(mContext)) {
//	        textShowWidth = getWidth()-paddingLeft-paddingRight;
//	        int lineCount = 0;
//	        text = this.getText().toString();//.replaceAll("\n", "\r\n");
//	        if(text==null)return;
//	        char[] textCharArray = text.toCharArray();
//	        // ÒÑ»æµÄ¿í¶È
//	        float drawedWidth = 0;
//	        float charWidth;
//	        for (int i = 0; i < textCharArray.length; i++) {
//	            char str = textCharArray[i];
//	            charWidth = paint1.measureText(textCharArray, i, 1);
//
//	            if(textCharArray[i]=='\n'){
//	                lineCount++;
//	                drawedWidth = 0;
//	                continue;
//	            }
//	            if (textShowWidth - drawedWidth < charWidth) {
//	                lineCount++;
//	                drawedWidth = 0;
//	            }
//	            canvas.drawText(textCharArray, i, 1, paddingLeft + drawedWidth,
//	                    (lineCount + 1) * textSize, paint1);
//	            drawedWidth += charWidth;
//	        }
//	        setHeight( (int) ((lineCount + 1)  * textSize + 5));
//	    } else {
	        super.onDraw(canvas);
//	    }
	}
}


text: Adds Emoji support to discourse. Thanks to the gemoji gem for the assets.


text:
title: Nik Costodia
seotitle: Nik Costodia - Senior Director, FTI Consulting / UX
img: /images/nik-costodia.jpg
name: Nik Costodia
position: Senior Director, FTI Consulting / UX
education:
experience:
short_desc:
long_desc:
affiliations: []
twitter: nik5ter
github:
residence:
cats: [ ]
website:
---

Nik Custodio (@nik5ter) is a Director at FTI Consulting / UX.


text:
package chapter05_thread.t03_security;

public class NoVisiabilityTest {

	private static class ReadThread extends Thread {

		private boolean ready;

		private int number;

		public void run() {
			while(!ready) {
				number++;
				Thread.yield();
			}
			System.out.println(ready);
		}

		public void readyOn() {
			this.ready = true;
		}
	}

	public static void main(String []args) throws InterruptedException {
		ReadThread readThread = new ReadThread();
		readThread.start();
		Thread.sleep(200);
		readThread.readyOn();
		System.out.println(readThread.ready);
	}
}


text:
from scipy import *
import scipy.io.array_import
import scipy.stats.kde
from pylab import *

filename=('rates')
data = scipy.io.array_import.read_array(filename)

# dollar-euro
# the histogram of the data
fig=figure()
x = data[:,0]
mu = mean(x)
sigma = std(x)
n, bins, patches = hist(x, 50, normed=1)
setp(patches, 'facecolor', 'g', 'alpha', 0.75)
# add a 'best fit' line
y = normpdf( bins, mu, sigma)
l = plot(bins, y, 'r--')
setp(l, 'linewidth', 1)
xlabel('rate')
ylabel('Density')
title(r'$\rm{Growth\ rate\ of\ dollar/euro\ exchange\ rate}\ $')
grid(True)

# time series plot
fig=figure()
xlabel('time')
ylabel('rate')
title(r'$\rm{Growth\ rate\ of\ dollar/euro\ exchange\ rate}\ $')
plot(x)

# dollar-yen
# the histogram of the data
fig=figure()
x = data[:,1]
mu = mean(x)
sigma = std(x)
n, bins, patches = hist(x, 50, normed=1)
setp(patches, 'facecolor', 'g', 'alpha', 0.75)

# add a 'best fit' line
y = normpdf( bins, mu, sigma)
l = plot(bins, y, 'r--')
setp(l, 'linewidth', 1)

xlabel('rate')
ylabel('Density')
title(r'$\rm{Growth\ rate\ of\ dollar/yen\ exchange\ rate}\ $')
#axis([40, 160, 0, 0.03])
grid(True)

# time series plot
fig=figure()
xlabel('time')
ylabel('rate')
title(r'$\rm{Growth\ rate\ of\ dollar/yen\ exchange\ rate}\ $')
plot(x)

show()