text:
@interface CCRenderState(){
	@public
	BOOL _immutable;
	CCBlendMode *_blendMode;
	CCShader *_shader;
	NSDictionary *_shaderUniforms;
}

/// Remove unused render states from the internal cache.
/// This is might be made public in the future.
+(void)flushCache;

-(void)transitionRenderer:(CCRenderer *)renderer FromState:(CCRenderState *)previous;

@end

/// Type of a CCGraphicsBuffer object.
typedef NS_ENUM(NSUInteger, CCGraphicsBufferType){
	CCGraphicsBufferTypeVertex,
	CCGraphicsBufferTypeIndex,
	CCGraphicsBufferTypeUniform,
};

/// Internal class used to abstract GPU buffers. (vertex, index buffers, etc)
/// This is an abstract class instead of a protocol because of CCGraphicsBufferPushElements().
@interface CCGraphicsBuffer : NSObject{
	@public
	/// Elements currently in the buffer.
	size_t _count;
	/// Element capacity of the buffer.
	size_t _capacity;
	/// Size in bytes of elements in the buffer.
	size_t _elementSize;

	/// Pointer to the buffer memory.
	/// Only valid between prepare and commmit method calls.
	void *_ptr;
}

-(instancetype)initWithCapacity:(NSUInteger)capacity elementSize:(size_t)elementSize type:(CCGraphicsBufferType)type;
-(void)resize:(size_t)newCapacity;

-(void)destroy;

-(void)prepare;
-(void)commit;

@end

/// Return a pointer to an array of elements that is 'requestedCount' in size.
/// The buffer is resized by calling [CCGraphicsBuffer resize:] if necessary.
static inline void *
CCGraphicsBufferPushElements(CCGraphicsBuffer *buffer, size_t requestedCount)
{
	NSCAssert(requestedCount > 0, @"Requested count must be positive.");

	size_t required = buffer->_count + requestedCount;
	size_t capacity = buffer->_capacity;
	if(required > capacity){
		// Why 1.5? https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md
		CCRenderDispatch(NO, ^{[buffer resize:required*1.5];});
	}

	void *array = buffer->_ptr + buffer->_count*buffer->_elementSize;
	buffer->_count += requestedCount;

	return array;
}

/// Internal abstract class used to wrap vertex buffer state. (GL VAOs, etc)
@interface CCGraphicsBufferBindings : NSObject {
	@public
	CCGraphicsBuffer *_vertexBuffer;
	CCGraphicsBuffer *_indexBuffer;

	// Not used by the GL2 renderer.
	CCGraphicsBuffer *_uniformBuffer;
}

/// Make the buffers ready to use by drawing commands.
-(void)bind:(BOOL)bind vertexPage:(NSUInteger)vertexPage;

/// Prepare buffers for changes.
-(void)prepare;

/// Commit changes to buffers.
-(void)commit;

@end

@interface CCFrameBufferObject : NSObject {
	GLuint _depthStencilFormat;
}

// Setters should be treated as protected.
@property(nonatomic, readonly) CCTexture *texture;
@property(nonatomic, assign) CGSize sizeInPixels;
@property(nonatomic, assign) CGFloat contentScale;

-(instancetype)initWithTexture:(CCTexture *)texture depthStencilFormat:(GLuint)depthStencilFormat;

-(void)syncWithView:(CC_VIEW<CCDirectorView> *)view;

// Not ideal to use GL enumerations here.
// It's out of convenience, and it's a private API.
-(void)bindWithClear:(GLbitfield)mask color:(GLKVector4)color4 depth:(GLclampf)depth stencil:(GLint)stencil;

@end


text:
import * as chai from 'chai';
import * as chaiAsPromised from 'chai-as-promised';

chai.should();
chai.use(chaiAsPromised);

redpajama_set_name: RedPajamaGithub


text:
#pragma once
#include <aws/dataexchange/DataExchange_EXPORTS.h>
#include <aws/core/Region.h>
#include <aws/core/utils/memory/stl/AWSString.h>

namespace Aws
{

namespace DataExchange
{
namespace DataExchangeEndpoint
{
AWS_DATAEXCHANGE_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
} // namespace DataExchangeEndpoint
} // namespace DataExchange
} // namespace Aws


text:
require 'pathname'

Puppet::Type.newtype(:dsc_xsqlserverinstall) do
  require Pathname.new(__FILE__).dirname + '../../' + 'puppet/type/base_dsc'
  require Pathname.new(__FILE__).dirname + '../../puppet_x/puppetlabs/dsc_type_helpers'

  @doc = %q{
    The DSC xSqlServerInstall resource type.
    Automatically generated from
    'xSqlPs/DSCResources/MSFT_xSqlServerInstall/MSFT_xSqlServerInstall.schema.mof'

    To learn more about PowerShell Desired State Configuration, please
    visit https://technet.microsoft.com/en-us/library/dn249912.aspx.

    For more information about built-in DSC Resources, please visit
    https://technet.microsoft.com/en-us/library/dn249921.aspx.

    For more information about xDsc Resources, please visit
    https://github.com/PowerShell/DscResources.
  }

  validate do
      fail('dsc_instancename is a required attribute') if self[:dsc_instancename].nil?
    end

  def dscmeta_resource_friendly_name; 'xSqlServerInstall' end
  def dscmeta_resource_name; 'MSFT_xSqlServerInstall' end
  def dscmeta_module_name; 'xSqlPs' end
  def dscmeta_module_version; '1.4.0.0' end

  newparam(:name, :namevar => true ) do
  end

  ensurable do
    newvalue(:exists?) { provider.exists? }
    newvalue(:present) { provider.create }
    defaultto { :present }
  end

  # Name:         PsDscRunAsCredential
  # Type:         MSFT_Credential
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_psdscrunascredential) do
    def mof_type; 'MSFT_Credential' end
    def mof_is_embedded?; true end
    desc "PsDscRunAsCredential"
    validate do |value|
      unless value.kind_of?(Hash)
        fail("Invalid value '#{value}'. Should be a hash")
      end
      PuppetX::Dsc::TypeHelpers.validate_MSFT_Credential("Credential", value)
    end
    munge do |value|
      PuppetX::Dsc::TypeHelpers.munge_sensitive_hash!(value)
    end
  end

  # Name:         InstanceName
  # Type:         string
  # IsMandatory:  True
  # Values:       None
  newparam(:dsc_instancename) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "InstanceName - The name of sql instance."
    isrequired
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SourcePath
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sourcepath) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SourcePath - The share path of sql server software."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         VersionID
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_versionid) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "VersionID - The numeric version identifier for the instance to be installed"
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SourcePathCredential
  # Type:         MSFT_Credential
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sourcepathcredential) do
    def mof_type; 'MSFT_Credential' end
    def mof_is_embedded?; true end
    desc "SourcePathCredential - The credential that vm could use to access net share of sql server software."
    validate do |value|
      unless value.kind_of?(Hash)
        fail("Invalid value '#{value}'. Should be a hash")
      end
      PuppetX::Dsc::TypeHelpers.validate_MSFT_Credential("SourcePathCredential", value)
    end
    munge do |value|
      PuppetX::Dsc::TypeHelpers.munge_sensitive_hash!(value)
    end
  end

  # Name:         Features
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_features) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "Features - List of names of Sql Server features to install"
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlAdministratorCredential
  # Type:         MSFT_Credential
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqladministratorcredential) do
    def mof_type; 'MSFT_Credential' end
    def mof_is_embedded?; true end
    desc "SqlAdministratorCredential - Sql sa credential"
    validate do |value|
      unless value.kind_of?(Hash)
        fail("Invalid value '#{value}'. Should be a hash")
      end
      PuppetX::Dsc::TypeHelpers.validate_MSFT_Credential("SqlAdministratorCredential", value)
    end
    munge do |value|
      PuppetX::Dsc::TypeHelpers.munge_sensitive_hash!(value)
    end
  end

  # Name:         UpdateEnabled
  # Type:         boolean
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_updateenabled) do
    def mof_type; 'boolean' end
    def mof_is_embedded?; false end
    desc "UpdateEnabled - Specify whether SQL server setup should discover and include product updates."
    validate do |value|
    end
    newvalues(true, false)
    munge do |value|
      PuppetX::Dsc::TypeHelpers.munge_boolean(value.to_s)
    end
  end

  # Name:         SvcAccount
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_svcaccount) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SvcAccount - Specify the startup account for the SQL server service."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SysAdminAccounts
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sysadminaccounts) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SysAdminAccounts - Specify logins to be members of the sysadmin role."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         AgentSvcAccount
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_agentsvcaccount) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "AgentSvcAccount - Specify the account for SQL server agent service."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlCollation
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqlcollation) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SqlCollation - Specify the default collation for SQL server"
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         InstallSqlDataDir
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_installsqldatadir) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "InstallSqlDataDir - Specify the directory for SQL server system db files"
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlTempDBDir
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqltempdbdir) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SqlTempDBDir - Specify the directory for TempDB files."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlUserDBDir
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqluserdbdir) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SqlUserDBDir - Specify the directory for UserDB data files."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlUserDBLogDir
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqluserdblogdir) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SqlUserDBLogDir - Specify the directory for UserDB log files."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  # Name:         SqlBackupDir
  # Type:         string
  # IsMandatory:  False
  # Values:       None
  newparam(:dsc_sqlbackupdir) do
    def mof_type; 'string' end
    def mof_is_embedded?; false end
    desc "SqlBackupDir - Specify the directory for backup files."
    validate do |value|
      unless value.kind_of?(String)
        fail("Invalid value '#{value}'. Should be a string")
      end
    end
  end

  def builddepends
    pending_relations = super()
    PuppetX::Dsc::TypeHelpers.ensure_reboot_relationship(self, pending_relations)
  end
end

Puppet::Type.type(:dsc_xsqlserverinstall).provide :powershell, :parent => Puppet::Type.type(:base_dsc).provider(:powershell) do
  confine :true => (Gem::Version.new(Facter.value(:powershell_version)) >= Gem::Version.new('5.0.10586.117'))
  defaultfor :operatingsystem => :windows

  mk_resource_methods
end


text:
// Copyright 2015 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

goog.provide('goog.net.streams.JsonStreamParserTest');
goog.setTestOnly('goog.net.streams.JsonStreamParserTest');

goog.require('goog.array');
goog.require('goog.json');
goog.require('goog.labs.testing.JsonFuzzing');
goog.require('goog.net.streams.JsonStreamParser');
goog.require('goog.testing.asserts');
goog.require('goog.testing.jsunit');
goog.require('goog.uri.utils');

var debug;

function setUp() {
  var uri = window.document.URL;
  if (uri) {
    var debugFlag = goog.uri.utils.getParamValue(uri, 'debug');
    if (debugFlag) {
      debug = window.document.getElementById('debug');
    }
  }
}

/**
 * Debug is enabled with "&debug=on" on the URL.
 *
 * @param {string} info The debug info
 */
function print(info) {
  if (debug) {
    debug.innerHTML += '<p><p>' + info;
  }
}

function testEmptyStream() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[]');
  assertNull(result);
}

function testEmptyStreamMore() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('  [   ]  ');
  assertNull(result);

  parser = new goog.net.streams.JsonStreamParser();
  result = parser.parse('  [   ');
  assertNull(result);

  result = parser.parse('  ]   ');
  assertNull(result);

  parser = new goog.net.streams.JsonStreamParser();
  assertThrows(function() { parser.parse(' a [   '); });
  assertThrows(function() { parser.parse(' [ ] '); });
}

function testSingleMessage() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[{"a" : "b"}]');
  assertEquals(1, result.length);
  assertEquals('b', result[0].a);
}

function testEnclosingArray() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[\n');
  assertNull(result);

  result = parser.parse('{"a" : "b"}');
  assertEquals(1, result.length);
  assertEquals('b', result[0].a);

  result = parser.parse('\n]');
  assertNull(result);
}

function testSingleMessageInChunks() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[{"a" : ');
  assertNull(result);
  result = parser.parse('"b"}]');
  assertEquals(1, result.length);
  assertEquals('b', result[0].a);

  parser = new goog.net.streams.JsonStreamParser();
  result = parser.parse('[ {  "a" : ');
  assertNull(result);
  result = parser.parse('"b"} ');
  assertEquals(1, result.length);
  assertEquals('b', result[0].a);

  result = parser.parse('] ');
  assertNull(result);
}

function testTwoMessages() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[{"a" : "b"}, {"c" : "d"}]');
  assertEquals(2, result.length);
  assertEquals('b', result[0].a);
  assertEquals('d', result[1].c);
}

function testTwoMessagesInChunks() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[{"a" : "b"}, ');
  assertEquals(1, result.length);
  assertEquals('b', result[0].a);
  result = parser.parse('{"c" : "d"} ');
  assertEquals(1, result.length);
  assertEquals('d', result[0].c);
  result = parser.parse('] ');
  assertNull(result);
  assertThrows(function() { parser.parse('  a   '); });
}

/**
 * Parse a fuzzy json string only once.
 */
function testSingleFuzzyMessages() {
  var fuzzing = new goog.labs.testing.JsonFuzzing();

  // total # of tests
  for (var i = 0; i < 5; i++) {
    var data = fuzzing.newArray();
    var dataString = goog.json.serialize(data);
    var parser = new goog.net.streams.JsonStreamParser();
    var result = parser.parse(dataString);

    assertEquals(data.length, result.length);
    goog.array.forEach(data, function(elm, index) {
      assertNotNull(elm);
      assertObjectEquals(dataString, elm, result[index]);
    });
  }
}

/**
 * Parse a fuzzy json string split (in two chunks) at each index of the string.
 *
 * This is a VERY expensive test, so change the fuzzing options for manual runs
 * as required.
 */
function testChunkedFuzzyMessages() {
  var options = {jsonSize: 5, numFields: 5, arraySize: 4, maxDepth: 3};
  var fuzzing = new goog.labs.testing.JsonFuzzing(options);

  var data = fuzzing.newArray();
  var dataString = goog.json.serialize(data);

  print(dataString);

  for (var j = 1; j < dataString.length; j++) {
    var parser = new goog.net.streams.JsonStreamParser();
    var result = [];

    var string1 = dataString.substring(0, j);

    var parsed = parser.parse(string1);
    if (parsed) {
      result = goog.array.concat(result, parsed);
    }

    var string2 = dataString.substring(j);

    parsed = parser.parse(string2);
    if (parsed) {
      result = goog.array.concat(result, parsed);
    }

    assertEquals(data.length, result.length);
    goog.array.forEach(data, function(elm, index) {
      assertObjectEquals(dataString, elm, result[index]);
    });
  }
}

/**
 * Parse a fuzzy json string in randomly generated chunks.
 */
function testRandomlyChunkedFuzzyMessages() {
  var fuzzing = new goog.labs.testing.JsonFuzzing();

  var data = fuzzing.newArray();
  var dataString = goog.json.serialize(data);

  var parser = new goog.net.streams.JsonStreamParser();

  var result = [];

  print(dataString);

  // randomly generated chunks
  var pos = 0;
  while (pos < dataString.length) {
    var num = fuzzing.nextInt(1, dataString.length - pos);
    var next = pos + num;
    var subString = dataString.substring(pos, next);

    print(subString);

    pos = next;
    var parsed = parser.parse(subString);
    if (parsed) {
      result = goog.array.concat(result, parsed);
    }
  }

  assertEquals(data.length, result.length);
  goog.array.forEach(data, function(elm, index) {
    assertObjectEquals(dataString + '\n@' + index, elm, result[index]);
  });
}

// TODO(user): add a fuzzy test for this.

function testGetExtraInput() {
  var parser = new goog.net.streams.JsonStreamParser();
  var result = parser.parse('[] , [[1, 2, 3]]');
  assertNull(result);
  assertTrue(parser.done());
  assertEquals(' , [[1, 2, 3]]', parser.getExtraInput());

  parser = new goog.net.streams.JsonStreamParser();
  assertFalse(parser.done());
  parser.parse(' [{"a" : "b"}, {"c" : "d"   ');
  assertFalse(parser.done());
  parser.parse(' } ]  a   ');
  assertTrue(parser.done());
  assertEquals('  a   ', parser.getExtraInput());
}

function testDeliverMessageAsRawString() {
  var parser = new goog.net.streams.JsonStreamParser(
      {'deliverMessageAsRawString': true});
  var result = parser.parse(' [{"a" : "b"}, {"c" : "d"},[],{}] ');
  assertEquals(4, result.length);
  assertEquals('{"a" : "b"}', result[0]);
  assertEquals(' {"c" : "d"}', result[1]);
  assertEquals('[]', result[2]);
  assertEquals('{}', result[3]);
}

function testCompactJsonArrayFormat() {
  var message1 = '{"a" : [1, ,2]}';
  var message2 = '[,  1,2,,  ,null,  ,,"abc"]';
  var message3 = '[ , ]';
  var stream = '[' + message1 + ',' + message2 + ',' + message3 + ']';

  var parser = new goog.net.streams.JsonStreamParser(
      {'allowCompactJsonArrayFormat': true});
  result = parser.parse(stream);
  // clang-format off
  assertEquals(3, result.length);
  assertElementsEquals([1, , 2], result[0].a);
  assertElementsEquals([, 1, 2, , , null, , , 'abc'], result[1]);
  assertElementsEquals([ , ], result[2]);
  // clang-format on

  // Raw message strings
  parser = new goog.net.streams.JsonStreamParser(
      {'allowCompactJsonArrayFormat': true, 'deliverMessageAsRawString': true});
  result = parser.parse(stream);
  assertEquals(3, result.length);
  assertEquals(message1, result[0]);
  assertEquals(message2, result[1]);
  assertEquals(message3, result[2]);
}


text:
        Getting started

Documentation

        Styling kit

Overview

Grid

Typography

Buttons

Badges

Bar

Breadcrumbs

Callouts

Cards

Color

Filter bar

Forms

Hit area boxes

Icons

Labels

Loader

Media

Tables

Tabs

Timeline

Helper classes

        Directives

Overview

Accordion

Back to top

Checkbox

Datepicker

Range datepicker

IBAN

Identity card number

Interactive table

Modal

National number

Navigation

Pagination

Popover

Sort table

Stick to top

Timepicker

Tooltip

Upload

        Themes

Overview

Stad

Brandweer

Politie

Ocmw

Guidelines

        UX guidelines

Form validation

Forms as a whole

        Code guidelines

General

Styling

JavaScript

AngularJs

Contributing

        F.A.Q.


text:
package com.esri.geoevent.solutions.processor.geometry;

import java.util.HashMap;

import com.esri.core.geometry.Geometry;
import com.esri.core.geometry.GeometryEngine;
import com.esri.core.geometry.Point;
import com.esri.core.geometry.Polygon;
import com.esri.core.geometry.SpatialReference;
import com.esri.ges.core.component.ComponentException;
import com.esri.ges.core.geoevent.GeoEvent;
import com.esri.ges.processor.GeoEventProcessorBase;
import com.esri.ges.processor.GeoEventProcessorDefinition;
import com.esri.ges.spatial.GeometryException;
import com.esri.ges.spatial.Spatial;

public class EllipseProcessor extends GeoEventProcessorBase {
	Spatial spatial;
	private static HashMap<String, Integer> wkidLookup = new HashMap<String, Integer>();
	public EllipseProcessor(GeoEventProcessorDefinition definition, Spatial s)
			throws ComponentException {
		super(definition);
		wkidLookup.put("METER", 9001);
		wkidLookup.put("KILOMETER", 9036);
		wkidLookup.put("FOOT_US", 9003);
		wkidLookup.put("MILE_US", 9035);
		wkidLookup.put("NAUTICAL_MILE", 9030);
		spatial = s;
		geoEventMutator= true;
	}

	@Override
	public GeoEvent process(GeoEvent ge) throws Exception {
		double majorAxisRadius;
		String majAxisSource = properties.get("majorAxisSource").getValue().toString();
		if(majAxisSource.equals("Constant"))
		{
			majorAxisRadius = (Double) properties.get("majorAxisRadius").getValue();
		}
		else
		{
			String eventfld = properties.get("majorAxisEvent").getValue().toString();
			String[] arr = eventfld.split(":");
			majorAxisRadius = (Double)ge.getField(arr[1]);
		}
		double minorAxisRadius;
		String minAxisSource = properties.get("minorAxisSource").getValue().toString();
		if(minAxisSource.equals("Constant"))
		{
			minorAxisRadius = (Double) properties.get("minorAxisRadius").getValue();
		}
		else
		{
			String eventfld = properties.get("minorAxisEvent").getValue().toString();
			String[] arr = eventfld.split(":");
			minorAxisRadius = (Double)ge.getField(arr[1]);
		}
		double rotation;
		String rotSource = properties.get("rotationSource").getValue().toString();
		if(rotSource.equals("Constant"))
		{
			rotation = (Double) properties.get("rotation").getValue();
		}
		else
		{
			String eventfld = properties.get("rotationEvent").getValue().toString();
			String[] arr = eventfld.split(":");
			rotation = (Double)ge.getField(arr[1]);
		}

		int inwkid = (Integer) properties.get("wkidin").getValue();
		int outwkid = (Integer) properties.get("wkidout").getValue();
		int bufferwkid = (Integer) properties.get("wkidbuffer").getValue();

		com.esri.ges.spatial.Point eventGeo = (com.esri.ges.spatial.Point) ge.getGeometry();
		double x = eventGeo.getX();
		double y = eventGeo.getY();
		double rdeg = GeometryUtility.Geo2Arithmetic(rotation);
		double r = Math.toRadians(rdeg);
		com.esri.ges.spatial.Geometry ellipse = constructEllipse(x, y, majorAxisRadius, minorAxisRadius, r, inwkid, bufferwkid, outwkid);
		ge.setGeometry(ellipse);
		return ge;
	}

	private com.esri.ges.spatial.Geometry constructEllipse(double x, double y, double majorAxis, double minorAxis, double rotation, int wkidin, int wkidbuffer, int wkidout) throws GeometryException
	{
		Point center = new Point();
		center.setX(x);
		center.setY(y);
		SpatialReference srIn = SpatialReference.create(wkidin);
		SpatialReference srBuffer = SpatialReference.create(wkidbuffer);
		SpatialReference srOut = SpatialReference.create(wkidout);
		Point centerProj = (Point) GeometryEngine.project(center, srIn, srBuffer);
		GeometryUtility geoutil = new GeometryUtility();
		Polygon ellipse = geoutil.GenerateEllipse(centerProj, majorAxis, minorAxis, rotation);
		Geometry ellipseOut = GeometryEngine.project(ellipse, srBuffer, srOut);
		String json = GeometryEngine.geometryToJson(srOut, ellipseOut);
		return spatial.fromJson(json);
	}

}


text:
<?xml version="1.0" encoding="UTF-8"?>

<!--L
   Copyright SAIC

   Distributed under the OSI-approved BSD 3-Clause License.
   See http://ncip.github.com/i-spy/LICENSE.txt for details.
L-->

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

	<!-- Datasource that works in any application server
		You could easily use J2EE data source instead if this were
		running inside of a J2EE container.
	-->
	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass">
			<value>oracle.jdbc.driver.OracleDriver</value>
		</property>
		<property name="jdbcUrl">
			<value>
				jdbc:oracle:thin:@cbiodb2-d.nci.nih.gov:1521:RBTDEV
			</value>
		</property>
		<property name="user">
			<value>ispydev</value>
		</property>
		<property name="password">
			<value>dev!234</value>
		</property>
	</bean>

	<!-- Hibernate SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation">
			<value>
				file:C:/dev/ispy/WebRoot/WEB-INF/ispy-domain-hibernate.cfg.xml
			</value>
		</property>
		<property name="dataSource" ref="dataSource"/>
	</bean>

	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate" >
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- Placeholder for analysis server bean -->

	<bean id="txManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
</beans>


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

namespace Humanizer.Localisation.CollectionFormatters
{
    internal class DefaultCollectionFormatter : ICollectionFormatter
    {
        protected string DefaultSeparator = "";

        public DefaultCollectionFormatter(string defaultSeparator)
        {
            DefaultSeparator = defaultSeparator;
        }

        public virtual string Humanize<T>(IEnumerable<T> collection)
        {
            return Humanize(collection, o => o?.ToString(), DefaultSeparator);
        }

        public virtual string Humanize<T>(IEnumerable<T> collection, Func<T, string> objectFormatter)
        {
            return Humanize(collection, objectFormatter, DefaultSeparator);
        }

        public string Humanize<T>(IEnumerable<T> collection, Func<T, object> objectFormatter)
        {
            return Humanize(collection, objectFormatter, DefaultSeparator);
        }

        public virtual string Humanize<T>(IEnumerable<T> collection, string separator)
        {
            return Humanize(collection, o => o?.ToString(), separator);
        }

        public virtual string Humanize<T>(IEnumerable<T> collection, Func<T, string> objectFormatter, string separator)
        {
            if (collection == null)
            {
                throw new ArgumentNullException(nameof(collection));
            }

            if (objectFormatter == null)
            {
                throw new ArgumentNullException(nameof(objectFormatter));
            }

            return HumanizeDisplayStrings(
                collection.Select(objectFormatter),
                separator);
        }

        public string Humanize<T>(IEnumerable<T> collection, Func<T, object> objectFormatter, string separator)
        {
            if (collection == null)
            {
                throw new ArgumentNullException(nameof(collection));
            }

            if (objectFormatter == null)
            {
                throw new ArgumentNullException(nameof(objectFormatter));
            }

            return HumanizeDisplayStrings(
                collection.Select(objectFormatter).Select(o => o?.ToString()),
                separator);
        }

        private string HumanizeDisplayStrings(IEnumerable<string> strings, string separator)
        {
            var itemsArray = strings
                .Select(item => item == null ? string.Empty : item.Trim())
                .Where(item => !string.IsNullOrWhiteSpace(item))
                .ToArray();

            var count = itemsArray.Length;

            if (count == 0)
            {
                return "";
            }

            if (count == 1)
            {
                return itemsArray[0];
            }

            var itemsBeforeLast = itemsArray.Take(count - 1);
            var lastItem = itemsArray.Skip(count - 1).First();

            return string.Format(GetConjunctionFormatString(count),
                string.Join(", ", itemsBeforeLast),
                separator,
                lastItem);
        }

        protected virtual string GetConjunctionFormatString(int itemCount) => "{0} {1} {2}";
    }
}


text:
<!DOCTYPE html>

                more_vert

remove

fullscreen

                        The user has not verified itself yet. We do not recommend adding any role to the user as it
                        would unconditionally give user access to the permissions while their account may be in a vulnerable,
                        unprotected and unverified condition.

                    <form id="role-form" th:action="@{|/admin/dean/roles/user/${user.userId}|}" method="post">

                            <fieldset class="checkbox">

                                    <input class="role-checkbox" type="checkbox" th:value="${role}" name="roles"
                                           th:id="${#strings.toLowerCase(role)}"
                                           th:checked="${@authService.containsRole(user.roles, role) || containsReachableRole}"
                                           th:disabled="${containsReachableRole}">
                                     -

                            </fieldset>

                        <button class="btn btn-primary float-right mb-1" type="submit">Save</button>
                    </form>

No Role Selected

                        <button type="button" class="close" data-dismiss="modal">×</button>

                        No role is selected for the user. This will reset the role to the default role depending on whether the user
                        is student or faculty member. If you want to revoke access of a particular user, please disable it account.

                        Please click 'Save' button again if you want to continue

                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>

Role Strength Reduction

                        <button type="button" class="close" data-dismiss="modal">×</button>

                        WARNING!!!  You are reducing your own privilege. You might not get
                         back access to change the setting again. Please proceed with caution!

                        Please click 'Save' button again if you want to continue

                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using System.Threading.Tasks;
using Azure.Core.TestFramework;
using NUnit.Framework;

namespace Azure.AI.Language.QuestionAnswering.Tests.Samples
{
    public partial class QuestionAnsweringClientSamples
    {
        [RecordedTest]
        [SyncOnly]
        public void Chat()
        {
            QuestionAnsweringClient client = Client;
            KnowledgeBaseAnswer previousAnswer = QuestionAnsweringModelFactory.KnowledgeBaseAnswer(qnaId: 27);

            #region Snippet:QuestionAnsweringClient_Chat
            string projectName = "{ProjectName}";
            string deploymentName = "{DeploymentName}";
#if SNIPPET
            // Answers are ordered by their ConfidenceScore so assume the user choose the first answer below:
            KnowledgeBaseAnswer previousAnswer = answers.Answers.First();
#else
            projectName = TestEnvironment.ProjectName;
            deploymentName = TestEnvironment.DeploymentName;
#endif
            QuestionAnsweringProject project = new QuestionAnsweringProject(projectName, deploymentName);
            AnswersOptions options = new AnswersOptions
            {
                AnswerContext = new KnowledgeBaseAnswerContext(previousAnswer.QnaId.Value)
            };

            Response<AnswersResult> response = client.GetAnswers("How long should charging take?", project, options);

            foreach (KnowledgeBaseAnswer answer in response.Value.Answers)
            {
                Console.WriteLine($"({answer.Confidence:P2}) {answer.Answer}");
                Console.WriteLine($"Source: {answer.Source}");
                Console.WriteLine();
            }
#endregion

            Assert.That(response.GetRawResponse().Status, Is.EqualTo(200));
        }

        [RecordedTest]
        [AsyncOnly]
        public async Task ChatAsync()
        {
            QuestionAnsweringClient client = Client;
            KnowledgeBaseAnswer previousAnswer = QuestionAnsweringModelFactory.KnowledgeBaseAnswer(qnaId: 27);

            #region Snippet:QuestionAnsweringClient_ChatAsync
            string projectName = "{ProjectName}";
            string deploymentName = "{DeploymentName}";
#if SNIPPET
            // Answers are ordered by their ConfidenceScore so assume the user choose the first answer below:
            KnowledgeBaseAnswer previousAnswer = answers.Answers.First();
#else
            projectName = TestEnvironment.ProjectName;
            deploymentName = TestEnvironment.DeploymentName;
#endif
            QuestionAnsweringProject project = new QuestionAnsweringProject(projectName, deploymentName);
            AnswersOptions options = new AnswersOptions
            {
                AnswerContext = new KnowledgeBaseAnswerContext(previousAnswer.QnaId.Value)
            };

            Response<AnswersResult> response = await client.GetAnswersAsync("How long should charging take?", project, options);

            foreach (KnowledgeBaseAnswer answer in response.Value.Answers)
            {
                Console.WriteLine($"({answer.Confidence:P2}) {answer.Answer}");
                Console.WriteLine($"Source: {answer.Source}");
                Console.WriteLine();
            }
            #endregion

            Assert.That(response.GetRawResponse().Status, Is.EqualTo(200));
        }
    }
}


text:
	<meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>GD6D</title>
	<link rel="shortcut icon" href="_common/images/gd6d.png">
    <!-- Bootstrap Core CSS -->
    <link href="_common/css/bootstrap.min.css" rel="stylesheet">

    <!-- Custom CSS -->
    <link href="_common/css/modern-business.css" rel="stylesheet">
    <!--  icon -->
<!--     <link href="//maxcdn.bootstrapcdn.com/font-awesome/4.1.0/css/font-awesome.min.css" rel="stylesheet" /> -->

    <!-- Custom Fonts -->
    <link href="_common/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">

    <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
        <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
        <script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
	<!-- jQuery -->
    <script src="_common/js/jquery-2.1.4.min.js"></script>

    <!-- Bootstrap Core JavaScript -->
    <script src="_common/js/bootstrap.min.js"></script>


text:
'use strict';

var XMLImporter = require('../../model/XMLImporter');
var schema = require('./TestSchema');
var TestArticle = require('./TestArticle');

var converters = [
  require('../../packages/paragraph/ParagraphXMLConverter'),
  require('../../packages/image/ImageXMLConverter'),
  require('../../packages/heading/HeadingXMLConverter'),
  require('../../packages/emphasis/EmphasisXMLConverter'),
  require('../../packages/strong/StrongXMLConverter'),
  require('../../packages/link/LinkXMLConverter'),
  require('../../packages/table/TableXMLConverter'),
  require('../../packages/table/TableSectionXMLConverter'),
  require('../../packages/table/TableRowXMLConverter'),
  require('../../packages/table/TableCellXMLConverter'),
  require('../../packages/list/ListXMLConverter'),
  require('../../packages/list/ListItemXMLConverter'),
  require('./TestMetaNodeXMLConverter')
];

function TestXMLImporter() {
  TestXMLImporter.super.call(this, {
    schema: schema,
    converters: converters,
    DocumentClass: TestArticle
  });
}

XMLImporter.extend(TestXMLImporter, function() {

  this.convertDocument = function(documentEl) {
    var bodyEl = documentEl.find('body');
    this.convertContainer(bodyEl.children, 'main');
  };

});

TestXMLImporter.converters = converters;

module.exports = TestXMLImporter;


text:
{%load i18n%}
<form id="container_form"  method="post">
  {% csrf_token %}
  {% for hidden in form.hidden_fields %}{{ hidden }}{% endfor %}
    {% for field in form.visible_fields %}
    {{ field.label_tag }}
    {{ field.errors }}
    {{ field }}
  {% endfor %}
  <input type="submit" value="{%trans "Create Container"%}" class="large-rounded" />
</form>


text:
<?php
/**
 * The staging database settings. These get merged with the global settings.
 */

return array(
	'default' => array(
		'connection'  => array(
			'dsn'        => 'mysql:host=mysql.hostinger.jp;dbname=u415850730_test',
			'username'   => 'u415850730_test',
			'password'   => 'yakisobameron',
		),
	),
);


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <title>SCOT - Smart Control Of Tasks</title>

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

      SCOT - Smart Control Of Tasks

        What?

          A smart tasks controller focused on visual aspects, gamification and priorizations

        Who?

          Everyone who wants to control tasks to be done without thinking in time

        Why?

          To simplify control of tasks, increasing the performance and accuracy of things to do

        Where?

          Anywhere in the world with internet access

        When?

          Right now, if you need a better control of your tasks to be done

        How?

          Just sign up, login and follow the instructions

 Sign Up

 Login

Los Angeles

LA is always so much fun!

Chicago

Thank you, Chicago!

New York

We love the Big Apple!

    Previous

    Next


text:
All notable changes to this project will be documented in this file.
This project tries to adhere to [Semantic Versioning](http://semver.org/).
Changes for version 1.0.0 describe differences to the [original project](https://github.com/drewhamlett/brackets-beautify).

## Unreleased
### Changed
- Updated Italian Language

## Fixed
- LivePreview duplication (see [#14](https://github.com/Hirse/brackets-beautify/issues/14))

## 1.0.2 - 2015-07-01
### Fixed
- Key Binding on Linux

## 1.0.1 - 2015-06-25
### Changed
- Updated js-beautify to version 1.5.10

## 1.0.0 - 2015-06-24
### Added
- Use Brackets Preferences language and path layer to configure `Beautify on save`
- Enable use of nested settings from `.jsbeautifyrc`
- Provide settings to _css_beautify_
- Format SVG as HTML
- Spanish translation
- Italian translation
- Japanese translation

### Changed
- Updated js-beautify to version 1.5.7
- Turned on `end_with_newline` option by default
- Only change document if beautified text looks different

### Removed
- SASS Formatting
- Fake French translation
- `git_happy` option as it is identical to `end_with_newline`

### Fixed
- Deprecation warnings for $().on/off() on Brackets modules


text:
Local Process    {#CommandLineModulesBackendLocalProcess_Page}
=============

\internal This page is best viewed in its [Doxygen processed]
(http://www.commontk.org/docs/html/CommandLineModulesBackendLocalProcess_Page.html) form. \endinternal

The Local Process back-end is a fully featured back-end implementation for handling executable
modules. When registered with a ctkCmdLineModuleManager instance, it will handle the registration
of all modules with a "file" location URL scheme. See the ctkCmdLineModuleBackendLocalProcess class
for details.

See the \ref CommandLineModulesBackendLocalProcess_API module for the API documentation.


text:
// Refactored gstGeoIndex internal data representation (optimization of memory
// usage): store reference to full FeatureHandle array in all geoindex-es and
// use index of array to address FeatureHandle-s.

#ifndef GEO_EARTH_ENTERPRISE_SRC_FUSION_GST_GSTGEOINDEX_H_
#define GEO_EARTH_ENTERPRISE_SRC_FUSION_GST_GSTGEOINDEX_H_

#include <vector>
#include <deque>
#include <set>
#include <string>

#include "common/base/macros.h"
#include "fusion/gst/gstBBox.h"
#include "common/khRefCounter.h"
#include "common/khPresenceMask.h"
#include "common/khCoverageMask.h"

class gstSharedSourceImpl;
typedef khRefGuard<gstSharedSourceImpl> gstSharedSource;

class gstGeoIndexImpl;
typedef khRefGuard<gstGeoIndexImpl> gstGeoIndexHandle;

class gstGeoIndexImpl : public khRefCounter {
 public:
  static khRefGuard<gstGeoIndexImpl> Create() {
    return khRefGuardFromNew(new gstGeoIndexImpl());
  }
  static gstGeoIndexHandle Load(const std::string &select_file,
                                const gstSharedSource &source,
                                const khTilespace &tilespace,
                                const double oversize_factor,
                                const uint target_level);

  void Reset();

  // Adds a feature id and it's corresponding bounding box.
  void Insert(int feature_id, const gstBBox& bounding_box);
  void Finalize();

  void Intersect(const gstBBox& b, std::vector<int>* match_list,
                 std::vector<gstBBox>* index_boxes = NULL);
  void SelectAll(std::vector<int>* list);

  bool ReadFile(const std::string& path, int source_id);
  bool WriteFile(const std::string& path);

  const gstBBox& GetBoundingBox() const { return bounding_box_; }
  int GetCount() const { return box_index_list_.size(); }
  const khLevelCoverage& GetCoverage(void) const { return coverage_; }

  // false return is definitive
  // true return may just be an estimate
  inline bool GetEstimatedPresence(const khTileAddr &addr) const {
    // Note: if it's not true then it means that we traverse odd
    // tiles (our quadtree partitioning is not effective).
    assert(presence_mask_);
    return presence_mask_->GetEstimatedPresence(addr);
  }

  inline void SetPresence(khTileAddr addr, bool present) {
    assert(presence_mask_);
    // Note: The vector data is fused starting from level 0.
    // The presence mask created here depends on feature distribution
    // statistics and it can happen that a start level of the presence mask
    // is not 0. Currently, the function is only called in 3d fuse pipeline,
    // and seems it never happens, but I encountered it trying to integrate
    // the qt partitioning optimization into 2d fuse pipeline. So we check
    // whether addr.level is valid.
    if (presence_mask_->ValidLevel(addr.level)) {
      presence_mask_->SetPresence(addr, present);
    }
  }

  // Sets that specific tile (addr) is completely covered by specific feature
  // (feature_id).
  inline void SetCovered(const khTileAddr &addr,
                          int feature_id) {
    assert(coverage_mask_);
    if (coverage_mask_->ValidLevel(addr.level)) {
      coverage_mask_->SetCovered(addr, feature_id);
    }
  }

  // Returns whether specific tile is completely covered with any polygonal
  // feature and a list of feature IDs covering that tile.
  inline bool GetCovered(const khTileAddr &addr,
                         std::set<int> *feature_id_set) const {
    assert(coverage_mask_);
    return coverage_mask_->GetCovered(addr, feature_id_set);
  }

  inline uint MaxLevel(void) const { return coverage_.level; }
  gstGeoIndexHandle SplitCell(uint32 row, uint32 col,
                              const khLevelCoverage &targetCov);

  typedef std::deque<uint> FeatureBucket;
  typedef FeatureBucket::iterator FeatureBucketIterator;
  typedef FeatureBucket::const_iterator FeatureBucketConstIterator;

  const FeatureBucket* GetBucket(uint32 row, uint32 col) const;
  void PopulateBucket(const khExtents<uint32> &extents,
                      FeatureBucket *bucket) const;

  void GetFeatureIdsFromBucket(uint32 row, uint32 col,
                               std::vector<int> &ids) const;
  void GetFeatureIdsFromBuckets(const khExtents<uint32> &extents,
                                std::vector<int> &ids) const;

  struct FeatureHandle {
    FeatureHandle(int fid, const gstBBox& b)
        : feature_id(fid), bounding_box(b) {}
    bool operator<(const FeatureHandle& fh) const {
      return (feature_id < fh.feature_id);
    }
    int feature_id;
    gstBBox bounding_box;
  };

  struct FeatureList;
  typedef khRefGuard<FeatureList> FeatureListHandle;

  class FeatureList : public khRefCounter {
   public:
    static khRefGuard<FeatureList> Create() {
      return khRefGuardFromNew(new FeatureList());
    }

    inline size_t size() const {
      return feature_handles_.size();
    }

    inline void push_back(const FeatureHandle& x) {
      feature_handles_.push_back(x);
    }

    inline const FeatureHandle& operator[](uint n) const {
      return feature_handles_[n];
    }

    inline FeatureHandle& operator[](uint n) {
      return feature_handles_[n];
    }

   private:
    FeatureList() : feature_handles_() {}

    std::deque<FeatureHandle> feature_handles_;
    DISALLOW_COPY_AND_ASSIGN(FeatureList);
  };

  const FeatureList& GetFeatureList(void) const {
    assert(box_list_);
    return (*box_list_);
  }

 private:
  friend class khRefGuard<gstGeoIndexImpl>;

  typedef std::vector<FeatureBucket> FeatureGrid;
  typedef FeatureGrid::iterator FeatureGridIterator;

  gstGeoIndexImpl();
  gstGeoIndexImpl(const khLevelCoverage &cov,
                  const khTilespace &tilespace,
                  double oversize_factor);
  gstGeoIndexImpl(const std::string &select_file,
                  const gstSharedSource &source,
                  const khTilespace &tilespace,
                  const double oversize_factor,
                  const uint target_level);

  void Init();

  // will throw - use ReadFile above if you don't want exceptions
  void ThrowingReadFile(const std::string& path, int source_id);

  // Adds a feature index and it's corresponding bounding box.
  // It's used in SplitCell() to create a new Index and fill it with features
  // based on an existing Index.
  void InsertIndex(uint idx);

  const khTilespace& tilespace_;
  const double oversize_factor_;

  FeatureGrid grid_;
  FeatureListHandle box_list_;
  typedef std::deque<uint32> BoxIndexList;
  BoxIndexList box_index_list_;

  gstBBox bounding_box_;
  khLevelCoverage coverage_;
  khDeleteGuard<khPresenceMask> presence_mask_;
  // The coverage mask keeps information about completely covered tiles:
  // whether tile is completely covered and list of features covering it.
  // It is built/updated while fusing every level and used for optimization
  // of processing of completely covered tiles.
  khDeleteGuard<khCoverageMask> coverage_mask_;
  const uint target_level_;

  DISALLOW_COPY_AND_ASSIGN(gstGeoIndexImpl);
};

#endif  // GEO_EARTH_ENTERPRISE_SRC_FUSION_GST_GSTGEOINDEX_H_


text:
package com.mechdome.maps.google;

import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.GoogleMap.OnMapLongClickListener;
import com.google.android.gms.maps.LocationSource;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;

import android.Manifest;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;

/**
 * This shows how to use a custom location source.
 */
public class LocationSourceDemoActivity extends AppCompatActivity implements OnMapReadyCallback {

    /**
     * A {@link LocationSource} which reports a new location whenever a user long presses the map
     * at
     * the point at which a user long pressed the map.
     */
    private static class LongPressLocationSource implements LocationSource, OnMapLongClickListener {

        private OnLocationChangedListener mListener;

        /**
         * Flag to keep track of the activity's lifecycle. This is not strictly necessary in this
         * case because onMapLongPress events don't occur while the activity containing the map is
         * paused but is included to demonstrate best practices (e.g., if a background service were
         * to be used).
         */
        private boolean mPaused;

        @Override
        public void activate(OnLocationChangedListener listener) {
            mListener = listener;
        }

        @Override
        public void deactivate() {
            mListener = null;
        }

        @Override
        public void onMapLongClick(LatLng point) {
            if (mListener != null && !mPaused) {
                Location location = new Location("LongPressLocationProvider");
                location.setLatitude(point.latitude);
                location.setLongitude(point.longitude);
                location.setAccuracy(100);
                mListener.onLocationChanged(location);
            }
        }

        public void onPause() {
            mPaused = true;
        }

        public void onResume() {
            mPaused = false;
        }
    }

    private LongPressLocationSource mLocationSource;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.basic_demo);

        mLocationSource = new LongPressLocationSource();

        SupportMapFragment mapFragment =
                (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
        // add back arrow to toolbar
        if (getSupportActionBar() != null){
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
            getSupportActionBar().setDisplayShowHomeEnabled(true);
        }

    }

    @Override
    public boolean onSupportNavigateUp() {
        onBackPressed();
        return true;
    }

    @Override
    protected void onResume() {
        super.onResume();
        mLocationSource.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mLocationSource.onPause();
    }

    @Override
    public void onMapReady(GoogleMap map) {
        map.setLocationSource(mLocationSource);
        map.setOnMapLongClickListener(mLocationSource);
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // TODO: Consider calling
            //    ActivityCompat#requestPermissions
            // here to request the missing permissions, and then overriding
            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
            //                                          int[] grantResults)
            // to handle the case where the user grants the permission. See the documentation
            // for ActivityCompat#requestPermissions for more details.
            return;
        }
        map.setMyLocationEnabled(true);
    }
}


text:
'use strict';

var config = require('../config');
var gulp = require('gulp');

var MergeStream = require('merge-stream');

var imagemin = require('gulp-imagemin');

/**************************
 * Task processes and copies all dependencies, either installed by npm or stored locally in the project
 **************************/
function dependencies() {

    //as we do multiple things in this task, we merge the multiple streams
    var stream = new MergeStream();

    // Pick the dependencies we need from each package
    // so we don't just ship with a lot of files that aren't needed
    const nodeModules = [
        {
            "name": "ace-builds",
            "src":  [
                "./node_modules/ace-builds/src-min-noconflict/ace.js",
                "./node_modules/ace-builds/src-min-noconflict/ext-language_tools.js",
                "./node_modules/ace-builds/src-min-noconflict/ext-searchbox.js",
                "./node_modules/ace-builds/src-min-noconflict/ext-settings_menu.js",
                "./node_modules/ace-builds/src-min-noconflict/snippets/text.js",
                "./node_modules/ace-builds/src-min-noconflict/snippets/javascript.js",
                "./node_modules/ace-builds/src-min-noconflict/snippets/css.js",
                "./node_modules/ace-builds/src-min-noconflict/theme-chrome.js",
                "./node_modules/ace-builds/src-min-noconflict/mode-razor.js",
                "./node_modules/ace-builds/src-min-noconflict/mode-javascript.js",
                "./node_modules/ace-builds/src-min-noconflict/mode-css.js",
                "./node_modules/ace-builds/src-min-noconflict/worker-javascript.js",
                "./node_modules/ace-builds/src-min-noconflict/worker-css.js"
            ],
            "base": "./node_modules/ace-builds"
        },
        {
            "name": "angular",
            "src":  ["./node_modules/angular/angular.js"],
            "base": "./node_modules/angular"
        },
        {
            "name": "angular-aria",
            "src":  ["./node_modules/angular-aria/angular-aria.min.js"],
            "base": "./node_modules/angular-aria"
        },
        {
            "name": "angular-cookies",
            "src":  ["./node_modules/angular-cookies/angular-cookies.js"],
            "base": "./node_modules/angular-cookies"
        },
        {
            "name": "angular-dynamic-locale",
            "src":  [
                "./node_modules/angular-dynamic-locale/dist/tmhDynamicLocale.min.js",
                "./node_modules/angular-dynamic-locale/dist/tmhDynamicLocale.min.js.map"
            ],
            "base": "./node_modules/angular-dynamic-locale/dist"
        },
        {
            "name": "angular-sanitize",
            "src":  ["./node_modules/angular-sanitize/angular-sanitize.js"],
            "base": "./node_modules/angular-sanitize"
        },
        {
            "name": "angular-touch",
            "src":  ["./node_modules/angular-touch/angular-touch.js"],
            "base": "./node_modules/angular-touch"
        },
        {
            "name": "angular-ui-sortable",
            "src":  ["./node_modules/angular-ui-sortable/dist/sortable.js"],
            "base": "./node_modules/angular-ui-sortable/dist"
        },
        {
            "name": "angular-route",
            "src":  ["./node_modules/angular-route/angular-route.js"],
            "base": "./node_modules/angular-route"
        },
        {
            "name": "angular-animate",
            "src":  ["./node_modules/angular-animate/angular-animate.js"],
            "base": "./node_modules/angular-animate"
        },
        {
            "name": "angular-i18n",
            "src":  [
                "./node_modules/angular-i18n/angular-i18n.js",
                "./node_modules/angular-i18n/angular-locale_*.js"
            ],
            "base": "./node_modules/angular-i18n"
        },
        {
            "name": "angular-local-storage",
            "src":  [
                "./node_modules/angular-local-storage/dist/angular-local-storage.min.js",
                "./node_modules/angular-local-storage/dist/angular-local-storage.min.js.map"
            ],
            "base": "./node_modules/angular-local-storage/dist"
        },
        {
            "name": "angular-messages",
            "src":  ["./node_modules/angular-messages/angular-messages.js"],
            "base": "./node_modules/angular-messages"
        },
        {
            "name": "angular-mocks",
            "src":  ["./node_modules/angular-mocks/angular-mocks.js"],
            "base": "./node_modules/angular-mocks"
        },
        {
            "name": "animejs",
            "src":  ["./node_modules/animejs/anime.min.js"],
            "base": "./node_modules/animejs"
        },
        {
            "name": "bootstrap-social",
            "src":  ["./node_modules/bootstrap-social/bootstrap-social.css"],
            "base": "./node_modules/bootstrap-social"
        },

        {
            "name": "angular-chart.js",
            "src":  ["./node_modules/angular-chart.js/dist/angular-chart.min.js"],
            "base": "./node_modules/angular-chart.js/dist"
        },
        {
            "name": "chart.js",
            "src":  ["./node_modules/chart.js/dist/chart.min.js"],
            "base": "./node_modules/chart.js/dist"
        },
        {
            "name": "clipboard",
            "src":  ["./node_modules/clipboard/dist/clipboard.min.js"],
            "base": "./node_modules/clipboard/dist"
        },
        {
            "name": "jsdiff",
            "src":  ["./node_modules/diff/dist/diff.min.js"],
            "base": "./node_modules/diff/dist"
        },
        {
            "name": "flatpickr",
            "src":  [
                "./node_modules/flatpickr/dist/flatpickr.js",
                "./node_modules/flatpickr/dist/flatpickr.css",
                "./node_modules/flatpickr/dist/l10n/*.js"
            ],
            "base": "./node_modules/flatpickr/dist"
        },
        {
            "name": "font-awesome",
            "src":  [
                "./node_modules/font-awesome/fonts/*",
                "./node_modules/font-awesome/css/font-awesome.min.css"
            ],
            "base": "./node_modules/font-awesome"
        },
        {
            "name": "jquery",
            "src":  [
                "./node_modules/jquery/dist/jquery.min.js",
                "./node_modules/jquery/dist/jquery.min.map"
            ],
            "base": "./node_modules/jquery/dist"
        },
        {
            "name": "jquery-ui",
            "src":  ["./node_modules/jquery-ui-dist/jquery-ui.min.js"],
            "base": "./node_modules/jquery-ui-dist"
        },
        {
            "name": "jquery-ui-touch-punch",
            "src":  ["./node_modules/jquery-ui-touch-punch/jquery.ui.touch-punch.min.js"],
            "base": "./node_modules/jquery-ui-touch-punch"
        },
        {
            "name": "lazyload-js",
            "src":  ["./node_modules/lazyload-js/lazyload.min.js"],
            "base": "./node_modules/lazyload-js"
        },
        {
            "name": "moment",
            "src":  ["./node_modules/moment/min/moment.min.js"],
            "base": "./node_modules/moment/min"
        },
        {
            "name": "moment",
            "src":  ["./node_modules/moment/locale/*.js"],
            "base": "./node_modules/moment/locale"
        },
        {
            "name": "ng-file-upload",
            "src":  ["./node_modules/ng-file-upload/dist/ng-file-upload.min.js"],
            "base": "./node_modules/ng-file-upload/dist"
        },
        {
            "name": "nouislider",
            "src":  [
                "./node_modules/nouislider/distribute/nouislider.min.js",
                "./node_modules/nouislider/distribute/nouislider.min.css"
            ],
            "base": "./node_modules/nouislider/distribute"
        },
        {
            "name": "signalr",
            "src":  ["./node_modules/signalr/jquery.signalR.js"],
            "base": "./node_modules/signalr"
        },
        {
            "name": "spectrum",
            "src":  [
                "./node_modules/spectrum-colorpicker/spectrum.js",
                "./node_modules/spectrum-colorpicker/spectrum.css"
            ],
            "base": "./node_modules/spectrum-colorpicker"
        },
        {
            "name": "tinymce",
            "src":  [
                "./node_modules/tinymce/tinymce.min.js",
                "./node_modules/tinymce/plugins/**",
                "./node_modules/tinymce/skins/**",
                "./node_modules/tinymce/themes/**"
            ],
            "base": "./node_modules/tinymce"
        },
        {
            "name": "typeahead.js",
            "src":  ["./node_modules/typeahead.js/dist/typeahead.bundle.min.js"],
            "base": "./node_modules/typeahead.js/dist"
        },
        {
            "name": "underscore",
            "src":  ["node_modules/underscore/underscore-min.js"],
            "base": "./node_modules/underscore"
        }
    ];

    // add streams for node modules
    nodeModules.forEach(module => {
        stream.add(
            gulp.src(module.src,
                { base: module.base, allowEmpty: true })
                .pipe(gulp.dest(config.root + config.targets.lib + "/" + module.name))
        );
    });

    //copy over libs which are not on npm (/lib)
    stream.add(
        gulp.src(config.sources.globs.lib, { allowEmpty: true })
            .pipe(gulp.dest(config.root + config.targets.lib))
        );

    //Copies all static assets into /root / assets folder
    //css, fonts and image files

    var assetsTask = gulp.src(config.sources.globs.assets, { allowEmpty: true });
    assetsTask = assetsTask.pipe(imagemin([
        imagemin.gifsicle({interlaced: true}),
        imagemin.jpegtran({progressive: true}),
        imagemin.optipng({optimizationLevel: 5}),
        imagemin.svgo({
            plugins: [
                {removeViewBox: true},
                {cleanupIDs: false}
            ]
        })
    ]));

    assetsTask = assetsTask.pipe(gulp.dest(config.root + config.targets.assets));

    stream.add(assetsTask);

    // Copies all the less files related to the preview into their folder
    //these are not pre-processed as preview has its own less compiler client side
    stream.add(
        gulp.src("src/canvasdesigner/editors/*.less", { allowEmpty: true })
                .pipe(gulp.dest(config.root + config.targets.assets + "/less"))
        );

	// TODO: check if we need these fileSize
    stream.add(
        gulp.src("src/views/propertyeditors/grid/config/*.*", { allowEmpty: true })
                .pipe(gulp.dest(config.root + config.targets.views + "/propertyeditors/grid/config"))
        );
    stream.add(
        gulp.src("src/views/dashboard/default/*.jpg", { allowEmpty: true })
                .pipe(gulp.dest(config.root + config.targets.views + "/dashboard/default"))
        );

    return stream;
};

module.exports = { dependencies: dependencies };


text:
import os
import sys
import shutil
import argparse
import subprocess

from fetch_sources import *
sys.path.append(os.path.join(os.path.dirname(__file__), "..", "scripts"))

from build.common import *

EXTERNAL_DIR	= os.path.realpath(os.path.normpath(os.path.dirname(__file__)))
SHA1 = "0f89d064412a69e9d39be6c2d5ec83ed27ee99a9"

PACKAGES = [
	GitRepo(
		"https://gitlab.khronos.org/opengl/kc-cts.git",
		"git@gitlab.khronos.org:opengl/kc-cts.git",
		SHA1,
		"kc-cts"),
]

if __name__ == "__main__":
	args = parseArgs()

	for pkg in PACKAGES:
		if args.clean:
			pkg.clean()
		else:
			pkg.update(args.protocol)


text:
"use strict";
var vscode = require('vscode');
var fs = require('fs');
var Gaze = require('gaze').Gaze;
var Glob = require('glob');
var Globule = require('globule');
var ftpclient = require('ftp');
var sftpclient = require('ssh2').Client;
var ClientSettings = (function () {
    function ClientSettings() {
    }
    return ClientSettings;
}());
var FtpClient = (function () {
    function FtpClient(projectpath) {
        this.projectdir = projectpath;
        this.queuedelay = 1000;
        var settings = new ClientSettings();
        var settingsfile = Glob.sync(this.projectdir + "/.ftpconfig.json");
        if (settingsfile[0] == null) {
            settingsfile = Glob.sync(this.projectdir + "/.remote-sync.json");
        }
        var parsedsettings = null;
        try {
            parsedsettings = JSON.parse(fs.readFileSync(settingsfile[0], "utf8"));
        }
        catch (e) {
            settings = null;
        }
        if (settings != null) {
            settings.hostname = parsedsettings.hostname;
            settings.username = parsedsettings.username;
            settings.password = parsedsettings.password;
            settings.target = parsedsettings.target;
            settings.mode = parsedsettings.mode;
            settings.port = parsedsettings.port;
            settings.ignore = new Array();
            parsedsettings.ignore.forEach(function (val, index, array) {
                settings.ignore.push(val);
            });
            settings.watch = new Array();
            parsedsettings.watch.forEach(function (val, index, array) {
                settings.watch.push(val);
            });
            this.clientsettings = settings;
            this.queueduploads = new Array();
            this.queueprocessing = false;
            if (this.clientsettings.mode == "sftp") {
                this.openSFTPConnection();
            }
            else {
                vscode.window.showInformationMessage("FTP Settings found and loaded for project.");
            }
            this.startWatchingFiles();
        }
        else {
            vscode.window.showWarningMessage(".ftpconfig.json, or .remote-sync.json cannot be loaded.  There may be a typo or syntax issue within the file.");
        }
    }
    FtpClient.prototype.destroy = function () {
        if (this.sftpinstance != null) {
            this.sftpinstance.end();
        }
    };
    FtpClient.prototype.openSFTPConnection = function () {
        var _this = this;
        this.sftpinstance = null;
        this.sftpinstance = new sftpclient();
        this.sftpinstance.connect({
            "host": this.clientsettings.hostname,
            "port": this.clientsettings.port,
            "username": this.clientsettings.username,
            "password": this.clientsettings.password
        });
        this.sftpinstance.on('error', function (err) {
            var errormessage = vscode.window.showErrorMessage("Failed to connect to server: " + err.message);
        });
        this.sftpinstance.on('ready', function () {
            vscode.window.showInformationMessage("SFTP Settings found and loaded for project.");
        });
        this.sftpinstance.on('end', function () { return _this.openSFTPConnection(); });
    };
    FtpClient.prototype.startWatchingFiles = function () {
        var _this = this;
        var gaze = new Gaze();
        gaze.on('changed', function (filepath) {
            _this.addUploadFileToQueue(filepath);
        });
        this.clientsettings.watch.forEach(function (val, index, array) {
            var separator = "";
            if (val.charAt(0) != "/") {
                separator = "/";
            }
            gaze.add(_this.projectdir + separator + val);
        });
    };
    FtpClient.prototype.addUploadFileToQueue = function (filepath) {
        if (this.queueduploads.indexOf(filepath) === -1) {
            this.queueduploads.push(filepath);
        }
        this.processQueue();
    };
    FtpClient.prototype.processQueue = function () {
        var _this = this;
        if (!this.queueprocessing) {
            this.queueprocessing = true;
            setTimeout(function () {
                _this.queueduploads.forEach(function (val, index, array) {
                    _this.uploadFile(val);
                });
                _this.queueduploads = new Array();
                _this.queueprocessing = false;
            }, this.queuedelay);
        }
    };
    FtpClient.prototype.checkIgnoredFiles = function (filename) {
        var globarray = new Array();
        globarray.push("**/*");
        globarray = globarray.concat(this.clientsettings.ignore);
        if (Globule.isMatch(globarray, filename)) {
            return false;
        }
        else {
            return true;
        }
    };
    FtpClient.prototype.uploadFile = function (filepath) {
        var messageDisposable = vscode.window.setStatusBarMessage("Uploading file ...", 2000);
        var remotefilepath = filepath.replace(this.projectdir, "");
        remotefilepath = this.clientsettings.target + remotefilepath;
        if (this.clientsettings.mode == "sftp") {
            this.sftpinstance.sftp(function (err, sftp) {
                if (err) {
                    var errormessage = vscode.window.showErrorMessage("Failed to upload file " + err.message);
                    sftp.end();
                }
                else {
                    var readStream = fs.createReadStream(filepath);
                    var writeStream = sftp.createWriteStream(remotefilepath);
                    writeStream.on('close', function () {
                        console.log("....upload complete!");
                        messageDisposable.dispose();
                        var successmessage = vscode.window.setStatusBarMessage("... upload complete!", 3000);
                        sftp.end();
                    });
                    readStream.pipe(writeStream);
                }
            });
        }
        if (this.clientsettings.mode == "ftp") {
            var c_1 = new ftpclient();
            c_1.on('ready', function () {
                c_1.list(remotefilepath, function (err, list) {
                    if (err) {
                        var patharray = remotefilepath.split('/');
                        patharray.pop();
                        var pathtocreate = patharray.join('/');
                        console.log(pathtocreate);
                        c_1.mkdir(pathtocreate, true, function (err) {
                            if (err) {
                                var errormessage = vscode.window.showErrorMessage("Failed to create directory: " + err.message);
                            }
                            c_1.put(filepath, remotefilepath, function (err) {
                                if (err) {
                                    var errormessage = vscode.window.showErrorMessage("Failed to upload file " + err.message);
                                }
                                else {
                                    console.log("....upload complete!");
                                    messageDisposable.dispose();
                                    var successmessage = vscode.window.setStatusBarMessage("... upload complete!", 3000);
                                }
                                c_1.end();
                            });
                        });
                    }
                    else {
                        c_1.put(filepath, remotefilepath, function (err) {
                            if (err) {
                                var errormessage = vscode.window.showErrorMessage("Failed to upload file " + err.message);
                            }
                            else {
                                console.log("....upload complete!");
                                messageDisposable.dispose();
                                var successmessage = vscode.window.setStatusBarMessage("... upload complete!", 3000);
                            }
                            c_1.end();
                        });
                    }
                });
            });
            c_1.on('error', function (err) {
                var errormessage = vscode.window.showErrorMessage("Failed to connect to server: " + err.message);
            });
            c_1.connect({
                host: this.clientsettings.hostname,
                user: this.clientsettings.username,
                password: this.clientsettings.password
            });
        }
    };
    return FtpClient;
}());
exports.FtpClient = FtpClient;
//# sourceMappingURL=ftpclient.js.map


text:
package org.onesocialweb.client;

public class XmppJID {

    public static String toBareJID(String jid) {
	if (jid != null) {
		if (jid.contains("/")) {
			return jid.substring(0, jid.indexOf('/'));
		} else {
			return jid;
		}
	}

	return null;
    }
}


text:
package com.eaw1805.data.dto.web.economy;

import java.io.Serializable;

/**
 * Class that contains read-only information about the goods.
 */
public class GoodDTO
        implements com.google.gwt.user.client.rpc.IsSerializable, Serializable {

    /**
     * Required by Serializable interface.
     */
    static final long serialVersionUID = 28L; //NOPMD

    /**
     * The identification number of the good.
     */
    private int goodId;

    /**
     * The good's name.
     */
    private String name;

    /**
     * The good's GF (good factor).
     */
    private int goodFactor;

    /**
     * The good's weight, units per tone.
     */
    private int weightOfGood;

    /**
     * Get the Identification number of the good.
     *
     * @return the identification number of the good.
     */
    public int getGoodId() {
        return goodId;
    }

    /**
     * Set the identification number of the good.
     *
     * @param identity the identification number of the good.
     */
    public void setGoodId(final int identity) {
        this.goodId = identity;
    }

    /**
     * Get the name of the good.
     *
     * @return the name of the good.
     */
    public String getName() {
        return name;
    }

    /**
     * Set the thisName of the good.
     *
     * @param thisName the name of the good.
     */
    public void setName(final String thisName) {
        this.name = thisName;
    }

    /**
     * Get the Good's Factor.
     *
     * @return the Good's Factor.
     */
    public int getGoodFactor() {
        return goodFactor;
    }

    /**
     * Set the Good's Factor.
     *
     * @param thisGoodFactor the good's Factor.
     */
    public void setGoodFactor(final int thisGoodFactor) {
        this.goodFactor = thisGoodFactor;
    }

    /**
     * Get the Good's weight in units per tone.
     *
     * @return the Good's weight in units per tone.
     */
    public int getWeightOfGood() {
        return weightOfGood;
    }

    /**
     * Set the Good's weight in units per tone.
     *
     * @param thisWeightOfGood the good's Factor in units per tone.
     */
    public void setWeightOfGood(final int thisWeightOfGood) {
        this.weightOfGood = thisWeightOfGood;
    }

}


text:
<?php

namespace Avanderbergh\Schoology\Facades;

use Illuminate\Support\Facades\Facade;

class Saml2Auth extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'Avanderbergh\Schoology\Saml2Auth';
    }
}


text:
package cn.felord.wepay.ali.sdk.api.domain;

import java.util.List;

import cn.felord.wepay.ali.sdk.api.AlipayObject;
import cn.felord.wepay.ali.sdk.api.internal.mapping.ApiField;
import cn.felord.wepay.ali.sdk.api.internal.mapping.ApiListField;

/**
 * 匹配用户标签删除接口
 *
 * @author auto create
 * @version $Id: $Id
 */
public class AlipayOpenPublicMatchuserLabelDeleteModel extends AlipayObject {

	private static final long serialVersionUID = 7841555497361927162L;

	/**
	 * 标签id
	 */
	@ApiField("label_id")
	private String labelId;

	/**
	 * 支付宝用户匹配器列表,最多传入10条
	 */
	@ApiListField("matchers")
	@ApiField("matcher")
	private List<Matcher> matchers;

	/**
	 *
Getter for the field labelId.

	 *
	 * @return a {@link java.lang.String} object.
	 */
	public String getLabelId() {
		return this.labelId;
	}
	/**
	 *
Setter for the field labelId.

	 *
	 * @param labelId a {@link java.lang.String} object.
	 */
	public void setLabelId(String labelId) {
		this.labelId = labelId;
	}

	/**
	 *
Getter for the field matchers.

	 *
	 * @return a {@link java.util.List} object.
	 */
	public List<Matcher> getMatchers() {
		return this.matchers;
	}
	/**
	 *
Setter for the field matchers.

	 *
	 * @param matchers a {@link java.util.List} object.
	 */
	public void setMatchers(List<Matcher> matchers) {
		this.matchers = matchers;
	}

}


text:
import {DirectiveResolver} from '@angular/compiler';
import {Compiler, Component, Directive, Injectable, Injector, Provider, Type, resolveForwardRef, ɵViewMetadata as ViewMetadata} from '@angular/core';
import {isPresent} from './facade/lang';

/**
 * An implementation of {@link DirectiveResolver} that allows overriding
 * various properties of directives.
 */
@Injectable()
export class MockDirectiveResolver extends DirectiveResolver {
  private _directives = new Map<Type<any>, Directive>();
  private _providerOverrides = new Map<Type<any>, any[]>();
  private _viewProviderOverrides = new Map<Type<any>, any[]>();
  private _views = new Map<Type<any>, ViewMetadata>();
  private _inlineTemplates = new Map<Type<any>, string>();

  constructor(private _injector: Injector) { super(); }

  private get _compiler(): Compiler { return this._injector.get(Compiler); }

  private _clearCacheFor(component: Type<any>) { this._compiler.clearCacheFor(component); }

  resolve(type: Type<any>, throwIfNotFound = true): Directive {
    let metadata = this._directives.get(type);
    if (!metadata) {
      metadata = super.resolve(type, throwIfNotFound);
    }
    if (!metadata) {
      return null;
    }

    const providerOverrides = this._providerOverrides.get(type);
    const viewProviderOverrides = this._viewProviderOverrides.get(type);

    let providers = metadata.providers;
    if (isPresent(providerOverrides)) {
      const originalViewProviders: Provider[] = metadata.providers || [];
      providers = originalViewProviders.concat(providerOverrides);
    }

    if (metadata instanceof Component) {
      let viewProviders = metadata.viewProviders;
      if (isPresent(viewProviderOverrides)) {
        const originalViewProviders: Provider[] = metadata.viewProviders || [];
        viewProviders = originalViewProviders.concat(viewProviderOverrides);
      }

      let view = this._views.get(type);
      if (!view) {
        view = <any>metadata;
      }

      let animations = view.animations;
      let templateUrl = view.templateUrl;

      let inlineTemplate = this._inlineTemplates.get(type);
      if (isPresent(inlineTemplate)) {
        templateUrl = null;
      } else {
        inlineTemplate = view.template;
      }

      return new Component({
        selector: metadata.selector,
        inputs: metadata.inputs,
        outputs: metadata.outputs,
        host: metadata.host,
        exportAs: metadata.exportAs,
        moduleId: metadata.moduleId,
        queries: metadata.queries,
        changeDetection: metadata.changeDetection,
        providers: providers,
        viewProviders: viewProviders,
        entryComponents: metadata.entryComponents,
        template: inlineTemplate,
        templateUrl: templateUrl,
        animations: animations,
        styles: view.styles,
        styleUrls: view.styleUrls,
        encapsulation: view.encapsulation,
        interpolation: view.interpolation
      });
    }

    return new Directive({
      selector: metadata.selector,
      inputs: metadata.inputs,
      outputs: metadata.outputs,
      host: metadata.host,
      providers: providers,
      exportAs: metadata.exportAs,
      queries: metadata.queries
    });
  }

  /**
   * Overrides the {@link Directive} for a directive.
   */
  setDirective(type: Type<any>, metadata: Directive): void {
    this._directives.set(type, metadata);
    this._clearCacheFor(type);
  }

  setProvidersOverride(type: Type<any>, providers: Provider[]): void {
    this._providerOverrides.set(type, providers);
    this._clearCacheFor(type);
  }

  setViewProvidersOverride(type: Type<any>, viewProviders: Provider[]): void {
    this._viewProviderOverrides.set(type, viewProviders);
    this._clearCacheFor(type);
  }

  /**
   * Overrides the {@link ViewMetadata} for a component.
   */
  setView(component: Type<any>, view: ViewMetadata): void {
    this._views.set(component, view);
    this._clearCacheFor(component);
  }
  /**
   * Overrides the inline template for a component - other configuration remains unchanged.
   */
  setInlineTemplate(component: Type<any>, template: string): void {
    this._inlineTemplates.set(component, template);
    this._clearCacheFor(component);
  }
}

function flattenArray(tree: any[], out: Array<Type<any>|any[]>): void {
  if (!isPresent(tree)) return;
  for (let i = 0; i < tree.length; i++) {
    const item = resolveForwardRef(tree[i]);
    if (Array.isArray(item)) {
      flattenArray(item, out);
    } else {
      out.push(item);
    }
  }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<title>Python: module app.autograder.pythongrader</title>
<meta charset="utf-8">

<big><big>app.autograder.pythongrader</big></big>	index
/home/plenk/SubSite/app/autograder/pythongrader.py

<big>Modules</big>

<tt>      </tt>

itertools

	json

	re

<big>Functions</big>

<tt>      </tt>

pythonResultParser(output, error)

pythonRunTest()

pythonTestParser(filename)

<tt>Takes a python pyunit test file and attempts to extract all the tests.

It may accidentally grab other helper functions you define because it is

using a simple regex search.</tt>

<big>Data</big>

<tt>      </tt>
PIPE = -1

PYTHON_TEST_REGEX = r'^.*?def (.*?)\(self\):$'

environ = {'MANDATORY_PATH': '/usr/share/gconf/ubuntu.mand...:*.spx=00;36:*.xspf=00;36:', 'XDG_SEAT': 'seat0'}


text:
package com.collective.celos;

import java.util.Properties;

import junit.framework.Assert;

import org.junit.Test;

import com.fasterxml.jackson.databind.node.ObjectNode;

public class OozieExternalServiceTest {

    @Test(expected=NullPointerException.class)
    public void oozieURLIsRequired() {
        new OozieExternalService(null, PropertiesGenerator.EMPTY);
    }

    @Test(expected=NullPointerException.class)
    public void propertiesGeneratorIsRequired() {
        new OozieExternalService("http://oozie", null);
    }

    @Test
    public void runPropertiesAreCorrectlySetup() {
        ScheduledTime t = new ScheduledTime("2013-11-26T17:23Z");
        SlotID id = new SlotID(new WorkflowID("test"), t);
        ObjectNode defaults = Util.newObjectNode();
        defaults.put("foo", "bar");
        defaults.put("uses-variables", "${year}-${month}-${day}-${hour}-${year}");
        defaults.put("another-one", "${year}-${month}-${day}T${hour}:${minute}:${second}.${millisecond}Z");
        Properties runProperties = makeOozieExternalService().setupRunProperties(defaults, id);
        Assert.assertEquals("bar", runProperties.getProperty("foo"));
        Assert.assertEquals("2013-11-26-17-2013", runProperties.getProperty("uses-variables"));
        Assert.assertEquals("2013-11-26T17:23:00.000Z", runProperties.getProperty("another-one"));
        Assert.assertEquals("2013", runProperties.getProperty(OozieExternalService.YEAR_PROP));
        Assert.assertEquals("11", runProperties.getProperty(OozieExternalService.MONTH_PROP));
        Assert.assertEquals("26", runProperties.getProperty(OozieExternalService.DAY_PROP));
        Assert.assertEquals("17", runProperties.getProperty(OozieExternalService.HOUR_PROP));
        Assert.assertEquals("23", runProperties.getProperty(OozieExternalService.MINUTE_PROP));
        Assert.assertEquals("00", runProperties.getProperty(OozieExternalService.SECOND_PROP));
        Assert.assertEquals("test@2013-11-26T17:23Z", runProperties.getProperty(OozieExternalService.WORKFLOW_NAME_PROP));
    }

    private OozieExternalService makeOozieExternalService() {
        return new OozieExternalService("http://example.com", PropertiesGenerator.EMPTY);
    }

}


text: svink -d -i ../samples/circle.svg -p ../output/scale -C 4


text:
package org.apache.qpid.protonj2.test.driver.codec.primitives;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import org.junit.jupiter.api.Test;

public class UnsignedIntegerTest {

    @Test
    public void testToString() {
        assertEquals("0",  UnsignedInteger.valueOf(0).toString());
        assertEquals("65535", UnsignedInteger.valueOf(65535).toString());
        assertEquals("127", UnsignedInteger.valueOf(127).toString());
    }

    @SuppressWarnings("unlikely-arg-type")
    @Test
    public void testEquals() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        UnsignedInteger uint2 = UnsignedInteger.valueOf(2);

        assertEquals(uint1, uint1);
        assertEquals(uint1, UnsignedInteger.valueOf(1));
        assertEquals(uint1, UnsignedInteger.valueOf("1"));
        assertFalse(uint1.equals(uint2));
        assertNotEquals(uint1.hashCode(), uint2.hashCode());

        assertEquals(uint1.hashCode(), UnsignedInteger.valueOf(1).hashCode());
        assertEquals(uint2.hashCode(), UnsignedInteger.valueOf(2).hashCode());

        assertFalse(uint1.equals(null));
        assertFalse(uint1.equals("test"));
    }

    @Test
    public void testValueOfFromLong() {
        long longValue = (long) Integer.MAX_VALUE + 1;

        UnsignedInteger uint1 = UnsignedInteger.valueOf(1l);
        UnsignedInteger uint2 = UnsignedInteger.valueOf(longValue);

        assertEquals(1, uint1.intValue());
        assertEquals(longValue, uint2.longValue());
    }

    @Test
    public void testValueOfFromString() {
        long longValue = (long) Integer.MAX_VALUE + 1;

        UnsignedInteger uint1 = UnsignedInteger.valueOf("1");
        UnsignedInteger uint2 = UnsignedInteger.valueOf(String.valueOf(longValue));

        assertEquals(1, uint1.intValue());
        assertEquals(longValue, uint2.longValue());
    }

    @Test
    public void testHashcode() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        UnsignedInteger uint2 = UnsignedInteger.valueOf(2);

        assertNotEquals(uint1, uint2);
        assertNotEquals(uint1.hashCode(), uint2.hashCode());

        assertEquals(uint1.hashCode(), UnsignedInteger.valueOf(1).hashCode());
        assertEquals(uint2.hashCode(), UnsignedInteger.valueOf(2).hashCode());
    }

    @Test
    public void testAdd() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        UnsignedInteger result = uint1.add(uint1);
        assertEquals(2, result.intValue());
    }

    @Test
    public void testSubtract() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        UnsignedInteger result = uint1.subtract(uint1);
        assertEquals(0, result.intValue());
    }

    @Test
    public void testCompareToPrimitiveInt() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        assertEquals(0, uint1.compareTo(1));
        assertEquals(1, uint1.compareTo(0));
        assertEquals(-1, uint1.compareTo(2));
    }

    @Test
    public void testCompareToPrimitiveLong() {
        UnsignedInteger uint1 = UnsignedInteger.valueOf(1);
        assertEquals(0, uint1.compareTo(1l));
        assertEquals(1, uint1.compareTo(0l));
        assertEquals(-1, uint1.compareTo(2l));
    }

    @Test
    public void testShortValue() {
        assertEquals((short) 0, UnsignedInteger.valueOf(0).shortValue());
        assertEquals((short) 65535, UnsignedInteger.valueOf(65535).shortValue());
        assertEquals((short) 1, UnsignedInteger.valueOf(1).shortValue());
        assertEquals((short) 127, UnsignedInteger.valueOf(127).shortValue());
    }

    @Test
    public void testIntValue() {
        assertEquals(0, UnsignedInteger.valueOf(0).intValue());
        assertEquals(65535, UnsignedInteger.valueOf(65535).intValue());
        assertEquals(1, UnsignedInteger.valueOf(1).intValue());
        assertEquals(127, UnsignedInteger.valueOf(127).intValue());
    }

    @Test
    public void testLongValue() {
        long longValue = (long) Integer.MAX_VALUE + 1;

        assertEquals(0l, UnsignedInteger.valueOf(0).longValue());
        assertEquals(65535l, UnsignedInteger.valueOf(65535).longValue());
        assertEquals(1l, UnsignedInteger.valueOf(1).longValue());
        assertEquals(127l, UnsignedInteger.valueOf(127).longValue());
        assertEquals(longValue, UnsignedInteger.valueOf(Integer.MAX_VALUE + 1).longValue());
    }

    @Test
    public void testToUnsignedLongValueFromInt() {
        long longValue = (long) Integer.MAX_VALUE + 1;

        assertEquals(0l, UnsignedInteger.toUnsignedLong(0));
        assertEquals(65535l, UnsignedInteger.toUnsignedLong(65535));
        assertEquals(1l, UnsignedInteger.toUnsignedLong(1));
        assertEquals(127l, UnsignedInteger.toUnsignedLong(127));
        assertEquals(longValue, UnsignedInteger.toUnsignedLong(Integer.MAX_VALUE + 1));
    }

    @Test
    public void testFloatValue() {
        assertEquals(0.0f, UnsignedInteger.valueOf(0).floatValue(), 0.0f);
        assertEquals(65535.0f, UnsignedInteger.valueOf(65535).floatValue(), 0.0f);
        assertEquals(1.0f, UnsignedInteger.valueOf(1).floatValue(), 0.0f);
        assertEquals(127.0f, UnsignedInteger.valueOf(127).floatValue(), 0.0f);
    }

    @Test
    public void testDoubleValue() {
        assertEquals(0.0, UnsignedInteger.valueOf(0).doubleValue(), 0.0);
        assertEquals(65535.0, UnsignedInteger.valueOf(65535).doubleValue(), 0.0);
        assertEquals(1.0, UnsignedInteger.valueOf(1).doubleValue(), 0.0);
        assertEquals(127.0, UnsignedInteger.valueOf(127).doubleValue(), 0.0);
    }

    @Test
    public void testCompareToByte() {
        assertTrue(UnsignedInteger.valueOf(255).compareTo(255) == 0);
        assertTrue(UnsignedInteger.valueOf(0).compareTo(0) == 0);
        assertTrue(UnsignedInteger.valueOf(127).compareTo(126) > 0);
        assertTrue(UnsignedInteger.valueOf(32).compareTo(64) < 0);
    }

    @Test
    public void testCompareToUnsignedInteger() {
        assertTrue(UnsignedInteger.valueOf(65535).compareTo(UnsignedInteger.valueOf(65535)) == 0);
        assertTrue(UnsignedInteger.valueOf(0).compareTo(UnsignedInteger.valueOf(0)) == 0);
        assertTrue(UnsignedInteger.valueOf(127).compareTo(UnsignedInteger.valueOf(126)) > 0);
        assertTrue(UnsignedInteger.valueOf(32).compareTo(UnsignedInteger.valueOf(64)) < 0);
    }

    @Test
    public void testCompareToIntInt() {
        assertTrue(UnsignedInteger.compare(65536, 65536) == 0);
        assertTrue(UnsignedInteger.compare(0, 0) == 0);
        assertTrue(UnsignedInteger.compare(1, 2) < 0);
        assertTrue(UnsignedInteger.compare(127, 32) > 0);
    }

    @Test
    public void testCompareToLongLong() {
        assertTrue(UnsignedInteger.compare(65536l, 65536l) == 0);
        assertTrue(UnsignedInteger.compare(0l, 0l) == 0);
        assertTrue(UnsignedInteger.compare(1l, 2l) < 0);
        assertTrue(UnsignedInteger.compare(127l, 32l) > 0);
    }

    @Test
    public void testValueOfLongWithNegativeNumberThrowsNFE() throws Exception {
        try {
            UnsignedInteger.valueOf(-1l);
            fail("Expected exception was not thrown");
        } catch (NumberFormatException nfe) {
            // expected
        }
    }

    @Test
    public void testValueOfLongWithLargeNumberThrowsNFE() throws Exception {
        try {
            UnsignedInteger.valueOf(Long.MAX_VALUE);
            fail("Expected exception was not thrown");
        } catch (NumberFormatException nfe) {
            // expected
        }
    }

    @Test
    public void testValueOfStringWithNegativeNumberThrowsNFE() throws Exception {
        try {
            UnsignedInteger.valueOf("-1");
            fail("Expected exception was not thrown");
        } catch (NumberFormatException nfe) {
            // expected
        }
    }

    @Test
    public void testValueOfStringWithTextThrowsNFE() throws Exception {
        try {
            UnsignedInteger.valueOf("TEST");
            fail("Expected exception was not thrown");
        } catch (NumberFormatException nfe) {
            // expected
        }
    }

    @Test
    public void testValueOfStringWithOutOfRangeValueThrowsNFE() throws Exception {
        try {
            UnsignedInteger.valueOf("" + Long.MAX_VALUE);
            fail("Expected exception was not thrown");
        } catch (NumberFormatException nfe) {
            // expected
        }
    }
}


text:
require 'LionWarranty/base'
require 'yaml'


text:
/**
* Category.js
*
* @description :: TODO: You might write a short summary of how this model works and what it represents here.
* @docs        :: http://sailsjs.org/#!documentation/models
*/

module.exports = {

  attributes: {
  	name: 'string',
  	description: 'string',

  	proposals: {
  		model: 'proposal',
  		via: 'category'
  	}
  }
};